@a5c-ai/babysitter-sdk 0.0.16

package/dist/testing/runHarness.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runToCompletionWithFakeRunner = runToCompletionWithFakeRunner;
+const orchestrateIteration_1 = require("../runtime/orchestrateIteration");
+const commitEffectResult_1 = require("../runtime/commitEffectResult");
+const DEFAULT_MAX_ITERATIONS = 100;
+async function runToCompletionWithFakeRunner(options) {
+    const { runDir, resolve, logger, onIteration } = options;
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    if (maxIterations <= 0 || !Number.isFinite(maxIterations)) {
+        throw new Error("maxIterations must be a positive finite number");
+    }
+    const cleanupProviders = applyDeterministicProviders(options.clock, options.ulids);
+    const executed = [];
+    const executionLog = [];
+    let iterations = 0;
+    try {
+        while (iterations < maxIterations) {
+            iterations += 1;
+            const clockHandle = options.clock;
+            const deterministicNow = clockHandle ? () => clockHandle.now() : undefined;
+            const iteration = await (0, orchestrateIteration_1.orchestrateIteration)({
+                runDir,
+                logger,
+                now: resolveNowOption(options.now ?? deterministicNow),
+            });
+            await onIteration?.(iteration);
+            const iterationLog = {
+                iteration: iterations,
+                status: iteration.status,
+                metadata: iteration.metadata ?? null,
+                pending: iteration.status === "waiting" ? iteration.nextActions.map(snapshotAction) : [],
+                executed: [],
+            };
+            if (iteration.status === "completed") {
+                executionLog.push(iterationLog);
+                return {
+                    status: "completed",
+                    output: iteration.output,
+                    metadata: iteration.metadata ?? null,
+                    executed,
+                    iterations,
+                    executionLog,
+                };
+            }
+            if (iteration.status === "failed") {
+                executionLog.push(iterationLog);
+                return {
+                    status: "failed",
+                    error: iteration.error,
+                    metadata: iteration.metadata ?? null,
+                    executed,
+                    iterations,
+                    executionLog,
+                };
+            }
+            if (iteration.status !== "waiting") {
+                executionLog.push(iterationLog);
+                throw new Error("Unexpected iteration status");
+            }
+            const pendingActions = iteration.nextActions;
+            const executedThisIteration = [];
+            let handled = false;
+            for (const action of pendingActions) {
+                const resolution = await resolve(action);
+                if (!resolution) {
+                    continue;
+                }
+                handled = true;
+                await (0, commitEffectResult_1.commitEffectResult)({
+                    runDir,
+                    effectId: action.effectId,
+                    invocationKey: action.invocationKey,
+                    result: toCommitResult(resolution),
+                });
+                const entry = { action, resolution };
+                executedThisIteration.push(entry);
+                executed.push(entry);
+            }
+            iterationLog.executed = executedThisIteration.map(({ action }) => snapshotAction(action));
+            executionLog.push(iterationLog);
+            if (!handled) {
+                return {
+                    status: "waiting",
+                    pending: pendingActions,
+                    metadata: iteration.metadata ?? null,
+                    executed,
+                    iterations,
+                    executionLog,
+                };
+            }
+        }
+        throw new Error(`runToCompletionWithFakeRunner exceeded maxIterations=${maxIterations}`);
+    }
+    finally {
+        cleanupProviders();
+    }
+}
+function toCommitResult(resolution) {
+    const base = {
+        stdout: resolution.stdout,
+        stderr: resolution.stderr,
+        startedAt: resolution.startedAt,
+        finishedAt: resolution.finishedAt,
+        metadata: resolution.metadata,
+    };
+    if (resolution.status === "ok") {
+        return {
+            status: "ok",
+            value: resolution.value,
+            ...base,
+        };
+    }
+    if (resolution.error === undefined) {
+        throw new Error("FakeActionResolution.status='error' requires an error payload");
+    }
+    return {
+        status: "error",
+        error: resolution.error,
+        ...base,
+    };
+}
+function snapshotAction(action) {
+    return {
+        effectId: action.effectId,
+        invocationKey: action.invocationKey,
+        taskId: action.taskId,
+        stepId: action.stepId,
+        kind: action.kind,
+        schedulerHints: action.schedulerHints,
+    };
+}
+function resolveNowOption(now) {
+    if (!now)
+        return () => new Date();
+    if (typeof now === "function") {
+        return now;
+    }
+    const fixed = now;
+    return () => fixed;
+}
+function applyDeterministicProviders(clock, ulids) {
+    const restoreFns = [];
+    if (clock) {
+        restoreFns.push(clock.apply());
+    }
+    if (ulids) {
+        restoreFns.push(ulids.apply());
+    }
+    return () => {
+        while (restoreFns.length > 0) {
+            const restore = restoreFns.pop();
+            try {
+                restore?.();
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    };
+}

package/dist/testing/snapshots.d.ts

@@ -0,0 +1,17 @@
+import type { JsonRecord } from "../storage/types";
+import { type StateCacheSnapshot } from "../runtime/replay/stateCache";
+export interface JournalSnapshotEntry {
+    seq: number;
+    ulid: string;
+    type: string;
+    recordedAt: string;
+    data: JsonRecord;
+}
+export interface RunSnapshot {
+    journal: JournalSnapshotEntry[];
+    state: StateCacheSnapshot | null;
+}
+export declare function readJournalSnapshot(runDir: string): Promise<JournalSnapshotEntry[]>;
+export declare function readStateSnapshot(runDir: string): Promise<StateCacheSnapshot | null>;
+export declare function captureRunSnapshot(runDir: string): Promise<RunSnapshot>;
+//# sourceMappingURL=snapshots.d.ts.map

package/dist/testing/snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshots.d.ts","sourceRoot":"","sources":["../../src/testing/snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAEvF,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAClC;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CASzF;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAE1F;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAG7E"}

package/dist/testing/snapshots.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJournalSnapshot = readJournalSnapshot;
+exports.readStateSnapshot = readStateSnapshot;
+exports.captureRunSnapshot = captureRunSnapshot;
+const journal_1 = require("../storage/journal");
+const stateCache_1 = require("../runtime/replay/stateCache");
+async function readJournalSnapshot(runDir) {
+    const events = await (0, journal_1.loadJournal)(runDir);
+    return events.map((event) => ({
+        seq: event.seq,
+        ulid: event.ulid,
+        type: event.type,
+        recordedAt: event.recordedAt,
+        data: event.data,
+    }));
+}
+async function readStateSnapshot(runDir) {
+    return (0, stateCache_1.readStateCache)(runDir);
+}
+async function captureRunSnapshot(runDir) {
+    const [journal, state] = await Promise.all([readJournalSnapshot(runDir), readStateSnapshot(runDir)]);
+    return { journal, state };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@a5c-ai/babysitter-sdk",
+  "version": "0.0.16",
+  "description": "Storage and run-registry primitives for event-sourced babysitter workflows.",
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "babysitter": "dist/cli/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "smoke:cli": "node scripts/smoke-cli.js --runs-dir packages/sdk/test-fixtures/cli/runs/smoke"
+  },
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "ulid": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.30",
+    "eslint": "^8.57.0",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.4.2",
+    "vitest": "^1.2.2"
+  }
+}