tines 0.0.89 → 0.0.90

package/dist/index.js

@@ -4078,6 +4078,36 @@ function runRow(run) {
     timestamp(run.created_at)
   ];
 }
+function byteSize(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = Math.max(0, bytes);
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  const rounded = unit <= 1 ? Math.round(value) : Math.round(value * 10) / 10;
+  return `${unit <= 1 ? rounded : rounded.toFixed(1)} ${units[unit]}`;
+}
+function ageLabel(isoTimestamp, now = Date.now()) {
+  const then = Date.parse(isoTimestamp);
+  if (!Number.isFinite(then)) return "\u2014";
+  const seconds = Math.max(0, Math.round((now - then) / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+function keptWorkspaceRow(kept, sizeBytes, now = Date.now()) {
+  return [
+    kept.run_id,
+    kept.issue_ref ?? "\u2014",
+    kept.status,
+    ageLabel(kept.kept_at, now),
+    byteSize(sizeBytes),
+    kept.path
+  ];
+}
 function formatTable(rows) {
   if (rows.length === 0) return "";
   const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
@@ -5501,10 +5531,11 @@ import { hostname as hostname2 } from "node:os";
 import { spawn as spawn2 } from "node:child_process";
 import {
   createWriteStream,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync6,
-  rmSync,
-  statSync as statSync2,
+  rmSync as rmSync2,
+  statSync as statSync3,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
@@ -5614,6 +5645,10 @@ import { dirname as dirname2, join as join2 } from "node:path";
 // src/daemon/support.ts
 import { delimiter } from "node:path";
 var HARNESS_KINDS = ["claude_code", "codex", "custom"];
+var KEEP_WORKSPACES_MODES = ["never", "failed", "always"];
+function keepWorkspace(mode, outcome) {
+  return mode === "always" || mode === "failed" && outcome === "failed";
+}
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
@@ -5642,11 +5677,14 @@ function buildHarnessInvocation(spec, input) {
   }
 }
 var RunTable = class {
-  constructor(effects) {
+  constructor(effects, opts = {}) {
     this.effects = effects;
+    this.keep = opts.keep ?? (() => false);
   }
   effects;
   runs = /* @__PURE__ */ new Map();
+  /** The daemon's keep decision, as data: `keepWorkspace` bound to its mode. */
+  keep;
   get size() {
     return this.runs.size;
   }
@@ -5667,11 +5705,19 @@ var RunTable = class {
   persist() {
     this.effects.persist();
   }
-  /** Removes the run and releases its local traces. Safe to call twice. */
-  cleanup(run) {
+  /**
+   * Removes the run and releases its local traces. Safe to call twice.
+   *
+   * The outcome defaults to `failed` because every route here that is not an
+   * explicit completed finish is a failure: a supervisor cancel (which
+   * reaches cleanup with no status at all), a clone failure on an
+   * already-settled run, a daemon shutdown. Guessing `failed` also errs the
+   * safe way — it keeps a directory rather than destroying evidence.
+   */
+  cleanup(run, outcome = "failed") {
     this.runs.delete(run.runId);
     this.effects.persist();
-    this.effects.release(run);
+    this.effects.release(run, { keep: this.keep(outcome), outcome });
   }
   /**
    * Ends a run: flush logs, finish-report, clean up. On a run someone
@@ -5682,7 +5728,9 @@ var RunTable = class {
   async finishAndCleanup(run, status, error) {
     if (run.settled) return this.cleanup(run);
     run.settled = true;
+    run.endNote ??= error;
     run.drain?.();
+    if (this.keep(status)) this.effects.noteKept?.(run);
     await run.flush?.();
     try {
       await this.effects.finish(run, status, error);
@@ -5692,7 +5740,7 @@ var RunTable = class {
         `finish report for run ${run.runId} not accepted: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    this.cleanup(run);
+    this.cleanup(run, status);
   }
   /**
    * Marks a supervisor-settled run (`cancels`): kill, do NOT finish-report.
@@ -5910,7 +5958,15 @@ function message(err) {
 }
 
 // src/daemon/store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname3, join as join3 } from "node:path";
 function defaultConfigDir() {
@@ -5981,6 +6037,80 @@ function processStartTimeMs(pid) {
     return null;
   }
 }
+function workspacesDir(configDir) {
+  return join3(configDir, "workspaces");
+}
+function keptMarkerPath(workspace) {
+  return join3(workspace, "kept.json");
+}
+function writeKeptMarker(workspace, marker) {
+  writeJsonFile(keptMarkerPath(workspace), marker);
+}
+function readKeptMarker(workspace) {
+  const marker = readJsonFile(keptMarkerPath(workspace));
+  if (!marker || typeof marker.run_id !== "string" || typeof marker.kept_at !== "string") {
+    return null;
+  }
+  return marker;
+}
+function listKeptWorkspaces(configDir) {
+  const root = workspacesDir(configDir);
+  let names;
+  try {
+    names = readdirSync2(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const kept = [];
+  for (const name2 of names) {
+    const path2 = join3(root, name2);
+    const marker = readKeptMarker(path2);
+    if (marker) kept.push({ ...marker, path: path2 });
+  }
+  return kept.sort((a, b) => Date.parse(b.kept_at) - Date.parse(a.kept_at));
+}
+function pruneKeptWorkspaces(configDir, opts) {
+  const kept = listKeptWorkspaces(configDir);
+  const now = (opts.now ?? Date.now)();
+  const doomed = [];
+  const survivors = [];
+  for (const entry of kept) {
+    const age = now - Date.parse(entry.kept_at);
+    const expired = opts.maxAgeMs !== void 0 && Number.isFinite(age) && age > opts.maxAgeMs;
+    if (opts.all || expired) doomed.push(entry);
+    else survivors.push(entry);
+  }
+  if (!opts.all && opts.maxCount !== void 0) doomed.push(...survivors.slice(opts.maxCount));
+  const removed = [];
+  for (const entry of doomed) {
+    try {
+      rmSync(entry.path, { recursive: true, force: true });
+      removed.push(entry);
+    } catch {
+    }
+  }
+  return removed;
+}
+function directorySizeBytes(path2) {
+  let total = 0;
+  let entries;
+  try {
+    entries = readdirSync2(path2, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const child = join3(path2, entry.name);
+    if (entry.isDirectory()) total += directorySizeBytes(child);
+    else if (entry.isFile()) {
+      try {
+        total += statSync2(child).size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
 
 // src/daemon/daemon.ts
 var CLI_REFRESH_TTL_MS = 10 * 6e4;
@@ -5990,7 +6120,7 @@ async function uploadRawLog(run) {
   run.rawSpoolPath = void 0;
   try {
     await new Promise((resolve) => run.rawSpool?.end(resolve) ?? resolve());
-    const size = statSync2(path2).size;
+    const size = statSync3(path2).size;
     if (size > 0) {
       let body = readFileSync6(path2);
       if (body.byteLength > RUN_LOG_RAW_MAX_BYTES) {
@@ -6032,6 +6162,34 @@ function pidAlive(pid) {
 }
 async function runDaemon(opts) {
   mkdirSync4(opts.configDir, { recursive: true });
+  mkdirSync4(workspacesDir(opts.configDir), { recursive: true, mode: 448 });
+  const sweepKeptWorkspaces = () => {
+    const removed = pruneKeptWorkspaces(opts.configDir, {
+      maxAgeMs: opts.keepWorkspacesForHours * 36e5,
+      maxCount: opts.keepWorkspacesMax
+    });
+    if (removed.length > 0) {
+      log(
+        `pruned ${removed.length} kept workspace(s) past retention (${opts.keepWorkspacesForHours}h, max ${opts.keepWorkspacesMax})`
+      );
+    }
+  };
+  sweepKeptWorkspaces();
+  const settleWorkspace = (workspace, keep, marker) => {
+    if (!keep) {
+      rmSync2(workspace, { recursive: true, force: true });
+      return;
+    }
+    if (!existsSync4(workspace)) return;
+    try {
+      writeKeptMarker(workspace, { ...marker, kept_at: (/* @__PURE__ */ new Date()).toISOString() });
+      log(`run ${marker.run_id}: workspace kept at ${workspace}`);
+    } catch (err) {
+      log(
+        `run ${marker.run_id}: workspace kept at ${workspace}, but kept.json could not be written (${message2(err)})`
+      );
+    }
+  };
   let creds = loadRunnerCredentials(opts.configDir, opts.url, opts.name);
   if (creds) {
     log(`reconnecting as runner "${opts.name}" (${creds.runner_id}) \u2014 token from ${opts.configDir}`);
@@ -6067,24 +6225,33 @@ async function runDaemon(opts) {
     finish: async (run, status, error) => {
       await client2.finishRun(run.runId, { status, ...error ? { error } : {} });
     },
-    release: (run) => {
+    release: (run, { keep, outcome }) => {
       if (run.timeout) clearTimeout(run.timeout);
       run.renderer?.finish();
-      rmSync(run.workspace, { recursive: true, force: true });
+      settleWorkspace(run.workspace, keep, {
+        run_id: run.runId,
+        ...run.issueLabel ? { issue_ref: run.issueLabel } : {},
+        status: outcome,
+        ...run.endNote ? { error: run.endNote } : {}
+      });
       void uploadRawLog(run);
+      sweepKeptWorkspaces();
     },
+    noteKept: (run) => run.batcher.append(`workspace kept at ${run.workspace}
+`),
     persist: () => {
       const entries = table2.values().filter((run) => run.child?.pid !== void 0).map((run) => ({
         run_id: run.runId,
         pid: run.child.pid,
         workspace: run.workspace,
         key_fingerprint: run.keyFingerprint,
-        started_at: run.spawnedAt
+        started_at: run.spawnedAt,
+        ...run.issueLabel ? { issue_ref: run.issueLabel } : {}
       }));
       saveDaemonState(statePath, entries);
     },
     log
-  });
+  }, { keep: (outcome) => keepWorkspace(opts.keepWorkspaces, outcome) });
   for (const orphan of loadDaemonState(statePath)) {
     if (pidAlive(orphan.pid)) {
       const processStart = processStartTimeMs(orphan.pid);
@@ -6103,12 +6270,18 @@ async function runDaemon(opts) {
       });
     } catch {
     }
-    rmSync(orphan.workspace, { recursive: true, force: true });
+    settleWorkspace(orphan.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
+      run_id: orphan.run_id,
+      ...orphan.issue_ref ? { issue_ref: orphan.issue_ref } : {},
+      status: "failed",
+      error: "daemon restarted; orphaned harness killed"
+    });
   }
   saveDaemonState(statePath, []);
   const killWithoutFinish = (runId) => {
     const run = table2.markCanceled(runId);
     if (!run) return;
+    run.endNote ??= "canceled by supervisor";
     log(`supervisor canceled run ${runId}; killing without finish-reporting`);
     if (run.child?.pid) {
       const pid = run.child.pid;
@@ -6119,10 +6292,12 @@ async function runDaemon(opts) {
   const launch = async (assignment) => {
     const runId = assignment.run.id;
     if (table2.has(runId)) return;
-    const workspace = join4(opts.configDir, "workspaces", runId);
+    const workspace = join4(workspacesDir(opts.configDir), runId);
+    const issueLabel = assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : void 0;
     const run = {
       runId,
       workspace,
+      ...issueLabel ? { issueLabel } : {},
       canceled: false,
       timedOut: false,
       settled: false,
@@ -6135,9 +6310,9 @@ async function runDaemon(opts) {
     };
     run.flush = () => run.batcher.flush();
     table2.track(run);
-    log(`run ${runId} assigned (issue ${assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : assignment.run.issue_id}); materializing workspace`);
+    log(`run ${runId} assigned (issue ${issueLabel ?? assignment.run.issue_id}); materializing workspace`);
     try {
-      rmSync(workspace, { recursive: true, force: true });
+      rmSync2(workspace, { recursive: true, force: true });
       mkdirSync4(workspace, { recursive: true });
       writeFileSync3(join4(workspace, "prompt.md"), `${assignment.prompt}
 `);
@@ -6284,7 +6459,12 @@ async function runDaemon(opts) {
       if (err instanceof ApiError && err.status === 401) {
         for (const run of table2.values()) {
           if (run.child?.pid) killTree(run.child.pid, "SIGKILL");
-          rmSync(run.workspace, { recursive: true, force: true });
+          settleWorkspace(run.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
+            run_id: run.runId,
+            ...run.issueLabel ? { issue_ref: run.issueLabel } : {},
+            status: "failed",
+            error: "daemon token rejected"
+          });
         }
         saveDaemonState(statePath, []);
         clearRunnerCredentials(opts.configDir, opts.url, opts.name);
@@ -6522,6 +6702,20 @@ function register6(program3) {
     runnerCmd.command("daemon").description("Run the local runner daemon: register/reconnect, poll for assigned runs, execute them").option("--name <name>", "runner name, unique per user (default: this hostname)").option("--harness <harness>", "claude-code | codex | custom", "claude-code").option("--command <template>", "custom harness command template ({prompt_file}, {workspace}, {model})").option("--max-concurrent <n>", "maximum simultaneous runs", (v) => Number.parseInt(v, 10), 1).option("--poll-interval <seconds>", "seconds between polls", (v) => Number.parseInt(v, 10), 15).option(
       "--no-cli-refresh",
       "do not install/refresh the agent-facing tines CLI from npm (harnesses use the ambient PATH)"
+    ).option(
+      "--keep-workspaces <mode>",
+      "keep settled runs' workspaces for debugging: never | failed | always",
+      "never"
+    ).option(
+      "--keep-workspaces-for <hours>",
+      "delete kept workspaces older than this",
+      (v) => Number(v),
+      72
+    ).option(
+      "--keep-workspaces-max <n>",
+      "keep at most this many workspaces (oldest removed first)",
+      (v) => Number.parseInt(v, 10),
+      20
     )
   ).action(
     async (opts) => {
@@ -6539,6 +6733,16 @@ function register6(program3) {
       if (!Number.isInteger(opts.pollInterval) || opts.pollInterval < 1) {
         die("--poll-interval must be a positive number of seconds");
       }
+      const keepWorkspaces = opts.keepWorkspaces;
+      if (!KEEP_WORKSPACES_MODES.includes(keepWorkspaces)) {
+        die(`--keep-workspaces must be ${KEEP_WORKSPACES_MODES.join(", ")}, got "${opts.keepWorkspaces}"`);
+      }
+      if (!Number.isFinite(opts.keepWorkspacesFor) || opts.keepWorkspacesFor <= 0) {
+        die("--keep-workspaces-for must be a positive number of hours");
+      }
+      if (!Number.isInteger(opts.keepWorkspacesMax) || opts.keepWorkspacesMax < 1) {
+        die("--keep-workspaces-max must be a positive integer");
+      }
       await runDaemon({
         url: resolveUrl(opts).replace(/\/+$/, ""),
         apiKey: resolveApiKey(opts),
@@ -6548,10 +6752,45 @@ function register6(program3) {
         maxConcurrent: opts.maxConcurrent,
         pollIntervalMs: opts.pollInterval * 1e3,
         configDir: defaultConfigDir(),
-        cliRefresh: opts.cliRefresh
+        cliRefresh: opts.cliRefresh,
+        keepWorkspaces,
+        keepWorkspacesForHours: opts.keepWorkspacesFor,
+        keepWorkspacesMax: opts.keepWorkspacesMax
       });
     }
   );
+  const workspacesCmd = runnerCmd.command("workspaces").description("List run workspaces the daemon kept for debugging (--keep-workspaces)").option("--json", "print JSON instead of a table").action((opts) => {
+    const configDir = defaultConfigDir();
+    const kept = listKeptWorkspaces(configDir);
+    const sized = kept.map((k) => ({ ...k, size_bytes: directorySizeBytes(k.path) }));
+    if (opts.json) return printJson({ items: sized });
+    if (sized.length === 0) {
+      console.log(`no kept workspaces in ${workspacesDir(configDir)}`);
+      return console.log(
+        "the daemon keeps them only with --keep-workspaces failed (or always)."
+      );
+    }
+    table([
+      ["RUN", "ISSUE", "STATUS", "AGE", "SIZE", "PATH"],
+      ...sized.map((k) => keptWorkspaceRow(k, k.size_bytes))
+    ]);
+  });
+  workspacesCmd.command("prune").description("Delete kept workspaces (never touches a live run's workspace)").option("--all", "delete every kept workspace").option("--older-than <hours>", "delete kept workspaces older than this", (v) => Number(v)).option("--json", "print JSON instead of a table").action((opts) => {
+    if (opts.all === void 0 && opts.olderThan === void 0) {
+      die("pass --all or --older-than <hours>");
+    }
+    if (opts.all && opts.olderThan !== void 0) die("--all cannot be combined with --older-than");
+    if (opts.olderThan !== void 0 && (!Number.isFinite(opts.olderThan) || opts.olderThan < 0)) {
+      die("--older-than must be a non-negative number of hours");
+    }
+    const removed = pruneKeptWorkspaces(defaultConfigDir(), {
+      all: opts.all,
+      ...opts.olderThan !== void 0 ? { maxAgeMs: opts.olderThan * 36e5 } : {}
+    });
+    if (opts.json) return printJson({ items: removed });
+    for (const entry of removed) console.log(`removed ${entry.path}`);
+    console.log(`pruned ${removed.length} kept workspace${removed.length === 1 ? "" : "s"}`);
+  });
   const runsCmd = program3.command("runs").description("Agent runs: attempts at issues by runners");
   withList(
     runsCmd.command("list").description("List runs, newest first").option("-i, --issue <ref>", "filter to one issue (<project>/<number>)").option("-r, --runner <name>", "filter by runner name").option("--active", "only runs holding a claim (assigned/launching/running)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.89",
+  "version": "0.0.90",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",