mcpforunityserver 8.7.0__py3-none-any.whl → 9.1.0__py3-none-any.whl

transport/plugin_hub.py

@@ -34,6 +34,10 @@ class PluginDisconnectedError(RuntimeError):
     """Raised when a plugin WebSocket disconnects while commands are in flight."""
 
 
+class NoUnitySessionError(RuntimeError):
+    """Raised when no Unity plugins are available."""
+
+
 class PluginHub(WebSocketEndpoint):
     """Manages persistent WebSocket connections to Unity plugins."""
 
@@ -41,10 +45,14 @@ class PluginHub(WebSocketEndpoint):
     KEEP_ALIVE_INTERVAL = 15
     SERVER_TIMEOUT = 30
     COMMAND_TIMEOUT = 30
+    # Timeout (seconds) for fast-fail commands like ping/read_console/get_editor_state.
+    # Keep short so MCP clients aren't blocked during Unity compilation/reload/unfocused throttling.
+    FAST_FAIL_TIMEOUT = 2.0
     # Fast-path commands should never block the client for long; return a retry hint instead.
     # This helps avoid the Cursor-side ~30s tool-call timeout when Unity is compiling/reloading
     # or is throttled while unfocused.
-    _FAST_FAIL_COMMANDS: set[str] = {"read_console", "get_editor_state", "ping"}
+    _FAST_FAIL_COMMANDS: set[str] = {
+        "read_console", "get_editor_state", "ping"}
 
     _registry: PluginRegistry | None = None
     _connections: dict[str, WebSocket] = {}
@@ -114,7 +122,8 @@ class PluginHub(WebSocketEndpoint):
                 ]
                 for command_id in pending_ids:
                     entry = cls._pending.get(command_id)
-                    future = entry.get("future") if isinstance(entry, dict) else None
+                    future = entry.get("future") if isinstance(
+                        entry, dict) else None
                     if future and not future.done():
                         future.set_exception(
                             PluginDisconnectedError(
@@ -136,18 +145,15 @@ class PluginHub(WebSocketEndpoint):
         future: asyncio.Future = asyncio.get_running_loop().create_future()
         # Compute a per-command timeout:
         # - fast-path commands: short timeout (encourage retry)
-        # - long-running commands (e.g., run_tests): allow caller to request a longer timeout via params
+        # - long-running commands: allow caller to request a longer timeout via params
         unity_timeout_s = float(cls.COMMAND_TIMEOUT)
         server_wait_s = float(cls.COMMAND_TIMEOUT)
         if command_type in cls._FAST_FAIL_COMMANDS:
-            try:
-                fast_timeout = float(os.environ.get("UNITY_MCP_FAST_COMMAND_TIMEOUT", "3"))
-            except Exception:
-                fast_timeout = 3.0
+            fast_timeout = float(cls.FAST_FAIL_TIMEOUT)
             unity_timeout_s = fast_timeout
             server_wait_s = fast_timeout
         else:
-            # Common tools pass a requested timeout in seconds (e.g., run_tests(timeout_seconds=900)).
+            # Common tools pass a requested timeout in seconds (e.g., timeout_seconds=900).
             requested = None
             try:
                 if isinstance(params, dict):
@@ -176,7 +182,8 @@ class PluginHub(WebSocketEndpoint):
             if command_id in cls._pending:
                 raise RuntimeError(
                     f"Duplicate command id generated: {command_id}")
-            cls._pending[command_id] = {"future": future, "session_id": session_id}
+            cls._pending[command_id] = {
+                "future": future, "session_id": session_id}
 
         try:
             msg = ExecuteCommandMessage(
@@ -308,6 +315,23 @@ class PluginHub(WebSocketEndpoint):
         logger.info(
             f"Registered {len(payload.tools)} tools for session {session_id}")
 
+        try:
+            from services.custom_tool_service import CustomToolService
+
+            service = CustomToolService.get_instance()
+            service.register_global_tools(payload.tools)
+        except RuntimeError as exc:
+            logger.debug(
+                "Skipping global custom tool registration: CustomToolService not initialized yet (%s)",
+                exc,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Unexpected error during global custom tool registration; "
+                "custom tools may not be available globally",
+                exc_info=exc,
+            )
+
     async def _handle_command_result(self, payload: CommandResultMessage) -> None:
         cls = type(self)
         lock = cls._lock
@@ -361,11 +385,21 @@ class PluginHub(WebSocketEndpoint):
         if cls._registry is None:
             raise RuntimeError("Plugin registry not configured")
 
-        # Use the same defaults as the stdio transport reload handling so that
-        # HTTP/WebSocket and TCP behave consistently without per-project env.
-        max_retries = max(1, int(getattr(config, "reload_max_retries", 40)))
+        # Bound waiting for Unity sessions so calls fail fast when editors are not ready.
+        try:
+            max_wait_s = float(
+                os.environ.get("UNITY_MCP_SESSION_RESOLVE_MAX_WAIT_S", "2.0"))
+        except ValueError as e:
+            raw_val = os.environ.get(
+                "UNITY_MCP_SESSION_RESOLVE_MAX_WAIT_S", "2.0")
+            logger.warning(
+                "Invalid UNITY_MCP_SESSION_RESOLVE_MAX_WAIT_S=%r, using default 2.0: %s",
+                raw_val, e)
+            max_wait_s = 2.0
+        # Clamp to [0, 30] to prevent misconfiguration from causing excessive waits
+        max_wait_s = max(0.0, min(max_wait_s, 30.0))
         retry_ms = float(getattr(config, "reload_retry_ms", 250))
-        sleep_seconds = max(0.05, retry_ms / 1000.0)
+        sleep_seconds = max(0.05, min(0.25, retry_ms / 1000.0))
 
         # Allow callers to provide either just the hash or Name@hash
         target_hash: str | None = None
@@ -394,7 +428,7 @@ class PluginHub(WebSocketEndpoint):
             return None, count
 
         session_id, session_count = await _try_once()
-        deadline = time.monotonic() + (max_retries * sleep_seconds)
+        deadline = time.monotonic() + max_wait_s
         wait_started = None
 
         # If there is no active plugin yet (e.g., Unity starting up or reloading),
@@ -403,33 +437,40 @@ class PluginHub(WebSocketEndpoint):
             if not target_hash and session_count > 1:
                 raise RuntimeError(
                     "Multiple Unity instances are connected. "
-                    "Call set_active_instance with Name@hash from unity://instances."
+                    "Call set_active_instance with Name@hash from mcpforunity://instances."
                 )
             if wait_started is None:
                 wait_started = time.monotonic()
                 logger.debug(
-                    f"No plugin session available (instance={unity_instance or 'default'}); waiting up to {deadline - wait_started:.2f}s",
+                    "No plugin session available (instance=%s); waiting up to %.2fs",
+                    unity_instance or "default",
+                    max_wait_s,
                 )
             await asyncio.sleep(sleep_seconds)
             session_id, session_count = await _try_once()
 
         if session_id is not None and wait_started is not None:
             logger.debug(
-                f"Plugin session restored after {time.monotonic() - wait_started:.3f}s (instance={unity_instance or 'default'})",
+                "Plugin session restored after %.3fs (instance=%s)",
+                time.monotonic() - wait_started,
+                unity_instance or "default",
             )
         if session_id is None and not target_hash and session_count > 1:
             raise RuntimeError(
                 "Multiple Unity instances are connected. "
-                "Call set_active_instance with Name@hash from unity://instances."
+                "Call set_active_instance with Name@hash from mcpforunity://instances."
             )
 
         if session_id is None:
             logger.warning(
-                f"No Unity plugin reconnected within {max_retries * sleep_seconds:.2f}s (instance={unity_instance or 'default'})",
+                "No Unity plugin reconnected within %.2fs (instance=%s)",
+                max_wait_s,
+                unity_instance or "default",
             )
             # At this point we've given the plugin ample time to reconnect; surface
             # a clear error so the client can prompt the user to open Unity.
-            raise RuntimeError("No Unity plugins are currently connected")
+            raise NoUnitySessionError(
+                "No Unity plugins are currently connected")
 
         return session_id
 
@@ -440,7 +481,20 @@ class PluginHub(WebSocketEndpoint):
         command_type: str,
         params: dict[str, Any],
     ) -> dict[str, Any]:
-        session_id = await cls._resolve_session_id(unity_instance)
+        try:
+            session_id = await cls._resolve_session_id(unity_instance)
+        except NoUnitySessionError:
+            logger.debug(
+                "Unity session unavailable; returning retry: command=%s instance=%s",
+                command_type,
+                unity_instance or "default",
+            )
+            return MCPResponse(
+                success=False,
+                error="Unity session not available; please retry",
+                hint="retry",
+                data={"reason": "no_unity_session", "retry_after_ms": 250},
+            ).model_dump()
 
         # During domain reload / immediate reconnect windows, the plugin may be connected but not yet
         # ready to process execute commands on the Unity main thread (which can be further delayed when
@@ -449,8 +503,14 @@ class PluginHub(WebSocketEndpoint):
         # register_tools (which can be delayed by EditorApplication.delayCall).
         if command_type in cls._FAST_FAIL_COMMANDS and command_type != "ping":
             try:
-                max_wait_s = float(os.environ.get("UNITY_MCP_SESSION_READY_WAIT_SECONDS", "6"))
-            except Exception:
+                max_wait_s = float(os.environ.get(
+                    "UNITY_MCP_SESSION_READY_WAIT_SECONDS", "6"))
+            except ValueError as e:
+                raw_val = os.environ.get(
+                    "UNITY_MCP_SESSION_READY_WAIT_SECONDS", "6")
+                logger.warning(
+                    "Invalid UNITY_MCP_SESSION_READY_WAIT_SECONDS=%r, using default 6.0: %s",
+                    raw_val, e)
                 max_wait_s = 6.0
             max_wait_s = max(0.0, min(max_wait_s, 30.0))
             if max_wait_s > 0:
@@ -463,7 +523,8 @@ class PluginHub(WebSocketEndpoint):
 
                     # The Unity-side dispatcher responds with {status:"success", result:{message:"pong"}}
                     if isinstance(probe, dict) and probe.get("status") == "success":
-                        result = probe.get("result") if isinstance(probe.get("result"), dict) else {}
+                        result = probe.get("result") if isinstance(
+                            probe.get("result"), dict) else {}
                         if result.get("message") == "pong":
                             break
                     await asyncio.sleep(0.1)

transport/unity_instance_middleware.py

@@ -27,7 +27,7 @@ def get_unity_instance_middleware() -> 'UnityInstanceMiddleware':
             if _unity_instance_middleware is None:
                 # Auto-initialize if not set (lazy singleton) to handle import order or test cases
                 _unity_instance_middleware = UnityInstanceMiddleware()
-        
+
     return _unity_instance_middleware
 
 
@@ -102,7 +102,8 @@ class UnityInstanceMiddleware(Middleware):
                     sessions = sessions_data.sessions or {}
                     ids: list[str] = []
                     for session_info in sessions.values():
-                        project = getattr(session_info, "project", None) or "Unknown"
+                        project = getattr(
+                            session_info, "project", None) or "Unknown"
                         hash_value = getattr(session_info, "hash", None)
                         if hash_value:
                             ids.append(f"{project}@{hash_value}")
@@ -183,7 +184,7 @@ class UnityInstanceMiddleware(Middleware):
             # But for stdio transport (no PluginHub needed or maybe partially configured),
             # we should be careful not to clear instance just because PluginHub can't resolve it.
             # The 'active_instance' (Name@hash) might be valid for stdio even if PluginHub fails.
-            
+
             session_id: str | None = None
             # Only validate via PluginHub if we are actually using HTTP transport
             # OR if we want to support hybrid mode. For now, let's be permissive.

transport/unity_transport.py

@@ -105,7 +105,8 @@ async def send_with_unity_instance(
             # Fail fast with a retry hint instead of hanging for COMMAND_TIMEOUT.
             # The client can decide whether retrying is appropriate for the command.
             return normalize_unity_response(
-                MCPResponse(success=False, error=err, hint="retry").model_dump()
+                MCPResponse(success=False, error=err,
+                            hint="retry").model_dump()
             )
 
     if unity_instance:

utils/focus_nudge.py

@@ -0,0 +1,321 @@
+"""
+Focus nudge utility for handling OS-level throttling of background Unity.
+
+When Unity is unfocused, the OS (especially macOS App Nap) can heavily throttle
+the process, causing PlayMode tests to stall. This utility temporarily brings
+Unity to focus, allows it to process, then returns focus to the original app.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import platform
+import shutil
+import subprocess
+import time
+
+logger = logging.getLogger(__name__)
+
+# Minimum seconds between nudges to avoid focus thrashing
+_MIN_NUDGE_INTERVAL_S = 5.0
+_last_nudge_time: float = 0.0
+
+
+def _is_available() -> bool:
+    """Check if focus nudging is available on this platform."""
+    system = platform.system()
+    if system == "Darwin":
+        return shutil.which("osascript") is not None
+    elif system == "Windows":
+        # PowerShell is typically available on Windows
+        return shutil.which("powershell") is not None
+    elif system == "Linux":
+        return shutil.which("xdotool") is not None
+    return False
+
+
+def _get_frontmost_app_macos() -> str | None:
+    """Get the name of the frontmost application on macOS."""
+    try:
+        result = subprocess.run(
+            [
+                "osascript", "-e",
+                'tell application "System Events" to get name of first process whose frontmost is true'
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception as e:
+        logger.debug(f"Failed to get frontmost app: {e}")
+    return None
+
+
+def _focus_app_macos(app_name: str) -> bool:
+    """Focus an application by name on macOS."""
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", f'tell application "{app_name}" to activate'],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        logger.debug(f"Failed to focus app {app_name}: {e}")
+    return False
+
+
+def _get_frontmost_app_windows() -> str | None:
+    """Get the title of the frontmost window on Windows."""
+    try:
+        # PowerShell command to get active window title
+        script = '''
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32 {
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")]
+    public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
+}
+"@
+$hwnd = [Win32]::GetForegroundWindow()
+$sb = New-Object System.Text.StringBuilder 256
+[Win32]::GetWindowText($hwnd, $sb, 256)
+$sb.ToString()
+'''
+        result = subprocess.run(
+            ["powershell", "-Command", script],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception as e:
+        logger.debug(f"Failed to get frontmost window: {e}")
+    return None
+
+
+def _focus_app_windows(window_title: str) -> bool:
+    """Focus a window by title on Windows. For Unity, uses Unity Editor pattern."""
+    try:
+        # For Unity, we use a pattern match since the title varies
+        if window_title == "Unity":
+            script = '''
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32 {
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll")]
+    public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+}
+"@
+$unity = Get-Process | Where-Object {$_.MainWindowTitle -like "*Unity*"} | Select-Object -First 1
+if ($unity) {
+    [Win32]::ShowWindow($unity.MainWindowHandle, 9)
+    [Win32]::SetForegroundWindow($unity.MainWindowHandle)
+}
+'''
+        else:
+            # Try to find window by title - escape special PowerShell characters
+            safe_title = window_title.replace("'", "''").replace("`", "``")
+            script = f'''
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32 {{
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll")]
+    public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+}}
+"@
+$proc = Get-Process | Where-Object {{$_.MainWindowTitle -eq '{safe_title}'}} | Select-Object -First 1
+if ($proc) {{
+    [Win32]::ShowWindow($proc.MainWindowHandle, 9)
+    [Win32]::SetForegroundWindow($proc.MainWindowHandle)
+}}
+'''
+        result = subprocess.run(
+            ["powershell", "-Command", script],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        logger.debug(f"Failed to focus window {window_title}: {e}")
+    return False
+
+
+def _get_frontmost_app_linux() -> str | None:
+    """Get the window ID of the frontmost window on Linux."""
+    try:
+        result = subprocess.run(
+            ["xdotool", "getactivewindow"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception as e:
+        logger.debug(f"Failed to get active window: {e}")
+    return None
+
+
+def _focus_app_linux(window_id: str) -> bool:
+    """Focus a window by ID on Linux, or Unity by name."""
+    try:
+        if window_id == "Unity":
+            # Find Unity window by name pattern
+            result = subprocess.run(
+                ["xdotool", "search", "--name", "Unity"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                window_id = result.stdout.strip().split("\n")[0]
+            else:
+                return False
+
+        result = subprocess.run(
+            ["xdotool", "windowactivate", window_id],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        logger.debug(f"Failed to focus window {window_id}: {e}")
+    return False
+
+
+def _get_frontmost_app() -> str | None:
+    """Get the frontmost application/window (platform-specific)."""
+    system = platform.system()
+    if system == "Darwin":
+        return _get_frontmost_app_macos()
+    elif system == "Windows":
+        return _get_frontmost_app_windows()
+    elif system == "Linux":
+        return _get_frontmost_app_linux()
+    return None
+
+
+def _focus_app(app_or_window: str) -> bool:
+    """Focus an application/window (platform-specific)."""
+    system = platform.system()
+    if system == "Darwin":
+        return _focus_app_macos(app_or_window)
+    elif system == "Windows":
+        return _focus_app_windows(app_or_window)
+    elif system == "Linux":
+        return _focus_app_linux(app_or_window)
+    return False
+
+
+async def nudge_unity_focus(
+    focus_duration_s: float = 0.5,
+    force: bool = False,
+) -> bool:
+    """
+    Temporarily focus Unity to allow it to process, then return focus.
+
+    Args:
+        focus_duration_s: How long to keep Unity focused (seconds)
+        force: If True, ignore the minimum interval between nudges
+
+    Returns:
+        True if nudge was performed, False if skipped or failed
+    """
+    global _last_nudge_time
+
+    if not _is_available():
+        logger.debug("Focus nudging not available on this platform")
+        return False
+
+    # Rate limit nudges
+    now = time.monotonic()
+    if not force and (now - _last_nudge_time) < _MIN_NUDGE_INTERVAL_S:
+        logger.info("Skipping nudge - too soon since last nudge")
+        return False
+
+    # Get current frontmost app
+    original_app = _get_frontmost_app()
+    if original_app is None:
+        logger.debug("Could not determine frontmost app")
+        return False
+
+    # Check if Unity is already focused (no nudge needed)
+    if "Unity" in original_app:
+        logger.debug("Unity already focused, no nudge needed")
+        return False
+
+    logger.info(f"Nudging Unity focus (will return to {original_app})")
+    _last_nudge_time = now
+
+    # Focus Unity
+    if not _focus_app("Unity"):
+        logger.warning("Failed to focus Unity")
+        return False
+
+    # Wait for Unity to process
+    await asyncio.sleep(focus_duration_s)
+
+    # Return focus to original app
+    if original_app and original_app != "Unity":
+        if _focus_app(original_app):
+            logger.info(f"Returned focus to {original_app}")
+        else:
+            logger.warning(f"Failed to return focus to {original_app}")
+
+    return True
+
+
+def should_nudge(
+    status: str,
+    editor_is_focused: bool,
+    last_update_unix_ms: int | None,
+    current_time_ms: int | None = None,
+    stall_threshold_ms: int = 10_000,
+) -> bool:
+    """
+    Determine if we should nudge Unity based on test job state.
+
+    Args:
+        status: Job status ("running", "succeeded", "failed")
+        editor_is_focused: Whether Unity reports being focused
+        last_update_unix_ms: Last time the job was updated (Unix ms)
+        current_time_ms: Current time (Unix ms), or None to use current time
+        stall_threshold_ms: How long without updates before considering it stalled
+
+    Returns:
+        True if conditions suggest a nudge would help
+    """
+    # Only nudge running jobs
+    if status != "running":
+        return False
+
+    # Only nudge unfocused Unity
+    if editor_is_focused:
+        return False
+
+    # Check if job appears stalled
+    if last_update_unix_ms is None:
+        return True  # No updates yet, might be stuck at start
+
+    if current_time_ms is None:
+        current_time_ms = int(time.time() * 1000)
+
+    time_since_update_ms = current_time_ms - last_update_unix_ms
+    return time_since_update_ms > stall_threshold_ms

mcpforunityserver-8.7.0.dist-info/RECORD

@@ -1,71 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-main.py,sha256=ITxelXUAmr9BoasG0knZifXKp3lWJyml_RLaIwvEyVs,19184
-core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-core/config.py,sha256=czkTtNji1crQcQbUvmdx4OL7f-RBqkVhj_PtHh-w7rs,1623
-core/logging_decorator.py,sha256=D9CD7rFvQz-MBG-G4inizQj0Ivr6dfc9RBmTrw7q8mI,1383
-core/telemetry.py,sha256=eHjYgzd8f7eTwSwF2Kbi8D4TtJIcdaDjKLeo1c-0hVA,19829
-core/telemetry_decorator.py,sha256=ycSTrzVNCDQHSd-xmIWOpVfKFURPxpiZe_XkOQAGDAo,6705
-mcpforunityserver-8.7.0.dist-info/licenses/LICENSE,sha256=bv5lDJZQEqxBgjjc1rkRbkEwpSIHF-8N-1Od0VnEJFw,1066
-models/__init__.py,sha256=JlscZkGWE9TRmSoBi99v_LSl8OAFNGmr8463PYkXin4,179
-models/models.py,sha256=heXuvdBtdats1SGwW8wKFFHM0qR4hA6A7qETn5s9BZ0,1827
-models/unity_response.py,sha256=oJ1PTsnNc5VBC-9OgM59C0C-R9N-GdmEdmz_yph4GSU,1454
-routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-services/custom_tool_service.py,sha256=ZOb6LsOQc3C9n3iLn5b7QaG3WJ25M-Id3WG_iE1YhMY,11960
-services/registry/__init__.py,sha256=QCwcYThvGF0kBt3WR6DBskdyxkegJC7NymEChgJA-YM,470
-services/registry/resource_registry.py,sha256=T_Kznqgvt5kKgV7mU85nb0LlFuB4rg-Tm4Cjhxt-IcI,1467
-services/registry/tool_registry.py,sha256=9tMwOP07JE92QFYUS4KvoysO0qC9pkBD5B79kjRsSPw,1304
-services/resources/__init__.py,sha256=O5heeMcgCswnQX1qG2nNtMeAZIaLut734qD7t5UsA0k,2801
-services/resources/active_tool.py,sha256=YTbsiy_hmnKH2q7IoM7oYD7pJkoveZTszRiL1PlhO9M,1474
-services/resources/custom_tools.py,sha256=8lyryGhN3vD2LwMt6ZyKIp5ONtxdI1nfcCAlYjlfQnQ,1704
-services/resources/editor_state.py,sha256=8hrNnskSFdsvdKagAYEeZGJ0Oz9QRlkWJjpM4q0XeNo,2013
-services/resources/editor_state_v2.py,sha256=zgss1EEhJo7oZeHnjOXsdJPuFQsHLwpsZmzcDy3ybq0,10874
-services/resources/layers.py,sha256=q4UQ5PUVUVhmM5l3oXID1wa_wOWAS8l5BGXadBgFuwY,1080
-services/resources/menu_items.py,sha256=9SNycjwTXoeS1ZHra0Y1fTyCjSEdPCo34JyxtuqauG8,1021
-services/resources/prefab_stage.py,sha256=C3mn3UapKYVOA8QUNmLsYreG5YiXdlvGm9ypHQeKBeQ,1382
-services/resources/project_info.py,sha256=gSVSFfwP0u2FmxSowOkdbNoSSQHxfQtLfndvoCXTVSw,1323
-services/resources/selection.py,sha256=4rI5Bdkes4uxtMc_5jQhUaqUl-iprhIiTWqnOJl8tmg,1839
-services/resources/tags.py,sha256=7EhmQjMotz85DSSr7cVKYIy7LPT5mmPfrEySr1mTE6w,1049
-services/resources/tests.py,sha256=xDvvgesPSU93nLD_ERQopOpkpq69pbMEqmFsJd0jekI,2063
-services/resources/unity_instances.py,sha256=fR0cVopGQnmF41IFDycwlo2XniKstfJWLGobgJeiabE,4348
-services/resources/windows.py,sha256=--QVsb0oyoBpSjK2D4kPcZFSe2zdR-t_KSHP-e2QNoY,1427
-services/state/external_changes_scanner.py,sha256=qwdiriHR1D11aPiLUbpS7COXtfVOjNj9DpzcSDK067o,9042
-services/tools/__init__.py,sha256=3Qav7fAowZ1_TbDRdZQQQES53gv2lTs-2D7PGECnlbM,2353
-services/tools/batch_execute.py,sha256=_ByjffeXQB9j64mcjaxJmrnbSJrMn0f9_6Zh9BBI_2c,2898
-services/tools/debug_request_context.py,sha256=WQBtQdXSH5stw2MAwIM32H6jGwUVQOgU2r35VUWLlYo,2765
-services/tools/execute_custom_tool.py,sha256=K2qaO4-FTPz0_3j53hhDP9idjC002ugc8C03FtHGTbY,1376
-services/tools/execute_menu_item.py,sha256=FAC-1v_TwOcy6GSxkogDsVxeRtdap0DsPlIngf8uJdU,1184
-services/tools/find_in_file.py,sha256=xp80lqRN2cdZc3XGJWlCpeQEy6WnwyKOj2l5WiHNx0Q,6379
-services/tools/manage_asset.py,sha256=6YjWOl2b58vRwjp-9XbQE9e1l3ajhGookVY8ncQN0wo,7877
-services/tools/manage_editor.py,sha256=_HZRT-_hBakH0g6p7BpxTv3gWpxsaV6KNGRol-qknwo,3243
-services/tools/manage_gameobject.py,sha256=OgFIsoPGiWHOj6-d3Lmtp3xlAW9Tr0c38tV4atAaFAU,14400
-services/tools/manage_material.py,sha256=wZB2H4orhL6wG9TTnmnk-Lj2Gj_zvg7koxW3t319BLU,3545
-services/tools/manage_prefabs.py,sha256=73XzznjFNOm1SazW_Y7l6uGIE7wosMpAIVQs8xpvK9A,3037
-services/tools/manage_scene.py,sha256=oJ1qDX0T06mINZ1hX2AcDp3ItHo-oUz7Uck0yujI9eA,4834
-services/tools/manage_script.py,sha256=lPA5HcS4Al0RiQVz-S6qahFTcPqsk3GSLLXJWHri8P4,27557
-services/tools/manage_scriptable_object.py,sha256=Oi03CJLgepaWR59V-nJiAjnCC8at4YqFhRGpACruqgw,3150
-services/tools/manage_shader.py,sha256=HHnHKh7vLij3p8FAinNsPdZGEKivgwSUTxdgDydfmbs,2882
-services/tools/preflight.py,sha256=VJn61h-9pvoVaCyKL7DTKLfbpoZfNK4fnRmj91c2o8M,4093
-services/tools/read_console.py,sha256=MdQcrnVXra9PLu5AFkmARjriObT0miExtQKkFaANznU,4662
-services/tools/refresh_unity.py,sha256=anTEuEzxKTFse6ldZxTsk43zI6ahRBDv3Sg_pMHYRYA,3719
-services/tools/run_tests.py,sha256=8CqmgRN6Bata666ytF_S9no4gaFmHCmeZM82ZwNQJ68,4666
-services/tools/script_apply_edits.py,sha256=qPm_PsmsK3mYXnziX_btyk8CaB66LTqpDFA2Y4ebZ4U,47504
-services/tools/set_active_instance.py,sha256=B18Y8Jga0pKsx9mFywXr1tWfy0cJVopIMXYO-UJ1jOU,4136
-services/tools/test_jobs.py,sha256=K6HjkzWPjJNldrp-Vq5gPH7oBkCq_sJZYXkK_Vg6I_I,4059
-services/tools/utils.py,sha256=4ZgfIu178eXZqRyzs8X77B5lKLP1f73OZoGBSDNokJ4,2409
-transport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-transport/models.py,sha256=6wp7wsmSaeeJEvUGXPF1m6zuJnxJ1NJlCC4YZ9oQIq0,1226
-transport/plugin_hub.py,sha256=g_DOhCThgJ9Oco_z3m2qpwDeUcFvvt7Z47xMS0diihw,21497
-transport/plugin_registry.py,sha256=nW-7O7PN0QUgSWivZTkpAVKKq9ZOe2b2yeIdpaNt_3I,4359
-transport/unity_instance_middleware.py,sha256=kf1QeA138r7PaC98dcMDYtUPGWZ4EUmZGESc2DdiWQs,10429
-transport/unity_transport.py,sha256=_cFVgD3pzFZRcDXANq4oPFYSoI6jntSGaN22dJC8LRU,3880
-transport/legacy/port_discovery.py,sha256=qM_mtndbYjAj4qPSZEWVeXFOt5_nKczG9pQqORXTBJ0,12768
-transport/legacy/stdio_port_registry.py,sha256=j4iARuP6wetppNDG8qKeuvo1bJKcSlgEhZvSyl_uf0A,2313
-transport/legacy/unity_connection.py,sha256=ujUX9WX7Gb-fxQveHts3uiepTPzFq8i7-XG7u5gSPuM,32668
-utils/module_discovery.py,sha256=My48ofB1BUqxiBoAZAGbEaLQYdsrDhMm8MayBP_bUSQ,2005
-utils/reload_sentinel.py,sha256=s1xMWhl-r2XwN0OUbiUv_VGUy8TvLtV5bkql-5n2DT0,373
-mcpforunityserver-8.7.0.dist-info/METADATA,sha256=m3U2_aFTIAFPWg8YE3v2KcMJmP-Ffz0R-EJsJwoD6pA,5712
-mcpforunityserver-8.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpforunityserver-8.7.0.dist-info/entry_points.txt,sha256=vCtkqw-J9t4pj7JwUZcB54_keVx7DpAR3fYzK6i-s6g,44
-mcpforunityserver-8.7.0.dist-info/top_level.txt,sha256=YKU5e5dREMfCnoVpmlsTm9bku7oqnrzSZ9FeTgjoxJw,58
-mcpforunityserver-8.7.0.dist-info/RECORD,,