mcpforunityserver 8.2.3__py3-none-any.whl

services/tools/read_console.py

@@ -0,0 +1,115 @@
+"""
+Defines the read_console tool for accessing Unity Editor console messages.
+"""
+from typing import Annotated, Any, Literal
+
+from fastmcp import Context
+from services.registry import mcp_for_unity_tool
+from services.tools import get_unity_instance_from_context
+from transport.unity_transport import send_with_unity_instance
+from transport.legacy.unity_connection import async_send_command_with_retry
+
+
+@mcp_for_unity_tool(
+    description="Gets messages from or clears the Unity Editor console. Note: For maximum client compatibility, pass count as a quoted string (e.g., '5')."
+)
+async def read_console(
+    ctx: Context,
+    action: Annotated[Literal['get', 'clear'],
+                      "Get or clear the Unity Editor console. Defaults to 'get' if omitted."] | None = None,
+    types: Annotated[list[Literal['error', 'warning',
+                                  'log', 'all']], "Message types to get"] | None = None,
+    count: Annotated[int | str,
+                     "Max messages to return (accepts int or string, e.g., 5 or '5')"] | None = None,
+    filter_text: Annotated[str, "Text filter for messages"] | None = None,
+    since_timestamp: Annotated[str,
+                               "Get messages after this timestamp (ISO 8601)"] | None = None,
+    format: Annotated[Literal['plain', 'detailed',
+                              'json'], "Output format"] | None = None,
+    include_stacktrace: Annotated[bool | str,
+                                  "Include stack traces in output (accepts true/false or 'true'/'false')"] | None = None,
+) -> dict[str, Any]:
+    # Get active instance from session state
+    # Removed session_state import
+    unity_instance = get_unity_instance_from_context(ctx)
+    # Set defaults if values are None
+    action = action if action is not None else 'get'
+    types = types if types is not None else ['error', 'warning', 'log']
+    format = format if format is not None else 'detailed'
+    # Coerce booleans defensively (strings like 'true'/'false')
+
+    def _coerce_bool(value, default=None):
+        if value is None:
+            return default
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            v = value.strip().lower()
+            if v in ("true", "1", "yes", "on"):
+                return True
+            if v in ("false", "0", "no", "off"):
+                return False
+        return bool(value)
+
+    include_stacktrace = _coerce_bool(include_stacktrace, True)
+
+    # Normalize action if it's a string
+    if isinstance(action, str):
+        action = action.lower()
+
+    # Coerce count defensively (string/float -> int)
+    def _coerce_int(value, default=None):
+        if value is None:
+            return default
+        try:
+            if isinstance(value, bool):
+                return default
+            if isinstance(value, int):
+                return int(value)
+            s = str(value).strip()
+            if s.lower() in ("", "none", "null"):
+                return default
+            return int(float(s))
+        except Exception:
+            return default
+
+    count = _coerce_int(count)
+
+    # Prepare parameters for the C# handler
+    params_dict = {
+        "action": action,
+        "types": types,
+        "count": count,
+        "filterText": filter_text,
+        "sinceTimestamp": since_timestamp,
+        "format": format.lower() if isinstance(format, str) else format,
+        "includeStacktrace": include_stacktrace
+    }
+
+    # Remove None values unless it's 'count' (as None might mean 'all')
+    params_dict = {k: v for k, v in params_dict.items()
+                   if v is not None or k == 'count'}
+
+    # Add count back if it was None, explicitly sending null might be important for C# logic
+    if 'count' not in params_dict:
+        params_dict['count'] = None
+
+    # Use centralized retry helper with instance routing
+    resp = await send_with_unity_instance(async_send_command_with_retry, unity_instance, "read_console", params_dict)
+    if isinstance(resp, dict) and resp.get("success") and not include_stacktrace:
+        # Strip stacktrace fields from returned lines if present
+        try:
+            data = resp.get("data")
+            # Handle standard format: {"data": {"lines": [...]}}
+            if isinstance(data, dict) and "lines" in data and isinstance(data["lines"], list):
+                for line in data["lines"]:
+                    if isinstance(line, dict) and "stacktrace" in line:
+                        line.pop("stacktrace", None)
+            # Handle legacy/direct list format if any
+            elif isinstance(data, list):
+                for line in data:
+                    if isinstance(line, dict) and "stacktrace" in line:
+                        line.pop("stacktrace", None)
+        except Exception:
+            pass
+    return resp if isinstance(resp, dict) else {"success": False, "message": str(resp)}

services/tools/run_tests.py

@@ -0,0 +1,108 @@
+"""Tool for executing Unity Test Runner suites."""
+from typing import Annotated, Literal, Any
+
+from fastmcp import Context
+from pydantic import BaseModel, Field
+
+from models import MCPResponse
+from services.registry import mcp_for_unity_tool
+from services.tools import get_unity_instance_from_context
+from transport.unity_transport import send_with_unity_instance
+from transport.legacy.unity_connection import async_send_command_with_retry
+
+
+class RunTestsSummary(BaseModel):
+    total: int
+    passed: int
+    failed: int
+    skipped: int
+    durationSeconds: float
+    resultState: str
+
+
+class RunTestsTestResult(BaseModel):
+    name: str
+    fullName: str
+    state: str
+    durationSeconds: float
+    message: str | None = None
+    stackTrace: str | None = None
+    output: str | None = None
+
+
+class RunTestsResult(BaseModel):
+    mode: str
+    summary: RunTestsSummary
+    results: list[RunTestsTestResult]
+
+
+class RunTestsResponse(MCPResponse):
+    data: RunTestsResult | None = None
+
+
+@mcp_for_unity_tool(
+    description="Runs Unity tests for the specified mode"
+)
+async def run_tests(
+    ctx: Context,
+    mode: Annotated[Literal["EditMode", "PlayMode"], "Unity test mode to run"] = "EditMode",
+    timeout_seconds: Annotated[int | str, "Optional timeout in seconds for the test run"] | None = None,
+    test_names: Annotated[list[str] | str, "Full names of specific tests to run (e.g., 'MyNamespace.MyTests.TestMethod')"] | None = None,
+    group_names: Annotated[list[str] | str, "Same as test_names, except it allows for Regex"] | None = None,
+    category_names: Annotated[list[str] | str, "NUnit category names to filter by (tests marked with [Category] attribute)"] | None = None,
+    assembly_names: Annotated[list[str] | str, "Assembly names to filter tests by"] | None = None,
+) -> RunTestsResponse:
+    unity_instance = get_unity_instance_from_context(ctx)
+
+    # Coerce timeout defensively (string/float -> int)
+    def _coerce_int(value, default=None):
+        if value is None:
+            return default
+        try:
+            if isinstance(value, bool):
+                return default
+            if isinstance(value, int):
+                return int(value)
+            s = str(value).strip()
+            if s.lower() in ("", "none", "null"):
+                return default
+            return int(float(s))
+        except Exception:
+            return default
+
+    # Coerce string or list to list of strings
+    def _coerce_string_list(value) -> list[str] | None:
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return [value] if value.strip() else None
+        if isinstance(value, list):
+            result = [str(v).strip() for v in value if v and str(v).strip()]
+            return result if result else None
+        return None
+
+    params: dict[str, Any] = {"mode": mode}
+    ts = _coerce_int(timeout_seconds)
+    if ts is not None:
+        params["timeoutSeconds"] = ts
+
+    # Add filter parameters if provided
+    test_names_list = _coerce_string_list(test_names)
+    if test_names_list:
+        params["testNames"] = test_names_list
+
+    group_names_list = _coerce_string_list(group_names)
+    if group_names_list:
+        params["groupNames"] = group_names_list
+
+    category_names_list = _coerce_string_list(category_names)
+    if category_names_list:
+        params["categoryNames"] = category_names_list
+
+    assembly_names_list = _coerce_string_list(assembly_names)
+    if assembly_names_list:
+        params["assemblyNames"] = assembly_names_list
+
+    response = await send_with_unity_instance(async_send_command_with_retry, unity_instance, "run_tests", params)
+    await ctx.info(f'Response {response}')
+    return RunTestsResponse(**response) if isinstance(response, dict) else response