gdharness 1.2.33 → 1.2.35

package/build/index.js

@@ -25071,6 +25071,12 @@ function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
   return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
 }
+var KEPT_ID = /^[A-Za-z0-9_]+$/;
+function keptInside(given) {
+  const at = given.indexOf("::");
+  const inner = at === -1 ? "" : given.slice(at + 2);
+  return KEPT_ID.test(inner) ? { file: given.slice(0, at), inner } : { file: given, inner: undefined };
+}
 function resolveWithinProject(projectPath, candidatePath, options = {}) {
   const trimmed = candidatePath.trim();
   if (trimmed === "") {
@@ -25099,6 +25105,13 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
       reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
     };
   }
+  const kept = keptInside(trimmed);
+  if (kept.inner !== undefined) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' names the resource ${kept.inner} kept inside ${kept.file}, not a file. resource_edit read reads one by that path; this argument takes a file.`
+    };
+  }
   if (withoutScheme.includes(":")) {
     return {
       ok: false,
@@ -28704,9 +28717,14 @@ class GameLog {
     const owner = this.lastHeadline[source];
     if (owner !== null && /^\s/.test(line)) {
       owner.detail.push(line.trim());
+      owner.continues = false;
       return;
     }
     const headline = announced(line);
+    if (owner?.continues === true && headline === null) {
+      owner.detail.push(line.trim());
+      return;
+    }
     const detail = [];
     const entry = {
       index: this.entries.length,
@@ -28719,7 +28737,7 @@ class GameLog {
     if (headline?.byScript === true) {
       this.byScript.add(entry.index);
     }
-    this.lastHeadline[source] = headline ? { detail } : null;
+    this.lastHeadline[source] = headline ? { detail, continues: source === "stderr" && headline.text.endsWith(":") } : null;
   }
   raisedByScript(entry) {
     return this.byScript.has(entry.index);
@@ -33301,7 +33319,7 @@ var HEADLESS_OPERATIONS = dictionary({
     uid: "get_uid",
     refresh_classes: "refresh_class_cache"
   }),
-  project_export: dictionary({ list: "list_export_presets" }),
+  project_export: dictionary({ list: "list_export_presets", add_preset: "add_export_preset" }),
   script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
   script_info: dictionary({ structure: "get_script_info" }),
   editor_classes: dictionary({
@@ -35040,7 +35058,7 @@ var TOOL_SPECS = [
   {
     name: "project_settings",
     title: "Project settings",
-    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
     parameters: {
       projectPath: PROJECT_PATH2,
       setting: {
@@ -35138,8 +35156,8 @@ var TOOL_SPECS = [
         requires: ["scenePath"]
       },
       add_input_action: {
-        effect: "additive",
-        summary: "register an input action and its events",
+        effect: "destructive",
+        summary: "register an input action and its events, or rebind one that exists",
         requires: ["actionName", "events"]
       },
       remove_input_action: {
@@ -35277,20 +35295,36 @@ var TOOL_SPECS = [
   {
     name: "project_export",
     title: "Export",
-    description: "Export presets and exports.",
+    description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one, every platform option left at its default, and makes it the platform's runnable preset when the platform has none. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      preset: { type: "string", description: "Preset name from export_presets.cfg." },
+      preset: {
+        type: "string",
+        ops: ["run", "add_preset"],
+        description: "Preset name from export_presets.cfg. add_preset: the name of the new one."
+      },
+      platform: {
+        type: "string",
+        ops: ["add_preset"],
+        enum: ["Windows Desktop", "Linux", "macOS", "Android", "iOS", "Web"],
+        description: "add_preset: the platform the preset exports for."
+      },
       outputPath: {
         type: "string",
-        description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset.`
+        ops: ["run", "add_preset"],
+        description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset. add_preset: the path the preset exports to from the editor, optional.`
       },
-      debug: { type: "boolean", description: "run: a debug export. Default false." }
+      debug: { type: "boolean", ops: ["run"], description: "run: a debug export. Default false." }
     },
     requires: ["projectPath"],
     operations: {
       list: { effect: "read", summary: "the presets in export_presets.cfg", requires: [] },
-      run: { effect: "destructive", summary: "export with a preset", requires: ["preset", "outputPath"] }
+      run: { effect: "destructive", summary: "export with a preset", requires: ["preset", "outputPath"] },
+      add_preset: {
+        effect: "additive",
+        summary: "add an export preset to export_presets.cfg",
+        requires: ["preset", "platform"]
+      }
     }
   },
   {
@@ -35487,7 +35521,7 @@ var TOOL_SPECS = [
   {
     name: "scene_animation",
     title: "Animations",
-    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. Needs the editor connected.",
+    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write need the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
@@ -35519,7 +35553,11 @@ var TOOL_SPECS = [
         ops: ["read_states", "add_state", "connect_states"],
         description: "The AnimationTree node."
       },
-      stateName: { type: "string", ops: ["add_state"], description: "add_state: the state to add." },
+      stateName: {
+        type: "string",
+        ops: ["add_state"],
+        description: "add_state: the state to add. It goes right of the rightmost state in the editor's graph, answered under position."
+      },
       stateMachinePath: {
         type: "string",
         ops: ["read_states", "add_state", "connect_states"],
@@ -35694,7 +35732,7 @@ var TOOL_SPECS = [
       projectPath: PROJECT_PATH2,
       resourcePath: {
         ...RESOURCE_PATH,
-        description: `${RESOURCE_FILE} move: a directory too.`
+        description: `${RESOURCE_FILE} move: a directory too. read: also a resource kept inside a scene or resource file, by the path a read answers a property holding it with, such as "res://hero.tscn::Animation_jump".`
       },
       resourceType: {
         type: "string",
@@ -37548,7 +37586,7 @@ function exportPresetRefusal(projectPath, preset) {
   try {
     text = readFileSync24(join26(projectPath, "export_presets.cfg"), "utf8");
   } catch {
-    return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. The editor writes the file when a preset is added in Project > Export.`;
+    return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
   const names = [];
   let inPreset = false;
@@ -37566,9 +37604,9 @@ function exportPresetRefusal(projectPath, preset) {
   if (names.includes(preset)) {
     return null;
   }
-  return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. The editor adds one in Project > Export.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
+  return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. project_export add_preset adds one.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
 }
-function exportAnswer(ending, asked, before, after) {
+function exportAnswer(ending, asked, before, after, beside = []) {
   const { log } = ending;
   const written = after !== null && after !== before;
   const notCopied = librariesNotCopied(log.all);
@@ -37580,6 +37618,7 @@ function exportAnswer(ending, asked, before, after) {
     failure: ending.failure ?? undefined,
     errors: log.count("error"),
     warnings: log.count("warning"),
+    ...beside.length === 0 ? {} : { alsoWritten: beside },
     ...notCopied.length === 0 ? {} : {
       librariesNotLoaded: notCopied,
       extensionNote: `The export could not load ${notCopied.join(" and ")}: on Windows an engine running as the editor, which an export is, loads a GDExtension from a ~ copy beside the library, and another engine on this project held that copy: it could not be moved aside before the export, or another engine made a new one in between. Export again once that engine has loaded or exited.`
@@ -37602,6 +37641,20 @@ function exportAnswer(ending, asked, before, after) {
     isError: true
   };
 }
+function writtenBeside(before, after, output, within) {
+  return [...after].filter(([name, at]) => name !== output && before.get(name) !== at).map(([name]) => within === "." ? name : `${within}/${name}`).sort();
+}
+function filesIn(folder) {
+  const found = new Map;
+  try {
+    for (const entry of readdirSync11(folder, { withFileTypes: true })) {
+      if (entry.isFile()) {
+        found.set(entry.name, statSync12(join26(folder, entry.name)).mtimeMs);
+      }
+    }
+  } catch {}
+  return found;
+}
 function scanWaitAnswer(scanned, started = "game") {
   if (scanned.waitedMs === 0) {
     return {};
@@ -37839,6 +37892,9 @@ 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 OUTPUT_PATH_SOLUTIONS = [
+  'Give outputPath inside the project, relative to it, such as "build/game.exe" or "res://build/game.exe"; copy the build elsewhere once it is exported'
+];
 var PROJECT_FILE_ARGUMENTS = [
   "scenePath",
   "instancePath",
@@ -38893,6 +38949,9 @@ class GodotServer {
     if (tool === "project_import" && op === "set_options") {
       return await this.handleSetImportOptions(args);
     }
+    if (tool === "project_export" && op === "add_preset") {
+      return await this.handleAddExportPreset(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -38950,7 +39009,11 @@ class GodotServer {
       case "scene_create":
         return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
       case "scene_tree":
-        return await this.readFromFile(args, "scenePath", "read_scene_tree", async () => await bridge("list_scene_nodes"));
+        return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
+          scenePath: file,
+          depth: readNumber(args, "depth") ?? -1,
+          includeProperties: readBoolean(args, "includeProperties") ?? false
+        }), async () => await bridge("list_scene_nodes"));
       case "scene_node":
         switch (op) {
           case "add":
@@ -38980,9 +39043,17 @@ class GodotServer {
       case "scene_animation":
         switch (op) {
           case "read":
-            return await bridge("read_animations");
+            return await this.readFromFile(args, "scenePath", "read_animations", (file) => ({
+              scenePath: file,
+              playerNodePath: readNonEmptyString(args, "playerNodePath") ?? ".",
+              animationName: readString(args, "animationName") ?? ""
+            }), async () => await bridge("read_animations"));
           case "read_states":
-            return await bridge("read_animation_states");
+            return await this.readFromFile(args, "scenePath", "read_animation_states", (file) => ({
+              scenePath: file,
+              animTreePath: readString(args, "animTreePath") ?? "",
+              stateMachinePath: readString(args, "stateMachinePath") ?? ""
+            }), async () => await bridge("read_animation_states"));
           case "create":
             return await bridge("create_animation");
           case "add_track":
@@ -39009,8 +39080,14 @@ class GodotServer {
         switch (op) {
           case "move":
             return await this.handleMoveFile(args);
-          case "read":
-            return await this.readFromFile(args, "resourcePath", "read_resource", async () => await bridge("read_resource"));
+          case "read": {
+            const { file, inner } = keptInside(readString(args, "resourcePath") ?? "");
+            const kept = inner === undefined ? {} : { resourcePath: file, subResource: inner };
+            return await this.readFromFile({ ...args, ...kept }, "resourcePath", "read_resource", (found) => ({
+              resourcePath: inner === undefined ? found : `${found}::${inner}`,
+              includeDefaults: readBoolean(args, "includeDefaults") ?? false
+            }), async () => await bridge("read_resource", kept));
+          }
           case "create":
             return await bridge("create_resource");
           case "modify":
@@ -39938,6 +40015,30 @@ class GodotServer {
       return this.createErrorResponse(`Search failed: ${errorMessage(error)}`);
     }
   }
+  async handleAddExportPreset(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const given = readNonEmptyString(args, "outputPath");
+    const output = given === undefined ? null : resolveWithinProject(project.value.path, given);
+    if (output !== null && !output.ok) {
+      return this.createErrorResponse(output.reason, OUTPUT_PATH_SOLUTIONS);
+    }
+    const outcome = await this.operation("add_export_preset", {
+      preset: readString(args, "preset") ?? "",
+      platform: readString(args, "platform") ?? "",
+      outputPath: output?.relativePath ?? ""
+    }, project.value.path);
+    if (!outcome.ok || !this.editorHasOpen(project.value.path)) {
+      return this.answer(outcome);
+    }
+    return this.jsonTextResponse({
+      ...outcome.payload,
+      editorNote: "The editor open on this project read export_presets.cfg when it started and does not list this preset, and saving presets in its Export dialog writes its own list over the file. editor_launch restart loads the file; an export through project_export run reads the file and needs no restart.",
+      ...engineExtras(outcome)
+    });
+  }
   async handleExportProject(args) {
     const project = this.project(args);
     if (!project.ok) {
@@ -39946,11 +40047,14 @@ class GodotServer {
     const preset = readNonEmptyString(args, "preset") ?? "";
     const output = resolveWithinProject(project.value.path, readString(args, "outputPath") ?? "");
     if (!output.ok) {
-      return this.createErrorResponse(output.reason, PATH_SOLUTIONS);
+      return this.createErrorResponse(output.reason, OUTPUT_PATH_SOLUTIONS);
     }
     const noPreset = exportPresetRefusal(project.value.path, preset);
     if (noPreset !== null) {
-      return this.createErrorResponse(noPreset, ["project_export list reads the presets the project has"]);
+      return this.createErrorResponse(noPreset, [
+        "project_export list reads the presets the project has",
+        "project_export add_preset adds one"
+      ]);
     }
     const engine = await this.engine();
     if (!engine.ok) {
@@ -39977,6 +40081,7 @@ class GodotServer {
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
     const writtenAt = () => existsSync20(output.absolutePath) ? statSync12(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
+    const listedBefore = filesIn(folder);
     const freed = freeLibraryCopies(project.value.path);
     if (freed.setAside.length > 0 || freed.swept.length > 0) {
       this.logDebug(`Before the export: set aside ${freed.setAside.join(", ")}; swept ${freed.swept.join(", ")}`);
@@ -39990,7 +40095,8 @@ class GodotServer {
     if (ending.exitSignal === null && ending.exitCode === null) {
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt());
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename7(output.absolutePath), dirname18(output.relativePath).replaceAll("\\", "/"));
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside);
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -43400,7 +43506,7 @@ class GodotServer {
       ...leftChanged === undefined ? {} : { note: leftChanged }
     });
   }
-  async readFromFile(args, pathKey, operation, throughTheEditor) {
+  async readFromFile(args, pathKey, operation, paramsFor, throughTheEditor) {
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -43418,12 +43524,7 @@ class GodotServer {
     if (file === null) {
       return this.createErrorResponse(`${pathKey} must name a file inside the project.`);
     }
-    const params = operation === "read_scene_tree" ? {
-      scenePath: file,
-      depth: readNumber(args, "depth") ?? -1,
-      includeProperties: readBoolean(args, "includeProperties") ?? false
-    } : { resourcePath: file, includeDefaults: readBoolean(args, "includeDefaults") ?? false };
-    const outcome = await this.operation(operation, params, projectPath);
+    const outcome = await this.operation(operation, paramsFor(file), projectPath);
     if (!outcome.ok) {
       return this.answer(outcome);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.2.33",
+  "version": "1.2.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",