Update mirror backend with latest code

Author: msanatan

Server/port_discovery.py

@@ -16,7 +16,7 @@
 import logging
 import os
 import struct
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 import socket
 from typing import Optional, List, Dict
@@ -238,7 +238,7 @@ def discover_all_unity_instances() -> List[UnityInstanceInfo]:
         for status_file_path in status_files:
             try:
                 status_path = Path(status_file_path)
-                file_mtime = datetime.fromtimestamp(status_path.stat().st_mtime, tz=timezone.utc)
+                file_mtime = datetime.fromtimestamp(status_path.stat().st_mtime)
 
                 with status_path.open('r') as f:
                     data = json.load(f)
@@ -258,12 +258,7 @@ def discover_all_unity_instances() -> List[UnityInstanceInfo]:
                 heartbeat_str = data.get('last_heartbeat')
                 if heartbeat_str:
                     try:
-                        parsed = datetime.fromisoformat(heartbeat_str.replace('Z', '+00:00'))
-                        # Normalize to UTC for consistent comparison
-                        if parsed.tzinfo is None:
-                            last_heartbeat = parsed.replace(tzinfo=timezone.utc)
-                        else:
-                            last_heartbeat = parsed.astimezone(timezone.utc)
+                        last_heartbeat = datetime.fromisoformat(heartbeat_str.replace('Z', '+00:00'))
                     except Exception:
                         pass
 

Server/pyproject.toml

@@ -35,6 +35,7 @@ py-modules = [
     "server",
     "telemetry",
     "telemetry_decorator",
-    "unity_connection"
+    "unity_connection",
+    "unity_instance_middleware"
 ]
-packages = ["tools", "resources", "registry"]
+packages = ["tools", "resources", "registry"]

Server/resources/__init__.py

@@ -49,7 +49,6 @@ def register_all_resources(mcp: FastMCP):
         has_query_params = '{?' in uri
 
         if has_query_params:
-            # Register template with query parameter support
             wrapped_template = telemetry_resource(resource_name)(func)
             wrapped_template = mcp.resource(
                 uri=uri,
@@ -61,7 +60,6 @@ def register_all_resources(mcp: FastMCP):
             registered_count += 1
             resource_info['func'] = wrapped_template
         else:
-            # No query parameters, register as-is
             wrapped = telemetry_resource(resource_name)(func)
             wrapped = mcp.resource(
                 uri=uri,

Server/resources/active_tool.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class Vector3(BaseModel):
+    """3D vector."""
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+
+class ActiveToolData(BaseModel):
+    """Active tool data fields."""
+    activeTool: str = ""
+    isCustom: bool = False
+    pivotMode: str = ""
+    pivotRotation: str = ""
+    handleRotation: Vector3 = Vector3()
+    handlePosition: Vector3 = Vector3()
+
+
+class ActiveToolResponse(MCPResponse):
+    """Information about the currently active editor tool."""
+    data: ActiveToolData = ActiveToolData()
+
+
+@mcp_for_unity_resource(
+    uri="unity://editor/active-tool",
+    name="editor_active_tool",
+    description="Currently active editor tool (Move, Rotate, Scale, etc.) and transform handle settings."
+)
+async def get_active_tool(ctx: Context) -> ActiveToolResponse | MCPResponse:
+    """Get active editor tool information."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_active_tool",
+        {}
+    )
+    return ActiveToolResponse(**response) if isinstance(response, dict) else response

Server/resources/editor_state.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class EditorStateData(BaseModel):
+    """Editor state data fields."""
+    isPlaying: bool = False
+    isPaused: bool = False
+    isCompiling: bool = False
+    isUpdating: bool = False
+    timeSinceStartup: float = 0.0
+    activeSceneName: str = ""
+    selectionCount: int = 0
+    activeObjectName: str | None = None
+
+
+class EditorStateResponse(MCPResponse):
+    """Dynamic editor state information that changes frequently."""
+    data: EditorStateData = EditorStateData()
+
+
+@mcp_for_unity_resource(
+    uri="unity://editor/state",
+    name="editor_state",
+    description="Current editor runtime state including play mode, compilation status, active scene, and selection summary. Refresh frequently for up-to-date information."
+)
+async def get_editor_state(ctx: Context) -> EditorStateResponse | MCPResponse:
+    """Get current editor runtime state."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_editor_state",
+        {}
+    )
+    return EditorStateResponse(**response) if isinstance(response, dict) else response

Server/resources/layers.py

@@ -0,0 +1,28 @@
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class LayersResponse(MCPResponse):
+    """Dictionary of layer indices to layer names."""
+    data: dict[int, str] = {}
+
+
+@mcp_for_unity_resource(
+    uri="unity://project/layers",
+    name="project_layers",
+    description="All layers defined in the project's TagManager with their indices (0-31). Read this before using add_layer or remove_layer tools."
+)
+async def get_layers(ctx: Context) -> LayersResponse | MCPResponse:
+    """Get all project layers with their indices."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_layers",
+        {}
+    )
+    return LayersResponse(**response) if isinstance(response, dict) else response

Server/resources/menu_items.py

@@ -12,10 +12,10 @@ class GetMenuItemsResponse(MCPResponse):
 
 @mcp_for_unity_resource(
     uri="mcpforunity://menu-items",
-    name="get_menu_items",
+    name="menu_items",
     description="Provides a list of all menu items."
 )
-async def get_menu_items(ctx: Context) -> GetMenuItemsResponse:
+async def get_menu_items(ctx: Context) -> GetMenuItemsResponse | MCPResponse:
     """Provides a list of all menu items.
     """
     unity_instance = get_unity_instance_from_context(ctx)

Server/resources/prefab_stage.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class PrefabStageData(BaseModel):
+    """Prefab stage data fields."""
+    isOpen: bool = False
+    assetPath: str | None = None
+    prefabRootName: str | None = None
+    mode: str | None = None
+    isDirty: bool = False
+
+
+class PrefabStageResponse(MCPResponse):
+    """Information about the current prefab editing context."""
+    data: PrefabStageData = PrefabStageData()
+
+
+@mcp_for_unity_resource(
+    uri="unity://editor/prefab-stage",
+    name="editor_prefab_stage",
+    description="Current prefab editing context if a prefab is open in isolation mode. Returns isOpen=false if no prefab is being edited."
+)
+async def get_prefab_stage(ctx: Context) -> PrefabStageResponse | MCPResponse:
+    """Get current prefab stage information."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_prefab_stage",
+        {}
+    )
+    return PrefabStageResponse(**response) if isinstance(response, dict) else response

Server/resources/project_info.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class ProjectInfoData(BaseModel):
+    """Project info data fields."""
+    projectRoot: str = ""
+    projectName: str = ""
+    unityVersion: str = ""
+    platform: str = ""
+    assetsPath: str = ""
+
+
+class ProjectInfoResponse(MCPResponse):
+    """Static project configuration information."""
+    data: ProjectInfoData = ProjectInfoData()
+
+
+@mcp_for_unity_resource(
+    uri="unity://project/info",
+    name="project_info",
+    description="Static project information including root path, Unity version, and platform. This data rarely changes."
+)
+async def get_project_info(ctx: Context) -> ProjectInfoResponse | MCPResponse:
+    """Get static project configuration information."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_project_info",
+        {}
+    )
+    return ProjectInfoResponse(**response) if isinstance(response, dict) else response

Server/resources/selection.py

@@ -0,0 +1,54 @@
+from pydantic import BaseModel
+from fastmcp import Context
+
+from models import MCPResponse
+from registry import mcp_for_unity_resource
+from tools import get_unity_instance_from_context, async_send_with_unity_instance
+from unity_connection import async_send_command_with_retry
+
+
+class SelectionObjectInfo(BaseModel):
+    """Information about a selected object."""
+    name: str | None = None
+    type: str | None = None
+    instanceID: int | None = None
+
+
+class SelectionGameObjectInfo(BaseModel):
+    """Information about a selected GameObject."""
+    name: str | None = None
+    instanceID: int | None = None
+
+
+class SelectionData(BaseModel):
+    """Selection data fields."""
+    activeObject: str | None = None
+    activeGameObject: str | None = None
+    activeTransform: str | None = None
+    activeInstanceID: int = 0
+    count: int = 0
+    objects: list[SelectionObjectInfo] = []
+    gameObjects: list[SelectionGameObjectInfo] = []
+    assetGUIDs: list[str] = []
+
+
+class SelectionResponse(MCPResponse):
+    """Detailed information about the current editor selection."""
+    data: SelectionData = SelectionData()
+
+
+@mcp_for_unity_resource(
+    uri="unity://editor/selection",
+    name="editor_selection",
+    description="Detailed information about currently selected objects in the editor, including GameObjects, assets, and their properties."
+)
+async def get_selection(ctx: Context) -> SelectionResponse | MCPResponse:
+    """Get detailed editor selection information."""
+    unity_instance = get_unity_instance_from_context(ctx)
+    response = await async_send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "get_selection",
+        {}
+    )
+    return SelectionResponse(**response) if isinstance(response, dict) else response