gdharness 1.0.28 → 1.0.30

package/build/keeper.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// src/keeper.ts
+import { spawn } from "node:child_process";
+import { closeSync, openSync as openSync2 } from "node:fs";
+
+// src/outside.ts
+import { fileURLToPath } from "node:url";
+var KEEPER_SCRIPT = fileURLToPath(new URL("./keeper.js", import.meta.url));
+function decodeSpec(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+}
+function readLaunched(printed) {
+  const line = printed.split(`
+`).find((one) => one.trim() !== "")?.trim() ?? "";
+  const pid = /^pid (\d+)$/.exec(line);
+  if (pid?.[1] !== undefined) {
+    return { pid: Number(pid[1]) };
+  }
+  return { error: line.replace(/^error /, "") || "the launcher said nothing" };
+}
+
+// src/run-record.ts
+import { mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, join as join2 } from "node:path";
+
+// src/process-children.ts
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+
+// src/runtime-client.ts
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+// src/launch.ts
+function envValue(name, variables = process.env) {
+  const value = variables[name];
+  return value === undefined || value === "" ? undefined : value;
+}
+
+// src/runtime-client.ts
+function runtimeDirectory(variables = process.env) {
+  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
+  if (explicit) {
+    return explicit;
+  }
+  const perUser = envValue("XDG_RUNTIME_DIR", variables);
+  return join(perUser ?? tmpdir(), "gdharness");
+}
+var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
+var verdicts = new Map;
+var LATE_ANSWER_MS = 30 * 60000;
+var lateAnswers = new Map;
+
+// src/run-record.ts
+function runsDirectory() {
+  return join2(runtimeDirectory(), "runs");
+}
+function recordPath() {
+  return join2(runsDirectory(), "run.json");
+}
+function writeRunRecord(record) {
+  mkdirSync(runsDirectory(), { recursive: true });
+  writeFileSync(recordPath(), JSON.stringify(record, null, 2), "utf8");
+}
+function recordRunEnded(pid, ending) {
+  const path = recordPath();
+  const record = recordAt(path);
+  if (record === null || record.pid !== pid) {
+    return;
+  }
+  const written = {
+    ...record,
+    ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
+    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal }
+  };
+  try {
+    writeFileSync(path, JSON.stringify(written, null, 2), "utf8");
+  } catch {}
+}
+function recordAt(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const fields = parsed;
+  const pid = fields["pid"];
+  const transcript = fields["transcript"];
+  const startedAt = fields["startedAt"];
+  if (typeof pid !== "number" || typeof transcript !== "string" || typeof startedAt !== "number") {
+    return null;
+  }
+  const args = fields["arguments"];
+  return {
+    pid,
+    transcript,
+    startedAt,
+    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
+    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
+    ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
+  };
+}
+
+// src/keeper.ts
+async function startDetached(spec, output) {
+  return await new Promise((resolve) => {
+    const child = spawn(spec.command, [...spec.args], {
+      stdio: ["ignore", output, output],
+      detached: true,
+      ...spec.env === undefined ? {} : { env: spec.env }
+    });
+    child.once("error", (error) => {
+      resolve({ error: error.message });
+    });
+    child.once("spawn", () => {
+      resolve(child.pid === undefined ? { error: "the operating system gave it no pid" } : { child, pid: child.pid });
+    });
+  });
+}
+async function launch(encoded) {
+  const spec = decodeSpec(encoded);
+  if (spec.run === undefined) {
+    const started = await startDetached(spec, "ignore");
+    if ("error" in started) {
+      process.stdout.write(`error ${started.error}
+`);
+    } else {
+      started.child.unref();
+      process.stdout.write(`pid ${started.pid}
+`);
+    }
+    process.exit(0);
+  }
+  const keeper = spawn(process.execPath, [KEEPER_SCRIPT, "keep", encoded], {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    windowsHide: true
+  });
+  let printed = "";
+  let complained = "";
+  keeper.once("error", (error) => {
+    process.stdout.write(`error the keeper did not start: ${error.message}
+`);
+    process.exit(0);
+  });
+  keeper.stderr.on("data", (chunk) => {
+    complained += chunk.toString();
+  });
+  keeper.stdout.on("data", (chunk) => {
+    printed += chunk.toString();
+    if (!printed.includes(`
+`)) {
+      return;
+    }
+    const launched = readLaunched(printed);
+    process.stdout.write("pid" in launched ? `pid ${launched.pid}
+` : `error ${launched.error}
+`);
+    keeper.unref();
+    process.exit(0);
+  });
+  keeper.once("close", () => {
+    process.stdout.write(`error the keeper ended before it said anything${complained ? `: ${complained.trim()}` : ""}
+`);
+    process.exit(0);
+  });
+}
+async function keep(encoded) {
+  const spec = decodeSpec(encoded);
+  if (spec.run === undefined) {
+    process.stdout.write(`error a keeper was started without a run
+`);
+    process.exit(1);
+  }
+  const run = spec.run;
+  const transcript = openSync2(run.transcript, "a");
+  let started;
+  try {
+    started = await startDetached(spec, transcript);
+  } finally {
+    closeSync(transcript);
+  }
+  if ("error" in started) {
+    process.stdout.write(`error ${started.error}
+`);
+    process.exit(1);
+  }
+  const { child, pid } = started;
+  writeRunRecord({
+    pid,
+    transcript: run.transcript,
+    startedAt: run.startedAt,
+    projectPath: run.projectPath,
+    arguments: spec.args,
+    command: spec.command
+  });
+  child.once("exit", (code, signal) => {
+    recordRunEnded(pid, { exitCode: code, exitSignal: code === null ? signal : null });
+    process.exit(0);
+  });
+  process.stdout.write(`pid ${pid}
+`);
+  process.stdout.end();
+}
+var [mode, encoded] = process.argv.slice(2);
+if (mode === "launch" && encoded !== undefined) {
+  await launch(encoded);
+} else if (mode === "keep" && encoded !== undefined) {
+  await keep(encoded);
+} else {
+  process.stderr.write(`keeper.js launch|keep <spec>
+`);
+  process.exit(2);
+}

package/package.json

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