mcpforunityserver 9.0.2__tar.gz → 9.0.7__tar.gz

{mcpforunityserver-9.0.2 → mcpforunityserver-9.0.7}/PKG-INFO

@@ -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 → mcpforunityserver-9.0.7}/README.md

@@ -69,7 +69,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 → mcpforunityserver-9.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcpforunityserver"
-version = "9.0.2"
+version = "9.0.7"
 description = "MCP for Unity Server: A Unity package for Unity Editor integration via the Model Context Protocol (MCP)."
 readme = "README.md"
 license = "MIT"
@@ -42,6 +42,7 @@ dependencies = [
 dev = [
     "pytest>=8.0.0",
     "pytest-asyncio>=0.23",
+    "pytest-cov>=4.1.0",
 ]
 
 [project.urls]
@@ -54,3 +55,26 @@ mcp-for-unity = "main:main"
 [build-system]
 requires = ["setuptools>=64.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == \"__main__\":",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+precision = 2
+show_missing = true
+
+[tool.coverage.html]
+directory = "htmlcov"

{mcpforunityserver-9.0.2 → mcpforunityserver-9.0.7}/src/mcpforunityserver.egg-info/PKG-INFO

@@ -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 → mcpforunityserver-9.0.7}/src/mcpforunityserver.egg-info/SOURCES.txt

@@ -71,5 +71,6 @@ src/transport/unity_transport.py
 src/transport/legacy/port_discovery.py
 src/transport/legacy/stdio_port_registry.py
 src/transport/legacy/unity_connection.py
+src/utils/focus_nudge.py
 src/utils/module_discovery.py
 src/utils/reload_sentinel.py

{mcpforunityserver-9.0.2 → mcpforunityserver-9.0.7}/src/mcpforunityserver.egg-info/requires.txt

@@ -9,3 +9,4 @@ uvicorn>=0.35.0
 [dev]
 pytest>=8.0.0
 pytest-asyncio>=0.23
+pytest-cov>=4.1.0

{mcpforunityserver-9.0.2 → mcpforunityserver-9.0.7}/src/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"}:

{mcpforunityserver-9.0.2 → mcpforunityserver-9.0.7}/src/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))
     

mcpforunityserver-9.0.7/src/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