gdharness 1.0.30 → 1.0.32

package/build/keeper.js

@@ -6,10 +6,28 @@ 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 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() ?? "";
@@ -21,8 +39,18 @@ function readLaunched(printed) {
 }
 
 // src/run-record.ts
-import { mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, join as join2 } from "node:path";
+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";
@@ -57,15 +85,36 @@ var lateAnswers = new Map;
 function runsDirectory() {
   return join2(runtimeDirectory(), "runs");
 }
-function recordPath() {
-  return join2(runsDirectory(), "run.json");
+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(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  writeFileSync(runRecordPath(record.projectPath), JSON.stringify(record, null, 2), "utf8");
 }
-function recordRunEnded(pid, ending) {
-  const path = recordPath();
+function recordRunEnded(projectPath, pid, ending) {
+  const path = runRecordPath(projectPath);
   const record = recordAt(path);
   if (record === null || record.pid !== pid) {
     return;
@@ -115,7 +164,7 @@ async function startDetached(spec, output) {
     const child = spawn(spec.command, [...spec.args], {
       stdio: ["ignore", output, output],
       detached: true,
-      ...spec.env === undefined ? {} : { env: spec.env }
+      env: withChanges(process.env, spec.envChanges)
     });
     child.once("error", (error) => {
       resolve({ error: error.message });
@@ -125,8 +174,8 @@ async function startDetached(spec, output) {
     });
   });
 }
-async function launch(encoded) {
-  const spec = decodeSpec(encoded);
+async function launch() {
+  const spec = await receivedSpec();
   if (spec.run === undefined) {
     const started = await startDetached(spec, "ignore");
     if ("error" in started) {
@@ -139,8 +188,8 @@ async function launch(encoded) {
     }
     process.exit(0);
   }
-  const keeper = spawn(process.execPath, [KEEPER_SCRIPT, "keep", encoded], {
-    stdio: ["ignore", "pipe", "pipe"],
+  const keeper = spawn(process.execPath, [KEEPER_SCRIPT, "keep"], {
+    stdio: ["pipe", "pipe", "pipe"],
     detached: true,
     windowsHide: true
   });
@@ -151,6 +200,7 @@ async function launch(encoded) {
 `);
     process.exit(0);
   });
+  sendSpec(keeper, spec);
   keeper.stderr.on("data", (chunk) => {
     complained += chunk.toString();
   });
@@ -173,8 +223,8 @@ async function launch(encoded) {
     process.exit(0);
   });
 }
-async function keep(encoded) {
-  const spec = decodeSpec(encoded);
+async function keep() {
+  const spec = await receivedSpec();
   if (spec.run === undefined) {
     process.stdout.write(`error a keeper was started without a run
 `);
@@ -203,20 +253,20 @@ async function keep(encoded) {
     command: spec.command
   });
   child.once("exit", (code, signal) => {
-    recordRunEnded(pid, { exitCode: code, exitSignal: code === null ? signal : null });
+    recordRunEnded(run.projectPath, 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);
+var mode = process.argv[2];
+if (mode === "launch") {
+  await launch();
+} else if (mode === "keep") {
+  await keep();
 } else {
-  process.stderr.write(`keeper.js launch|keep <spec>
+  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.30",
+  "version": "1.0.32",
   "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",