gdharness 0.12.17 → 0.13.0

package/build/index.js

@@ -10138,7 +10138,7 @@ function defectReport(where, error, godotVersion) {
 }
 
 // src/server.ts
-import { execFile as execFile3, spawn } from "node:child_process";
+import { execFile as execFile4, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync,
@@ -10157,7 +10157,7 @@ import { tmpdir as tmpdir4 } from "node:os";
 import { basename as basename2, dirname as dirname4, join as join10, normalize as normalize2 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -25450,6 +25450,9 @@ function announced(line) {
   return { severity: match[2] === "WARNING" ? "warning" : "error", text: match[3] ?? "" };
 }
 var STREAMS = ["stdout", "stderr", "transcript"];
+function forAnswer(entries) {
+  return entries.map((entry) => entry.detail.length === 0 ? { index: entry.index, severity: entry.severity, source: entry.source, text: entry.text } : entry);
+}
 
 class GameLog {
   entries = [];
@@ -26356,6 +26359,40 @@ async function runOperation(engine, operation, params, projectPath) {
   return { ok: true, payload, messages: problems(stderr) };
 }
 
+// src/headless-operations.ts
+var HEADLESS_OPERATIONS = dictionary({
+  project_settings: dictionary({
+    get: "get_project_setting",
+    set: "set_project_setting",
+    add_autoload: "add_autoload",
+    remove_autoload: "remove_autoload",
+    set_main_scene: "set_main_scene",
+    add_input_action: "add_input_action",
+    enable_plugin: "enable_plugin",
+    disable_plugin: "disable_plugin",
+    add_audio_bus: "create_audio_bus",
+    set_audio_bus_effect: "set_audio_bus_effect",
+    set_audio_bus_volume: "set_audio_bus_volume"
+  }),
+  project_import: dictionary({
+    status: "get_import_status",
+    options: "get_import_options",
+    set_options: "set_import_options",
+    reimport: "reimport_resource",
+    uid: "get_uid",
+    refresh_uids: "resave_resources",
+    refresh_classes: "refresh_class_cache"
+  }),
+  project_export: dictionary({ list: "list_export_presets" }),
+  script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
+  script_info: dictionary({ structure: "get_script_info" }),
+  editor_classes: dictionary({
+    query: "query_classes",
+    info: "query_class_info",
+    inheritance: "inspect_inheritance"
+  })
+});
+
 // src/issues.ts
 import { createHash as createHash2 } from "node:crypto";
 import process5 from "node:process";
@@ -27212,6 +27249,43 @@ async function handleLSPTool(client, toolName, args) {
   }
 }
 
+// src/process-time.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
+var ASK_TIMEOUT_MS = 2000;
+async function cpuSecondsOf(pid) {
+  try {
+    return process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
+  } catch {
+    return;
+  }
+}
+async function askWindows(pid) {
+  const { stdout } = await run3("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS, windowsHide: true });
+  const seconds = Number(stdout.trim().replace(",", "."));
+  return Number.isFinite(seconds) ? seconds : undefined;
+}
+async function askPosix(pid) {
+  const { stdout } = await run3("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS });
+  return secondsFromClock(stdout.trim());
+}
+function secondsFromClock(printed) {
+  if (printed === "") {
+    return;
+  }
+  const dashed = printed.includes("-");
+  const days = dashed ? printed.slice(0, printed.indexOf("-")) : null;
+  const clock = dashed ? printed.slice(printed.indexOf("-") + 1) : printed;
+  const parts = clock.split(":").map((part) => Number(part));
+  if (parts.length === 0 || parts.some((part) => !Number.isFinite(part))) {
+    return;
+  }
+  const seconds = parts.reduce((total, part) => total * 60 + part, 0);
+  const extra = days === null ? 0 : Number(days) * 86400;
+  return Number.isFinite(extra) ? seconds + extra : undefined;
+}
+
 // src/project-scan.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { join as join6 } from "node:path";
@@ -27562,6 +27636,11 @@ function readPositiveNumber(params, key) {
   const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
   return typeof number === "number" && Number.isFinite(number) && number > 0 ? number : undefined;
 }
+function readNonNegativeNumber(params, key) {
+  const value = params[key];
+  const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) && number >= 0 ? number : undefined;
+}
 function readBoolean(params, key) {
   const value = params[key];
   if (typeof value === "boolean") {
@@ -28205,6 +28284,11 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH,
       setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
+      prefix: {
+        type: "string",
+        ops: ["get"],
+        description: 'get: answer with every setting whose name starts with this, and the type the engine registers for each, instead of one setting by name. "debug/gdscript/warnings/" answers the whole family. The type matters: a family of levels can hold a setting that is a bool, and writing a level over it looks like it worked.'
+      },
       value: {
         blank: true,
         description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}. "" writes an empty string.'
@@ -28226,7 +28310,7 @@ var TOOL_SPECS = [
     },
     requires: ["projectPath"],
     operations: {
-      get: { summary: "read one setting", requires: ["setting"] },
+      get: { summary: "read one setting, or every setting under prefix", requires: [] },
       set: { summary: "write one setting", requires: ["setting", "value"] },
       add_autoload: { summary: "register an autoload singleton", requires: ["name", "path"] },
       remove_autoload: { summary: "unregister an autoload", requires: ["name"] },
@@ -28633,7 +28717,7 @@ var TOOL_SPECS = [
       runtimeWaitMs: {
         type: "number",
         ops: ["start"],
-        description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later."
+        description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
       },
       frames: {
         type: "number",
@@ -28642,15 +28726,16 @@ var TOOL_SPECS = [
       },
       timeoutMs: {
         type: "number",
-        ops: ["check"],
-        description: "check: how long to give the boot before it is called hung. Default 60000."
+        ops: ["check", "wait"],
+        description: "check: how long to give the boot before it is called hung. Default 60000. wait: how long to wait for the run to end before answering anyway. Default 600000."
       }
     },
     requires: ["projectPath"],
     operations: {
       start: { summary: "run the project until it quits or is stopped", requires: [] },
       stop: { summary: "end the run and answer with what it printed last", requires: [] },
-      check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] }
+      check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] },
+      wait: { summary: "wait for the run to end, then answer as editor_output does", requires: [] }
     },
     defaultOperation: "start"
   },
@@ -28667,6 +28752,10 @@ var TOOL_SPECS = [
         type: "boolean",
         description: "Only entries printed since the previous editor_output. Default false."
       },
+      cpu: {
+        type: "boolean",
+        description: "Also answer with cpuSeconds, the processor time the run has used. Default false, because asking costs a subprocess. Worth it when elapsedMs is climbing and nothing is being printed: processor time standing still is a run that has stopped doing anything, rather than one that is slow."
+      },
       contains: {
         type: "string",
         description: "Only entries mentioning this text, matched against everything the run has printed rather than against the entries this answer would otherwise carry: a line is found however much was printed after it."
@@ -29092,7 +29181,7 @@ function buildToolDefinitions() {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
-var run3 = promisify3(execFile3);
+var run4 = promisify4(execFile4);
 var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var SLOWEST_FRAME_RATE = 20;
@@ -29198,11 +29287,20 @@ function wrongTypes(spec, args) {
 }
 var BRIDGE_RETRY_MS = 2000;
 var SUCCESSOR_CHECK_MS = 1e4;
+var WAIT_FOR_RUN_MS = 600000;
+var RUN_POLL_MS = 250;
 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"
 ];
-var PROJECT_FILE_ARGUMENTS = ["scenePath", "scriptPath", "resourcePath", "newPath", "path", "script"];
+var PROJECT_FILE_ARGUMENTS = [
+  "scenePath",
+  "scriptPath",
+  "resourcePath",
+  "newPath",
+  "path",
+  "script"
+];
 function escapingPropertyValue(properties) {
   if (typeof properties !== "object" || properties === null) {
     return;
@@ -29222,38 +29320,6 @@ var DEBUG_STATE_CALLS = dictionary({
   output: "dap_get_output",
   variables: "dap_get_variables"
 });
-var HEADLESS_OPERATIONS = dictionary({
-  project_settings: dictionary({
-    get: "get_project_setting",
-    set: "set_project_setting",
-    add_autoload: "add_autoload",
-    remove_autoload: "remove_autoload",
-    set_main_scene: "set_main_scene",
-    add_input_action: "add_input_action",
-    enable_plugin: "enable_plugin",
-    disable_plugin: "disable_plugin",
-    add_audio_bus: "create_audio_bus",
-    set_audio_bus_effect: "set_audio_bus_effect",
-    set_audio_bus_volume: "set_audio_bus_volume"
-  }),
-  project_import: dictionary({
-    status: "get_import_status",
-    options: "get_import_options",
-    set_options: "set_import_options",
-    reimport: "reimport_resource",
-    uid: "get_uid",
-    refresh_uids: "resave_resources",
-    refresh_classes: "refresh_class_cache"
-  }),
-  project_export: dictionary({ list: "list_export_presets" }),
-  script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
-  script_info: dictionary({ structure: "get_script_info" }),
-  editor_classes: dictionary({
-    query: "query_classes",
-    info: "query_class_info",
-    inheritance: "inspect_inheritance"
-  })
-});
 var PROJECT_INFO_SECTIONS = dictionary({
   autoloads: { operation: "list_autoloads", params: () => ({}) },
   plugins: { operation: "list_plugins", params: () => ({}) },
@@ -29786,9 +29852,15 @@ class GodotServer {
       case "editor_launch":
         return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
       case "editor_run":
-        return op === "stop" ? await this.handleStopProject() : await this.handleRunProject(args, op);
+        if (op === "stop") {
+          return await this.handleStopProject();
+        }
+        if (op === "wait") {
+          return await this.handleWaitForRun(args);
+        }
+        return await this.handleRunProject(args, op);
       case "editor_output":
-        return this.handleGetDebugOutput(args);
+        return await this.handleGetDebugOutput(args);
       case "editor_status":
         return await this.handleEditorStatus();
       case "editor_rescan":
@@ -30159,7 +30231,7 @@ class GodotServer {
     const log = new GameLog;
     let exitCode = 0;
     try {
-      const { stdout, stderr } = await run3(engine.value, exportArgs, { timeout: 300000 });
+      const { stdout, stderr } = await run4(engine.value, exportArgs, { timeout: 300000 });
       log.append("stdout", stdout);
       log.append("stderr", stderr);
     } catch (error) {
@@ -30183,7 +30255,7 @@ class GodotServer {
       exitCode,
       errors: log.count("error"),
       warnings: log.count("warning"),
-      entries: problems.entries
+      entries: forAnswer(problems.entries)
     };
     if (!verdict.exported) {
       return {
@@ -30300,7 +30372,7 @@ class GodotServer {
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: printed.slice(0, 60)
+              entries: forAnswer(printed.slice(0, 60))
             }, null, 2)
           }
         ],
@@ -30354,7 +30426,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run3(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run4(godotPath, ["--version"], { timeout: 1e4 });
       return stdout.trim();
     } catch (error) {
       this.logDebug(`Godot did not answer --version: ${errorMessage(error)}`);
@@ -30649,7 +30721,7 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    const runtimeWaitMs = readPositiveNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
+    const runtimeWaitMs = readNonNegativeNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
@@ -30971,10 +31043,24 @@ class GodotServer {
       frames,
       errors,
       warnings,
-      entries: boot.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries
+      entries: forAnswer(boot.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
-  handleGetDebugOutput(args) {
+  async handleWaitForRun(args) {
+    const run = this.currentRun();
+    if (!run) {
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
+    }
+    const budgetMs = readPositiveNumber(args, "timeoutMs") ?? WAIT_FOR_RUN_MS;
+    const until = Date.now() + budgetMs;
+    while (stillRunning(run) && Date.now() < until) {
+      this.drainEditorOutput(run);
+      this.drainTranscript(run);
+      await delay3(RUN_POLL_MS);
+    }
+    return await this.handleGetDebugOutput(args, stillRunning(run) ? budgetMs : undefined);
+  }
+  async handleGetDebugOutput(args, waitedMs) {
     const run = this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
@@ -30993,14 +31079,19 @@ class GodotServer {
       limit: readPositiveNumber(args, "limit") ?? 200
     });
     const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const wanted = readBoolean(args, "cpu") ?? false;
+    const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
     const notes = [];
+    if (waitedMs !== undefined) {
+      notes.push(`The wait of ${waitedMs}ms ran out and the run is still going, so this is what it had printed by then rather than everything it will print. editor_run wait again to keep waiting.`);
+    }
     if (run.endedUnwatched === true) {
       notes.push("This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript.");
     }
     if (typeof run.endedHere === "string") {
       notes.push(`This run was ended here, by ${run.endedHere}.`);
     } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
-      notes.push("Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
+      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.`);
@@ -31018,9 +31109,12 @@ class GodotServer {
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
       transcript: run.transcript ?? undefined,
+      startedAt: new Date(run.startedAt).toISOString(),
+      elapsedMs: Date.now() - run.startedAt,
+      cpuSeconds,
       note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,
-      entries: selected.entries
+      entries: forAnswer(selected.entries)
     });
   }
   async handleStopProject() {
@@ -31040,7 +31134,7 @@ class GodotServer {
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      entries: stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries
+      entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
   async handleRescanFilesystem(args) {

package/package.json

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