gdharness 1.0.29 → 1.0.31

package/build/keeper.js

@@ -0,0 +1,272 @@
+#!/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";
+function withChanges(base, changes) {
+  const env = { ...base };
+  for (const [name, value] of Object.entries(changes)) {
+    if (value === null) {
+      delete env[name];
+    } else {
+      env[name] = value;
+    }
+  }
+  return env;
+}
+function sendSpec(child, spec) {
+  child.stdin?.end(JSON.stringify(spec), "utf8");
+}
+async function receivedSpec() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+var KEEPER_SCRIPT = fileURLToPath(new URL("./keeper.js", import.meta.url));
+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 { createHash } from "node:crypto";
+import {
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname as dirname2, join as join2, resolve as resolve2 } 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 realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join2(realpathSync.native(at), ...missing);
+    } catch {
+      const parent = dirname2(at);
+      if (parent === at) {
+        return path;
+      }
+      missing.unshift(basename(at));
+      at = parent;
+    }
+  }
+}
+function projectKey(projectPath) {
+  const real = realAsFarAsItExists(resolve2(projectPath)).replace(/[\\/]+$/, "");
+  const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
+  return createHash("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+}
+function runRecordPath(projectPath, directory = runtimeDirectory()) {
+  return join2(directory, "runs", `note-${projectKey(projectPath)}.json`);
+}
+function writeRunRecord(record) {
+  mkdirSync(runsDirectory(), { recursive: true });
+  writeFileSync(runRecordPath(record.projectPath), JSON.stringify(record, null, 2), "utf8");
+}
+function recordRunEnded(projectPath, pid, ending) {
+  const path = runRecordPath(projectPath);
+  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,
+      env: withChanges(process.env, spec.envChanges)
+    });
+    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() {
+  const spec = await receivedSpec();
+  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"], {
+    stdio: ["pipe", "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);
+  });
+  sendSpec(keeper, spec);
+  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() {
+  const spec = await receivedSpec();
+  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(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
+    process.exit(0);
+  });
+  process.stdout.write(`pid ${pid}
+`);
+  process.stdout.end();
+}
+var mode = process.argv[2];
+if (mode === "launch") {
+  await launch();
+} else if (mode === "keep") {
+  await keep();
+} else {
+  process.stderr.write(`keeper.js launch|keep, with the spec on stdin
+`);
+  process.exit(2);
+}

package/package.json

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