@agwab/pi-workflow 0.3.0 → 0.4.0

package/dist/store.js

@@ -13,6 +13,7 @@ const DEFAULT_INDEX_UPDATE_DEBOUNCE_MS = 500;
 let indexUpdateDebounceMs = DEFAULT_INDEX_UPDATE_DEBOUNCE_MS;
 const pendingIndexUpdates = new Map();
 const runLeaseContext = new AsyncLocalStorage();
+let runLeaseTestHooks = {};
 const TASK_STATUSES = [
     "pending",
     "running",
@@ -80,6 +81,9 @@ export async function writeJsonAtomic(file, value) {
     await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
     await rename(temp, file);
 }
+export function setRunLeaseTestHooksForTests(hooks) {
+    runLeaseTestHooks = hooks ?? {};
+}
 export async function withRunLease(cwd, runId, action) {
     const dir = workflowRunDir(cwd, runId);
     await ensureDir(dir);
@@ -88,8 +92,15 @@ export async function withRunLease(cwd, runId, action) {
     const lock = await acquireLock(lockFile, ownerId);
     if (!lock)
         return undefined;
+    const abortController = new AbortController();
+    const abortLease = (error) => {
+        if (abortController.signal.aborted)
+            return;
+        abortController.abort(asLeaseError(error));
+    };
     const supervisorFile = join(dir, "supervisor.json");
     const heartbeat = async () => {
+        assertLeaseNotAborted(abortController.signal);
         await assertLockOwner(lockFile, ownerId);
         const timestamp = nowIso();
         const now = new Date();
@@ -104,17 +115,37 @@ export async function withRunLease(cwd, runId, action) {
     };
     await heartbeat();
     const heartbeatTimer = setInterval(() => {
-        void heartbeat().catch(() => undefined);
-    }, Math.max(1000, Math.floor(LEASE_STALE_MS / 3)));
+        void heartbeat().catch(abortLease);
+    }, runLeaseHeartbeatIntervalMs());
     heartbeatTimer.unref?.();
     try {
-        return await runLeaseContext.run({ cwd, runId, ownerId }, action);
+        const result = await runLeaseContext.run({ cwd, runId, ownerId, abortSignal: abortController.signal }, () => action(abortController.signal));
+        assertLeaseNotAborted(abortController.signal);
+        return result;
     }
     finally {
         clearInterval(heartbeatTimer);
         await releaseLock(lockFile, ownerId);
     }
 }
+function runLeaseHeartbeatIntervalMs() {
+    return Math.max(1, Math.floor(runLeaseTestHooks.heartbeatIntervalMs ??
+        Math.max(1000, Math.floor(LEASE_STALE_MS / 3))));
+}
+function assertLeaseNotAborted(signal) {
+    if (signal.aborted)
+        throw abortSignalError(signal);
+}
+function abortSignalError(signal) {
+    return asLeaseError(signal.reason);
+}
+function asLeaseError(error) {
+    if (error instanceof Error)
+        return error;
+    return new Error(error === undefined
+        ? "Lost supervisor lease"
+        : `Lost supervisor lease: ${String(error)}`);
+}
 async function acquireLock(lockFile, ownerId) {
     const tryCreate = async () => {
         try {
@@ -154,6 +185,7 @@ async function reclaimStaleLock(lockFile) {
             return true;
         return false;
     }
+    await runLeaseTestHooks.onAfterReclaimRename?.({ lockFile, reclaimFile });
     const claimed = await readLockSnapshot(reclaimFile);
     if (!claimed)
         return true;
@@ -169,16 +201,20 @@ async function reclaimStaleLock(lockFile) {
     return true;
 }
 async function restoreReclaimFile(reclaimFile, lockFile) {
+    await runLeaseTestHooks.onBeforeRestoreReclaimFile?.({
+        lockFile,
+        reclaimFile,
+    });
     try {
         await link(reclaimFile, lockFile);
     }
     catch (error) {
-        if (error.code !== "EEXIST")
-            throw error;
-    }
-    finally {
-        await unlink(reclaimFile).catch(() => undefined);
+        if (error.code === "EEXIST") {
+            throw new Error(`Could not restore reclaimed lock because another owner acquired ${lockFile}`, { cause: error });
+        }
+        throw error;
     }
+    await unlink(reclaimFile).catch(() => undefined);
 }
 function isReclaimableLockSnapshot(snapshot) {
     const now = Date.now();
@@ -238,8 +274,31 @@ async function acquireLockWithWait(lockFile, ownerId) {
     }
 }
 async function releaseLock(lockFile, ownerId) {
-    if (await ownsLock(lockFile, ownerId))
-        await unlink(lockFile).catch(() => undefined);
+    const snapshot = await readLockSnapshot(lockFile);
+    if (!snapshot || snapshot.ownerId !== ownerId)
+        return;
+    const releaseFile = `${lockFile}.release-${process.pid}-${randomBytes(3).toString("hex")}`;
+    await runLeaseTestHooks.onBeforeReleaseLockRename?.({
+        lockFile,
+        releaseFile,
+        ownerId,
+    });
+    try {
+        await rename(lockFile, releaseFile);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    const claimed = await readLockSnapshot(releaseFile);
+    if (!claimed)
+        return;
+    if (sameLockOwnerSnapshot(snapshot, claimed)) {
+        await unlink(releaseFile).catch(() => undefined);
+        return;
+    }
+    await restoreReclaimFile(releaseFile, lockFile);
 }
 async function assertLockOwner(lockFile, ownerId) {
     if (!(await ownsLock(lockFile, ownerId)))
@@ -833,6 +892,7 @@ async function assertActiveRunLease(cwd, runId) {
         return;
     if (context.cwd !== cwd || context.runId !== runId)
         return;
+    assertLeaseNotAborted(context.abortSignal);
     await assertLockOwner(join(workflowRunDir(cwd, runId), "supervisor.lock"), context.ownerId);
 }
 export async function findRunRecordPath(cwd, runIdOrPrefix) {
@@ -943,6 +1003,7 @@ async function updateIndexIncremental(cwd, changedRunId) {
     const changedEntry = buildIndexEntry(cwd, changedRun);
     const entries = existing.runs
         .filter((entry) => entry.runId !== changedRun.runId)
+        .map(stripIndexTaskRows)
         .concat(changedEntry);
     return {
         schemaVersion: 1,
@@ -978,6 +1039,10 @@ function selectIndexEntries(entries) {
         .slice(0, TERMINAL_INDEX_LIMIT);
     return [...active, ...terminal].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
+function stripIndexTaskRows(entry) {
+    const { tasks: _tasks, ...slim } = entry;
+    return slim;
+}
 function buildIndexEntry(cwd, run) {
     return {
         runId: run.runId,
@@ -993,28 +1058,20 @@ function buildIndexEntry(cwd, run) {
         round: run.round,
         fanout: run.fanout,
         runJson: toProjectPath(cwd, workflowRunPath(cwd, run.runId)),
-        tasks: run.tasks.map((task) => ({
-            taskId: task.taskId,
-            displayName: task.displayName,
-            agent: task.agent,
-            kind: task.kind,
-            stageId: task.stageId,
-            backendHandle: task.backendHandle,
-            status: task.status,
-            statusDetail: task.statusDetail,
-            lastMessage: task.lastMessage,
-        })),
     };
 }
 function isIndexRecordLike(value) {
     return (value?.schemaVersion === 1 &&
         Array.isArray(value.runs) &&
-        value.runs.every((entry) => entry &&
-            typeof entry === "object" &&
-            typeof entry.runId === "string" &&
-            typeof entry.updatedAt === "string" &&
-            typeof entry.status === "string" &&
-            Array.isArray(entry.tasks)));
+        value.runs.every((entry) => {
+            if (!entry || typeof entry !== "object")
+                return false;
+            const tasks = entry.tasks;
+            return (typeof entry.runId === "string" &&
+                typeof entry.updatedAt === "string" &&
+                typeof entry.status === "string" &&
+                (tasks === undefined || Array.isArray(tasks)));
+        }));
 }
 export function deriveRunStatus(run) {
     const next = { ...run, tasks: run.tasks };
@@ -1072,10 +1129,13 @@ const RESUMABLE_BLOCKED_STATUS_DETAILS = new Set([
     "dynamic_ui_unavailable",
     "dynamic_approval_timeout",
 ]);
+export function isBlockedTaskResumableForResume(task) {
+    return (task.status === "blocked" &&
+        RESUMABLE_BLOCKED_STATUS_DETAILS.has(task.statusDetail));
+}
 export function resetTaskForResume(task) {
     if (!RESUMABLE_TASK_STATUSES.has(task.status) &&
-        !(task.status === "blocked" &&
-            RESUMABLE_BLOCKED_STATUS_DETAILS.has(task.statusDetail))) {
+        !isBlockedTaskResumableForResume(task)) {
         return false;
     }
     recordTaskResumeEvent(task);

package/dist/strings.d.ts

@@ -0,0 +1,11 @@
+export interface CompactStringsOptions {
+    /** Trim returned strings before filtering. Defaults to true. */
+    trim?: boolean;
+    /** Drop duplicate strings after optional trimming. Defaults to true. */
+    unique?: boolean;
+    /** Drop strings whose raw/trimmed form is empty. Defaults to true. */
+    dropEmpty?: boolean;
+    /** Drop strings whose trimmed form is empty even when trim=false. */
+    dropWhitespaceOnly?: boolean;
+}
+export declare function compactStrings(values: readonly unknown[], options?: CompactStringsOptions): string[];

package/dist/strings.js

@@ -0,0 +1,24 @@
+export function compactStrings(values, options = {}) {
+    const trim = options.trim ?? true;
+    const unique = options.unique ?? true;
+    const dropEmpty = options.dropEmpty ?? true;
+    const dropWhitespaceOnly = options.dropWhitespaceOnly ?? trim;
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const compacted = trim ? value.trim() : value;
+        if (dropEmpty &&
+            (dropWhitespaceOnly ? value.trim().length === 0 : compacted.length === 0)) {
+            continue;
+        }
+        if (unique) {
+            if (seen.has(compacted))
+                continue;
+            seen.add(compacted);
+        }
+        result.push(compacted);
+    }
+    return result;
+}