594 lines
29 KiB
Python
594 lines
29 KiB
Python
from mcp.server.fastmcp import FastMCP, Context
|
|
from typing import Dict, Any, List
|
|
from unity_connection import send_command_with_retry
|
|
import base64
|
|
import os
|
|
from urllib.parse import urlparse, unquote
|
|
|
|
|
|
def register_manage_script_tools(mcp: FastMCP):
|
|
"""Register all script management tools with the MCP server."""
|
|
|
|
def _split_uri(uri: str) -> tuple[str, str]:
|
|
"""Split an incoming URI or path into (name, directory) suitable for Unity.
|
|
|
|
Rules:
|
|
- unity://path/Assets/... → keep as Assets-relative (after decode/normalize)
|
|
- file://... → percent-decode, normalize, strip host and leading slashes,
|
|
then, if any 'Assets' segment exists, return path relative to that 'Assets' root.
|
|
Otherwise, fall back to original name/dir behavior.
|
|
- plain paths → decode/normalize separators; if they contain an 'Assets' segment,
|
|
return relative to 'Assets'.
|
|
"""
|
|
raw_path: str
|
|
if uri.startswith("unity://path/"):
|
|
raw_path = uri[len("unity://path/") :]
|
|
elif uri.startswith("file://"):
|
|
parsed = urlparse(uri)
|
|
host = (parsed.netloc or "").strip()
|
|
p = parsed.path or ""
|
|
# UNC: file://server/share/... -> //server/share/...
|
|
if host and host.lower() != "localhost":
|
|
p = f"//{host}{p}"
|
|
# Use percent-decoded path, preserving leading slashes
|
|
raw_path = unquote(p)
|
|
else:
|
|
raw_path = uri
|
|
|
|
# Percent-decode any residual encodings and normalize separators
|
|
raw_path = unquote(raw_path).replace("\\", "/")
|
|
# Strip leading slash only for Windows drive-letter forms like "/C:/..."
|
|
if os.name == "nt" and len(raw_path) >= 3 and raw_path[0] == "/" and raw_path[2] == ":":
|
|
raw_path = raw_path[1:]
|
|
|
|
# Normalize path (collapse ../, ./)
|
|
norm = os.path.normpath(raw_path).replace("\\", "/")
|
|
|
|
# If an 'Assets' segment exists, compute path relative to it (case-insensitive)
|
|
parts = [p for p in norm.split("/") if p not in ("", ".")]
|
|
idx = next((i for i, seg in enumerate(parts) if seg.lower() == "assets"), None)
|
|
assets_rel = "/".join(parts[idx:]) if idx is not None else None
|
|
|
|
effective_path = assets_rel if assets_rel else norm
|
|
# For POSIX absolute paths outside Assets, drop the leading '/'
|
|
# to return a clean relative-like directory (e.g., '/tmp' -> 'tmp').
|
|
if effective_path.startswith("/"):
|
|
effective_path = effective_path[1:]
|
|
|
|
name = os.path.splitext(os.path.basename(effective_path))[0]
|
|
directory = os.path.dirname(effective_path)
|
|
return name, directory
|
|
|
|
@mcp.tool(description=(
|
|
"Apply small text edits to a C# script identified by URI.\n\n"
|
|
"⚠️ IMPORTANT: This tool replaces EXACT character positions. Always verify content at target lines/columns BEFORE editing!\n"
|
|
"Common mistakes:\n"
|
|
"- Assuming what's on a line without checking\n"
|
|
"- Using wrong line numbers (they're 1-indexed)\n"
|
|
"- Miscounting column positions (also 1-indexed, tabs count as 1)\n\n"
|
|
"RECOMMENDED WORKFLOW:\n"
|
|
"1) First call resources/read with start_line/line_count to verify exact content\n"
|
|
"2) Count columns carefully (or use find_in_file to locate patterns)\n"
|
|
"3) Apply your edit with precise coordinates\n"
|
|
"4) Consider script_apply_edits with anchors for safer pattern-based replacements\n\n"
|
|
"Args:\n"
|
|
"- uri: unity://path/Assets/... or file://... or Assets/...\n"
|
|
"- edits: list of {startLine,startCol,endLine,endCol,newText} (1-indexed!)\n"
|
|
"- precondition_sha256: optional SHA of current file (prevents concurrent edit conflicts)\n\n"
|
|
"Notes:\n"
|
|
"- Path must resolve under Assets/\n"
|
|
"- For method/class operations, use script_apply_edits (safer, structured edits)\n"
|
|
"- For pattern-based replacements, consider anchor operations in script_apply_edits\n"
|
|
))
|
|
def apply_text_edits(
|
|
ctx: Context,
|
|
uri: str,
|
|
edits: List[Dict[str, Any]],
|
|
precondition_sha256: str | None = None,
|
|
strict: bool | None = None,
|
|
options: Dict[str, Any] | None = None,
|
|
) -> Dict[str, Any]:
|
|
"""Apply small text edits to a C# script identified by URI."""
|
|
name, directory = _split_uri(uri)
|
|
|
|
# Normalize common aliases/misuses for resilience:
|
|
# - Accept LSP-style range objects: {range:{start:{line,character}, end:{...}}, newText|text}
|
|
# - Accept index ranges as a 2-int array: {range:[startIndex,endIndex], text}
|
|
# If normalization is required, read current contents to map indices -> 1-based line/col.
|
|
def _needs_normalization(arr: List[Dict[str, Any]]) -> bool:
|
|
for e in arr or []:
|
|
if ("startLine" not in e) or ("startCol" not in e) or ("endLine" not in e) or ("endCol" not in e) or ("newText" not in e and "text" in e):
|
|
return True
|
|
return False
|
|
|
|
normalized_edits: List[Dict[str, Any]] = []
|
|
warnings: List[str] = []
|
|
if _needs_normalization(edits):
|
|
# Read file to support index->line/col conversion when needed
|
|
read_resp = send_command_with_retry("manage_script", {
|
|
"action": "read",
|
|
"name": name,
|
|
"path": directory,
|
|
})
|
|
if not (isinstance(read_resp, dict) and read_resp.get("success")):
|
|
return read_resp if isinstance(read_resp, dict) else {"success": False, "message": str(read_resp)}
|
|
data = read_resp.get("data", {})
|
|
contents = data.get("contents")
|
|
if not contents and data.get("contentsEncoded"):
|
|
try:
|
|
contents = base64.b64decode(data.get("encodedContents", "").encode("utf-8")).decode("utf-8", "replace")
|
|
except Exception:
|
|
contents = contents or ""
|
|
|
|
# Helper to map 0-based character index to 1-based line/col
|
|
def line_col_from_index(idx: int) -> tuple[int, int]:
|
|
if idx <= 0:
|
|
return 1, 1
|
|
# Count lines up to idx and position within line
|
|
nl_count = contents.count("\n", 0, idx)
|
|
line = nl_count + 1
|
|
last_nl = contents.rfind("\n", 0, idx)
|
|
col = (idx - (last_nl + 1)) + 1 if last_nl >= 0 else idx + 1
|
|
return line, col
|
|
|
|
for e in edits or []:
|
|
e2 = dict(e)
|
|
# Map text->newText if needed
|
|
if "newText" not in e2 and "text" in e2:
|
|
e2["newText"] = e2.pop("text")
|
|
|
|
if "startLine" in e2 and "startCol" in e2 and "endLine" in e2 and "endCol" in e2:
|
|
# Guard: explicit fields must be 1-based.
|
|
zero_based = False
|
|
for k in ("startLine","startCol","endLine","endCol"):
|
|
try:
|
|
if int(e2.get(k, 1)) < 1:
|
|
zero_based = True
|
|
except Exception:
|
|
pass
|
|
if zero_based:
|
|
if strict:
|
|
return {"success": False, "code": "zero_based_explicit_fields", "message": "Explicit line/col fields are 1-based; received zero-based.", "data": {"normalizedEdits": normalized_edits}}
|
|
# Normalize by clamping to 1 and warn
|
|
for k in ("startLine","startCol","endLine","endCol"):
|
|
try:
|
|
if int(e2.get(k, 1)) < 1:
|
|
e2[k] = 1
|
|
except Exception:
|
|
pass
|
|
warnings.append("zero_based_explicit_fields_normalized")
|
|
normalized_edits.append(e2)
|
|
continue
|
|
|
|
rng = e2.get("range")
|
|
if isinstance(rng, dict):
|
|
# LSP style: 0-based
|
|
s = rng.get("start", {})
|
|
t = rng.get("end", {})
|
|
e2["startLine"] = int(s.get("line", 0)) + 1
|
|
e2["startCol"] = int(s.get("character", 0)) + 1
|
|
e2["endLine"] = int(t.get("line", 0)) + 1
|
|
e2["endCol"] = int(t.get("character", 0)) + 1
|
|
e2.pop("range", None)
|
|
normalized_edits.append(e2)
|
|
continue
|
|
if isinstance(rng, (list, tuple)) and len(rng) == 2:
|
|
try:
|
|
a = int(rng[0])
|
|
b = int(rng[1])
|
|
if b < a:
|
|
a, b = b, a
|
|
sl, sc = line_col_from_index(a)
|
|
el, ec = line_col_from_index(b)
|
|
e2["startLine"] = sl
|
|
e2["startCol"] = sc
|
|
e2["endLine"] = el
|
|
e2["endCol"] = ec
|
|
e2.pop("range", None)
|
|
normalized_edits.append(e2)
|
|
continue
|
|
except Exception:
|
|
pass
|
|
# Could not normalize this edit
|
|
return {
|
|
"success": False,
|
|
"code": "missing_field",
|
|
"message": "apply_text_edits requires startLine/startCol/endLine/endCol/newText or a normalizable 'range'",
|
|
"data": {"expected": ["startLine","startCol","endLine","endCol","newText"], "got": e}
|
|
}
|
|
else:
|
|
# Even when edits appear already in explicit form, validate 1-based coordinates.
|
|
normalized_edits = []
|
|
for e in edits or []:
|
|
e2 = dict(e)
|
|
has_all = all(k in e2 for k in ("startLine","startCol","endLine","endCol"))
|
|
if has_all:
|
|
zero_based = False
|
|
for k in ("startLine","startCol","endLine","endCol"):
|
|
try:
|
|
if int(e2.get(k, 1)) < 1:
|
|
zero_based = True
|
|
except Exception:
|
|
pass
|
|
if zero_based:
|
|
if strict:
|
|
return {"success": False, "code": "zero_based_explicit_fields", "message": "Explicit line/col fields are 1-based; received zero-based.", "data": {"normalizedEdits": [e2]}}
|
|
for k in ("startLine","startCol","endLine","endCol"):
|
|
try:
|
|
if int(e2.get(k, 1)) < 1:
|
|
e2[k] = 1
|
|
except Exception:
|
|
pass
|
|
if "zero_based_explicit_fields_normalized" not in warnings:
|
|
warnings.append("zero_based_explicit_fields_normalized")
|
|
normalized_edits.append(e2)
|
|
|
|
# Preflight: detect overlapping ranges among normalized line/col spans
|
|
def _pos_tuple(e: Dict[str, Any], key_start: bool) -> tuple[int, int]:
|
|
return (
|
|
int(e.get("startLine", 1)) if key_start else int(e.get("endLine", 1)),
|
|
int(e.get("startCol", 1)) if key_start else int(e.get("endCol", 1)),
|
|
)
|
|
|
|
def _le(a: tuple[int, int], b: tuple[int, int]) -> bool:
|
|
return a[0] < b[0] or (a[0] == b[0] and a[1] <= b[1])
|
|
|
|
# Consider only true replace ranges (non-zero length). Pure insertions (zero-width) don't overlap.
|
|
spans = []
|
|
for e in normalized_edits or []:
|
|
try:
|
|
s = _pos_tuple(e, True)
|
|
t = _pos_tuple(e, False)
|
|
if s != t:
|
|
spans.append((s, t))
|
|
except Exception:
|
|
# If coordinates missing or invalid, let the server validate later
|
|
pass
|
|
|
|
if spans:
|
|
spans_sorted = sorted(spans, key=lambda p: (p[0][0], p[0][1]))
|
|
for i in range(1, len(spans_sorted)):
|
|
prev_end = spans_sorted[i-1][1]
|
|
curr_start = spans_sorted[i][0]
|
|
# Overlap if prev_end > curr_start (strict), i.e., not prev_end <= curr_start
|
|
if not _le(prev_end, curr_start):
|
|
conflicts = [{
|
|
"startA": {"line": spans_sorted[i-1][0][0], "col": spans_sorted[i-1][0][1]},
|
|
"endA": {"line": spans_sorted[i-1][1][0], "col": spans_sorted[i-1][1][1]},
|
|
"startB": {"line": spans_sorted[i][0][0], "col": spans_sorted[i][0][1]},
|
|
"endB": {"line": spans_sorted[i][1][0], "col": spans_sorted[i][1][1]},
|
|
}]
|
|
return {"success": False, "code": "overlap", "data": {"status": "overlap", "conflicts": conflicts}}
|
|
|
|
# Note: Do not auto-compute precondition if missing; callers should supply it
|
|
# via mcp__unity__get_sha or a prior read. This avoids hidden extra calls and
|
|
# preserves existing call-count expectations in clients/tests.
|
|
|
|
# Default options: for multi-span batches, prefer atomic to avoid mid-apply imbalance
|
|
opts: Dict[str, Any] = dict(options or {})
|
|
try:
|
|
if len(normalized_edits) > 1 and "applyMode" not in opts:
|
|
opts["applyMode"] = "atomic"
|
|
except Exception:
|
|
pass
|
|
# Support optional debug preview for span-by-span simulation without write
|
|
if opts.get("debug_preview"):
|
|
try:
|
|
import difflib
|
|
# Apply locally to preview final result
|
|
lines = []
|
|
# Build an indexable original from a read if we normalized from read; otherwise skip
|
|
prev = ""
|
|
# We cannot guarantee file contents here without a read; return normalized spans only
|
|
return {
|
|
"success": True,
|
|
"message": "Preview only (no write)",
|
|
"data": {
|
|
"normalizedEdits": normalized_edits,
|
|
"preview": True
|
|
}
|
|
}
|
|
except Exception as e:
|
|
return {"success": False, "code": "preview_failed", "message": f"debug_preview failed: {e}", "data": {"normalizedEdits": normalized_edits}}
|
|
|
|
params = {
|
|
"action": "apply_text_edits",
|
|
"name": name,
|
|
"path": directory,
|
|
"edits": normalized_edits,
|
|
"precondition_sha256": precondition_sha256,
|
|
"options": opts,
|
|
}
|
|
params = {k: v for k, v in params.items() if v is not None}
|
|
resp = send_command_with_retry("manage_script", params)
|
|
if isinstance(resp, dict):
|
|
data = resp.setdefault("data", {})
|
|
data.setdefault("normalizedEdits", normalized_edits)
|
|
if warnings:
|
|
data.setdefault("warnings", warnings)
|
|
if resp.get("success") and (options or {}).get("force_sentinel_reload"):
|
|
# Optional: flip sentinel via menu if explicitly requested
|
|
try:
|
|
import threading, time, json, glob, os
|
|
def _latest_status() -> dict | None:
|
|
try:
|
|
files = sorted(glob.glob(os.path.expanduser("~/.unity-mcp/unity-mcp-status-*.json")), key=os.path.getmtime, reverse=True)
|
|
if not files:
|
|
return None
|
|
with open(files[0], "r") as f:
|
|
return json.loads(f.read())
|
|
except Exception:
|
|
return None
|
|
|
|
def _flip_async():
|
|
try:
|
|
time.sleep(0.1)
|
|
st = _latest_status()
|
|
if st and st.get("reloading"):
|
|
return
|
|
send_command_with_retry(
|
|
"execute_menu_item",
|
|
{"menuPath": "MCP/Flip Reload Sentinel"},
|
|
max_retries=0,
|
|
retry_ms=0,
|
|
)
|
|
except Exception:
|
|
pass
|
|
threading.Thread(target=_flip_async, daemon=True).start()
|
|
except Exception:
|
|
pass
|
|
return resp
|
|
return resp
|
|
return {"success": False, "message": str(resp)}
|
|
|
|
@mcp.tool(description=(
|
|
"Create a new C# script at the given project path.\n\n"
|
|
"Args: path (e.g., 'Assets/Scripts/My.cs'), contents (string), script_type, namespace.\n"
|
|
"Rules: path must be under Assets/. Contents will be Base64-encoded over transport.\n"
|
|
))
|
|
def create_script(
|
|
ctx: Context,
|
|
path: str,
|
|
contents: str = "",
|
|
script_type: str | None = None,
|
|
namespace: str | None = None,
|
|
) -> Dict[str, Any]:
|
|
"""Create a new C# script at the given path."""
|
|
name = os.path.splitext(os.path.basename(path))[0]
|
|
directory = os.path.dirname(path)
|
|
# Local validation to avoid round-trips on obviously bad input
|
|
norm_path = os.path.normpath((path or "").replace("\\", "/")).replace("\\", "/")
|
|
if not directory or directory.split("/")[0].lower() != "assets":
|
|
return {"success": False, "code": "path_outside_assets", "message": f"path must be under 'Assets/'; got '{path}'."}
|
|
if ".." in norm_path.split("/") or norm_path.startswith("/"):
|
|
return {"success": False, "code": "bad_path", "message": "path must not contain traversal or be absolute."}
|
|
if not name:
|
|
return {"success": False, "code": "bad_path", "message": "path must include a script file name."}
|
|
if not norm_path.lower().endswith(".cs"):
|
|
return {"success": False, "code": "bad_extension", "message": "script file must end with .cs."}
|
|
params: Dict[str, Any] = {
|
|
"action": "create",
|
|
"name": name,
|
|
"path": directory,
|
|
"namespace": namespace,
|
|
"scriptType": script_type,
|
|
}
|
|
if contents:
|
|
params["encodedContents"] = base64.b64encode(contents.encode("utf-8")).decode("utf-8")
|
|
params["contentsEncoded"] = True
|
|
params = {k: v for k, v in params.items() if v is not None}
|
|
resp = send_command_with_retry("manage_script", params)
|
|
return resp if isinstance(resp, dict) else {"success": False, "message": str(resp)}
|
|
|
|
@mcp.tool(description=(
|
|
"Delete a C# script by URI or Assets-relative path.\n\n"
|
|
"Args: uri (unity://path/... or file://... or Assets/...).\n"
|
|
"Rules: Target must resolve under Assets/.\n"
|
|
))
|
|
def delete_script(ctx: Context, uri: str) -> Dict[str, Any]:
|
|
"""Delete a C# script by URI."""
|
|
name, directory = _split_uri(uri)
|
|
if not directory or directory.split("/")[0].lower() != "assets":
|
|
return {"success": False, "code": "path_outside_assets", "message": "URI must resolve under 'Assets/'."}
|
|
params = {"action": "delete", "name": name, "path": directory}
|
|
resp = send_command_with_retry("manage_script", params)
|
|
return resp if isinstance(resp, dict) else {"success": False, "message": str(resp)}
|
|
|
|
@mcp.tool(description=(
|
|
"Validate a C# script and return diagnostics.\n\n"
|
|
"Args: uri, level=('basic'|'standard').\n"
|
|
"- basic: quick syntax checks.\n"
|
|
"- standard: deeper checks (performance hints, common pitfalls).\n"
|
|
))
|
|
def validate_script(
|
|
ctx: Context, uri: str, level: str = "basic"
|
|
) -> Dict[str, Any]:
|
|
"""Validate a C# script and return diagnostics."""
|
|
name, directory = _split_uri(uri)
|
|
if not directory or directory.split("/")[0].lower() != "assets":
|
|
return {"success": False, "code": "path_outside_assets", "message": "URI must resolve under 'Assets/'."}
|
|
if level not in ("basic", "standard"):
|
|
return {"success": False, "code": "bad_level", "message": "level must be 'basic' or 'standard'."}
|
|
params = {
|
|
"action": "validate",
|
|
"name": name,
|
|
"path": directory,
|
|
"level": level,
|
|
}
|
|
resp = send_command_with_retry("manage_script", params)
|
|
return resp if isinstance(resp, dict) else {"success": False, "message": str(resp)}
|
|
|
|
@mcp.tool(description=(
|
|
"Compatibility router for legacy script operations.\n\n"
|
|
"Actions: create|read|delete (update is routed to apply_text_edits with precondition).\n"
|
|
"Args: name (no .cs), path (Assets/...), contents (for create), script_type, namespace.\n"
|
|
"Notes: prefer apply_text_edits (ranges) or script_apply_edits (structured) for edits.\n"
|
|
))
|
|
def manage_script(
|
|
ctx: Context,
|
|
action: str,
|
|
name: str,
|
|
path: str,
|
|
contents: str = "",
|
|
script_type: str | None = None,
|
|
namespace: str | None = None,
|
|
) -> Dict[str, Any]:
|
|
"""Compatibility router for legacy script operations.
|
|
|
|
IMPORTANT:
|
|
- Direct file reads should use resources/read.
|
|
- Edits should use apply_text_edits.
|
|
|
|
Args:
|
|
action: Operation ('create', 'read', 'delete').
|
|
name: Script name (no .cs extension).
|
|
path: Asset path (default: "Assets/").
|
|
contents: C# code for 'create'/'update'.
|
|
script_type: Type hint (e.g., 'MonoBehaviour').
|
|
namespace: Script namespace.
|
|
|
|
Returns:
|
|
Dictionary with results ('success', 'message', 'data').
|
|
"""
|
|
try:
|
|
# Graceful migration for legacy 'update': route to apply_text_edits (whole-file replace)
|
|
if action == 'update':
|
|
try:
|
|
# 1) Read current contents to compute end range and precondition
|
|
read_resp = send_command_with_retry("manage_script", {
|
|
"action": "read",
|
|
"name": name,
|
|
"path": path,
|
|
})
|
|
if not (isinstance(read_resp, dict) and read_resp.get("success")):
|
|
return {"success": False, "code": "deprecated_update", "message": "Use apply_text_edits; automatic migration failed to read current file."}
|
|
data = read_resp.get("data", {})
|
|
current = data.get("contents")
|
|
if not current and data.get("contentsEncoded"):
|
|
current = base64.b64decode(data.get("encodedContents", "").encode("utf-8")).decode("utf-8", "replace")
|
|
if current is None:
|
|
return {"success": False, "code": "deprecated_update", "message": "Use apply_text_edits; current file read returned no contents."}
|
|
|
|
# 2) Compute whole-file range (1-based, end exclusive) and SHA
|
|
import hashlib as _hashlib
|
|
old_lines = current.splitlines(keepends=True)
|
|
end_line = len(old_lines) + 1
|
|
sha = _hashlib.sha256(current.encode("utf-8")).hexdigest()
|
|
|
|
# 3) Apply single whole-file text edit with provided 'contents'
|
|
edits = [{
|
|
"startLine": 1,
|
|
"startCol": 1,
|
|
"endLine": end_line,
|
|
"endCol": 1,
|
|
"newText": contents or "",
|
|
}]
|
|
route_params = {
|
|
"action": "apply_text_edits",
|
|
"name": name,
|
|
"path": path,
|
|
"edits": edits,
|
|
"precondition_sha256": sha,
|
|
"options": {"refresh": "debounced", "validate": "standard"},
|
|
}
|
|
# Preflight size vs. default cap (256 KiB) to avoid opaque server errors
|
|
try:
|
|
import json as _json
|
|
payload_bytes = len(_json.dumps({"edits": edits}, ensure_ascii=False).encode("utf-8"))
|
|
if payload_bytes > 256 * 1024:
|
|
return {"success": False, "code": "payload_too_large", "message": f"Edit payload {payload_bytes} bytes exceeds 256 KiB cap; try structured ops or chunking."}
|
|
except Exception:
|
|
pass
|
|
routed = send_command_with_retry("manage_script", route_params)
|
|
if isinstance(routed, dict):
|
|
routed.setdefault("message", "Routed legacy update to apply_text_edits")
|
|
return routed
|
|
return {"success": False, "message": str(routed)}
|
|
except Exception as e:
|
|
return {"success": False, "code": "deprecated_update", "message": f"Use apply_text_edits; migration error: {e}"}
|
|
|
|
# Prepare parameters for Unity
|
|
params = {
|
|
"action": action,
|
|
"name": name,
|
|
"path": path,
|
|
"namespace": namespace,
|
|
"scriptType": script_type,
|
|
}
|
|
|
|
# Base64 encode the contents if they exist to avoid JSON escaping issues
|
|
if contents:
|
|
if action == 'create':
|
|
params["encodedContents"] = base64.b64encode(contents.encode('utf-8')).decode('utf-8')
|
|
params["contentsEncoded"] = True
|
|
else:
|
|
params["contents"] = contents
|
|
|
|
params = {k: v for k, v in params.items() if v is not None}
|
|
|
|
response = send_command_with_retry("manage_script", params)
|
|
|
|
if isinstance(response, dict):
|
|
if response.get("success"):
|
|
if response.get("data", {}).get("contentsEncoded"):
|
|
decoded_contents = base64.b64decode(response["data"]["encodedContents"]).decode('utf-8')
|
|
response["data"]["contents"] = decoded_contents
|
|
del response["data"]["encodedContents"]
|
|
del response["data"]["contentsEncoded"]
|
|
|
|
return {
|
|
"success": True,
|
|
"message": response.get("message", "Operation successful."),
|
|
"data": response.get("data"),
|
|
}
|
|
return response
|
|
|
|
return {"success": False, "message": str(response)}
|
|
|
|
except Exception as e:
|
|
return {
|
|
"success": False,
|
|
"message": f"Python error managing script: {str(e)}",
|
|
}
|
|
|
|
@mcp.tool(description=(
|
|
"Get manage_script capabilities (supported ops, limits, and guards).\n\n"
|
|
"Returns:\n- ops: list of supported structured ops\n- text_ops: list of supported text ops\n- max_edit_payload_bytes: server edit payload cap\n- guards: header/using guard enabled flag\n"
|
|
))
|
|
def manage_script_capabilities(ctx: Context) -> Dict[str, Any]:
|
|
try:
|
|
# Keep in sync with server/Editor ManageScript implementation
|
|
ops = [
|
|
"replace_class","delete_class","replace_method","delete_method",
|
|
"insert_method","anchor_insert","anchor_delete","anchor_replace"
|
|
]
|
|
text_ops = ["replace_range","regex_replace","prepend","append"]
|
|
# Match ManageScript.MaxEditPayloadBytes if exposed; hardcode a sensible default fallback
|
|
max_edit_payload_bytes = 256 * 1024
|
|
guards = {"using_guard": True}
|
|
extras = {"get_sha": True}
|
|
return {"success": True, "data": {
|
|
"ops": ops,
|
|
"text_ops": text_ops,
|
|
"max_edit_payload_bytes": max_edit_payload_bytes,
|
|
"guards": guards,
|
|
"extras": extras,
|
|
}}
|
|
except Exception as e:
|
|
return {"success": False, "error": f"capabilities error: {e}"}
|
|
|
|
@mcp.tool(description=(
|
|
"Get SHA256 and metadata for a Unity C# script without returning file contents.\n\n"
|
|
"Args: uri (unity://path/Assets/... or file://... or Assets/...).\n"
|
|
"Returns: {sha256, lengthBytes, lastModifiedUtc, uri, path}."
|
|
))
|
|
def get_sha(ctx: Context, uri: str) -> Dict[str, Any]:
|
|
"""Return SHA256 and basic metadata for a script."""
|
|
try:
|
|
name, directory = _split_uri(uri)
|
|
params = {"action": "get_sha", "name": name, "path": directory}
|
|
resp = send_command_with_retry("manage_script", params)
|
|
return resp if isinstance(resp, dict) else {"success": False, "message": str(resp)}
|
|
except Exception as e:
|
|
return {"success": False, "message": f"get_sha error: {e}"}
|