gdharness 0.13.35 → 0.13.36

package/build/cli.js

@@ -15994,7 +15994,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: running is asked of the operating system, endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
       parameters: {
         severity: {
           type: "string",
@@ -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. 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.',
+      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 that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
       parameters: {},
       requires: []
     },
@@ -36662,23 +36662,32 @@ function recordAt(path) {
 }
 function runningAs(pid) {
   if (process.platform === "win32") {
-    const line = windowsCommandLine(pid);
-    if (line !== null) {
-      return { kind: "commandLine", text: line };
+    const answer = windowsCommandLine(pid);
+    if (answer !== null) {
+      const [, ...rest] = answer.split(`
+`);
+      const line = rest.join(`
+`).trim();
+      const began = startedAt(pid, answer);
+      if (line !== "") {
+        return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
+      }
     }
     const image = windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
+    const began = startedAt(pid, null);
+    const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
       const raw = readFileSync14(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
-    return args === "" ? null : { kind: "commandLine", text: args };
+    return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
@@ -36717,13 +36726,30 @@ function windowsCommandLine(pid) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+      `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
     ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
+function startedAt(pid, windowsAnswer) {
+  if (process.platform === "win32") {
+    const when = Date.parse(windowsAnswer?.split(`
+`)[0]?.trim() ?? "");
+    return Number.isNaN(when) ? null : when;
+  }
+  try {
+    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    const when = Date.parse(said);
+    return said === "" || Number.isNaN(when) ? null : when;
+  } catch {
+    return null;
+  }
+}
 function windowsImage(pid) {
   try {
     const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
@@ -36746,6 +36772,9 @@ function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
   }
+  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
+    return false;
+  }
   const engine = record.command === undefined ? null : basename2(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
@@ -36804,7 +36833,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
-var AN_EDITOR;
+var AN_EDITOR, SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_runtime_client();
   AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
@@ -36840,12 +36869,18 @@ function stillRunning(run) {
   if (!run.throughEditor && run.process === null && run.pid !== null) {
     return alive(run.pid);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return true;
 }
 function runIsUp(run, editorSays) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return editorSays ?? stillRunning(run);
 }
 function runtimeVerdict(endpoint, after) {
@@ -38599,6 +38634,10 @@ class GodotServer {
       budgetMs,
       giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
     });
+    const going = this.currentRun();
+    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+      going.announcedPid = endpoint.pid;
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -38708,9 +38747,15 @@ class GodotServer {
       running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return;
     }
+    const signalled = runningAs(running.pid);
+    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    let landed = true;
     try {
       process.kill(running.pid);
-    } catch {}
+    } catch {
+      landed = false;
+    }
+    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -39048,7 +39093,7 @@ class GodotServer {
       notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),
@@ -40844,8 +40889,13 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
   from being known. For a long run it also names a transcript file: read that for output and this
   answer for state. Never decide a run has ended by watching the file stop growing, or a process
-  list, or a timeout. \`running\` is asked of the operating system and \`endedBy\` says whether
-  gdharness ended it; a bench between prints looks exactly like a bench that died to everything else.
+  list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
+  \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
+  whenever there is a process to ask about: every run started through \`editor_run\`, and every
+  editor-played run whose game announced its runtime. An editor-played run in a project with no
+  runtime addon announces nothing, so there is no process id and \`running\` is the editor's answer,
+  which can lag by seconds after the game has gone. \`editor_status\` names the game under
+  \`runtimes\`, which does not depend on the editor answering.
 - One server, one editor. A second project is a second harness session with its own server, and
   that works: each editor is opened on its own language server and debug adapter ports, and says
   where it serves. Two editors on one project is the thing to refuse.

package/build/index.js

@@ -28256,23 +28256,32 @@ function recordAt(path) {
 }
 function runningAs(pid) {
   if (process.platform === "win32") {
-    const line = windowsCommandLine(pid);
-    if (line !== null) {
-      return { kind: "commandLine", text: line };
+    const answer = windowsCommandLine(pid);
+    if (answer !== null) {
+      const [, ...rest] = answer.split(`
+`);
+      const line = rest.join(`
+`).trim();
+      const began = startedAt(pid, answer);
+      if (line !== "") {
+        return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
+      }
     }
     const image = windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
+    const began = startedAt(pid, null);
+    const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
       const raw = readFileSync9(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
-    return args === "" ? null : { kind: "commandLine", text: args };
+    return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
@@ -28311,13 +28320,30 @@ function windowsCommandLine(pid) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+      `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
     ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
+function startedAt(pid, windowsAnswer) {
+  if (process.platform === "win32") {
+    const when = Date.parse(windowsAnswer?.split(`
+`)[0]?.trim() ?? "");
+    return Number.isNaN(when) ? null : when;
+  }
+  try {
+    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    const when = Date.parse(said);
+    return said === "" || Number.isNaN(when) ? null : when;
+  } catch {
+    return null;
+  }
+}
 function windowsImage(pid) {
   try {
     const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
@@ -28337,10 +28363,14 @@ function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, runningAs(record.pid), "possible");
 }
 var AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
+var SAME_RUN_WINDOW_MS = 1e4;
 function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
   }
+  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
+    return false;
+  }
   const engine = record.command === undefined ? null : basename(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
@@ -29080,7 +29110,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: running is asked of the operating system, endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
     parameters: {
       severity: {
         type: "string",
@@ -29108,7 +29138,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. 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.',
+    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 that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
     parameters: {},
     requires: []
   },
@@ -29538,12 +29568,18 @@ function stillRunning(run) {
   if (!run.throughEditor && run.process === null && run.pid !== null) {
     return alive(run.pid);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return true;
 }
 function runIsUp(run, editorSays) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return editorSays ?? stillRunning(run);
 }
 function runtimeVerdict(endpoint, after) {
@@ -31339,6 +31375,10 @@ class GodotServer {
       budgetMs,
       giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
     });
+    const going = this.currentRun();
+    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+      going.announcedPid = endpoint.pid;
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -31448,9 +31488,15 @@ class GodotServer {
       running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return;
     }
+    const signalled = runningAs(running.pid);
+    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    let landed = true;
     try {
       process.kill(running.pid);
-    } catch {}
+    } catch {
+      landed = false;
+    }
+    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -31788,7 +31834,7 @@ class GodotServer {
       notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),

package/package.json

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