gdharness 0.5.5 → 0.5.7

package/build/cli.js

@@ -7153,10 +7153,10 @@ function runLine(runner, version, rest = "") {
 function spawnFor(runner, version, execPath = process2.execPath) {
   const spec = `gdharness@${version}`;
   if (runner !== currentRunner()) {
-    return { command: runner, args: runner === "npx" ? ["-y", spec] : [spec] };
+    return { command: runner, args: runner === "npx" ? ["-y", spec] : ["--bun", spec] };
   }
   if (runner === "bunx") {
-    return { command: execPath, args: ["x", spec] };
+    return { command: execPath, args: ["x", "--bun", spec] };
   }
   return { command: alongside(execPath, "npx") ?? "npx", args: ["-y", spec] };
 }
@@ -34164,6 +34164,8 @@ var init_godot_bridge = __esm(() => {
         server.once("error", (error) => {
           if (!settled) {
             settled = true;
+            server.close();
+            godotWss.close();
             reject(error);
             return;
           }
@@ -35730,6 +35732,7 @@ class GodotServer {
   lspClient = null;
   dapClient = null;
   bridgeStartupError = null;
+  bridgeRetry = null;
   lastProjectPath = null;
   shutdownInitiated = false;
   constructor() {
@@ -35786,11 +35789,43 @@ class GodotServer {
       const reason = errorMessage(bridgeError);
       this.bridgeStartupError = code && !reason.includes(code) ? `${code}: ${reason}` : reason;
       console.error(`[SERVER] Warning: Godot Editor Bridge failed to start: ${this.bridgeStartupError}`);
-      console.error("[SERVER] Continuing without bridge-backed editor tools.");
+      console.error("[SERVER] Continuing without bridge-backed editor tools, and trying again.");
+      this.keepTryingTheBridge();
+    }
+  }
+  keepTryingTheBridge() {
+    if (this.bridgeRetry !== null || this.shutdownInitiated) {
+      return;
+    }
+    this.bridgeRetry = setInterval(() => {
+      this.tryTheBridgeAgain();
+    }, BRIDGE_RETRY_MS);
+    this.bridgeRetry.unref();
+  }
+  async tryTheBridgeAgain() {
+    if (this.shutdownInitiated) {
+      this.stopTryingTheBridge();
+      return;
+    }
+    try {
+      await this.godotBridge.start();
+    } catch {
+      return;
+    }
+    this.bridgeStartupError = null;
+    this.stopTryingTheBridge();
+    const bridgeStatus = this.godotBridge.getStatus();
+    console.error(`[SERVER] Godot Editor Bridge came up on ${bridgeStatus.host}:${bridgeStatus.port}; editor tools are live.`);
+  }
+  stopTryingTheBridge() {
+    if (this.bridgeRetry !== null) {
+      clearInterval(this.bridgeRetry);
+      this.bridgeRetry = null;
     }
   }
   async cleanup() {
     this.logDebug("Cleaning up resources");
+    this.stopTryingTheBridge();
     if (this.activeProcess) {
       this.activeProcess.process?.kill();
       this.activeProcess = null;
@@ -36612,8 +36647,9 @@ class GodotServer {
       bridgeAvailable: this.bridgeStartupError === null,
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
-      note: isPortConflict ? "Bridge port is already in use. Another gdharness instance may own the editor bridge, so this server cannot report that editor connection." : undefined,
-      suggestion: isPortConflict ? "Stop duplicate gdharness/MCP server instances or re-run the command from the same server process that owns the bridge port." : undefined
+      retryingBridge: this.bridgeRetry === null ? undefined : true,
+      note: isPortConflict ? "Bridge port is already in use. Another gdharness instance owns the editor bridge, so this server cannot reach the editor. Usually the server this one replaced, still on its way out." : undefined,
+      suggestion: isPortConflict ? `This server is asking for the port again every ${BRIDGE_RETRY_MS / 1000}s and takes it the moment the other one lets go, so editor tools come back on their own. Ask again, or end the older gdharness process to have it now.` : undefined
     };
   }
   async editorPlayingState() {
@@ -37091,7 +37127,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, BRIDGE_RETRY_MS = 2000, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS;
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -37,6 +37,14 @@ var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
 ## Bytes received from each client that do not yet end in a newline, keyed by the peer.
 var _pending: Dictionary = {}
+## Bytes owed to each client that the socket has not taken yet, keyed by the peer.
+##
+## A reply is queued rather than written, because the write happens on the main thread and
+## `put_data` blocks until every byte is gone. A client that asked a large question and then
+## stopped reading, which is exactly what our own server does when a call times out, leaves that
+## write with nowhere to go: the frame never ends, the game freezes, and the listener never
+## accepts again, so every later request times out too. One timeout would take the game with it.
+var _outgoing: Dictionary = {}
 var _port: int = 0
 var _enabled: bool = true
 var _announcement: String = ""
@@ -102,10 +110,27 @@ func _process(_delta: float) -> void:
 			var received: Array = client.get_data(available)
 			var bytes: PackedByteArray = received[1]
 			_receive(client, bytes)
+		if not _drain(client):
+			gone.append(client)
 
 	for client: StreamPeerTCP in gone:
 		_clients.erase(client)
 		_pending.erase(client)
+		_outgoing.erase(client)
+
+
+## Hands the socket as much of what it is owed as it will take, and says whether it is still worth
+## talking to. Reading comes first in the frame, so a client that asked and left is noticed here
+## rather than blocking on a write that can never finish.
+func _drain(client: StreamPeerTCP) -> bool:
+	var owed: PackedByteArray = _outgoing.get(client, PackedByteArray())
+	if owed.is_empty():
+		return true
+	var sent: Array = client.put_partial_data(owed)
+	if sent[0] != OK:
+		return false
+	_outgoing[client] = owed.slice(int(sent[1]))
+	return true
 
 
 ## Bytes arrive in whatever pieces the socket makes of them, so a request is only handled once
@@ -259,10 +284,15 @@ func _ping(_params: Dictionary) -> Dictionary:
 	return {"type": "pong", "timestamp": Time.get_unix_time_from_system()}
 
 
-## One JSON object and a newline. put_data rather than put_utf8_string, which would prefix the
-## bytes with a length the other side is not expecting.
+## One JSON object and a newline, queued for [method _drain] rather than written here.
+##
+## Raw bytes rather than put_utf8_string, which would prefix them with a length the other side is
+## not expecting, and queued rather than put_data, which blocks the frame until the socket has
+## taken the lot: see [member _outgoing].
 func _send_response(client: StreamPeerTCP, data: Dictionary) -> void:
-	client.put_data((JSON.stringify(data) + "\n").to_utf8_buffer())
+	var owed: PackedByteArray = _outgoing.get(client, PackedByteArray())
+	owed.append_array((JSON.stringify(data) + "\n").to_utf8_buffer())
+	_outgoing[client] = owed
 
 
 ## A request that could not be read far enough to find its id is answered with a null one.
@@ -280,6 +310,7 @@ func _cleanup() -> void:
 		client.disconnect_from_host()
 	_clients.clear()
 	_pending.clear()
+	_outgoing.clear()
 
 	if _server:
 		_server.stop()

package/build/index.js

@@ -25468,6 +25468,8 @@ class GodotBridge extends EventEmitter {
       server.once("error", (error) => {
         if (!settled) {
           settled = true;
+          server.close();
+          godotWss.close();
           reject(error);
           return;
         }
@@ -28405,6 +28407,7 @@ var FEEDBACK_NOTICE_EVERY = 250;
 var run3 = promisify3(execFile3);
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
+var BRIDGE_RETRY_MS = 2000;
 var PATH_SOLUTIONS = [
   'Give the path relative to the project, such as "scenes/main.tscn" or "res://scenes/main.tscn"',
   "Point projectPath at the project the file belongs to"
@@ -28511,6 +28514,7 @@ class GodotServer {
   lspClient = null;
   dapClient = null;
   bridgeStartupError = null;
+  bridgeRetry = null;
   lastProjectPath = null;
   shutdownInitiated = false;
   constructor() {
@@ -28567,11 +28571,43 @@ class GodotServer {
       const reason = errorMessage(bridgeError);
       this.bridgeStartupError = code && !reason.includes(code) ? `${code}: ${reason}` : reason;
       console.error(`[SERVER] Warning: Godot Editor Bridge failed to start: ${this.bridgeStartupError}`);
-      console.error("[SERVER] Continuing without bridge-backed editor tools.");
+      console.error("[SERVER] Continuing without bridge-backed editor tools, and trying again.");
+      this.keepTryingTheBridge();
+    }
+  }
+  keepTryingTheBridge() {
+    if (this.bridgeRetry !== null || this.shutdownInitiated) {
+      return;
+    }
+    this.bridgeRetry = setInterval(() => {
+      this.tryTheBridgeAgain();
+    }, BRIDGE_RETRY_MS);
+    this.bridgeRetry.unref();
+  }
+  async tryTheBridgeAgain() {
+    if (this.shutdownInitiated) {
+      this.stopTryingTheBridge();
+      return;
+    }
+    try {
+      await this.godotBridge.start();
+    } catch {
+      return;
+    }
+    this.bridgeStartupError = null;
+    this.stopTryingTheBridge();
+    const bridgeStatus = this.godotBridge.getStatus();
+    console.error(`[SERVER] Godot Editor Bridge came up on ${bridgeStatus.host}:${bridgeStatus.port}; editor tools are live.`);
+  }
+  stopTryingTheBridge() {
+    if (this.bridgeRetry !== null) {
+      clearInterval(this.bridgeRetry);
+      this.bridgeRetry = null;
     }
   }
   async cleanup() {
     this.logDebug("Cleaning up resources");
+    this.stopTryingTheBridge();
     if (this.activeProcess) {
       this.activeProcess.process?.kill();
       this.activeProcess = null;
@@ -29393,8 +29429,9 @@ class GodotServer {
       bridgeAvailable: this.bridgeStartupError === null,
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
-      note: isPortConflict ? "Bridge port is already in use. Another gdharness instance may own the editor bridge, so this server cannot report that editor connection." : undefined,
-      suggestion: isPortConflict ? "Stop duplicate gdharness/MCP server instances or re-run the command from the same server process that owns the bridge port." : undefined
+      retryingBridge: this.bridgeRetry === null ? undefined : true,
+      note: isPortConflict ? "Bridge port is already in use. Another gdharness instance owns the editor bridge, so this server cannot reach the editor. Usually the server this one replaced, still on its way out." : undefined,
+      suggestion: isPortConflict ? `This server is asking for the port again every ${BRIDGE_RETRY_MS / 1000}s and takes it the moment the other one lets go, so editor tools come back on their own. Ask again, or end the older gdharness process to have it now.` : undefined
     };
   }
   async editorPlayingState() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",