Merge pull request #1320 from CoplayDev/fix/stdio-configurable-command-timeout

fix: make stdio bridge command timeout configurable (default 5m)

Author: Scriptwonder

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

@@ -58,11 +58,33 @@ public static class StdioBridgeHost
         private static int currentUnityPort = 6400;
         private static bool isAutoConnectMode = false;
         private const ulong MaxFrameBytes = 64UL * 1024 * 1024;
-        private const int FrameIOTimeoutMs = 30000;
+        // Command/frame I/O timeout for the stdio bridge TCP hop. Previously a
+        // hardcoded 30s const, which cut off long-running tool calls mid-execution
+        // (the client would then reconnect and re-send, causing the bridge to
+        // restart on a new port). Now defaults to 5 minutes and is overridable via
+        // the UNITY_MCP_STDIO_COMMAND_TIMEOUT_MS environment variable.
+        private const int DefaultFrameIOTimeoutMs = 300000;
+        private static readonly int FrameIOTimeoutMs = ResolveFrameIOTimeoutMs();
         private static readonly Stopwatch _uptime = Stopwatch.StartNew();
         private static volatile int _consecutiveTimeouts = 0;
         private static bool _processCommandsHooked = false;
 
+        private static int ResolveFrameIOTimeoutMs()
+        {
+            try
+            {
+                string raw = Environment.GetEnvironmentVariable("UNITY_MCP_STDIO_COMMAND_TIMEOUT_MS");
+                if (!string.IsNullOrWhiteSpace(raw)
+                    && int.TryParse(raw.Trim(), out int ms)
+                    && ms > 0)
+                {
+                    return ms;
+                }
+            }
+            catch { /* fall through to default */ }
+            return DefaultFrameIOTimeoutMs;
+        }
+
         private static void IoInfo(string s) { McpLog.Info(s, always: false); }
 
         private static bool IsDebugEnabled()
@@ -465,7 +487,9 @@ private static async Task ListenerLoopAsync(CancellationToken token)
                         true
                     );
 
-                    client.ReceiveTimeout = 60000;
+                    // Keep the socket receive timeout at least as long as the command
+                    // timeout so it never fires before a long-running tool call completes.
+                    client.ReceiveTimeout = Math.Max(60000, FrameIOTimeoutMs);
 
                     _ = Task.Run(() => HandleClientAsync(client, token), token);
                 }
@@ -825,7 +849,7 @@ private static void ProcessCommands()
 
                     // Evict commands stuck with IsExecuting=true for too long (e.g. from pre-reload state).
                     long nowMs = _uptime.ElapsedMilliseconds;
-                    const long staleThresholdMs = 2L * FrameIOTimeoutMs; // 60s
+                    long staleThresholdMs = 2L * FrameIOTimeoutMs; // 2x the command timeout
                     List<string> staleIds = null;
                     foreach (var kvp in commandQueue)
                     {

Server/src/core/config.py

@@ -3,7 +3,27 @@
 This file contains all configurable parameters for the server.
 """
 
-from dataclasses import dataclass
+import math
+import os
+from dataclasses import dataclass, field
+
+
+def _env_float(name: str, default: float) -> float:
+    """Read a positive, finite float from an environment variable.
+
+    Invalid, non-positive, or non-finite values (e.g. "inf", "1e309", "nan")
+    are ignored so a bad override can't disable the timeout or produce unusable
+    socket/timeout behaviour.
+    """
+    raw = os.environ.get(name)
+    if raw:
+        try:
+            value = float(raw.strip())
+            if math.isfinite(value) and value > 0:
+                return value
+        except (TypeError, ValueError):
+            pass
+    return default
 
 
 @dataclass
@@ -31,9 +51,19 @@ class ServerConfig:
     api_key_service_token: str | None = None         # The token value
 
     # Connection settings
-    connection_timeout: float = 30.0
+    # Socket receive timeout for a single Unity command (seconds). Raised from the
+    # historical 30s so long-running tools (e.g. imports, test runs, batched edits)
+    # aren't cut off mid-execution, which previously forced a reconnect + re-send and
+    # made the Unity stdio bridge restart. Override via UNITY_MCP_CONNECTION_TIMEOUT.
+    connection_timeout: float = field(
+        default_factory=lambda: _env_float("UNITY_MCP_CONNECTION_TIMEOUT", 300.0)
+    )
     # Hard ceiling on a command's total time across all retries (wedged-socket guard).
-    command_total_timeout: float = 90.0
+    # Kept above connection_timeout so a single slow-but-progressing command still fits.
+    # Override via UNITY_MCP_COMMAND_TOTAL_TIMEOUT.
+    command_total_timeout: float = field(
+        default_factory=lambda: _env_float("UNITY_MCP_COMMAND_TOTAL_TIMEOUT", 600.0)
+    )
     buffer_size: int = 16 * 1024 * 1024  # 16MB buffer
 
     # STDIO framing behaviour

Server/tests/test_core_infrastructure_characterization.py

@@ -654,21 +654,44 @@ def error_tool():
 class TestServerConfigDefaults:
     """Tests for ServerConfig default values."""
 
-    def test_config_default_values(self):
+    def test_config_default_values(self, monkeypatch):
         """Verify ServerConfig has expected default values."""
+        # Clear env overrides so the defaults aren't masked by the ambient env.
+        monkeypatch.delenv("UNITY_MCP_CONNECTION_TIMEOUT", raising=False)
+        monkeypatch.delenv("UNITY_MCP_COMMAND_TOTAL_TIMEOUT", raising=False)
         config = ServerConfig()
 
         assert config.unity_host == "127.0.0.1"
         assert config.unity_port == 6400
         assert config.mcp_port == 6500
-        assert config.connection_timeout == 30.0
+        assert config.connection_timeout == 300.0
+        assert config.command_total_timeout == 600.0
         assert config.buffer_size == 16 * 1024 * 1024
         assert config.require_framing is True
         assert config.handshake_timeout == 1.0
         assert config.framed_receive_timeout == 2.0
         assert config.max_heartbeat_frames == 16
         assert config.heartbeat_timeout == 2.0
 
+    def test_timeout_env_overrides_are_honored(self, monkeypatch):
+        """Valid env overrides for the stdio timeouts are applied."""
+        monkeypatch.setenv("UNITY_MCP_CONNECTION_TIMEOUT", "120.5")
+        monkeypatch.setenv("UNITY_MCP_COMMAND_TOTAL_TIMEOUT", "240")
+        config = ServerConfig()
+
+        assert config.connection_timeout == 120.5
+        assert config.command_total_timeout == 240.0
+
+    @pytest.mark.parametrize("bad_value", ["0", "-5", "abc", "", "inf", "Infinity", "1e309", "nan"])
+    def test_timeout_env_invalid_values_fall_back(self, monkeypatch, bad_value):
+        """Invalid, non-positive, or non-finite overrides preserve the defaults."""
+        monkeypatch.setenv("UNITY_MCP_CONNECTION_TIMEOUT", bad_value)
+        monkeypatch.setenv("UNITY_MCP_COMMAND_TOTAL_TIMEOUT", bad_value)
+        config = ServerConfig()
+
+        assert config.connection_timeout == 300.0
+        assert config.command_total_timeout == 600.0
+
     def test_config_logging_defaults(self):
         """Verify logging configuration defaults."""
         config = ServerConfig()