@vimhead.dev/norn-cli 0.1.0-tip.36679386408.1 → 0.1.0-tip.37307659560.1

package/dist/internal/run-lease.js

@@ -1,7 +1,7 @@
 // src/internal/run-lease.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir2, readFile, rm as rm2, stat as stat2 } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir as mkdir2, readFile, rename as rename2, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname2, join } from "node:path";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -17,6 +17,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -26,7 +29,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {
@@ -83,6 +86,27 @@ var NornRunLease = class _NornRunLease {
     if (!owner || owner.token !== this.token)
       throw new Error("Run lease was lost");
   }
+  async deleteRunDirectory() {
+    await this.assertOwned();
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    await this.heartbeatChain;
+    await this.assertOwned();
+    const runRoot = dirname2(this.lockRoot);
+    const retiredRoot = join(
+      dirname2(dirname2(runRoot)),
+      `.pruned-run-${randomUUID2()}`
+    );
+    await rename2(runRoot, retiredRoot);
+    this.isReleased = true;
+    try {
+      await rm2(retiredRoot, { recursive: true, force: true });
+    } catch (error) {
+      throw new Error(
+        `Run was removed from the run list but directory cleanup failed: ${retiredRoot}`,
+        { cause: error }
+      );
+    }
+  }
   async release() {
     if (this.isReleased) return;
     this.isReleased = true;

package/dist/internal/run-log.js

@@ -15,6 +15,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -24,7 +27,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/run-pruning.d.ts

@@ -0,0 +1,14 @@
+import type { NornRunPruneOptions, NornRunPruneResult } from "@vimhead.dev/norn";
+export declare function parseRunPruneOptions(args: readonly string[]): NornRunPruneOptions;
+export declare class NornRunPruner {
+    private readonly input;
+    private readonly olderThan;
+    private readonly cutoff;
+    constructor(input: {
+        readonly projectRoot: string;
+        readonly options: NornRunPruneOptions;
+        readonly now: Date;
+    });
+    prune(): Promise<NornRunPruneResult>;
+    private findIneligibilityReason;
+}

package/dist/internal/run-pruning.js

@@ -0,0 +1,141 @@
+// src/internal/run-pruning.ts
+import { errorMessage } from "./errors.js";
+import { getRunLeaseOwner, NornRunLease } from "./run-lease.js";
+import { getRunInfo, listRuns } from "./run-state.js";
+import { NornRunStore } from "./run-store.js";
+var DURATION_UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseRunPruneOptions(args) {
+  const flags = /* @__PURE__ */ new Set();
+  let olderThan = null;
+  for (let index = 0; index < args.length; index++) {
+    const flag = args[index];
+    if (!["--delete-runs", "--all", "--dry-run", "--older-than"].includes(flag))
+      throw new Error(`runs prune: unknown argument ${flag}`);
+    if (flags.has(flag))
+      throw new Error(`runs prune: duplicate option ${flag}`);
+    flags.add(flag);
+    if (flag === "--older-than") {
+      const value = args[++index];
+      if (value === void 0 || value.startsWith("--"))
+        throw new Error(
+          "runs prune: --older-than requires a duration such as 24h or 7d"
+        );
+      olderThan = value;
+    }
+  }
+  return {
+    deleteRuns: flags.has("--delete-runs"),
+    all: flags.has("--all"),
+    olderThan,
+    dryRun: flags.has("--dry-run")
+  };
+}
+function parsePruneDuration(value) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/.exec(value);
+  const duration = match ? Number(match[1]) * DURATION_UNITS[match[2]] : NaN;
+  if (!Number.isFinite(duration) || duration < 0 || duration > Number.MAX_SAFE_INTEGER)
+    throw new Error(
+      `runs prune: invalid duration ${value}; use a non-negative number followed by ms, s, m, h, d, or w`
+    );
+  return duration;
+}
+var NornRunPruner = class {
+  constructor(input) {
+    this.input = input;
+    if (input.options.all && !input.options.deleteRuns)
+      throw new Error("runs prune: --all requires --delete-runs");
+    if (input.options.all && input.options.olderThan !== null)
+      throw new Error(
+        "runs prune: --all and --older-than are mutually exclusive"
+      );
+    if (!Number.isFinite(input.now.getTime()))
+      throw new Error("Invalid pruning time");
+    this.olderThan = input.options.all ? null : input.options.olderThan ?? "24h";
+    this.cutoff = this.olderThan === null ? null : input.now.getTime() - parsePruneDuration(this.olderThan);
+  }
+  input;
+  olderThan;
+  cutoff;
+  async prune() {
+    const results = [];
+    for (const run of await listRuns(this.input.projectRoot)) {
+      const identity = { id: run.id, name: run.name, path: run.path };
+      let lease;
+      try {
+        let reason = this.findIneligibilityReason(run);
+        if (!reason && await getRunLeaseOwner(run.path))
+          reason = "Run is owned by an executor";
+        if (reason) {
+          results.push({ ...identity, status: "skipped", reason });
+          continue;
+        }
+        if (this.input.options.dryRun) {
+          results.push({ ...identity, status: "planned" });
+          continue;
+        }
+        try {
+          lease = await NornRunLease.acquire(run.path);
+        } catch (error) {
+          if (error instanceof Error && error.message.startsWith("Run is already active:")) {
+            results.push({
+              ...identity,
+              status: "skipped",
+              reason: "Run is owned by an executor"
+            });
+            continue;
+          }
+          throw error;
+        }
+        reason = this.findIneligibilityReason(await getRunInfo(run.path));
+        if (reason) {
+          results.push({ ...identity, status: "skipped", reason });
+          continue;
+        }
+        await lease.assertOwned();
+        if (this.input.options.deleteRuns) {
+          await lease.deleteRunDirectory();
+        } else {
+          const store = await NornRunStore.open(run.path);
+          await store.pruneCheckpointHistory(this.input.now.toISOString());
+        }
+        results.push({ ...identity, status: "pruned" });
+      } catch (error) {
+        results.push({
+          ...identity,
+          status: "failed",
+          reason: errorMessage(error)
+        });
+      } finally {
+        await lease?.release();
+      }
+    }
+    return {
+      mode: this.input.options.deleteRuns ? "runs" : "checkpoints",
+      dryRun: this.input.options.dryRun,
+      olderThan: this.olderThan,
+      runs: results
+    };
+  }
+  findIneligibilityReason(run) {
+    if (run.status !== "completed" && run.status !== "failed")
+      return `Run status is ${run.status}; only completed or failed runs are eligible`;
+    const finishedAt = run.status === "failed" ? run.failed?.failedAt ?? run.outcome?.completedAt ?? run.updatedAt : run.outcome?.completedAt ?? run.updatedAt;
+    const finishedTime = Date.parse(finishedAt);
+    if (!Number.isFinite(finishedTime))
+      return "Run completion/failure time is invalid";
+    if (this.cutoff !== null && finishedTime >= this.cutoff)
+      return `Run finished less than or exactly ${this.olderThan} ago`;
+    return void 0;
+  }
+};
+export {
+  NornRunPruner,
+  parseRunPruneOptions
+};

package/dist/internal/run-state.js

@@ -24,6 +24,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -33,7 +36,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/run-store.d.ts

@@ -12,6 +12,10 @@ export declare class NornRunStore {
     restoreSnapshot(ref: string, prepare: ((stagedRunRoot: string) => Promise<void>) | undefined): Promise<void>;
     restoreCurrentSnapshot(): Promise<void>;
     listCheckpoints(): Promise<NornRunCheckpoint[]>;
+    pruneCheckpointHistory(prunedAt: string): Promise<void>;
+    private get prunedHistoryPath();
+    private isCheckpointHistoryPruned;
+    private assertCheckpointHistoryAvailable;
     private readCheckpointHistory;
     assertWorkspaceCanBeSnapshotted(_workspace: string): Promise<void>;
     private get objectsRoot();
@@ -29,6 +33,7 @@ export declare class NornRunStore {
     private materializedPath;
     private readSnapshot;
     private snapshotPath;
+    private getLegacySnapshotPath;
     private snapshotRelativePath;
     private assertCheckpointPathMatchesId;
     private objectPath;

package/dist/internal/run-store.js

@@ -34,6 +34,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -43,7 +46,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {
@@ -59,6 +62,7 @@ var SNAPSHOT_VERSION = 1;
 var CURRENT_DIR_NAME = "current";
 var STORE_DIR_NAME = "store";
 var CHECKPOINTS_FILE_NAME = "checkpoints.json";
+var PRUNED_HISTORY_FILE_NAME = "checkpoint-history-pruned.json";
 function runCurrentRoot(runRoot) {
   return join(runRoot, CURRENT_DIR_NAME);
 }
@@ -82,13 +86,16 @@ var NornRunStore = class _NornRunStore {
   static async open(root) {
     const runStore = new _NornRunStore(root);
     await access(runStore.currentRoot, constants.R_OK | constants.W_OK);
-    await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
+    if (!await runStore.isCheckpointHistoryPruned())
+      await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
     return runStore;
   }
   async currentSnapshotRef() {
+    await this.assertCheckpointHistoryAvailable();
     return readFile(this.currentRefPath, "utf8").then((value) => value.trim());
   }
   async snapshotCurrent(message) {
+    await this.assertCheckpointHistoryAvailable();
     const previous = await this.readCheckpointHistory();
     const checkpoint = this.createCheckpoint(
       message,
@@ -109,6 +116,7 @@ var NornRunStore = class _NornRunStore {
     return checkpoint;
   }
   async restoreSnapshot(ref, prepare) {
+    await this.assertCheckpointHistoryAvailable();
     const checkpoint = (await this.listCheckpoints()).find(
       (entry) => entry.id === ref
     );
@@ -125,8 +133,42 @@ var NornRunStore = class _NornRunStore {
     );
   }
   async listCheckpoints() {
+    if (await this.isCheckpointHistoryPruned()) return [];
     return (await this.readCheckpointHistory()).checkpoints;
   }
+  async pruneCheckpointHistory(prunedAt) {
+    if (!await this.isCheckpointHistoryPruned())
+      await writeJsonAtomically(this.prunedHistoryPath, {
+        version: 1,
+        prunedAt
+      });
+    await writeJsonAtomically(this.checkpointsPath, []);
+    await rm2(this.storeRoot, { recursive: true, force: true });
+  }
+  get prunedHistoryPath() {
+    return join(this.runRoot, PRUNED_HISTORY_FILE_NAME);
+  }
+  async isCheckpointHistoryPruned() {
+    let content;
+    try {
+      content = await readFile(this.prunedHistoryPath, "utf8");
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return false;
+      throw error;
+    }
+    const marker = JSON.parse(content);
+    if (!marker || typeof marker !== "object" || !("version" in marker) || marker.version !== 1 || !("prunedAt" in marker) || typeof marker.prunedAt !== "string" || !Number.isFinite(Date.parse(marker.prunedAt)))
+      throw new Error(
+        `Invalid pruned checkpoint history marker: ${this.prunedHistoryPath}`
+      );
+    return true;
+  }
+  async assertCheckpointHistoryAvailable() {
+    if (await this.isCheckpointHistoryPruned())
+      throw new Error(
+        `Checkpoint history was pruned for this run: ${this.runRoot}`
+      );
+  }
   async readCheckpointHistory() {
     try {
       const content = await readFile(this.checkpointsPath, "utf8");
@@ -196,7 +238,10 @@ var NornRunStore = class _NornRunStore {
       createdAt: checkpoint.createdAt,
       entries
     };
-    await writeJsonAtomically(this.snapshotPath(snapshot.id), snapshot);
+    await writeBytesAtomically(
+      this.snapshotPath(snapshot.id),
+      await gzipBuffer(Buffer.from(JSON.stringify(snapshot)))
+    );
     return snapshot;
   }
   async snapshotEntries(root) {
@@ -346,11 +391,23 @@ var NornRunStore = class _NornRunStore {
     return path;
   }
   async readSnapshot(id) {
+    let compressed;
+    try {
+      compressed = await readFile(this.snapshotPath(id));
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+      return parseRunSnapshotManifest(
+        JSON.parse(await readFile(this.getLegacySnapshotPath(id), "utf8"))
+      );
+    }
     return parseRunSnapshotManifest(
-      JSON.parse(await readFile(this.snapshotPath(id), "utf8"))
+      JSON.parse((await gunzipBuffer(compressed)).toString("utf8"))
     );
   }
   snapshotPath(id) {
+    return join(this.snapshotsRoot, `${id}.json.gz`);
+  }
+  getLegacySnapshotPath(id) {
     return join(this.snapshotsRoot, `${id}.json`);
   }
   snapshotRelativePath(id) {
@@ -358,7 +415,11 @@ var NornRunStore = class _NornRunStore {
   }
   assertCheckpointPathMatchesId(checkpoint) {
     const expectedPath = this.snapshotRelativePath(checkpoint.id);
-    if (checkpoint.path !== expectedPath)
+    const legacyPath = relative(
+      this.runRoot,
+      this.getLegacySnapshotPath(checkpoint.id)
+    );
+    if (checkpoint.path !== expectedPath && checkpoint.path !== legacyPath)
       throw new Error(
         `Run checkpoint path does not match id: ${checkpoint.id}`
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn-cli",
-  "version": "0.1.0-tip.36679386408.1",
+  "version": "0.1.0-tip.37307659560.1",
   "description": "Harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "@earendil-works/pi-coding-agent": "0.99.1",
     "jiti": "^2.7.0",
     "typebox": "^1.3.34",
-    "@vimhead.dev/norn": "0.1.0-tip.36679386408.1"
+    "@vimhead.dev/norn": "0.1.0-tip.37307659560.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"