Fix/auto port fallback

MCPForUnity/Editor/Helpers/PortManager.cs

@@ -119,17 +119,41 @@ private static int FindAvailablePort()
         /// <returns>True if port is available</returns>
         public static bool IsPortAvailable(int port)
         {
+            // Start with quick loopback check
             try
             {
                 var testListener = new TcpListener(IPAddress.Loopback, port);
                 testListener.Start();
                 testListener.Stop();
-                return true;
             }
             catch (SocketException)
             {
                 return false;
             }
+
+#if UNITY_EDITOR_OSX
+            // On macOS, the OS might report the port as available (SO_REUSEADDR) even if another process
+            // is using it, unless we also check active connections or try a stricter bind.
+            // Double check by trying to Connect to it. If we CAN connect, it's NOT available.
+            try
+            {
+                using var client = new TcpClient();
+                var connectTask = client.ConnectAsync(IPAddress.Loopback, port);
+                // If we connect successfully, someone is listening -> Not available
+                if (connectTask.Wait(50) && client.Connected)
+                {
+                    if (IsDebugEnabled()) McpLog.Info($"[PortManager] Port {port} bind succeeded but connection also succeeded -> Not available (Conflict).");
+                    return false;
+                }
+            }
+            catch
+            {
+                // Connection failed -> likely available (or firewall blocked, but we assume available)
+                if (IsDebugEnabled()) McpLog.Info($"[PortManager] Port {port} connection failed -> likely available.");
+            }
+#endif
+
+            return true;
         }
 
         /// <summary>

MCPForUnity/Editor/Services/Transport/Transports/StdioBridgeHost.cs

@@ -306,26 +306,7 @@ public static void Start()
                     {
                         try
                         {
-                            listener = new TcpListener(IPAddress.Loopback, currentUnityPort);
-                            listener.Server.SetSocketOption(
-                                SocketOptionLevel.Socket,
-                                SocketOptionName.ReuseAddress,
-                                true
-                            );
-#if UNITY_EDITOR_WIN
-                            try
-                            {
-                                listener.ExclusiveAddressUse = false;
-                            }
-                            catch { }
-#endif
-                            try
-                            {
-                                listener.Server.LingerState = new LingerOption(true, 0);
-                            }
-                            catch (Exception)
-                            {
-                            }
+                            listener = CreateConfiguredListener(currentUnityPort);
                             listener.Start();
                             break;
                         }
@@ -355,7 +336,14 @@ public static void Start()
                             }
                             catch { }
 
-                            currentUnityPort = PortManager.GetPortWithFallback();
+                            currentUnityPort = PortManager.DiscoverNewPort();
+
+                            // Persist the new port so next time we start on this port
+                            try
+                            {
+                                EditorPrefs.SetInt(EditorPrefKeys.UnitySocketPort, currentUnityPort);
+                            }
+                            catch { }
 
                             if (IsDebugEnabled())
                             {
@@ -369,26 +357,7 @@ public static void Start()
                                 }
                             }
 
-                            listener = new TcpListener(IPAddress.Loopback, currentUnityPort);
-                            listener.Server.SetSocketOption(
-                                SocketOptionLevel.Socket,
-                                SocketOptionName.ReuseAddress,
-                                true
-                            );
-#if UNITY_EDITOR_WIN
-                            try
-                            {
-                                listener.ExclusiveAddressUse = false;
-                            }
-                            catch { }
-#endif
-                            try
-                            {
-                                listener.Server.LingerState = new LingerOption(true, 0);
-                            }
-                            catch (Exception)
-                            {
-                            }
+                            listener = CreateConfiguredListener(currentUnityPort);
                             listener.Start();
                             break;
                         }
@@ -416,6 +385,33 @@ public static void Start()
             }
         }
 
+        private static TcpListener CreateConfiguredListener(int port)
+        {
+            var newListener = new TcpListener(IPAddress.Loopback, port);
+#if !UNITY_EDITOR_OSX
+            newListener.Server.SetSocketOption(
+                SocketOptionLevel.Socket,
+                SocketOptionName.ReuseAddress,
+                true
+            );
+#endif
+#if UNITY_EDITOR_WIN
+            try
+            {
+                newListener.ExclusiveAddressUse = false;
+            }
+            catch { }
+#endif
+            try
+            {
+                newListener.Server.LingerState = new LingerOption(true, 0);
+            }
+            catch (Exception)
+            {
+            }
+            return newListener;
+        }
+
         public static void Stop()
         {
             Task toWait = null;

MCPForUnity/Editor/Windows/Components/Connection/McpConnectionSection.cs

@@ -173,24 +173,30 @@ public void UpdateConnectionStatus()
                 statusIndicator.RemoveFromClassList("disconnected");
                 statusIndicator.AddToClassList("connected");
                 connectionToggleButton.text = "End Session";
+
+                // Force the UI to reflect the actual port being used
+                unityPortField.value = bridgeService.CurrentPort.ToString();
+                unityPortField.SetEnabled(false);
             }
             else
             {
                 connectionStatusLabel.text = "No Session";
                 statusIndicator.RemoveFromClassList("connected");
                 statusIndicator.AddToClassList("disconnected");
                 connectionToggleButton.text = "Start Session";
+
+                unityPortField.SetEnabled(true);
 
                 healthStatusLabel.text = HealthStatusUnknown;
                 healthIndicator.RemoveFromClassList("healthy");
                 healthIndicator.RemoveFromClassList("warning");
                 healthIndicator.AddToClassList("unknown");
-            }
-
-            int savedPort = EditorPrefs.GetInt(EditorPrefKeys.UnitySocketPort, 0);
-            if (savedPort == 0)
-            {
-                unityPortField.value = bridgeService.CurrentPort.ToString();
+                
+                int savedPort = EditorPrefs.GetInt(EditorPrefKeys.UnitySocketPort, 0);
+                if (savedPort == 0)
+                {
+                    unityPortField.value = bridgeService.CurrentPort.ToString();
+                }
             }
         }
 

Server/src/services/tools/debug_request_context.py

@@ -40,6 +40,7 @@ def debug_request_context(ctx: Context) -> dict[str, Any]:
     active_instance = middleware.get_active_instance(ctx)
 
     # Debugging middleware internals
+    # NOTE: These fields expose internal implementation details and may change between versions.
     with middleware._lock:
         all_keys = list(middleware._active_by_key.keys())
 

Server/src/transport/unity_instance_middleware.py

@@ -103,7 +103,7 @@ async def on_call_tool(self, context: MiddlewareContext, call_next):
                     # We only need session_id for HTTP transport routing.
                     # For stdio, we just need the instance ID.
                     session_id = await PluginHub._resolve_session_id(active_instance)
-                except Exception as exc:
+                except (ConnectionError, ValueError, KeyError, TimeoutError) as exc:
                     # If resolution fails, it means the Unity instance is not reachable via HTTP/WS.
                     # If we are in stdio mode, this might still be fine if the user is just setting state?
                     # But usually if PluginHub is configured, we expect it to work.
@@ -115,6 +115,16 @@ async def on_call_tool(self, context: MiddlewareContext, call_next):
                         exc,
                         exc_info=True,
                     )
+                except Exception as exc:
+                    # Re-raise unexpected system exceptions to avoid swallowing critical failures
+                    if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                        raise
+                    logger.error(
+                        "Unexpected error during PluginHub session resolution for %s: %s",
+                        active_instance,
+                        exc,
+                        exc_info=True
+                    )
 
             ctx.set_state("unity_instance", active_instance)
             if session_id is not None: