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

Long-running tool calls (asset imports, test runs, batched edits) were
cut off ~30-90s into execution, so the task could never finish. On the
stdio transport this was governed by hardcoded values on both hops:

- Unity side: StdioBridgeHost.FrameIOTimeoutMs (30s const) capped every
  command's execution and frame I/O; on timeout the client reconnected
  and re-sent, which force-closed the prior client and made the bridge
  restart on a new port (the repeated "StdioBridgeHost started on port
  6400/6402" churn).
- Server side: ServerConfig.connection_timeout (30s socket recv) and
  command_total_timeout (90s cross-retry ceiling) cut the command off
  first.

Unlike the WebSocket transport (WebSocketTransportClient reads a per-call
timeout off the wire), the stdio bridge had no way to raise these.

Make all three configurable with a 5-minute default:
- FrameIOTimeoutMs: 30s -> 300s, env UNITY_MCP_STDIO_COMMAND_TIMEOUT_MS.
  ReceiveTimeout now scales with it (max(60s, timeout)).
- connection_timeout: 30s -> 300s, env UNITY_MCP_CONNECTION_TIMEOUT.
- command_total_timeout: 90s -> 600s, env UNITY_MCP_COMMAND_TOTAL_TIMEOUT.

Invalid/non-positive env values fall back to the default so a bad
override can't disable the timeout. Updates the config characterization
test to the new defaults.

Author: amykhajlyshyn

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,25 @@
 This file contains all configurable parameters for the server.
 """
 
-from dataclasses import dataclass
+import os
+from dataclasses import dataclass, field
+
+
+def _env_float(name: str, default: float) -> float:
+    """Read a positive float from an environment variable, falling back to default.
+
+    Invalid or non-positive values are ignored so a bad override can't disable
+    the timeout entirely.
+    """
+    raw = os.environ.get(name)
+    if raw:
+        try:
+            value = float(raw.strip())
+            if value > 0:
+                return value
+        except (TypeError, ValueError):
+            pass
+    return default
 
 
 @dataclass
@@ -31,9 +49,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

@@ -661,7 +661,8 @@ def test_config_default_values(self):
         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