gdharness 0.12.1 → 0.12.3

package/build/cli.js

@@ -15714,7 +15714,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.",
+      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.",
       parameters: {
         severity: {
           type: "string",
@@ -38002,6 +38002,13 @@ class GodotServer {
       limit: readPositiveNumber(args, "limit") ?? 200
     });
     const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const notes = [];
+    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 (run.transcript !== null && selected.omitted > 0) {
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written.`);
+    }
     return this.jsonTextResponse({
       running: stillRunning(run),
       exitCode: run.exitCode,
@@ -38013,7 +38020,8 @@ class GodotServer {
       heldAt: halt,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
-      note: run.endedUnwatched === true ? "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." : undefined,
+      transcript: run.transcript ?? undefined,
+      note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,
       entries: selected.entries
     });
@@ -39483,6 +39491,23 @@ function autoloadIsOurs(named) {
 async function setRuntime(engine, projectPath, on) {
   return on ? await runOperation2(engine, "add_autoload", { name: RUNTIME_AUTOLOAD.name, path: `res://${RUNTIME_AUTOLOAD.path}`, enabled: true }, projectPath) : await runOperation2(engine, "remove_autoload", { name: RUNTIME_AUTOLOAD.name }, projectPath);
 }
+function loaderAmong(projectPath, named) {
+  let byName = null;
+  for (const [entry, path] of named) {
+    if (entry === RUNTIME_AUTOLOAD.name || path === RUNTIME_AUTOLOAD.path) {
+      continue;
+    }
+    let source = "";
+    try {
+      source = readFileSync7(join8(projectPath, path), "utf8");
+    } catch {}
+    if (source.includes(RUNTIME_AUTOLOAD.path)) {
+      return { name: entry, path };
+    }
+    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path } : null;
+  }
+  return byName;
+}
 function autoloadPaths(settings) {
   const named = new Map;
   for (const [name, value] of Object.entries(settings["autoload"] ?? {})) {
@@ -39537,9 +39562,10 @@ function inspectProject(projectPath) {
   }
   const autoload = settings["autoload"];
   const registered = autoload === undefined ? undefined : readString(autoload, RUNTIME_AUTOLOAD.name);
-  const runtimeAutoload = typeof registered === "string";
   const runtimeAutoloadPath = typeof registered === "string" ? registered.replace(/^\*/, "") : null;
   const named = autoloadPaths(settings);
+  const runtimeLoaderAutoload = loaderAmong(projectPath, named);
+  const runtimeAutoload = runtimeAutoloadPath !== null || runtimeLoaderAutoload !== null;
   const tracked = trackedByGit(projectPath, [...named.values()]);
   for (const [name, path] of named) {
     if (tracked !== null && !tracked.has(path) && existsSync7(join8(projectPath, path))) {
@@ -39559,6 +39585,7 @@ function inspectProject(projectPath) {
     pluginsEnabled,
     runtimeAutoload,
     runtimeAutoloadPath,
+    runtimeLoaderAutoload,
     staleClasses,
     classCacheExists: cached !== null,
     problems
@@ -39846,7 +39873,13 @@ function said2(outcome, what) {
   }
 }
 async function registerRuntime(godot, projectPath) {
-  const named = inspectProject(projectPath).runtimeAutoloadPath;
+  const report = inspectProject(projectPath);
+  const named = report.runtimeAutoloadPath;
+  const loader = report.runtimeLoaderAutoload;
+  if (named === null && loader !== null) {
+    console.log(`${loader.name} autoload already names res://${loader.path}, which is this project bringing the runtime up its own way, so ${RUNTIME_AUTOLOAD.name} was not added: a second entry would come up beside it without whatever that file refuses. If it is not a loader, add ${RUNTIME_AUTOLOAD.name} yourself.`);
+    return;
+  }
   if (autoloadIsOurs(named)) {
     said2(await setRuntime(godot, projectPath, true), "registering the runtime autoload");
     console.log(`${RUNTIME_AUTOLOAD.name} autoload registered at res://${RUNTIME_AUTOLOAD.path}`);
@@ -40092,7 +40125,7 @@ function doctorReport(projectPath) {
       console.log(`addons/${addon.name}: ${addon.installed ? `installed, ${addon.version ?? "unknown version"}${addon.current ? "" : " (not this version)"}` : "missing"}`);
     }
     console.log(`editor plugins enabled: ${report.pluginsEnabled.join(", ") || "none"}`);
-    console.log(`runtime autoload: ${report.runtimeAutoload ? "registered" : "not registered"}`);
+    console.log(`runtime autoload: ${report.runtimeLoaderAutoload === null ? report.runtimeAutoload ? "registered" : "not registered" : `registered through res://${report.runtimeLoaderAutoload.path}, as ${report.runtimeLoaderAutoload.name}`}`);
     console.log(report.classCacheExists ? `class cache: ${report.staleClasses.length === 0 ? "current" : `stale for ${report.staleClasses.join(", ")}`}` : "class cache: missing");
     for (const problem of report.problems) {
       console.log(`problem: ${problem}`);
@@ -40113,8 +40146,20 @@ async function runtime3() {
     await registerRuntime(godot, projectPath);
     return;
   }
+  const before = inspectProject(projectPath);
+  const loader = before.runtimeLoaderAutoload;
+  if (before.runtimeAutoloadPath === null) {
+    console.log(`${RUNTIME_AUTOLOAD.name} autoload is not registered, so there was nothing to remove`);
+    if (loader !== null) {
+      console.log(`  ${loader.name} names res://${loader.path}, which brings the runtime up its own way. That line is this project's, not this tool's, so nothing here has changed it: whatever that file decides about a release build still decides it.`);
+    }
+    return;
+  }
   said2(await setRuntime(godot, projectPath, false), "turning the runtime off");
   console.log(`${RUNTIME_AUTOLOAD.name} autoload removed`);
+  if (loader !== null) {
+    console.log(`  ${loader.name} still names res://${loader.path}, which brings the runtime up its own way: this command has not touched it, so whatever that file decides about a release build still decides it`);
+  }
 }
 async function classes() {
   const projectPath = projectArgument(1);

package/build/index.js

@@ -28518,7 +28518,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.",
+    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.",
     parameters: {
       severity: {
         type: "string",
@@ -30784,6 +30784,13 @@ class GodotServer {
       limit: readPositiveNumber(args, "limit") ?? 200
     });
     const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const notes = [];
+    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 (run.transcript !== null && selected.omitted > 0) {
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written.`);
+    }
     return this.jsonTextResponse({
       running: stillRunning(run),
       exitCode: run.exitCode,
@@ -30795,7 +30802,8 @@ class GodotServer {
       heldAt: halt,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
-      note: run.endedUnwatched === true ? "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." : undefined,
+      transcript: run.transcript ?? undefined,
+      note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,
       entries: selected.entries
     });

package/package.json

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