gdharness 0.13.34 → 0.13.35

package/build/cli.js

@@ -16022,7 +16022,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
+      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade: installing moves the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with. Those games are real and running, but no tool here can reach them until the two halves match, so runtimes stays empty and runtimeConnected stays false.',
       parameters: {},
       requires: []
     },
@@ -36752,6 +36752,9 @@ function judgeRun(record, running, needed) {
   if (wanted !== null && !said.includes(wanted)) {
     return false;
   }
+  if (running.kind === "commandLine" && AN_EDITOR.test(said)) {
+    return false;
+  }
   if (record.projectPath === "") {
     return wanted !== null;
   }
@@ -36801,8 +36804,10 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
+var AN_EDITOR;
 var init_run_record = __esm(() => {
   init_runtime_client();
+  AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
 });
 
 // src/server.ts
@@ -38229,7 +38234,10 @@ class GodotServer {
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
   anEditorIsStillComing(listeningSince) {
-    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+    return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
+  }
+  launchedEditorIsUp() {
+    return this.launchedEditor?.exitCode === null && this.launchedEditor.signalCode === null;
   }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
@@ -38275,7 +38283,7 @@ class GodotServer {
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
       mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
-      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
@@ -38311,7 +38319,8 @@ class GodotServer {
   }
   async handleEditorStatus() {
     const godotPath = await this.locator.find();
-    const games = await Promise.all(discoverRuntimes().map(async (endpoint) => {
+    const announced = runtimesAnnounced();
+    const games = await Promise.all(announced.running.map(async (endpoint) => {
       const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
       return {
         pid: endpoint.pid,
@@ -38333,10 +38342,17 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: stillRunning(this.currentRun()),
+        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
-        runtimes: games
+        runtimes: games,
+        unreadable: announced.unspoken.map((game) => ({
+          pid: game.pid,
+          project: game.project,
+          protocol: game.protocol,
+          serverSpeaks: RUNTIME_PROTOCOL,
+          behind: game.protocol > RUNTIME_PROTOCOL ? "server" : "addon"
+        }))
       }
     });
   }
@@ -38486,7 +38502,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
-    this.launchedEditor = editor.pid ?? null;
+    this.launchedEditor = editor.pid === undefined ? null : editor;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -38533,6 +38549,7 @@ class GodotServer {
       await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
+    const wereHereFirst = this.everyRuntimeOfOurs();
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
@@ -38553,16 +38570,20 @@ class GodotServer {
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
     const endedForThis = ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`;
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
+    const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
+      alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
       endedPreviousRun: ended ?? undefined,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async gameIsUp() {
@@ -38878,7 +38899,12 @@ class GodotServer {
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const live = this.aRuntimeOfOursIsAnswering();
     if (live !== null) {
-      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " Do not start another: editor_run start replaces the game that is playing rather than" + " adding one, so it would end this one." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+    }
+    const unreadable = this.aRuntimeOfOursIsTooFarOff();
+    if (unreadable !== null) {
+      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
     if (record === null) {
@@ -38890,12 +38916,34 @@ class GodotServer {
     return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
   }
   aRuntimeOfOursIsAnswering() {
+    return this.announcedForOurProject(discoverRuntimes());
+  }
+  aRuntimeOfOursIsTooFarOff() {
+    return this.announcedForOurProject(runtimesAnnounced().unspoken);
+  }
+  announcedForOurProject(announced) {
+    return this.allAnnouncedForOurProject(announced)[0] ?? null;
+  }
+  allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     if (mine === null) {
-      return null;
+      return [];
     }
-    return discoverRuntimes().find((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path)) ?? null;
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path));
+  }
+  everyRuntimeOfOurs() {
+    const announced = runtimesAnnounced();
+    return [
+      ...this.allAnnouncedForOurProject(announced.running).map((one) => ({
+        pid: one.pid,
+        protocol: null
+      })),
+      ...this.allAnnouncedForOurProject(announced.unspoken).map((one) => ({
+        pid: one.pid,
+        protocol: one.protocol
+      }))
+    ];
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();

package/build/index.js

@@ -28336,6 +28336,7 @@ function stillTheRecordedRun(record) {
 function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, runningAs(record.pid), "possible");
 }
+var AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
 function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
@@ -28346,6 +28347,9 @@ function judgeRun(record, running, needed) {
   if (wanted !== null && !said.includes(wanted)) {
     return false;
   }
+  if (running.kind === "commandLine" && AN_EDITOR.test(said)) {
+    return false;
+  }
   if (record.projectPath === "") {
     return wanted !== null;
   }
@@ -29104,7 +29108,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
+    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade: installing moves the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with. Those games are real and running, but no tool here can reach them until the two halves match, so runtimes stays empty and runtimeConnected stays false.',
     parameters: {},
     requires: []
   },
@@ -30970,7 +30974,10 @@ class GodotServer {
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
   anEditorIsStillComing(listeningSince) {
-    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+    return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
+  }
+  launchedEditorIsUp() {
+    return this.launchedEditor?.exitCode === null && this.launchedEditor.signalCode === null;
   }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
@@ -31016,7 +31023,7 @@ class GodotServer {
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
       mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
-      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
@@ -31052,7 +31059,8 @@ class GodotServer {
   }
   async handleEditorStatus() {
     const godotPath = await this.locator.find();
-    const games = await Promise.all(discoverRuntimes().map(async (endpoint) => {
+    const announced = runtimesAnnounced();
+    const games = await Promise.all(announced.running.map(async (endpoint) => {
       const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
       return {
         pid: endpoint.pid,
@@ -31074,10 +31082,17 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: stillRunning(this.currentRun()),
+        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
-        runtimes: games
+        runtimes: games,
+        unreadable: announced.unspoken.map((game) => ({
+          pid: game.pid,
+          project: game.project,
+          protocol: game.protocol,
+          serverSpeaks: RUNTIME_PROTOCOL,
+          behind: game.protocol > RUNTIME_PROTOCOL ? "server" : "addon"
+        }))
       }
     });
   }
@@ -31227,7 +31242,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
-    this.launchedEditor = editor.pid ?? null;
+    this.launchedEditor = editor.pid === undefined ? null : editor;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -31274,6 +31289,7 @@ class GodotServer {
       await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
+    const wereHereFirst = this.everyRuntimeOfOurs();
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
@@ -31294,16 +31310,20 @@ class GodotServer {
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
     const endedForThis = ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`;
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
+    const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
+      alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
       endedPreviousRun: ended ?? undefined,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async gameIsUp() {
@@ -31619,7 +31639,12 @@ class GodotServer {
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const live = this.aRuntimeOfOursIsAnswering();
     if (live !== null) {
-      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " Do not start another: editor_run start replaces the game that is playing rather than" + " adding one, so it would end this one." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+    }
+    const unreadable = this.aRuntimeOfOursIsTooFarOff();
+    if (unreadable !== null) {
+      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
     if (record === null) {
@@ -31631,12 +31656,34 @@ class GodotServer {
     return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
   }
   aRuntimeOfOursIsAnswering() {
+    return this.announcedForOurProject(discoverRuntimes());
+  }
+  aRuntimeOfOursIsTooFarOff() {
+    return this.announcedForOurProject(runtimesAnnounced().unspoken);
+  }
+  announcedForOurProject(announced) {
+    return this.allAnnouncedForOurProject(announced)[0] ?? null;
+  }
+  allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     if (mine === null) {
-      return null;
+      return [];
     }
-    return discoverRuntimes().find((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path)) ?? null;
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path));
+  }
+  everyRuntimeOfOurs() {
+    const announced = runtimesAnnounced();
+    return [
+      ...this.allAnnouncedForOurProject(announced.running).map((one) => ({
+        pid: one.pid,
+        protocol: null
+      })),
+      ...this.allAnnouncedForOurProject(announced.unspoken).map((one) => ({
+        pid: one.pid,
+        protocol: one.protocol
+      }))
+    ];
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.13.34",
+  "version": "0.13.35",
   "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",