gdharness 0.12.0 → 0.12.2

package/README.md

@@ -73,11 +73,12 @@ and integration suites run against a real engine on all three before anything is
 
 What each kind of release means here:
 
-- **Patch**: an answer that was wrong is now right. The output can change, because a wrong answer
-  corrected is a fix rather than a feature, and leaving one wrong to protect whoever parsed it is
-  how a tool stops being worth asking.
-- **Minor**: a tool, an op, an argument or a field was added, or behaviour a caller can see
-  changed.
+- **Patch**: nearly everything. An answer that was wrong is now right, and the output may change
+  shape for it, because a wrong answer corrected is a fix rather than a feature and leaving one
+  wrong to protect whoever parsed it is how a tool stops being worth asking. An addition nothing
+  has to adapt to is a patch too: a new argument, a new field, an argument reaching further than it
+  did. Ignore all of it and your calls still work.
+- **Minor**: a new tool or a new op, meaning this does something it could not do before.
 - **Major**: a tool, an op, an argument or a field was renamed or taken away. Nothing else earns
   one.
 

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
     });
@@ -39477,6 +39485,9 @@ async function enablePlugins(engine, projectPath, names) {
   }
   return outcomes;
 }
+function autoloadIsOurs(named) {
+  return named === null || named === `res://${RUNTIME_AUTOLOAD.path}`;
+}
 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);
 }
@@ -39533,8 +39544,12 @@ function inspectProject(projectPath) {
     }
   }
   const autoload = settings["autoload"];
-  const runtimeAutoload = autoload !== undefined && typeof readString(autoload, RUNTIME_AUTOLOAD.name) === "string";
+  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 loaderEntry = [...named].find(([entry, path]) => entry !== RUNTIME_AUTOLOAD.name && path !== RUNTIME_AUTOLOAD.path && path.toLowerCase().includes("gdharness")) ?? null;
+  const runtimeLoaderAutoload = loaderEntry === null ? null : { name: loaderEntry[0], path: loaderEntry[1] };
   const tracked = trackedByGit(projectPath, [...named.values()]);
   for (const [name, path] of named) {
     if (tracked !== null && !tracked.has(path) && existsSync7(join8(projectPath, path))) {
@@ -39553,6 +39568,8 @@ function inspectProject(projectPath) {
     addons,
     pluginsEnabled,
     runtimeAutoload,
+    runtimeAutoloadPath,
+    runtimeLoaderAutoload,
     staleClasses,
     classCacheExists: cached !== null,
     problems
@@ -39839,6 +39856,24 @@ function said2(outcome, what) {
     console.error(`  engine ${entry.severity}: ${entry.text}`);
   }
 }
+async function registerRuntime(godot, projectPath) {
+  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}`);
+    return;
+  }
+  console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
+  if (!existsSync13(join17(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+    console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
+  }
+}
 var SETUP_FLAGS = new Set(["--runtime", "--no-runtime", "--no-connect", "--no-skill", "--json", "--yes"]);
 function namedHarnesses() {
   const flags = args.filter((arg) => arg.startsWith("--") && !SETUP_FLAGS.has(arg));
@@ -39941,8 +39976,7 @@ async function setup() {
     console.log(`${name}: ${outcome.ok ? String(outcome.payload["action"]) : "failed"}`);
   }
   if (runtime) {
-    said2(await setRuntime(godot, projectPath, true), "registering the runtime autoload");
-    console.log(`${RUNTIME_AUTOLOAD.name} autoload registered`);
+    await registerRuntime(godot, projectPath);
   }
   const classes = await runOperation(godot, "refresh_class_cache", {}, projectPath);
   said2(classes, "rebuilding the class list");
@@ -40042,7 +40076,7 @@ async function upgrade() {
     said2(outcome, `enabling ${EDITOR_PLUGINS[index] ?? ""}`);
   }
   if (before.runtimeAutoload) {
-    said2(await setRuntime(godot, projectPath, true), "registering the runtime autoload");
+    await registerRuntime(godot, projectPath);
   }
   said2(await runOperation(godot, "refresh_class_cache", {}, projectPath), "rebuilding the class list");
   const launch = launchFor(version, godot.godotPath, projectPath);
@@ -40092,8 +40126,12 @@ async function runtime3() {
   }
   const projectPath = projectArgument(2);
   const godot = await engine();
-  said2(await setRuntime(godot, projectPath, state === "on"), `turning the runtime ${state}`);
-  console.log(`${RUNTIME_AUTOLOAD.name} autoload ${state === "on" ? "registered" : "removed"}`);
+  if (state === "on") {
+    await registerRuntime(godot, projectPath);
+    return;
+  }
+  said2(await setRuntime(godot, projectPath, false), "turning the runtime off");
+  console.log(`${RUNTIME_AUTOLOAD.name} autoload removed`);
 }
 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.0",
+  "version": "0.12.2",
   "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",