@sema-agent/core 1.452.0 → 2.0.0

package/dist/stores/file/background-agent-store.js

@@ -1,105 +1,49 @@
 import { join } from "node:path";
 import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, } from "../../core/background-agent-store.js";
-import { canonicalStoreKey, AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "./fs-atomic.js";
-const sharedAgentDirs = new Map();
+import { SharedLedgerTable } from "./shared-ledger.js";
+const agentLedgers = new SharedLedgerTable({
+    keyOf: (r) => FileBackgroundAgentStore.key(r.handle, r.scope),
+    apply: (rows, ev) => {
+        if (ev.t === "delete") {
+            rows.delete(ev.k);
+            return;
+        }
+        rows.set(ev.k, ev.r);
+    },
+});
 export class FileBackgroundAgentStore {
-    dir;
-    tmpDir;
-    ledgerPath;
-    snapshotPath;
     fsyncEnabled;
     compactEvery;
-    shared;
+    ledger;
     closed = false;
     get rows() {
-        return this.shared.rows;
-    }
-    get locks() {
-        return this.shared.locks;
-    }
-    get ledgerEvents() {
-        return this.shared.ledgerEvents;
-    }
-    set ledgerEvents(v) {
-        this.shared.ledgerEvents = v;
-    }
-    get log() {
-        return this.shared.log;
-    }
-    set log(v) {
-        this.shared.log = v;
+        return this.ledger.rows;
     }
     constructor(root, opts = {}) {
-        this.dir = join(root, "background-agents");
-        this.tmpDir = join(root, "tmp");
-        this.ledgerPath = join(this.dir, "agents.jsonl");
-        this.snapshotPath = join(this.dir, "agents.snapshot.jsonl");
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 1000;
-        ensureDir(this.dir);
-        ensureDir(this.tmpDir);
-        const canonical = canonicalStoreKey(this.dir);
-        const existing = sharedAgentDirs.get(canonical);
-        if (existing !== undefined) {
-            existing.refs += 1;
-            this.shared = existing;
-            this.canonicalDir = canonical;
-            return;
-        }
-        this.shared = { rows: new Map(), locks: new Map(), ledgerEvents: 0, log: undefined, refs: 1 };
-        this.canonicalDir = canonical;
-        sharedAgentDirs.set(canonical, this.shared);
-        this.replay();
-        this.log = new AppendLog(this.ledgerPath);
+        const dir = join(root, "background-agents");
+        this.ledger = agentLedgers.acquire({
+            dir,
+            tmpDir: join(root, "tmp"),
+            ledgerPath: join(dir, "agents.jsonl"),
+            snapshotPath: join(dir, "agents.snapshot.jsonl"),
+        });
     }
-    canonicalDir;
-    key(handle, scope) {
+    static key(handle, scope) {
         return `${scope}\u0000${handle}`;
     }
-    replay() {
-        for (const snap of readJsonlRecords(this.snapshotPath)) {
-            this.rows.set(this.key(snap.handle, snap.scope), snap);
-        }
-        const events = readJsonlRecords(this.ledgerPath);
-        this.ledgerEvents = events.length;
-        for (const ev of events)
-            this.applyEvent(ev);
-    }
-    applyEvent(ev) {
-        if (ev.t === "delete") {
-            this.rows.delete(ev.k);
-            return;
-        }
-        this.rows.set(ev.k, ev.r);
-    }
     withLock(key, fn) {
-        const prev = this.locks.get(key) ?? Promise.resolve();
-        const run = prev.then(() => fn(), () => fn());
-        const tail = run.then(() => { }, () => { });
-        this.locks.set(key, tail);
-        void tail.then(() => {
-            if (this.locks.get(key) === tail)
-                this.locks.delete(key);
-        });
-        return run;
+        return this.ledger.withLock(key, fn);
     }
     commit(ev) {
-        this.log.append(ev, this.fsyncEnabled);
-        this.applyEvent(ev);
-        this.ledgerEvents++;
-        if (this.ledgerEvents >= this.compactEvery) {
-            try {
-                this.compact();
-            }
-            catch {
-            }
-        }
+        this.ledger.commit(ev, this.fsyncEnabled, this.compactEvery);
     }
     async put(record) {
         if (record.scope === undefined || record.scope === "") {
             throw new Error("BackgroundAgentStore.put: refusing a row without a scope (world-readable through the fallback)");
         }
-        const k = this.key(record.handle, record.scope);
+        const k = FileBackgroundAgentStore.key(record.handle, record.scope);
         return this.withLock(k, () => {
             if (this.rows.has(k)) {
                 throw new BackgroundAgentStoreError("agent_record.already_exists", "agent record already exists");
@@ -110,11 +54,11 @@ export class FileBackgroundAgentStore {
         });
     }
     async get(handle, scope) {
-        const row = this.rows.get(this.key(handle, scope));
+        const row = this.rows.get(FileBackgroundAgentStore.key(handle, scope));
         return row ? structuredClone(row) : null;
     }
     async update(handle, scope, record, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, () => {
             const live = this.rows.get(k);
             if (!live || live.scope !== scope || live.rev !== expect.rev)
@@ -128,7 +72,7 @@ export class FileBackgroundAgentStore {
         });
     }
     async updateIf(handle, scope, record, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, async () => {
             const live = this.rows.get(k);
             if (!live || live.scope !== scope || live.rev !== expect.rev)
@@ -178,7 +122,7 @@ export class FileBackgroundAgentStore {
         return [...new Set([...this.rows.values()].map((r) => r.scope))].sort();
     }
     async delete(handle, scope, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, () => {
             const live = this.rows.get(k);
             if (!live)
@@ -248,15 +192,8 @@ export class FileBackgroundAgentStore {
         }
         return changed.size;
     }
-    compact() {
-        const lines = [...this.rows.values()].map((r) => JSON.stringify(r)).join("\n");
-        atomicWriteFile(this.tmpDir, this.snapshotPath, lines.length ? `${lines}\n` : "");
-        this.log.closeForSwap();
-        atomicWriteFile(this.tmpDir, this.ledgerPath, "");
-        this.ledgerEvents = 0;
-    }
     compactNow() {
-        this.compact();
+        this.ledger.compact();
     }
     get size() {
         return this.rows.size;
@@ -265,14 +202,7 @@ export class FileBackgroundAgentStore {
         if (this.closed)
             return;
         this.closed = true;
-        const st = sharedAgentDirs.get(this.canonicalDir);
-        if (st !== undefined && st === this.shared) {
-            st.refs -= 1;
-            if (st.refs > 0)
-                return;
-            sharedAgentDirs.delete(this.canonicalDir);
-        }
-        this.log.close();
+        this.ledger.release();
     }
 }
 function toSummary(r) {

package/dist/stores/file/checkpoint-store.d.ts

@@ -4,25 +4,13 @@ export interface FileCheckpointStoreOptions {
     compactEvery?: number;
 }
 export declare class FileCheckpointStore implements CheckpointStore {
-    private readonly dir;
-    private readonly tmpDir;
-    private readonly ledgerPath;
-    private readonly snapshotPath;
     private readonly fsyncEnabled;
     private readonly compactEvery;
-    private readonly shared;
-    private readonly sharedKey;
+    private readonly ledger;
     private closed;
     private get cps();
-    private get locks();
-    private get ledgerEvents();
-    private set ledgerEvents(value);
-    private get log();
-    private set log(value);
     private fault;
     constructor(root: string, opts?: FileCheckpointStoreOptions);
-    private replay;
-    private applyEvent;
     private withLock;
     private commit;
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
@@ -37,7 +25,6 @@ export declare class FileCheckpointStore implements CheckpointStore {
     reap(scope: string, cutoff: number): Promise<number>;
     listByScope(scope: string): Promise<CheckpointSummary[]>;
     listScopes(): Promise<string[]>;
-    private compact;
     compactNow(): void;
     testInjectFault(mode: CheckpointFaultMode | null): void;
     get size(): number;

package/dist/stores/file/checkpoint-store.js

@@ -1,124 +1,64 @@
 import { join } from "node:path";
 import { CheckpointError, summarizeCheckpoint, validatePendingSteer, winnerFromOutcome, } from "../../core/checkpoint-store.js";
-import { canonicalStoreKey, AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "./fs-atomic.js";
-const sharedCheckpointDirs = new Map();
+import { SharedLedgerTable } from "./shared-ledger.js";
+function applyCheckpointEvent(cps, ev) {
+    if (ev.t === "put") {
+        cps.set(ev.token, ev.cp);
+        return;
+    }
+    const cp = cps.get(ev.token);
+    if (!cp)
+        return;
+    switch (ev.t) {
+        case "resolve":
+            cp.status = "resolved";
+            cp.rev = ev.rev;
+            if (ev.resolvedOutcome !== undefined)
+                cp.resolvedOutcome = ev.resolvedOutcome;
+            cp.reopenReason = undefined;
+            break;
+        case "reopen":
+            cp.status = "pending";
+            cp.rev = ev.rev;
+            cp.reopenReason = ev.reason;
+            break;
+        case "expire":
+            cp.status = "expired";
+            break;
+        case "steer":
+            cp.state.pendingSteer = ev.steer;
+            break;
+    }
+}
+const checkpointLedgers = new SharedLedgerTable({
+    keyOf: (cp) => cp.token,
+    apply: applyCheckpointEvent,
+});
 export class FileCheckpointStore {
-    dir;
-    tmpDir;
-    ledgerPath;
-    snapshotPath;
     fsyncEnabled;
     compactEvery;
-    shared;
-    sharedKey;
+    ledger;
     closed = false;
     get cps() {
-        return this.shared.cps;
-    }
-    get locks() {
-        return this.shared.locks;
-    }
-    get ledgerEvents() {
-        return this.shared.ledgerEvents;
-    }
-    set ledgerEvents(v) {
-        this.shared.ledgerEvents = v;
-    }
-    get log() {
-        return this.shared.log;
-    }
-    set log(v) {
-        this.shared.log = v;
+        return this.ledger.rows;
     }
     fault = null;
     constructor(root, opts = {}) {
-        this.dir = join(root, "checkpoints");
-        this.tmpDir = join(root, "tmp");
-        this.ledgerPath = join(this.dir, "checkpoints.jsonl");
-        this.snapshotPath = join(this.dir, "checkpoints.snapshot.jsonl");
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 1000;
-        ensureDir(this.dir);
-        ensureDir(this.tmpDir);
-        const key = canonicalStoreKey(this.dir);
-        this.sharedKey = key;
-        const live = sharedCheckpointDirs.get(key);
-        if (live !== undefined) {
-            live.refs += 1;
-            this.shared = live;
-            return;
-        }
-        this.shared = {
-            cps: new Map(),
-            locks: new Map(),
-            ledgerEvents: 0,
-            log: undefined,
-            refs: 1,
-        };
-        sharedCheckpointDirs.set(key, this.shared);
-        this.replay();
-        this.log = new AppendLog(this.ledgerPath);
-    }
-    replay() {
-        for (const snap of readJsonlRecords(this.snapshotPath)) {
-            this.cps.set(snap.token, snap);
-        }
-        const events = readJsonlRecords(this.ledgerPath);
-        this.ledgerEvents = events.length;
-        for (const ev of events)
-            this.applyEvent(ev);
-    }
-    applyEvent(ev) {
-        if (ev.t === "put") {
-            this.cps.set(ev.token, ev.cp);
-            return;
-        }
-        const cp = this.cps.get(ev.token);
-        if (!cp)
-            return;
-        switch (ev.t) {
-            case "resolve":
-                cp.status = "resolved";
-                cp.rev = ev.rev;
-                if (ev.resolvedOutcome !== undefined)
-                    cp.resolvedOutcome = ev.resolvedOutcome;
-                cp.reopenReason = undefined;
-                break;
-            case "reopen":
-                cp.status = "pending";
-                cp.rev = ev.rev;
-                cp.reopenReason = ev.reason;
-                break;
-            case "expire":
-                cp.status = "expired";
-                break;
-            case "steer":
-                cp.state.pendingSteer = ev.steer;
-                break;
-        }
+        const dir = join(root, "checkpoints");
+        this.ledger = checkpointLedgers.acquire({
+            dir,
+            tmpDir: join(root, "tmp"),
+            ledgerPath: join(dir, "checkpoints.jsonl"),
+            snapshotPath: join(dir, "checkpoints.snapshot.jsonl"),
+        });
     }
     withLock(token, fn) {
-        const prev = this.locks.get(token) ?? Promise.resolve();
-        const run = prev.then(() => fn(), () => fn());
-        const tail = run.then(() => { }, () => { });
-        this.locks.set(token, tail);
-        void tail.then(() => {
-            if (this.locks.get(token) === tail)
-                this.locks.delete(token);
-        });
-        return run;
+        return this.ledger.withLock(token, fn);
     }
     commit(ev, fsync) {
-        this.log.append(ev, fsync);
-        this.applyEvent(ev);
-        this.ledgerEvents++;
-        if (this.ledgerEvents >= this.compactEvery) {
-            try {
-                this.compact();
-            }
-            catch {
-            }
-        }
+        this.ledger.commit(ev, fsync, this.compactEvery);
     }
     async put(token, cp) {
         return this.withLock(token, () => {
@@ -222,15 +162,8 @@ export class FileCheckpointStore {
                 out.add(cp.scope);
         return [...out];
     }
-    compact() {
-        const lines = [...this.cps.values()].map((cp) => JSON.stringify(cp)).join("\n");
-        atomicWriteFile(this.tmpDir, this.snapshotPath, lines.length ? `${lines}\n` : "");
-        this.log.closeForSwap();
-        atomicWriteFile(this.tmpDir, this.ledgerPath, "");
-        this.ledgerEvents = 0;
-    }
     compactNow() {
-        this.compact();
+        this.ledger.compact();
     }
     testInjectFault(mode) {
         this.fault = mode;
@@ -242,11 +175,6 @@ export class FileCheckpointStore {
         if (this.closed)
             return;
         this.closed = true;
-        this.shared.refs -= 1;
-        if (this.shared.refs > 0)
-            return;
-        this.log.close();
-        if (sharedCheckpointDirs.get(this.sharedKey) === this.shared)
-            sharedCheckpointDirs.delete(this.sharedKey);
+        this.ledger.release();
     }
 }

package/dist/stores/file/file-snapshot-store.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../../internal/harness.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 import { type FileSnapshotBounds, type FileSnapshotResult, type FileSnapshotStore } from "../../core/file-snapshot-store.js";
 export declare class FileFileSnapshotStore implements FileSnapshotStore {
     private readonly base;

package/dist/stores/file/shared-ledger.d.ts

@@ -0,0 +1,35 @@
+export interface LedgerPaths {
+    readonly dir: string;
+    readonly tmpDir: string;
+    readonly ledgerPath: string;
+    readonly snapshotPath: string;
+}
+export interface LedgerModel<Row, Ev> {
+    keyOf(row: Row): string;
+    apply(rows: Map<string, Row>, ev: Ev): void;
+}
+export declare class LedgerCore<Row, Ev> {
+    private readonly key;
+    private readonly paths;
+    private readonly model;
+    private readonly table;
+    readonly rows: Map<string, Row>;
+    refs: number;
+    private readonly locks;
+    private events;
+    private handle;
+    constructor(key: string, paths: LedgerPaths, model: LedgerModel<Row, Ev>, table: Map<string, LedgerCore<Row, Ev>>);
+    bootstrap(): void;
+    withLock<T>(key: string, fn: () => Promise<T> | T): Promise<T>;
+    commit(ev: Ev, fsync: boolean, compactEvery: number): void;
+    compact(): void;
+    release(): void;
+    get pendingEvents(): number;
+    private get log();
+}
+export declare class SharedLedgerTable<Row, Ev> {
+    private readonly model;
+    private readonly live;
+    constructor(model: LedgerModel<Row, Ev>);
+    acquire(paths: LedgerPaths): LedgerCore<Row, Ev>;
+}

package/dist/stores/file/shared-ledger.js

@@ -0,0 +1,94 @@
+import { AppendLog, atomicWriteFile, canonicalStoreKey, ensureDir, readJsonlRecords } from "./fs-atomic.js";
+export class LedgerCore {
+    key;
+    paths;
+    model;
+    table;
+    rows = new Map();
+    refs = 1;
+    locks = new Map();
+    events = 0;
+    handle;
+    constructor(key, paths, model, table) {
+        this.key = key;
+        this.paths = paths;
+        this.model = model;
+        this.table = table;
+    }
+    bootstrap() {
+        for (const row of readJsonlRecords(this.paths.snapshotPath))
+            this.rows.set(this.model.keyOf(row), row);
+        const events = readJsonlRecords(this.paths.ledgerPath);
+        this.events = events.length;
+        for (const ev of events)
+            this.model.apply(this.rows, ev);
+        this.handle = new AppendLog(this.paths.ledgerPath);
+    }
+    withLock(key, fn) {
+        const prev = this.locks.get(key) ?? Promise.resolve();
+        const run = prev.then(() => fn(), () => fn());
+        const tail = run.then(() => { }, () => { });
+        this.locks.set(key, tail);
+        void tail.then(() => {
+            if (this.locks.get(key) === tail)
+                this.locks.delete(key);
+        });
+        return run;
+    }
+    commit(ev, fsync, compactEvery) {
+        this.log.append(ev, fsync);
+        this.model.apply(this.rows, ev);
+        this.events++;
+        if (this.events >= compactEvery) {
+            try {
+                this.compact();
+            }
+            catch {
+            }
+        }
+    }
+    compact() {
+        const lines = [...this.rows.values()].map((r) => JSON.stringify(r)).join("\n");
+        atomicWriteFile(this.paths.tmpDir, this.paths.snapshotPath, lines.length ? `${lines}\n` : "");
+        this.log.closeForSwap();
+        atomicWriteFile(this.paths.tmpDir, this.paths.ledgerPath, "");
+        this.events = 0;
+    }
+    release() {
+        this.refs -= 1;
+        if (this.refs > 0)
+            return;
+        if (this.table.get(this.key) === this)
+            this.table.delete(this.key);
+        this.handle?.close();
+    }
+    get pendingEvents() {
+        return this.events;
+    }
+    get log() {
+        if (this.handle === undefined)
+            throw new Error("file ledger: used before bootstrap");
+        return this.handle;
+    }
+}
+export class SharedLedgerTable {
+    model;
+    live = new Map();
+    constructor(model) {
+        this.model = model;
+    }
+    acquire(paths) {
+        ensureDir(paths.dir);
+        ensureDir(paths.tmpDir);
+        const key = canonicalStoreKey(paths.dir);
+        const existing = this.live.get(key);
+        if (existing !== undefined) {
+            existing.refs += 1;
+            return existing;
+        }
+        const core = new LedgerCore(key, paths, this.model, this.live);
+        this.live.set(key, core);
+        core.bootstrap();
+        return core;
+    }
+}

package/dist/stores/file/workflow-run-store.d.ts

@@ -5,24 +5,12 @@ export interface FileWorkflowRunStoreOptions {
     compactEvery?: number;
 }
 export declare class FileWorkflowRunStore implements WorkflowRunStore {
-    private readonly dir;
-    private readonly tmpDir;
-    private readonly ledgerPath;
-    private readonly snapshotPath;
     private readonly fsyncEnabled;
     private readonly compactEvery;
-    private readonly shared;
+    private readonly ledger;
     private closed;
-    private readonly canonicalDir;
     private get runs();
-    private get locks();
-    private get ledgerEvents();
-    private set ledgerEvents(value);
-    private get log();
-    private set log(value);
     constructor(root: string, opts?: FileWorkflowRunStoreOptions);
-    private replay;
-    private applyEvent;
     private withLock;
     private commit;
     put(id: string, run: WorkflowRun): Promise<void>;
@@ -39,7 +27,6 @@ export declare class FileWorkflowRunStore implements WorkflowRunStore {
         maxAgeMs?: number;
         keep?: number;
     }): Promise<number>;
-    private compact;
     compactNow(): void;
     get size(): number;
     close(): void;