forgedock 1.23.1 → 1.24.1

package/bin/forgedock.mjs

@@ -3209,6 +3209,7 @@ function help() {
     ["npx forgedock run <cmd> [args]", "Run a command headlessly (local claude CLI or Anthropic API)"],
     ["npx forgedock run-issue <issue> --lane <lane> [--path core|full] [--retry] [--wait-lease]", "Run the lean core work-on on one issue (default; --path full = legacy multi-phase pipeline) (--retry reopens an engine-error run, or a needs-human run once the label is cleared; --wait-lease waits for a held lease; exit 75 = deferred, lease held)"],
     ["npx forgedock orchestrate <issue...> [--parallel K] [--lane L]", "Run core work-on on several issues with bounded concurrency and Depends-on ordering"],
+    ["npx forgedock gc", "Prune stale per-run scratch dirs under ~/.forge/tmp/runs (older than 6h, owner dead)"],
     ["npx forgedock resume-stalled [--dry-run]", "Fleet stall recovery — re-dispatch expired-lease issues"],
     ["npx forgedock demo", "Set up a risk-free demo repo and print next steps"],
     ["npx forgedock labels [setup] [--repo owner/repo]", "Bootstrap ForgeDock-managed labels on a GitHub repo (idempotent)"],
@@ -3782,10 +3783,10 @@ async function watch() {
 // The journey-routed commands render their own branded marks (hero/compact);
 // splash() would double-brand them. Engine-surface commands, help, and
 // unknown-command output keep the logo.
-const SPLASH_COMMANDS = new Set(["run", "run-issue", "orchestrate", "resume-stalled", "demo", "doctor", "watch", "help", "--help", "-h"]);
+const SPLASH_COMMANDS = new Set(["run", "run-issue", "orchestrate", "gc", "resume-stalled", "demo", "doctor", "watch", "help", "--help", "-h"]);
 const KNOWN_COMMANDS = new Set([
   "install", "init", "enable", "disable", "status", "uninstall", "update",
-  "run", "backend-check", "run-issue", "orchestrate", "resume-stalled", "demo", "doctor", "watch", "labels", "config", "stats", "help", "--help", "-h",
+  "run", "backend-check", "run-issue", "orchestrate", "gc", "resume-stalled", "demo", "doctor", "watch", "labels", "config", "stats", "help", "--help", "-h",
   "version", "--version", "-v",
 ]);
 if (SPLASH_COMMANDS.has(command) || !KNOWN_COMMANDS.has(command)) splash(command);
@@ -3983,6 +3984,13 @@ switch (command) {
     }
     break;
   }
+  case "gc": {
+    // Best-effort prune of core-run scratch dirs (older than 6h, owner pid dead). Never touches dirs we did not create.
+    const { makeRunTmp } = await import("./lean/effects.mjs");
+    const removed = await makeRunTmp().prune();
+    process.stdout.write(`gc: removed ${removed.length} stale run tmp dir(s)\n`);
+    break;
+  }
   case "orchestrate": {
     const { orchestrateFromCli } = await import("./engine-cli.mjs");
     try {

package/bin/lean/effects.mjs

@@ -3,10 +3,11 @@
 /** Core work-on: the real effects behind runCore's injected `io`. Argv only, no shell. */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { readFileSync, appendFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync, appendFileSync, mkdirSync, statSync, existsSync, rmSync, writeFileSync, readdirSync, lstatSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { runCliBackend, resolveClaudeCliBinary, getClaudeCliCapabilities, buildLeanSessionFlags, buildReadOnlyToolFlags } from "../runner.mjs";
+import { runCliBackendAsync, resolveClaudeCliBinary, getClaudeCliCapabilities, buildLeanSessionFlags, buildReadOnlyToolFlags } from "../runner.mjs";
 import { makeIo } from "../engine-cli.mjs";
 import { makeProjector } from "../engine/projector.mjs";
 
@@ -14,23 +15,66 @@ const pexec = promisify(execFile);
 const script = (n) => fileURLToPath(new URL(`../../scripts/${n}`, import.meta.url));
 
 /** Claude CLI session runner: fresh session, or `--resume <id>` for the builder. Resolves usage + session_id. */
-export function makeLeanRunner({ runCli = runCliBackend } = {}) {
-  return async ({ role, issue, cwd, model, resume, system, prompt, readOnly = false }) => {
+export function makeLeanRunner({ runCli = runCliBackendAsync } = {}) {
+  return async ({ role, issue, cwd, model, resume, system, prompt, readOnly = false, env = null }) => {
     const bin = resolveClaudeCliBinary(cwd) || "claude";
     const caps = getClaudeCliCapabilities(cwd);
     const flags = [...buildLeanSessionFlags(caps), ...(readOnly ? buildReadOnlyToolFlags(caps) : [])];
-    const r = runCli({ spec: { name: `core-${role}` }, userMessage: prompt, systemPrompt: resume ? "" : system,
-      args: [String(issue)], cwd, bin, model, sessionFlags: flags, extraArgs: resume ? ["--resume", resume] : [],
+    const r = await runCli({ spec: { name: `core-${role}` }, userMessage: prompt, systemPrompt: resume ? "" : system,
+      args: [String(issue)], cwd, bin, model, env, sessionFlags: flags, extraArgs: resume ? ["--resume", resume] : [],
       logger: { log() {} } });
     return { text: r.text, sessionId: r.sessionId, usage: r.usage, costUsd: r.costUsd, durationMs: r.durationMs, turns: r.turns, model: r.cliModel ?? "default" };
   };
 }
 
+export const RUN_TMP_MAX_AGE_MS = 6 * 3600 * 1000;
+export const runTmpRoot = () => join(homedir(), ".forge", "tmp", "runs");
+const OWNER = ".forge-run-owner";
+const pidAlive = (pid) => { try { process.kill(pid, 0); return true; } catch (e) { return e?.code !== "ESRCH"; } };
+
+/** Per-run scratch dirs under ~/.forge/tmp/runs/<issue>-<run>/. Only dirs carrying our owner marker are ever removed. */
+export function makeRunTmp({ root = runTmpRoot(), now = () => Date.now(), alive = pidAlive, host = hostname() } = {}) {
+  const inside = (d) => { const r = resolve(d); return r.startsWith(resolve(root) + sep) && !r.slice(resolve(root).length + 1).includes(sep); };
+  return {
+    async make(issue, runId) {
+      const dir = join(root, String(runId));
+      mkdirSync(dir, { recursive: true, mode: 0o700 });
+      writeFileSync(join(dir, OWNER), JSON.stringify({ issue, pid: process.pid, host, created: now() }));
+      return dir;
+    },
+    /** Remove a dir this module created (marker present, direct child of the runs root). */
+    async remove(dir) {
+      if (!dir || !inside(dir) || !existsSync(join(dir, OWNER))) return false;
+      rmSync(dir, { recursive: true, force: true });
+      return true;
+    },
+    /** Best-effort: dirs older than 6h whose owner pid is dead on this host. Never touches dirs without our marker. */
+    async prune({ maxAgeMs = RUN_TMP_MAX_AGE_MS } = {}) {
+      const removed = [];
+      let names = [];
+      try { names = readdirSync(root); } catch { return removed; }
+      for (const n of names) {
+        const dir = join(root, n);
+        try {
+          if (!lstatSync(dir).isDirectory()) continue;
+          const own = JSON.parse(readFileSync(join(dir, OWNER), "utf8"));
+          if (now() - Number(own.created) < maxAgeMs) continue;
+          if (own.host === host && Number.isSafeInteger(own.pid) && alive(own.pid)) continue;
+          if (own.host !== host) continue;
+          rmSync(dir, { recursive: true, force: true });
+          removed.push(n);
+        } catch { /* not ours or unreadable: leave it */ }
+      }
+      return removed;
+    },
+  };
+}
+
 export function makeLeanIo({ repo }) {
   const base = makeIo();
   const run = (bin) => async (args, opts = {}) => (await pexec(bin, args, { cwd: opts.cwd, maxBuffer: 100 * 1024 * 1024, timeout: 120000 })).stdout;
   return {
-    gh: run("gh"), git: run("git"), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
+    gh: run("gh"), git: run("git"), runTmp: makeRunTmp(), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
     /** Names of the checks the base branch requires (contexts + checks). [] on 404 / no protection. */
     async requiredChecks(lane) {
       try {
@@ -50,6 +94,9 @@ export function makeLeanIo({ repo }) {
     async transitionLabel(issue, state) { await pexec("bash", [script("transition-label.sh"), String(issue), "-R", repo, state], { timeout: 60000 }); },
     fs: {
       read: async (p) => readFileSync(p, "utf8"),
+      exists: async (p) => existsSync(p),
+      rmdir: async (p) => rmSync(p, { recursive: true, force: true }),
+      stat: async (p) => { try { return { mtimeMs: statSync(p).mtimeMs }; } catch { return null; } },
       append: async (p, t) => { mkdirSync(dirname(p), { recursive: true }); appendFileSync(p, t); },
     },
   };