mcpforunityserver 9.0.2__py3-none-any.whl → 9.0.7__py3-none-any.whl

{mcpforunityserver-9.0.2.dist-info → mcpforunityserver-9.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpforunityserver
-Version: 9.0.2
+Version: 9.0.7
 Summary: MCP for Unity Server: A Unity package for Unity Editor integration via the Model Context Protocol (MCP).
 Author-email: Marcus Sanatan <msanatan@gmail.com>, David Sarno <david.sarno@gmail.com>, Wu Shutong <martinwfire@gmail.com>
 License-Expression: MIT
@@ -35,6 +35,7 @@ Requires-Dist: uvicorn>=0.35.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
 Dynamic: license-file
 
 # MCP for Unity Server
@@ -108,7 +109,7 @@ Use this to run the latest released version from the repository. Change the vers
       "command": "uvx",
       "args": [
         "--from",
-        "git+https://github.com/CoplayDev/unity-mcp@v9.0.2#subdirectory=Server",
+        "git+https://github.com/CoplayDev/unity-mcp@v9.0.7#subdirectory=Server",
         "mcp-for-unity",
         "--transport",
         "stdio"

{mcpforunityserver-9.0.2.dist-info → mcpforunityserver-9.0.7.dist-info}/RECORD

@@ -5,7 +5,7 @@ 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-9.0.2.dist-info/licenses/LICENSE,sha256=bv5lDJZQEqxBgjjc1rkRbkEwpSIHF-8N-1Od0VnEJFw,1066
+mcpforunityserver-9.0.7.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
@@ -49,8 +49,8 @@ services/tools/manage_shader.py,sha256=bucRKzQww7opy6DK5nf6isVaEECWWqJ-DVkFulp8C
 services/tools/manage_vfx.py,sha256=eeqf4xUYw_yT2rALIGHrHLJCpemx9H__S3zCjj_GZsI,34054
 services/tools/preflight.py,sha256=0nvo0BmZMdIGop1Ha_vypkjn2VLiRvskF0uxh_SlZgE,4162
 services/tools/read_console.py,sha256=k1brS1yR-wyMgdhL6TPL-j4KJCD0CKSWrHYiTh-gj9Y,5452
-services/tools/refresh_unity.py,sha256=IcShwasfveDGxXQ3YdbaQP3ICCt8e8O_q_NsnDa8glw,4054
-services/tools/run_tests.py,sha256=9M9noRsZWjqcCfUWo5XVVtGNggxg5HpPvmkobs2lu-A,8082
+services/tools/refresh_unity.py,sha256=ksLcYkLK_es871MsyZSvE8XKUZBP09X2xaD8Qw949a8,4152
+services/tools/run_tests.py,sha256=wg8Ke8vpKHxyz0kqFaJC5feXTL3e6Cxzi0QKNitLDRE,9176
 services/tools/script_apply_edits.py,sha256=0f-SaP5NUYGuivl4CWHjR8F-CXUpt3-5qkHpf_edn1U,47677
 services/tools/set_active_instance.py,sha256=pdmC1SxFijyzzjeEyC2N1bXk-GNMu_iXsbCieIpa-R4,4242
 services/tools/utils.py,sha256=uk--6w_-O0eVAxczackXbgKde2ONmsgci43G3wY7dfA,4258
@@ -63,10 +63,11 @@ transport/unity_transport.py,sha256=G6aMC1qR31YZOBZs4fxQbSQBHuXBP1d5Qn0MJaB3yGs,
 transport/legacy/port_discovery.py,sha256=JDSCqXLodfTT7fOsE0DFC1jJ3QsU6hVaYQb7x7FgdxY,12728
 transport/legacy/stdio_port_registry.py,sha256=j4iARuP6wetppNDG8qKeuvo1bJKcSlgEhZvSyl_uf0A,2313
 transport/legacy/unity_connection.py,sha256=UZ6tztBO9VlXNiV0jN66k5QMrtTIGAOdGxwtcLnkXLU,35808
+utils/focus_nudge.py,sha256=HaTOSI7wzDmdRviodUHx2oQFPIL_jSwubai3YkDJbH0,9910
 utils/module_discovery.py,sha256=My48ofB1BUqxiBoAZAGbEaLQYdsrDhMm8MayBP_bUSQ,2005
 utils/reload_sentinel.py,sha256=s1xMWhl-r2XwN0OUbiUv_VGUy8TvLtV5bkql-5n2DT0,373
-mcpforunityserver-9.0.2.dist-info/METADATA,sha256=SBjpanrzyKviifHD6RPkbJWT5bCf6Ee5i6fi4uutWZU,5712
-mcpforunityserver-9.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpforunityserver-9.0.2.dist-info/entry_points.txt,sha256=vCtkqw-J9t4pj7JwUZcB54_keVx7DpAR3fYzK6i-s6g,44
-mcpforunityserver-9.0.2.dist-info/top_level.txt,sha256=UYGWDnyTlnS7PnuZNw8-gM_jWcdmcHwffK_2yBRl6Cc,51
-mcpforunityserver-9.0.2.dist-info/RECORD,,
+mcpforunityserver-9.0.7.dist-info/METADATA,sha256=rgfRwWOoUSBsEeHS3CUCeOtvEuaQq91I8dRSxppYk5o,5761
+mcpforunityserver-9.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcpforunityserver-9.0.7.dist-info/entry_points.txt,sha256=vCtkqw-J9t4pj7JwUZcB54_keVx7DpAR3fYzK6i-s6g,44
+mcpforunityserver-9.0.7.dist-info/top_level.txt,sha256=UYGWDnyTlnS7PnuZNw8-gM_jWcdmcHwffK_2yBRl6Cc,51
+mcpforunityserver-9.0.7.dist-info/RECORD,,

services/tools/refresh_unity.py

@@ -55,10 +55,13 @@ async def refresh_unity(
     # interpret that as a hard failure (#503-style loops).
     if isinstance(response, dict) and not response.get("success", True):
         hint = response.get("hint")
-        err = (response.get("error") or response.get("message") or "")
+        err = (response.get("error") or response.get("message") or "").lower()
         reason = _extract_response_reason(response)
-        is_retryable = (hint == "retry") or (
-            "disconnected" in str(err).lower())
+        is_retryable = (
+            hint == "retry"
+            or "disconnected" in err
+            or "could not connect" in err  # Connection failed during domain reload
+        )
         if (not wait_for_ready) or (not is_retryable):
             return MCPResponse(**response)
         if reason not in {"reloading", "no_unity_session"}:

services/tools/run_tests.py

@@ -2,6 +2,8 @@
 from __future__ import annotations
 
 import asyncio
+import logging
+import time
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
@@ -14,6 +16,9 @@ from services.tools import get_unity_instance_from_context
 from services.tools.preflight import preflight
 import transport.unity_transport as unity_transport
 from transport.legacy.unity_connection import async_send_command_with_retry
+from utils.focus_nudge import nudge_unity_focus, should_nudge
+
+logger = logging.getLogger(__name__)
 
 
 class RunTestsSummary(BaseModel):
@@ -195,28 +200,48 @@ async def get_test_job(
     if wait_timeout and wait_timeout > 0:
         deadline = asyncio.get_event_loop().time() + wait_timeout
         poll_interval = 2.0  # Poll Unity every 2 seconds
-        
+
         while True:
             response = await _fetch_status()
-            
+
             if not isinstance(response, dict):
                 return MCPResponse(success=False, error=str(response))
-            
+
             if not response.get("success", True):
                 return MCPResponse(**response)
-            
+
             # Check if tests are done
             data = response.get("data", {})
             status = data.get("status", "")
             if status in ("succeeded", "failed", "cancelled"):
                 return GetTestJobResponse(**response)
-            
+
+            # Check if Unity needs a focus nudge to make progress
+            # This handles OS-level throttling (e.g., macOS App Nap) that can
+            # stall PlayMode tests when Unity is in the background.
+            progress = data.get("progress", {})
+            editor_is_focused = progress.get("editor_is_focused", True)
+            last_update_unix_ms = data.get("last_update_unix_ms")
+            current_time_ms = int(time.time() * 1000)
+
+            if should_nudge(
+                status=status,
+                editor_is_focused=editor_is_focused,
+                last_update_unix_ms=last_update_unix_ms,
+                current_time_ms=current_time_ms,
+                stall_threshold_ms=10_000,  # 10 seconds without progress
+            ):
+                logger.info(f"Test job {job_id} appears stalled (unfocused Unity), attempting nudge...")
+                nudged = await nudge_unity_focus(focus_duration_s=0.5)
+                if nudged:
+                    logger.info(f"Test job {job_id} nudge completed")
+
             # Check timeout
             remaining = deadline - asyncio.get_event_loop().time()
             if remaining <= 0:
                 # Timeout reached, return current status
                 return GetTestJobResponse(**response)
-            
+
             # Wait before next poll (but don't exceed remaining time)
             await asyncio.sleep(min(poll_interval, remaining))
     

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