@a5c-ai/babysitter-sdk 0.0.40 → 0.0.42

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAmwCA,wBAAgB,mBAAmB;eAEf,MAAM,EAAE,GAA2B,OAAO,CAAC,MAAM,CAAC;kBAsCpD,MAAM;EAIvB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AA43CA,wBAAgB,mBAAmB;eAEf,MAAM,EAAE,GAA2B,OAAO,CAAC,MAAM,CAAC;kBAyCpD,MAAM;EAIvB"}

package/dist/cli/main.js

@@ -37,10 +37,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBabysitterCli = createBabysitterCli;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
 const commitEffectResult_1 = require("../runtime/commitEffectResult");
 const createRun_1 = require("../runtime/createRun");
 const effectIndex_1 = require("../runtime/replay/effectIndex");
 const stateCache_1 = require("../runtime/replay/stateCache");
+const ulids_1 = require("../storage/ulids");
 const tasks_1 = require("../storage/tasks");
 const journal_1 = require("../storage/journal");
 const runFiles_1 = require("../storage/runFiles");
@@ -50,6 +52,7 @@ const USAGE = `Usage:
   babysitter run:status <runDir> [--runs-dir <dir>] [--json]
   babysitter run:events <runDir> [--runs-dir <dir>] [--json] [--limit <n>] [--reverse] [--filter-type <type>]
   babysitter run:rebuild-state <runDir> [--runs-dir <dir>] [--json] [--dry-run]
+  babysitter run:repair-journal <runDir> [--runs-dir <dir>] [--json] [--dry-run]
   babysitter run:iterate <runDir> [--runs-dir <dir>] [--json] [--verbose] [--iteration <n>]
   babysitter task:post <runDir> <effectId> --status <ok|error> [--runs-dir <dir>] [--json] [--dry-run] [--value <file>] [--error <file>] [--stdout-ref <ref>] [--stderr-ref <ref>] [--stdout-file <file>] [--stderr-file <file>] [--started-at <iso8601>] [--finished-at <iso8601>] [--metadata <file>] [--invocation-key <key>]
   babysitter task:list <runDir> [--runs-dir <dir>] [--pending] [--kind <kind>] [--json]
@@ -223,6 +226,9 @@ function parseArgs(argv) {
     else if (parsed.command === "run:rebuild-state") {
         [parsed.runDirArg] = positionals;
     }
+    else if (parsed.command === "run:repair-journal") {
+        [parsed.runDirArg] = positionals;
+    }
     return parsed;
 }
 function resolveRunDir(baseDir, runDirArg) {
@@ -689,6 +695,111 @@ async function handleRunRebuildState(parsed) {
     console.log(`[run:rebuild-state] runDir=${runDir}${suffix}`);
     return 0;
 }
+async function handleRunRepairJournal(parsed) {
+    if (!parsed.runDirArg) {
+        console.error(USAGE);
+        return 1;
+    }
+    const runDir = resolveRunDir(parsed.runsDir, parsed.runDirArg);
+    logVerbose("run:repair-journal", parsed, {
+        runDir,
+        dryRun: parsed.dryRun,
+        json: parsed.json,
+    });
+    if (!(await readRunMetadataSafe(runDir, "run:repair-journal")))
+        return 1;
+    const journalDir = path.join(runDir, "journal");
+    const files = (await node_fs_1.promises.readdir(journalDir)).filter((name) => name.endsWith(".json")).sort();
+    const rawEvents = [];
+    for (const filename of files) {
+        const fullPath = path.join(journalDir, filename);
+        const payload = JSON.parse(await node_fs_1.promises.readFile(fullPath, "utf8"));
+        rawEvents.push({ filename, payload });
+    }
+    const seenInvocation = new Set();
+    const keptEffectIds = new Set();
+    const droppedEffectIds = new Set();
+    const kept = [];
+    let droppedRequested = 0;
+    let droppedResolved = 0;
+    for (const entry of rawEvents) {
+        const type = typeof entry.payload.type === "string" ? entry.payload.type : "UNKNOWN";
+        const recordedAt = typeof entry.payload.recordedAt === "string" ? entry.payload.recordedAt : undefined;
+        const data = isJsonRecord(entry.payload.data) ? entry.payload.data : {};
+        if (type === "EFFECT_REQUESTED") {
+            const invocationKey = typeof data.invocationKey === "string" ? data.invocationKey : "";
+            const effectId = typeof data.effectId === "string" ? data.effectId : "";
+            if (invocationKey && seenInvocation.has(invocationKey)) {
+                droppedRequested += 1;
+                if (effectId)
+                    droppedEffectIds.add(effectId);
+                continue;
+            }
+            if (invocationKey)
+                seenInvocation.add(invocationKey);
+            if (effectId)
+                keptEffectIds.add(effectId);
+            kept.push({ type, recordedAt, data });
+            continue;
+        }
+        if (type === "EFFECT_RESOLVED") {
+            const effectId = typeof data.effectId === "string" ? data.effectId : "";
+            if (effectId && droppedEffectIds.has(effectId) && !keptEffectIds.has(effectId)) {
+                droppedResolved += 1;
+                continue;
+            }
+            kept.push({ type, recordedAt, data });
+            continue;
+        }
+        // Keep all other events.
+        kept.push({ type, recordedAt, data });
+    }
+    const summary = {
+        runDir,
+        journal: {
+            originalFiles: files.length,
+            keptEvents: kept.length,
+            droppedRequested,
+            droppedResolved,
+        },
+    };
+    if (parsed.dryRun) {
+        if (parsed.json) {
+            console.log(JSON.stringify({ dryRun: true, ...summary }));
+        }
+        else {
+            console.log(`[run:repair-journal] dry-run originalFiles=${files.length} keptEvents=${kept.length} droppedRequested=${droppedRequested} droppedResolved=${droppedResolved}`);
+        }
+        return 0;
+    }
+    const stamp = Date.now();
+    const repairedDir = path.join(runDir, `journal.repaired.${stamp}`);
+    await node_fs_1.promises.mkdir(repairedDir, { recursive: true });
+    for (let i = 0; i < kept.length; i += 1) {
+        const seq = String(i + 1).padStart(6, "0");
+        const ulid = (0, ulids_1.nextUlid)();
+        const filename = `${seq}.${ulid}.json`;
+        const eventPayload = {
+            type: kept[i].type,
+            recordedAt: kept[i].recordedAt ?? new Date().toISOString(),
+            data: kept[i].data,
+        };
+        const contents = JSON.stringify(eventPayload, null, 2) + "\n";
+        const checksum = crypto.createHash("sha256").update(contents).digest("hex");
+        const withChecksum = JSON.stringify({ ...eventPayload, checksum }, null, 2) + "\n";
+        await node_fs_1.promises.writeFile(path.join(repairedDir, filename), withChecksum, "utf8");
+    }
+    const backupDir = path.join(runDir, `journal.bak.${stamp}`);
+    await node_fs_1.promises.rename(journalDir, backupDir);
+    await node_fs_1.promises.rename(repairedDir, journalDir);
+    if (parsed.json) {
+        console.log(JSON.stringify({ ...summary, backupDir, repaired: true }));
+    }
+    else {
+        console.log(`[run:repair-journal] repaired originalFiles=${files.length} keptEvents=${kept.length} droppedRequested=${droppedRequested} droppedResolved=${droppedResolved} backupDir=${backupDir}`);
+    }
+    return 0;
+}
 async function handleTaskPost(parsed) {
     if (!parsed.runDirArg || !parsed.effectId) {
         console.error(USAGE);
@@ -1190,6 +1301,9 @@ function createBabysitterCli() {
                 if (parsed.command === "run:rebuild-state") {
                     return await handleRunRebuildState(parsed);
                 }
+                if (parsed.command === "run:repair-journal") {
+                    return await handleRunRepairJournal(parsed);
+                }
                 if (parsed.command === "run:status") {
                     return await handleRunStatus(parsed);
                 }

package/dist/runtime/commitEffectResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commitEffectResult.d.ts","sourceRoot":"","sources":["../../src/runtime/commitEffectResult.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EAG1B,MAAM,SAAS,CAAC;AAOjB,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAoEjH"}
+{"version":3,"file":"commitEffectResult.d.ts","sourceRoot":"","sources":["../../src/runtime/commitEffectResult.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EAG1B,MAAM,SAAS,CAAC;AAOjB,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAsEjH"}

package/dist/runtime/commitEffectResult.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commitEffectResult = commitEffectResult;
 const journal_1 = require("../storage/journal");
+const lock_1 = require("../storage/lock");
 const effectIndex_1 = require("./replay/effectIndex");
 const exceptions_1 = require("./exceptions");
 const errorUtils_1 = require("./errorUtils");
@@ -9,65 +10,67 @@ const instrumentation_1 = require("./instrumentation");
 const registry_1 = require("../tasks/registry");
 const serializer_1 = require("../tasks/serializer");
 async function commitEffectResult(options) {
-    guardResultPayload(options);
-    const effectIndex = await (0, effectIndex_1.buildEffectIndex)({ runDir: options.runDir });
-    const record = effectIndex.getByEffectId(options.effectId);
-    if (!record) {
-        logCommitFailure(options, "unknown_effect");
-        throw new exceptions_1.RunFailedError(`Unknown effectId ${options.effectId}`);
-    }
-    if (record.status !== "requested") {
-        logCommitFailure(options, "already_resolved", { currentStatus: record.status });
-        throw new exceptions_1.RunFailedError(`Effect ${options.effectId} is already resolved`);
-    }
-    ensureInvocationKeyMatches(options, record);
-    const resultPayload = buildResultPayload(options);
-    const { resultRef, stdoutRef: writtenStdoutRef, stderrRef: writtenStderrRef } = await (0, serializer_1.serializeAndWriteTaskResult)({
-        runDir: options.runDir,
-        effectId: options.effectId,
-        taskId: requireTaskId(record),
-        invocationKey: record.invocationKey,
-        payload: resultPayload,
-    });
-    const stdoutRef = resultPayload.stdoutRef ?? writtenStdoutRef;
-    const stderrRef = resultPayload.stderrRef ?? writtenStderrRef;
-    const eventError = resultPayload.status === "error" ? resultPayload.error : undefined;
-    const resolvedEvent = await (0, journal_1.appendEvent)({
-        runDir: options.runDir,
-        eventType: "EFFECT_RESOLVED",
-        event: {
+    return await (0, lock_1.withRunLock)(options.runDir, "runtime:commitEffectResult", async () => {
+        guardResultPayload(options);
+        const effectIndex = await (0, effectIndex_1.buildEffectIndex)({ runDir: options.runDir });
+        const record = effectIndex.getByEffectId(options.effectId);
+        if (!record) {
+            logCommitFailure(options, "unknown_effect");
+            throw new exceptions_1.RunFailedError(`Unknown effectId ${options.effectId}`);
+        }
+        if (record.status !== "requested") {
+            logCommitFailure(options, "already_resolved", { currentStatus: record.status });
+            throw new exceptions_1.RunFailedError(`Effect ${options.effectId} is already resolved`);
+        }
+        ensureInvocationKeyMatches(options, record);
+        const resultPayload = buildResultPayload(options);
+        const { resultRef, stdoutRef: writtenStdoutRef, stderrRef: writtenStderrRef } = await (0, serializer_1.serializeAndWriteTaskResult)({
+            runDir: options.runDir,
             effectId: options.effectId,
-            status: options.result.status,
+            taskId: requireTaskId(record),
+            invocationKey: record.invocationKey,
+            payload: resultPayload,
+        });
+        const stdoutRef = resultPayload.stdoutRef ?? writtenStdoutRef;
+        const stderrRef = resultPayload.stderrRef ?? writtenStderrRef;
+        const eventError = resultPayload.status === "error" ? resultPayload.error : undefined;
+        const resolvedEvent = await (0, journal_1.appendEvent)({
+            runDir: options.runDir,
+            eventType: "EFFECT_RESOLVED",
+            event: {
+                effectId: options.effectId,
+                status: options.result.status,
+                resultRef,
+                error: eventError,
+                stdoutRef,
+                stderrRef,
+                startedAt: resultPayload.startedAt,
+                finishedAt: resultPayload.finishedAt,
+            },
+        });
+        registry_1.globalTaskRegistry.resolveEffect(options.effectId, {
+            status: options.result.status === "ok" ? "resolved_ok" : "resolved_error",
             resultRef,
-            error: eventError,
             stdoutRef,
             stderrRef,
+            resolvedAt: resolvedEvent.recordedAt,
+        });
+        (0, instrumentation_1.emitRuntimeMetric)(options.logger, "commit.effect", {
+            effectId: options.effectId,
+            invocationKey: record.invocationKey,
+            status: options.result.status,
+            runDir: options.runDir,
+            hasStdout: Boolean(stdoutRef),
+            hasStderr: Boolean(stderrRef),
+        });
+        return {
+            resultRef,
+            stdoutRef: stdoutRef ?? undefined,
+            stderrRef: stderrRef ?? undefined,
             startedAt: resultPayload.startedAt,
             finishedAt: resultPayload.finishedAt,
-        },
-    });
-    registry_1.globalTaskRegistry.resolveEffect(options.effectId, {
-        status: options.result.status === "ok" ? "resolved_ok" : "resolved_error",
-        resultRef,
-        stdoutRef,
-        stderrRef,
-        resolvedAt: resolvedEvent.recordedAt,
-    });
-    (0, instrumentation_1.emitRuntimeMetric)(options.logger, "commit.effect", {
-        effectId: options.effectId,
-        invocationKey: record.invocationKey,
-        status: options.result.status,
-        runDir: options.runDir,
-        hasStdout: Boolean(stdoutRef),
-        hasStderr: Boolean(stderrRef),
+        };
     });
-    return {
-        resultRef,
-        stdoutRef: stdoutRef ?? undefined,
-        stderrRef: stderrRef ?? undefined,
-        startedAt: resultPayload.startedAt,
-        finishedAt: resultPayload.finishedAt,
-    };
 }
 function ensureInvocationKeyMatches(options, record) {
     if (!options.invocationKey)

package/dist/runtime/orchestrateIteration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateIteration.d.ts","sourceRoot":"","sources":["../../src/runtime/orchestrateIteration.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,eAAe,EACf,kBAAkB,EAGnB,MAAM,SAAS,CAAC;AAYjB,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CA2HhG"}
+{"version":3,"file":"orchestrateIteration.d.ts","sourceRoot":"","sources":["../../src/runtime/orchestrateIteration.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,eAAe,EACf,kBAAkB,EAGnB,MAAM,SAAS,CAAC;AAYjB,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CA6HhG"}

package/dist/runtime/orchestrateIteration.js

@@ -8,6 +8,7 @@ const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
 const journal_1 = require("../storage/journal");
 const runFiles_1 = require("../storage/runFiles");
+const lock_1 = require("../storage/lock");
 const createReplayEngine_1 = require("./replay/createReplayEngine");
 const processContext_1 = require("./processContext");
 const exceptions_1 = require("./exceptions");
@@ -17,104 +18,106 @@ const runtime_1 = require("./hooks/runtime");
 // Use an indirect dynamic import so TypeScript does not downlevel to require() in CommonJS builds.
 const dynamicImportModule = new Function("specifier", "return import(specifier);");
 async function orchestrateIteration(options) {
-    const iterationStartedAt = Date.now();
-    const nowFn = resolveNow(options.now);
-    const engine = await initializeReplayEngine(options, nowFn, iterationStartedAt);
-    const defaultEntrypoint = {
-        importPath: engine.metadata.entrypoint?.importPath ?? engine.metadata.processPath,
-        exportName: engine.metadata.entrypoint?.exportName,
-    };
-    const processFn = await loadProcessFunction(options, defaultEntrypoint, options.runDir);
-    const inputs = options.inputs ?? engine.inputs;
-    let finalStatus = "failed";
-    const logger = engine.internalContext.logger ?? options.logger;
-    // Compute project root for hook calls (parent of .a5c dir where plugins/ is located)
-    // runDir is like: /path/to/project/.a5c/runs/<runId>
-    // So we need 3 levels up: runs -> .a5c -> project
-    const projectRoot = path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(options.runDir)));
-    // Call on-iteration-start hook
-    await (0, runtime_1.callRuntimeHook)("on-iteration-start", {
-        runId: engine.runId,
-        iteration: engine.replayCursor.value,
-    }, {
-        cwd: projectRoot,
-        logger,
-    });
-    try {
-        const output = await (0, processContext_1.withProcessContext)(engine.internalContext, () => processFn(inputs, engine.context, options.context));
-        const outputRef = await (0, runFiles_1.writeRunOutput)(options.runDir, output);
-        await (0, journal_1.appendEvent)({
-            runDir: options.runDir,
-            eventType: "RUN_COMPLETED",
-            event: {
-                outputRef,
-            },
-        });
-        // Call on-run-complete hook
-        await (0, runtime_1.callRuntimeHook)("on-run-complete", {
+    return await (0, lock_1.withRunLock)(options.runDir, "runtime:orchestrateIteration", async () => {
+        const iterationStartedAt = Date.now();
+        const nowFn = resolveNow(options.now);
+        const engine = await initializeReplayEngine(options, nowFn, iterationStartedAt);
+        const defaultEntrypoint = {
+            importPath: engine.metadata.entrypoint?.importPath ?? engine.metadata.processPath,
+            exportName: engine.metadata.entrypoint?.exportName,
+        };
+        const processFn = await loadProcessFunction(options, defaultEntrypoint, options.runDir);
+        const inputs = options.inputs ?? engine.inputs;
+        let finalStatus = "failed";
+        const logger = engine.internalContext.logger ?? options.logger;
+        // Compute project root for hook calls (parent of .a5c dir where plugins/ is located)
+        // runDir is like: /path/to/project/.a5c/runs/<runId>
+        // So we need 3 levels up: runs -> .a5c -> project
+        const projectRoot = path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(options.runDir)));
+        // Call on-iteration-start hook
+        await (0, runtime_1.callRuntimeHook)("on-iteration-start", {
             runId: engine.runId,
-            status: "completed",
-            output,
-            duration: Date.now() - iterationStartedAt,
+            iteration: engine.replayCursor.value,
         }, {
             cwd: projectRoot,
             logger,
         });
-        const result = { status: "completed", output, metadata: createIterationMetadata(engine) };
-        finalStatus = result.status;
-        return result;
-    }
-    catch (error) {
-        const waiting = asWaitingResult(error);
-        if (waiting) {
-            finalStatus = waiting.status;
-            return {
-                status: "waiting",
-                nextActions: annotateWaitingActions(waiting.nextActions),
+        try {
+            const output = await (0, processContext_1.withProcessContext)(engine.internalContext, () => processFn(inputs, engine.context, options.context));
+            const outputRef = await (0, runFiles_1.writeRunOutput)(options.runDir, output);
+            await (0, journal_1.appendEvent)({
+                runDir: options.runDir,
+                eventType: "RUN_COMPLETED",
+                event: {
+                    outputRef,
+                },
+            });
+            // Call on-run-complete hook
+            await (0, runtime_1.callRuntimeHook)("on-run-complete", {
+                runId: engine.runId,
+                status: "completed",
+                output,
+                duration: Date.now() - iterationStartedAt,
+            }, {
+                cwd: projectRoot,
+                logger,
+            });
+            const result = { status: "completed", output, metadata: createIterationMetadata(engine) };
+            finalStatus = result.status;
+            return result;
+        }
+        catch (error) {
+            const waiting = asWaitingResult(error);
+            if (waiting) {
+                finalStatus = waiting.status;
+                return {
+                    status: "waiting",
+                    nextActions: annotateWaitingActions(waiting.nextActions),
+                    metadata: createIterationMetadata(engine),
+                };
+            }
+            const failure = (0, errorUtils_1.serializeUnknownError)(error);
+            await (0, journal_1.appendEvent)({
+                runDir: options.runDir,
+                eventType: "RUN_FAILED",
+                event: { error: failure },
+            });
+            // Call on-run-fail hook
+            await (0, runtime_1.callRuntimeHook)("on-run-fail", {
+                runId: engine.runId,
+                status: "failed",
+                error: failure.message || "Unknown error",
+                duration: Date.now() - iterationStartedAt,
+            }, {
+                cwd: projectRoot,
+                logger,
+            });
+            const result = {
+                status: "failed",
+                error: failure,
                 metadata: createIterationMetadata(engine),
             };
+            finalStatus = result.status;
+            return result;
         }
-        const failure = (0, errorUtils_1.serializeUnknownError)(error);
-        await (0, journal_1.appendEvent)({
-            runDir: options.runDir,
-            eventType: "RUN_FAILED",
-            event: { error: failure },
-        });
-        // Call on-run-fail hook
-        await (0, runtime_1.callRuntimeHook)("on-run-fail", {
-            runId: engine.runId,
-            status: "failed",
-            error: failure.message || "Unknown error",
-            duration: Date.now() - iterationStartedAt,
-        }, {
-            cwd: projectRoot,
-            logger,
-        });
-        const result = {
-            status: "failed",
-            error: failure,
-            metadata: createIterationMetadata(engine),
-        };
-        finalStatus = result.status;
-        return result;
-    }
-    finally {
-        (0, instrumentation_1.emitRuntimeMetric)(logger, "replay.iteration", {
-            duration_ms: Date.now() - iterationStartedAt,
-            status: finalStatus,
-            runId: engine.runId,
-            stepCount: engine.replayCursor.value,
-        });
-        // Call on-iteration-end hook
-        await (0, runtime_1.callRuntimeHook)("on-iteration-end", {
-            runId: engine.runId,
-            iteration: engine.replayCursor.value,
-            status: finalStatus,
-        }, {
-            cwd: projectRoot,
-            logger,
-        });
-    }
+        finally {
+            (0, instrumentation_1.emitRuntimeMetric)(logger, "replay.iteration", {
+                duration_ms: Date.now() - iterationStartedAt,
+                status: finalStatus,
+                runId: engine.runId,
+                stepCount: engine.replayCursor.value,
+            });
+            // Call on-iteration-end hook
+            await (0, runtime_1.callRuntimeHook)("on-iteration-end", {
+                runId: engine.runId,
+                iteration: engine.replayCursor.value,
+                status: finalStatus,
+            }, {
+                cwd: projectRoot,
+                logger,
+            });
+        }
+    });
 }
 async function loadProcessFunction(options, defaults, runDir) {
     const importPath = options.process?.importPath ?? defaults.importPath;

package/dist/storage/lock.d.ts

@@ -2,4 +2,9 @@ import { RunLockInfo } from "./types";
 export declare function acquireRunLock(runDir: string, owner: string): Promise<RunLockInfo>;
 export declare function releaseRunLock(runDir: string): Promise<void>;
 export declare function readRunLock(runDir: string): Promise<RunLockInfo | null>;
+export interface WithRunLockOptions {
+    retries?: number;
+    delayMs?: number;
+}
+export declare function withRunLock<T>(runDir: string, owner: string, fn: () => Promise<T>, options?: WithRunLockOptions): Promise<T>;
 //# sourceMappingURL=lock.d.ts.map

package/dist/storage/lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/storage/lock.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAItC,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAcxF;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,iBAGlD;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAU7E"}
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/storage/lock.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAItC,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAcxF;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,iBAGlD;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAU7E;AAWD,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/storage/lock.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.acquireRunLock = acquireRunLock;
 exports.releaseRunLock = releaseRunLock;
 exports.readRunLock = readRunLock;
+exports.withRunLock = withRunLock;
 const fs_1 = require("fs");
 const paths_1 = require("./paths");
 const clock_1 = require("./clock");
@@ -39,3 +40,37 @@ async function readRunLock(runDir) {
         throw err;
     }
 }
+function isLockHeldError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.message.startsWith("run.lock already held");
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRunLock(runDir, owner, fn, options = {}) {
+    const retries = typeof options.retries === "number" ? Math.max(0, Math.floor(options.retries)) : 40;
+    const delayMs = typeof options.delayMs === "number" ? Math.max(0, Math.floor(options.delayMs)) : 250;
+    let acquired = false;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            await acquireRunLock(runDir, owner);
+            acquired = true;
+            break;
+        }
+        catch (error) {
+            if (!isLockHeldError(error) || attempt === retries) {
+                throw error;
+            }
+            await sleep(delayMs);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (acquired) {
+            await releaseRunLock(runDir);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/babysitter-sdk",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "Storage and run-registry primitives for event-sourced babysitter workflows.",
   "license": "UNLICENSED",
   "type": "commonjs",