gdharness 0.9.5 → 0.9.6

package/build/cli.js

@@ -15382,7 +15382,10 @@ var init_tool_definitions = __esm(() => {
       parameters: {
         projectPath: PROJECT_PATH,
         preset: { type: "string", description: "Preset name from export_presets.cfg." },
-        outputPath: { type: "string", description: "Where the export is written, inside the project." },
+        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.`
+        },
         debug: { type: "boolean", description: "run: a debug export. Default false." }
       },
       requires: ["projectPath"],
@@ -15791,7 +15794,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match."
+          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern."
         },
         limit: {
           type: "number",
@@ -36002,7 +36005,7 @@ var init_setup = __esm(() => {
 
 // src/server.ts
 import { execFile as execFile5, spawn } from "node:child_process";
-import { existsSync as existsSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename2, dirname as dirname9, join as join15, normalize as normalize3 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -36935,6 +36938,12 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const folder = dirname9(output.absolutePath);
+    try {
+      mkdirSync7(folder, { recursive: true });
+    } catch (error) {
+      return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
+    }
     const debug = readBoolean(args, "debug") ?? false;
     const exportArgs = [
       "--headless",
@@ -38930,6 +38939,7 @@ init_class_cache();
 init_headless();
 init_resources();
 init_server_version();
+import { spawnSync } from "node:child_process";
 import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname3, join as join8 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -38992,6 +39002,29 @@ async function enablePlugins(engine, projectPath, names) {
 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 autoloadPaths(settings) {
+  const named = new Map;
+  for (const [name, value] of Object.entries(settings["autoload"] ?? {})) {
+    const said = typeof value === "string" ? value.replace(/^\*/, "") : "";
+    if (said.startsWith("res://")) {
+      named.set(name, said.slice("res://".length));
+    }
+  }
+  return named;
+}
+function trackedByGit(projectPath, wanted) {
+  if (wanted.length === 0) {
+    return new Set;
+  }
+  const asked = spawnSync("git", ["ls-files", "-z", "--", ...wanted], {
+    cwd: projectPath,
+    encoding: "utf8"
+  });
+  if (asked.status !== 0) {
+    return null;
+  }
+  return new Set(asked.stdout.split("\x00").filter(Boolean));
+}
 function enabledPlugins(settings) {
   const raw = settings["editor_plugins"]?.["enabled"];
   if (typeof raw !== "string") {
@@ -39023,6 +39056,13 @@ function inspectProject(projectPath) {
   }
   const autoload = settings["autoload"];
   const runtimeAutoload = autoload !== undefined && typeof readString(autoload, RUNTIME_AUTOLOAD.name) === "string";
+  const named = autoloadPaths(settings);
+  const tracked = trackedByGit(projectPath, [...named.values()]);
+  for (const [name, path] of named) {
+    if (tracked !== null && !tracked.has(path) && existsSync7(join8(projectPath, path))) {
+      problems.push(`the ${name} autoload names res://${path}, which git does not carry, so a clone boots with a missing script; commit that file, or point the autoload at one the project tracks`);
+    }
+  }
   const cached = cachedClasses(projectPath);
   const staleClasses = cached === null ? [] : staleAgainst(cached, projectPath);
   if (cached === null) {
@@ -39157,6 +39197,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a
 window and refuses headless rather than handing back the last frame anything drew.
 
+A headless game answers; a \`godot -s\` script run does not. It has no game in it, so the autoload
+stays quiet there rather than announcing a test tier as the project.
+
 The autoload reaches an export. \`gdharness runtime off\` in the project before shipping.
 
 ## At a breakpoint

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -23,6 +23,12 @@ const BIND_ADDRESS_SETTING: String = "gdharness/runtime/bind_address"
 ## expects. A fixed port is for a client that cannot read the announcement.
 const PORT_SETTING: String = "gdharness/runtime/port"
 
+## How the engine is told to run a script instead of the game: `godot -s thing.gd`.
+const SCRIPT_FLAGS: PackedStringArray = ["-s", "--script"]
+
+## Serve a script run anyway, for somebody driving a `-s` script rather than a game.
+const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
+
 var values: Values = Values.new()
 
 # The modules are members and not locals of _init, because a Callable holds its object by id
@@ -161,6 +167,15 @@ func _start_server() -> void:
 		_enabled = false
 		return
 
+	# And a script run has nothing to serve. Autoloads come up for `godot -s` as well, so a test
+	# tier or a batch tool binds a loopback port and writes an announcement under the project's
+	# own path: a gate that starts sixteen engines at once announces sixteen games that are not
+	# games, and a client asking the runtime anything while they run can be answered by whichever
+	# of them replies first. Measured on two projects before it was written here.
+	if _script_run() and not bool(ProjectSettings.get_setting(SCRIPT_RUNS_SETTING, false)):
+		_enabled = false
+		return
+
 	_server = TCPServer.new()
 	# listen() defaults bind_address to "*", which exposes the game to the whole network.
 	var bind_address: String = str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
@@ -180,6 +195,15 @@ func _start_server() -> void:
 	print("[gdharness] runtime listening on %s:%d, announced at %s" % [bind_address, _port, _announcement])
 
 
+## Whether the engine was told to run a script rather than the game.
+func _script_run() -> bool:
+	var given: PackedStringArray = OS.get_cmdline_args()
+	for flag: String in SCRIPT_FLAGS:
+		if given.has(flag):
+			return true
+	return false
+
+
 ## Where the announcement goes. The server derives the same path with the same precedence, so
 ## the two only meet if this stays in step with `runtimeDirectory` in src/runtime-client.ts.
 func _announcement_directory() -> String:

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -160,6 +160,17 @@ static func _is_literal(pattern: String) -> bool:
 	return not pattern.is_empty() and not pattern.contains("*") and not pattern.contains("?")
 
 
+## Whether [param said] is what a find asked for in [param wanted].
+##
+## A plain word is a contains, which is what somebody looking for the row about a person means. A
+## pattern is a glob, because [code]namePattern[/code] beside it is one and nobody writes `*Still*`
+## in one field meaning a glob and in the other meaning those characters. Written as a contains
+## only, a glob matched nothing at all and an empty answer reads as a control that is not on the
+## screen: twice in one session here, over a button that was.
+static func _says(said: String, wanted: String) -> bool:
+	return said.containsn(wanted) if _is_literal(wanted) else said.matchn(wanted)
+
+
 ## Every filter but the name, so a find that came back empty can say how many nodes the name was
 ## the only thing standing between it and.
 func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) -> bool:
@@ -168,7 +179,7 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 	# What this node says, rather than everything said underneath it. A row is then found by the
 	# label in it, and the path answered is that label's, which is where the words a caller is
 	# looking at actually are: matching every container above it would answer with the screen.
-	if not wanted["says"].is_empty() and not said_by(node).containsn(wanted["says"]):
+	if not wanted["says"].is_empty() and not _says(said_by(node), wanted["says"]):
 		return false
 	var script: Variant = node.get_script()
 	if not wanted["script"].is_empty():

package/build/index.js

@@ -10126,7 +10126,7 @@ function defectReport(where, error, godotVersion) {
 
 // src/server.ts
 import { execFile as execFile3, spawn } from "node:child_process";
-import { existsSync as existsSync7, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename, dirname as dirname4, join as join9, normalize as normalize2 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -27985,7 +27985,10 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH,
       preset: { type: "string", description: "Preset name from export_presets.cfg." },
-      outputPath: { type: "string", description: "Where the export is written, inside the project." },
+      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.`
+      },
       debug: { type: "boolean", description: "run: a debug export. Default false." }
     },
     requires: ["projectPath"],
@@ -28394,7 +28397,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["find"],
-        description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match."
+        description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern."
       },
       limit: {
         type: "number",
@@ -29715,6 +29718,12 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const folder = dirname4(output.absolutePath);
+    try {
+      mkdirSync4(folder, { recursive: true });
+    } catch (error) {
+      return this.createErrorResponse(`Cannot create ${dirname4(output.relativePath)} to export into: ${errorMessage(error)}`);
+    }
     const debug = readBoolean(args, "debug") ?? false;
     const exportArgs = [
       "--headless",

package/package.json

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