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

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
 
 
@@ -83,17 +83,108 @@ class UnityInstanceMiddleware(Middleware):
         with self._lock:
             self._active_by_key.pop(key, None)
 
+    async def _maybe_autoselect_instance(self, ctx) -> str | None:
+        """
+        Auto-select the sole Unity instance when no active instance is set.
+
+        Note: This method both *discovers* and *persists* the selection via
+        `set_active_instance` as a side-effect, since callers expect the selection
+        to stick for subsequent tool/resource calls in the same session.
+        """
+        try:
+            # Import here to avoid circular dependencies / optional transport modules.
+            from transport.unity_transport import _current_transport
+
+            transport = _current_transport()
+            if PluginHub.is_configured():
+                try:
+                    sessions_data = await PluginHub.get_sessions()
+                    sessions = sessions_data.sessions or {}
+                    ids: list[str] = []
+                    for session_info in sessions.values():
+                        project = getattr(
+                            session_info, "project", None) or "Unknown"
+                        hash_value = getattr(session_info, "hash", None)
+                        if hash_value:
+                            ids.append(f"{project}@{hash_value}")
+                    if len(ids) == 1:
+                        chosen = ids[0]
+                        self.set_active_instance(ctx, chosen)
+                        logger.info(
+                            "Auto-selected sole Unity instance via PluginHub: %s",
+                            chosen,
+                        )
+                        return chosen
+                except (ConnectionError, ValueError, KeyError, TimeoutError, AttributeError) as exc:
+                    logger.debug(
+                        "PluginHub auto-select probe failed (%s); falling back to stdio",
+                        type(exc).__name__,
+                        exc_info=True,
+                    )
+                except Exception as exc:
+                    if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                        raise
+                    logger.debug(
+                        "PluginHub auto-select probe failed with unexpected error (%s); falling back to stdio",
+                        type(exc).__name__,
+                        exc_info=True,
+                    )
+
+            if transport != "http":
+                try:
+                    # Import here to avoid circular imports in legacy transport paths.
+                    from transport.legacy.unity_connection import get_unity_connection_pool
+
+                    pool = get_unity_connection_pool()
+                    instances = pool.discover_all_instances(force_refresh=True)
+                    ids = [getattr(inst, "id", None) for inst in instances]
+                    ids = [inst_id for inst_id in ids if inst_id]
+                    if len(ids) == 1:
+                        chosen = ids[0]
+                        self.set_active_instance(ctx, chosen)
+                        logger.info(
+                            "Auto-selected sole Unity instance via stdio discovery: %s",
+                            chosen,
+                        )
+                        return chosen
+                except (ConnectionError, ValueError, KeyError, TimeoutError, AttributeError) as exc:
+                    logger.debug(
+                        "Stdio auto-select probe failed (%s)",
+                        type(exc).__name__,
+                        exc_info=True,
+                    )
+                except Exception as exc:
+                    if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                        raise
+                    logger.debug(
+                        "Stdio auto-select probe failed with unexpected error (%s)",
+                        type(exc).__name__,
+                        exc_info=True,
+                    )
+        except Exception as exc:
+            if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                raise
+            logger.debug(
+                "Auto-select path encountered an unexpected error (%s)",
+                type(exc).__name__,
+                exc_info=True,
+            )
+
+        return None
+
     async def _inject_unity_instance(self, context: MiddlewareContext) -> None:
         """Inject active Unity instance into context if available."""
         ctx = context.fastmcp_context
 
         active_instance = self.get_active_instance(ctx)
+        if not active_instance:
+            active_instance = await self._maybe_autoselect_instance(ctx)
         if active_instance:
             # If using HTTP transport (PluginHub configured), validate session
             # 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

@@ -9,6 +9,7 @@ from typing import Awaitable, Callable, TypeVar
 from fastmcp import Context
 
 from transport.plugin_hub import PluginHub
+from models.models import MCPResponse
 from models.unity_response import normalize_unity_response
 from services.tools import get_unity_instance_from_context
 
@@ -91,12 +92,22 @@ async def send_with_unity_instance(
         if not isinstance(params, dict):
             raise TypeError(
                 "Command parameters must be a dict for HTTP transport")
-        raw = await PluginHub.send_command_for_instance(
-            unity_instance,
-            command_type,
-            params,
-        )
-        return normalize_unity_response(raw)
+        try:
+            raw = await PluginHub.send_command_for_instance(
+                unity_instance,
+                command_type,
+                params,
+            )
+            return normalize_unity_response(raw)
+        except Exception as exc:
+            # NOTE: asyncio.TimeoutError has an empty str() by default, which is confusing for clients.
+            err = str(exc) or f"{type(exc).__name__}"
+            # 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()
+            )
 
     if unity_instance:
         kwargs.setdefault("instance_id", 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.5.0.dist-info/RECORD

@@ -1,66 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-main.py,sha256=OH_Ux5Aj43q1lXPu4AS8zafRnFHZWFYCDZbswReQOac,18011
-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.5.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=acrSyMfdulRgYQIn7wKHqKqyw4uED_oUf9GU-4o4GAg,1497
-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/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=Kpqr82cmXH7wxXub3O0D8whksORSqn9nDRjskDe_A_w,7534
-services/tools/manage_editor.py,sha256=_HZRT-_hBakH0g6p7BpxTv3gWpxsaV6KNGRol-qknwo,3243
-services/tools/manage_gameobject.py,sha256=kYIouvt-iNUEsY0VIWp4FqagLjo7Up2TwKDhB4Nfxmo,14213
-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=3BhIsbbtGiMNqBMQMqEsB4ajYmtx-VwWl-krOkFR_Bw,4648
-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/read_console.py,sha256=gZWEf0Ru0hvN9oJUZqZ4w-mMBBLm5Z5KAUPv282XbYQ,4091
-services/tools/run_tests.py,sha256=LBVwGasLvmF4k1FiX3DdBQ8udh89WZJFiVHfJRWGvOs,3313
-services/tools/script_apply_edits.py,sha256=qPm_PsmsK3mYXnziX_btyk8CaB66LTqpDFA2Y4ebZ4U,47504
-services/tools/set_active_instance.py,sha256=B18Y8Jga0pKsx9mFywXr1tWfy0cJVopIMXYO-UJ1jOU,4136
-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=55R00ohrmUI0mk_smc_8BsYTvrQMPX4wwsvqXprj0Vk,15596
-transport/plugin_registry.py,sha256=nW-7O7PN0QUgSWivZTkpAVKKq9ZOe2b2yeIdpaNt_3I,4359
-transport/unity_instance_middleware.py,sha256=a-ULWU9b86w0CbYN3meyLxWGxTBXL5CQmBKZmmQ0xZQ,6197
-transport/unity_transport.py,sha256=dvwCjo2jRvnFXd8ruOL36C8W4P1VIQ91qreS2750lPM,3307
-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.5.0.dist-info/METADATA,sha256=3YWJc7I-EKxcLzMgG0MweNSJm3QR_VYCNTTwwB45UNE,5712
-mcpforunityserver-8.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpforunityserver-8.5.0.dist-info/entry_points.txt,sha256=vCtkqw-J9t4pj7JwUZcB54_keVx7DpAR3fYzK6i-s6g,44
-mcpforunityserver-8.5.0.dist-info/top_level.txt,sha256=YKU5e5dREMfCnoVpmlsTm9bku7oqnrzSZ9FeTgjoxJw,58
-mcpforunityserver-8.5.0.dist-info/RECORD,,