fix port detection

Author: sakurachan

MCPForUnity/Editor/Helpers/PortManager.cs

@@ -60,14 +60,17 @@ public static int GetPortWithFallback()
                     if (IsDebugEnabled()) Debug.Log($"<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Stored port {storedConfig.unity_port} became available after short wait");
                     return storedConfig.unity_port;
                 }
-                // Prefer sticking to the same port; let the caller handle bind retries/fallbacks
-                return storedConfig.unity_port;
+                // Port is still busy after waiting - find a new available port instead
+                if (IsDebugEnabled()) Debug.Log($"<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Stored port {storedConfig.unity_port} is occupied by another instance, finding alternative...");
+                int newPort = FindAvailablePort();
+                SavePort(newPort);
+                return newPort;
             }
 
             // If no valid stored port, find a new one and save it
-            int newPort = FindAvailablePort();
-            SavePort(newPort);
-            return newPort;
+            int foundPort = FindAvailablePort();
+            SavePort(foundPort);
+            return foundPort;
         }
 
         /// <summary>

MCPForUnity/Editor/MCPForUnityBridge.cs

@@ -362,7 +362,22 @@ public static void Start()
                         }
                         catch (SocketException se) when (se.SocketErrorCode == SocketError.AddressAlreadyInUse && attempt >= maxImmediateRetries)
                         {
+                            // Port is occupied by another instance, get a new available port
+                            int oldPort = currentUnityPort;
                             currentUnityPort = PortManager.GetPortWithFallback();
+
+                            // Safety check: ensure we got a different port
+                            if (currentUnityPort == oldPort)
+                            {
+                                McpLog.Error($"Port {oldPort} is occupied and no alternative port available");
+                                throw;
+                            }
+
+                            if (IsDebugEnabled())
+                            {
+                                McpLog.Info($"Port {oldPort} occupied, switching to port {currentUnityPort}");
+                            }
+
                             listener = new TcpListener(IPAddress.Loopback, currentUnityPort);
                             listener.Server.SetSocketOption(
                                 SocketOptionLevel.Socket,

MCPForUnity/UnityMcpServer~/src/models.py

@@ -1,4 +1,5 @@
 from typing import Any
+from datetime import datetime
 from pydantic import BaseModel
 
 
@@ -7,3 +8,28 @@ class MCPResponse(BaseModel):
     message: str | None = None
     error: str | None = None
     data: Any | None = None
+
+
+class UnityInstanceInfo(BaseModel):
+    """Information about a Unity Editor instance"""
+    id: str  # "ProjectName@hash" or fallback to hash
+    name: str  # Project name extracted from path
+    path: str  # Full project path (Assets folder)
+    hash: str  # 8-char hash of project path
+    port: int  # TCP port
+    status: str  # "running", "reloading", "offline"
+    last_heartbeat: datetime | None = None
+    unity_version: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "path": self.path,
+            "hash": self.hash,
+            "port": self.port,
+            "status": self.status,
+            "last_heartbeat": self.last_heartbeat.isoformat() if self.last_heartbeat else None,
+            "unity_version": self.unity_version
+        }

MCPForUnity/UnityMcpServer~/src/port_discovery.py

@@ -14,10 +14,15 @@
 import glob
 import json
 import logging
+import os
+import struct
+from datetime import datetime
 from pathlib import Path
 import socket
 from typing import Optional, List
 
+from models import UnityInstanceInfo
+
 logger = logging.getLogger("mcp-for-unity-server")
 
 
@@ -56,22 +61,43 @@ def list_candidate_files() -> List[Path]:
     @staticmethod
     def _try_probe_unity_mcp(port: int) -> bool:
         """Quickly check if a MCP for Unity listener is on this port.
-        Tries a short TCP connect, sends 'ping', expects Unity bridge welcome message.
+        Uses Unity's framed protocol: receives handshake, sends framed ping, expects framed pong.
         """
         try:
             with socket.create_connection(("127.0.0.1", port), PortDiscovery.CONNECT_TIMEOUT) as s:
                 s.settimeout(PortDiscovery.CONNECT_TIMEOUT)
                 try:
-                    s.sendall(b"ping")
-                    data = s.recv(512)
-                    # Check for Unity bridge welcome message format
-                    if data and (b"WELCOME UNITY-MCP" in data or b'"message":"pong"' in data):
-                        return True
-                except Exception:
+                    # 1. Receive handshake from Unity
+                    handshake = s.recv(512)
+                    if not handshake or b"FRAMING=1" not in handshake:
+                        # Try legacy mode as fallback
+                        s.sendall(b"ping")
+                        data = s.recv(512)
+                        return data and b'"message":"pong"' in data
+
+                    # 2. Send framed ping command
+                    # Frame format: 8-byte length header (big-endian uint64) + payload
+                    payload = b"ping"
+                    header = struct.pack('>Q', len(payload))
+                    s.sendall(header + payload)
+
+                    # 3. Receive framed response
+                    response_header = s.recv(8)
+                    if len(response_header) != 8:
+                        return False
+
+                    response_length = struct.unpack('>Q', response_header)[0]
+                    if response_length > 10000:  # Sanity check
+                        return False
+
+                    response = s.recv(response_length)
+                    return b'"message":"pong"' in response
+                except Exception as e:
+                    logger.debug(f"Port probe failed for {port}: {e}")
                     return False
-        except Exception:
+        except Exception as e:
+            logger.debug(f"Connection failed for port {port}: {e}")
             return False
-        return False
 
     @staticmethod
     def _read_latest_status() -> Optional[dict]:
@@ -158,3 +184,94 @@ def get_port_config() -> Optional[dict]:
                 logger.warning(
                     f"Could not read port configuration {path}: {e}")
         return None
+
+    @staticmethod
+    def _extract_project_name(project_path: str) -> str:
+        """Extract project name from Assets path.
+
+        Examples:
+            /Users/sakura/Projects/MyGame/Assets -> MyGame
+            C:\\Projects\\TestProject\\Assets -> TestProject
+        """
+        if not project_path:
+            return "Unknown"
+
+        try:
+            # Remove trailing /Assets or \Assets
+            path = project_path.rstrip('/\\')
+            if path.endswith('Assets'):
+                path = path[:-6].rstrip('/\\')
+
+            # Get the last directory name
+            name = os.path.basename(path)
+            return name if name else "Unknown"
+        except Exception:
+            return "Unknown"
+
+    @staticmethod
+    def discover_all_unity_instances() -> List[UnityInstanceInfo]:
+        """
+        Discover all running Unity Editor instances by scanning status files.
+
+        Returns:
+            List of UnityInstanceInfo objects for all discovered instances
+        """
+        instances = []
+        base = PortDiscovery.get_registry_dir()
+
+        # Scan all status files
+        status_pattern = str(base / "unity-mcp-status-*.json")
+        status_files = glob.glob(status_pattern)
+
+        for status_file_path in status_files:
+            try:
+                with open(status_file_path, 'r') as f:
+                    data = json.load(f)
+
+                # Extract hash from filename: unity-mcp-status-{hash}.json
+                filename = os.path.basename(status_file_path)
+                hash_value = filename.replace('unity-mcp-status-', '').replace('.json', '')
+
+                # Extract information
+                project_path = data.get('project_path', '')
+                project_name = PortDiscovery._extract_project_name(project_path)
+                port = data.get('unity_port')
+                is_reloading = data.get('reloading', False)
+
+                # Parse last_heartbeat
+                last_heartbeat = None
+                heartbeat_str = data.get('last_heartbeat')
+                if heartbeat_str:
+                    try:
+                        last_heartbeat = datetime.fromisoformat(heartbeat_str.replace('Z', '+00:00'))
+                    except Exception:
+                        pass
+
+                # Verify port is actually responding
+                is_alive = PortDiscovery._try_probe_unity_mcp(port) if isinstance(port, int) else False
+
+                if not is_alive:
+                    logger.debug(f"Instance {project_name}@{hash_value} has heartbeat but port {port} not responding")
+                    continue
+
+                # Create instance info
+                instance = UnityInstanceInfo(
+                    id=f"{project_name}@{hash_value}",
+                    name=project_name,
+                    path=project_path,
+                    hash=hash_value,
+                    port=port,
+                    status="reloading" if is_reloading else "running",
+                    last_heartbeat=last_heartbeat,
+                    unity_version=data.get('unity_version')  # May not be available in current version
+                )
+
+                instances.append(instance)
+                logger.debug(f"Discovered Unity instance: {instance.id} on port {instance.port}")
+
+            except Exception as e:
+                logger.debug(f"Failed to parse status file {status_file_path}: {e}")
+                continue
+
+        logger.info(f"Discovered {len(instances)} Unity instances")
+        return instances

MCPForUnity/UnityMcpServer~/src/server.py

@@ -8,7 +8,7 @@
 from config import config
 from tools import register_all_tools
 from resources import register_all_resources
-from unity_connection import get_unity_connection, UnityConnection
+from unity_connection import get_unity_connection_pool, UnityConnectionPool
 import time
 
 # Configure logging using settings from config
@@ -61,14 +61,14 @@
 except Exception:
     pass
 
-# Global connection state
-_unity_connection: UnityConnection = None
+# Global connection pool
+_unity_connection_pool: UnityConnectionPool = None
 
 
 @asynccontextmanager
 async def server_lifespan(server: FastMCP) -> AsyncIterator[Dict[str, Any]]:
     """Handle server startup and shutdown."""
-    global _unity_connection
+    global _unity_connection_pool
     logger.info("MCP for Unity Server starting up")
 
     # Record server startup telemetry
@@ -101,22 +101,35 @@ def _emit_startup():
             logger.info(
                 "Skipping Unity connection on startup (UNITY_MCP_SKIP_STARTUP_CONNECT=1)")
         else:
-            _unity_connection = get_unity_connection()
-            logger.info("Connected to Unity on startup")
-
-            # Record successful Unity connection (deferred)
-            import threading as _t
-            _t.Timer(1.0, lambda: record_telemetry(
-                RecordType.UNITY_CONNECTION,
-                {
-                    "status": "connected",
-                    "connection_time_ms": (time.perf_counter() - start_clk) * 1000,
-                }
-            )).start()
+            # Initialize connection pool and discover instances
+            _unity_connection_pool = get_unity_connection_pool()
+            instances = _unity_connection_pool.discover_all_instances()
+
+            if instances:
+                logger.info(f"Discovered {len(instances)} Unity instance(s): {[i.id for i in instances]}")
+
+                # Try to connect to default instance
+                try:
+                    default_conn = _unity_connection_pool.get_connection()
+                    logger.info("Connected to default Unity instance on startup")
+
+                    # Record successful Unity connection (deferred)
+                    import threading as _t
+                    _t.Timer(1.0, lambda: record_telemetry(
+                        RecordType.UNITY_CONNECTION,
+                        {
+                            "status": "connected",
+                            "connection_time_ms": (time.perf_counter() - start_clk) * 1000,
+                            "instance_count": len(instances)
+                        }
+                    )).start()
+                except Exception as e:
+                    logger.warning("Could not connect to default Unity instance: %s", e)
+            else:
+                logger.warning("No Unity instances found on startup")
 
     except ConnectionError as e:
         logger.warning("Could not connect to Unity on startup: %s", e)
-        _unity_connection = None
 
         # Record connection failure (deferred)
         import threading as _t
@@ -132,7 +145,6 @@ def _emit_startup():
     except Exception as e:
         logger.warning(
             "Unexpected error connecting to Unity on startup: %s", e)
-        _unity_connection = None
         import threading as _t
         _err_msg = str(e)[:200]
         _t.Timer(1.0, lambda: record_telemetry(
@@ -145,13 +157,12 @@ def _emit_startup():
         )).start()
 
     try:
-        # Yield the connection object so it can be attached to the context
-        # The key 'bridge' matches how tools like read_console expect to access it (ctx.bridge)
-        yield {"bridge": _unity_connection}
+        # Yield the connection pool so it can be attached to the context
+        # Note: Tools will use get_unity_connection_pool() directly
+        yield {"pool": _unity_connection_pool}
     finally:
-        if _unity_connection:
-            _unity_connection.disconnect()
-            _unity_connection = None
+        if _unity_connection_pool:
+            _unity_connection_pool.disconnect_all()
         logger.info("MCP for Unity Server shut down")
 
 # Initialize MCP server

MCPForUnity/UnityMcpServer~/src/tools/execute_menu_item.py

@@ -17,9 +17,11 @@ async def execute_menu_item(
     ctx: Context,
     menu_path: Annotated[str,
                          "Menu path for 'execute' or 'exists' (e.g., 'File/Save Project')"] | None = None,
+    unity_instance: Annotated[str,
+                             "Target Unity instance (project name, hash, or 'Name@hash'). If not specified, uses default instance."] | None = None,
 ) -> MCPResponse:
     await ctx.info(f"Processing execute_menu_item: {menu_path}")
     params_dict: dict[str, Any] = {"menuPath": menu_path}
     params_dict = {k: v for k, v in params_dict.items() if v is not None}
-    result = await async_send_command_with_retry("execute_menu_item", params_dict)
+    result = await async_send_command_with_retry("execute_menu_item", params_dict, instance_id=unity_instance)
     return MCPResponse(**result) if isinstance(result, dict) else result

MCPForUnity/UnityMcpServer~/src/tools/manage_asset.py

@@ -31,7 +31,9 @@ async def manage_asset(
     filter_date_after: Annotated[str,
                                  "Date after which to filter"] | None = None,
     page_size: Annotated[int | float | str, "Page size for pagination"] | None = None,
-    page_number: Annotated[int | float | str, "Page number for pagination"] | None = None
+    page_number: Annotated[int | float | str, "Page number for pagination"] | None = None,
+    unity_instance: Annotated[str,
+                             "Target Unity instance (project name, hash, or 'Name@hash'). If not specified, uses default instance."] | None = None
 ) -> dict[str, Any]:
     ctx.info(f"Processing manage_asset: {action}")
     # Coerce 'properties' from JSON string to dict for client compatibility
@@ -86,7 +88,7 @@ def _coerce_int(value, default=None):
     # Get the current asyncio event loop
     loop = asyncio.get_running_loop()
 
-    # Use centralized async retry helper to avoid blocking the event loop
-    result = await async_send_command_with_retry("manage_asset", params_dict, loop=loop)
+    # Use centralized async retry helper with instance routing
+    result = await async_send_command_with_retry("manage_asset", params_dict, instance_id=unity_instance, loop=loop)
     # Return the result obtained from Unity
     return result if isinstance(result, dict) else {"success": False, "message": str(result)}