@osolmaz/pi-workflows 0.11.0 → 0.11.2

package/dist/extension/index.js

@@ -1,8 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { builtinWorkflowCatalog } from "../builtins/catalog.js";
-import { projectControllerStorePath, SqliteControllerStore } from "../controllers/index.js";
+import { projectControllerStorePath, SqliteControllerStore, } from "../controllers/index.js";
+import { compositionMetadata } from "../workflows/composition.js";
 import { humanDecisionChannelRequest } from "../workflows/decision-presentation.js";
 import { WorkflowEngine } from "../workflows/engine.js";
 import { ClaimLostError, errorMessage, isClaimLostError, TimeoutError, } from "../workflows/errors.js";
@@ -56,6 +57,44 @@ function humanDecisionRequest(value) {
     }
     return value;
 }
+function definitionDigest(snapshot) {
+    return `sha256:${createHash("sha256").update(JSON.stringify(snapshot)).digest("hex")}`;
+}
+function launchSourceIdentity(workflow, root) {
+    return {
+        root,
+        mounted: compositionMetadata(workflow)?.sources ?? [],
+    };
+}
+function preparedLaunchOptions(options) {
+    return {
+        ...(options.presentation !== undefined ? { presentation: options.presentation } : {}),
+        ...(options.parentRunId !== undefined ? { parentRunId: options.parentRunId } : {}),
+        ...(options.humanDecision !== undefined ? { humanDecision: options.humanDecision } : {}),
+    };
+}
+function parsePreparedLaunchOptions(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Stored workflow launch options are invalid");
+    }
+    return value;
+}
+function safeLaunchError(error) {
+    const raw = errorMessage(error)
+        .replace(/Bearer\s+\S+/giu, "Bearer [redacted]")
+        .replace(/(token|api[_-]?key|secret|password)(\s*[:=]\s*)\S+/giu, "$1$2[redacted]")
+        .replaceAll("\n", " ")
+        .trim();
+    const code = /not found|cannot find|unknown workflow/iu.test(raw)
+        ? "workflow_not_found"
+        : /source changed|source mismatch/iu.test(raw)
+            ? "source_changed"
+            : /invalid|must be/iu.test(raw)
+                ? "workflow_invalid"
+                : "activation_failed";
+    const message = raw.length <= 500 ? raw : `${raw.slice(0, 480)}… [error truncated]`;
+    return { code, message: message || "The deferred workflow could not start" };
+}
 /** Parse `/workflow` arguments. Exported for tests. */
 export function parseWorkflowArgs(args) {
     const trimmed = args.trim();
@@ -178,6 +217,7 @@ export default function piWorkflows(pi) {
     // Run events remain an audit feed and never enter a conversation.
     let syncArmed = false;
     let runSyncTimer = null;
+    let activationRecovery;
     let decisionRecoveryTimer = null;
     let decisionRecoveryActive = false;
     const recordRunEvent = (event) => {
@@ -207,6 +247,7 @@ export default function piWorkflows(pi) {
         if (runQueueStore === null || !syncArmed)
             return;
         try {
+            activationRecovery?.(ctx);
             const sessionId = ctx.sessionManager.getSessionId();
             const alreadyDelivered = deliveredNotificationIds(ctx);
             const claimToken = randomUUID();
@@ -225,7 +266,9 @@ export default function piWorkflows(pi) {
                             runId: notification.runId,
                             kind: notification.kind,
                         },
-                    }, { triggerTurn: false });
+                    }, notification.kind === "launch_failure"
+                        ? { triggerTurn: true, deliverAs: "followUp" }
+                        : { triggerTurn: false });
                     alreadyDelivered.add(notification.notificationId);
                 }
                 runQueueStore.markWorkflowNotificationDelivered({
@@ -252,7 +295,6 @@ export default function piWorkflows(pi) {
     let systemTurnAbort = null;
     let suppressWorkflowAssistantTail = false;
     let lastExpiredAttempt = null;
-    let pendingToolLaunch = null;
     // The interactive run currently parked at a checkpoint, if any.
     let lastWaitingRunId = null;
     let widgetTimer = null;
@@ -671,7 +713,10 @@ export default function piWorkflows(pi) {
                     workflowSourceRef: workflowSource.kind === "builtin"
                         ? `builtin:${workflowSource.id}`
                         : workflowSource.path,
+                    workflowSource: launchSourceIdentity(workflow, workflowSource),
+                    definitionDigest: definitionDigest(snapshot),
                     input,
+                    launchOptions: preparedLaunchOptions(options),
                     runnerId,
                     claimToken: token,
                     leaseMs: RUN_CLAIM_LEASE_MS,
@@ -799,6 +844,11 @@ export default function piWorkflows(pi) {
             ...(options.resume === true ? { resume: true } : {}),
             ...(options.parentRunId !== undefined ? { parentRunId: options.parentRunId } : {}),
         };
+        if (queueStore !== null &&
+            claimToken !== undefined &&
+            !queueStore.markWorkflowRunRunning({ runId, claimToken })) {
+            throw new ClaimLostError(runId);
+        }
         activeRun = run;
         if (queueStore !== null && claimToken !== undefined) {
             const store = queueStore;
@@ -948,8 +998,10 @@ export default function piWorkflows(pi) {
                 : bundle.state.workflowSource.kind === "builtin"
                     ? `builtin:${bundle.state.workflowSource.id}`
                     : bundle.state.workflowSource.path;
+            const launchOptions = parsePreparedLaunchOptions(claimed.launchOptions);
             started = await startRun(ctx, sourceRef, claimed.input, {
-                resume: true,
+                ...launchOptions,
+                resume: bundle !== null,
                 runId: claimed.runId,
                 claimToken,
             });
@@ -1103,8 +1155,8 @@ export default function piWorkflows(pi) {
         }
         return null;
     };
-    const cancelWorkflowControl = async (ctx) => {
-        if (activeRun) {
+    const cancelWorkflowControl = async (ctx, requestedRunId) => {
+        if (activeRun && (requestedRunId === undefined || requestedRunId === activeRun.runId)) {
             const workflowName = activeRun.workflowName;
             const runId = activeRun.runId;
             activeRun.engine.cancel();
@@ -1113,12 +1165,30 @@ export default function piWorkflows(pi) {
                 details: { action: "cancel", workflowName, runId },
             };
         }
-        if (pendingToolLaunch !== null) {
-            const ref = pendingToolLaunch.ref;
-            pendingToolLaunch = null;
+        const queue = ensureRunQueueStore(ctx.cwd);
+        const queued = requestedRunId === undefined
+            ? queue.findSessionReservation(ctx.sessionManager.getSessionId())
+            : queue.getWorkflowRun(requestedRunId);
+        if (queued !== undefined &&
+            ["queued", "starting"].includes(queued.status) &&
+            (queued.originSessionId === null ||
+                queued.originSessionId === ctx.sessionManager.getSessionId())) {
+            if (!queue.cancelWorkflowRun({ runId: queued.runId })) {
+                throw new Error(`Workflow ${queued.runId} could not be cancelled because its state changed.`);
+            }
+            recordRunEvent({
+                runId: queued.runId,
+                workflowRef: queued.workflowName,
+                type: "cancelled",
+            });
             return {
-                message: `Cancelled the queued workflow launch for ${ref}.`,
-                details: { action: "cancel", workflow: ref, queued: false },
+                message: `Cancelled queued workflow ${queued.workflowName} (run ${queued.runId}).`,
+                details: {
+                    action: "cancel",
+                    workflow: queued.workflowName,
+                    runId: queued.runId,
+                    queued: false,
+                },
             };
         }
         if (widgetSource) {
@@ -1225,11 +1295,28 @@ export default function piWorkflows(pi) {
             },
         };
     };
+    const workflowLaunchStatus = (record) => ({
+        message: `Workflow ${record.workflowName} is ${record.status} (run ${record.runId}).`,
+        details: {
+            action: "status",
+            active: ["starting", "running"].includes(record.status),
+            queued: record.status === "queued",
+            workflowName: record.workflowName,
+            runId: record.runId,
+            status: record.status,
+            ...(record.errorCode === null ? {} : { errorCode: record.errorCode }),
+            ...(record.errorMessage === null ? {} : { error: record.errorMessage }),
+        },
+        ...(["failed", "cancelled"].includes(record.status) ? { level: "warning" } : {}),
+    });
     const statusWorkflowControl = async (ctx, runId) => {
         if (runId !== undefined) {
             const bundle = await readRunBundle(new WorkflowRunStore().runDirFor(runId));
             if (bundle === null) {
-                throw new Error(`Workflow run not found: ${runId}`);
+                const launch = ensureRunQueueStore(ctx.cwd).getWorkflowRun(runId);
+                if (launch === undefined)
+                    throw new Error(`Workflow run not found: ${runId}`);
+                return workflowLaunchStatus(launch);
             }
             const { state } = bundle;
             return {
@@ -1238,11 +1325,10 @@ export default function piWorkflows(pi) {
             };
         }
         const state = activeRun?.lastState ?? widgetSource?.state;
-        if ((state === undefined || state === null) && pendingToolLaunch !== null) {
-            return {
-                message: `Workflow ${pendingToolLaunch.ref} is queued until the current turn finishes.`,
-                details: { active: false, queued: true, workflow: pendingToolLaunch.ref },
-            };
+        if (state === undefined || state === null) {
+            const queued = ensureRunQueueStore(ctx.cwd).findSessionReservation(ctx.sessionManager.getSessionId());
+            if (queued !== undefined)
+                return workflowLaunchStatus(queued);
         }
         if (state === undefined || state === null) {
             return {
@@ -1545,8 +1631,9 @@ export default function piWorkflows(pi) {
         if (activeRun !== null) {
             throw new Error(`A workflow is already running: ${activeRun.workflowName}.`);
         }
-        if (pendingToolLaunch !== null) {
-            throw new Error("A workflow launch is already waiting for the current turn to finish.");
+        const reserved = ensureRunQueueStore(ctx.cwd).findSessionReservation(ctx.sessionManager.getSessionId());
+        if (reserved !== undefined) {
+            throw new Error(`Workflow ${reserved.workflowName} is already ${reserved.status} (run ${reserved.runId}).`);
         }
         if (presentationPending !== null) {
             throw new Error("The previous workflow result is still being presented.");
@@ -1564,36 +1651,140 @@ export default function piWorkflows(pi) {
         if (activeRun !== null) {
             throw new Error(`A workflow is already running: ${activeRun.workflowName}. Cancel it before starting another.`);
         }
-        if (pendingToolLaunch !== null) {
-            throw new Error("A workflow launch is already waiting for the current turn to finish.");
+        const queue = ensureRunQueueStore(ctx.cwd);
+        const existing = queue.findSessionReservation(ctx.sessionManager.getSessionId());
+        if (existing !== undefined) {
+            throw new Error(`Workflow ${existing.workflowName} is already ${existing.status} (run ${existing.runId}).`);
         }
         if (presentationPending !== null) {
             throw new Error("The previous workflow result is still being presented.");
         }
-        const reservation = { ctx, ref, input, options };
-        pendingToolLaunch = reservation;
-        try {
-            const resolved = await resolveWorkflowRef(ref, { cwd: ctx.cwd }, builtinWorkflowCatalog);
-            const workflow = resolved.definition;
-            if (pendingToolLaunch !== reservation) {
-                throw new Error("The queued workflow launch was cancelled before validation finished.");
+        const resolved = await resolveWorkflowRef(ref, { cwd: ctx.cwd }, builtinWorkflowCatalog);
+        const workflow = resolved.definition;
+        const workflowSource = resolved.source;
+        if (options.parentRunId !== undefined) {
+            const parent = await readRunBundle(new WorkflowRunStore().runDirFor(options.parentRunId));
+            if (parent === null || parent.state.status !== "waiting") {
+                throw new Error(`Workflow run ${options.parentRunId} is not waiting at a checkpoint`);
             }
-            return {
-                message: `Workflow ${workflow.name} will start after this turn finishes.`,
-                details: {
-                    action: "start",
-                    workflow: workflow.name,
-                    source: resolved.source,
-                    queued: true,
-                },
-            };
+            if (parent.state.workflowSource !== undefined &&
+                !isDeepStrictEqual(parent.state.workflowSource, workflowSource)) {
+                throw new Error(`Workflow source changed since run ${options.parentRunId} started; revert the edit to answer its checkpoint`);
+            }
+        }
+        const snapshot = createDefinitionSnapshot(workflow);
+        const runId = createRunId(workflow.name);
+        try {
+            queue.reserveWorkflowRun({
+                runId,
+                workflowName: workflow.name,
+                workflowSourceRef: workflowSource.kind === "builtin" ? `builtin:${workflowSource.id}` : workflowSource.path,
+                workflowSource: launchSourceIdentity(workflow, workflowSource),
+                definitionDigest: definitionDigest(snapshot),
+                input,
+                launchOptions: preparedLaunchOptions(options),
+                runnerId,
+                originSessionId: ctx.sessionManager.getSessionId(),
+                ...(options.parentRunId !== undefined ? { parentRunId: options.parentRunId } : {}),
+            });
         }
         catch (error) {
-            if (pendingToolLaunch === reservation) {
-                pendingToolLaunch = null;
+            const reserved = queue.findSessionReservation(ctx.sessionManager.getSessionId());
+            if (reserved !== undefined) {
+                throw new Error(`A workflow launch is already waiting: ${reserved.workflowName} (run ${reserved.runId}).`, { cause: error });
             }
             throw error;
         }
+        recordRunEvent({
+            runId,
+            workflowRef: workflow.name,
+            type: "queued",
+            payload: options.parentRunId === undefined ? {} : { parentRunId: options.parentRunId },
+        });
+        syncArmed = true;
+        return {
+            message: `Workflow ${workflow.name} queued (run ${runId}).`,
+            details: {
+                action: "start",
+                workflow: workflow.name,
+                runId,
+                source: workflowSource,
+                queued: true,
+            },
+        };
+    };
+    const activatePreparedLaunch = async (ctx, prepared) => {
+        const queue = ensureRunQueueStore(ctx.cwd);
+        const claimToken = randomUUID();
+        const claimed = queue.claimWorkflowRun({
+            runId: prepared.runId,
+            runnerId,
+            claimToken,
+            leaseMs: RUN_CLAIM_LEASE_MS,
+        });
+        if (claimed === undefined)
+            return false;
+        try {
+            const resolved = await resolveWorkflowRef(claimed.workflowSourceRef, { cwd: ctx.cwd }, builtinWorkflowCatalog);
+            const snapshot = createDefinitionSnapshot(resolved.definition);
+            if (!isDeepStrictEqual(launchSourceIdentity(resolved.definition, resolved.source), claimed.workflowSource) ||
+                definitionDigest(snapshot) !== claimed.definitionDigest) {
+                throw new Error("Workflow source changed after the launch was queued");
+            }
+            const launchOptions = parsePreparedLaunchOptions(claimed.launchOptions);
+            const started = await startRun(ctx, claimed.workflowSourceRef, claimed.input, {
+                ...launchOptions,
+                runId: claimed.runId,
+                claimToken,
+            });
+            if (started === undefined)
+                throw new Error("The queued workflow could not start");
+            if (launchOptions.parentRunId !== undefined)
+                lastWaitingRunId = null;
+            return true;
+        }
+        catch (error) {
+            const safe = safeLaunchError(error);
+            queue.failWorkflowRun({
+                runId: claimed.runId,
+                claimToken,
+                errorCode: safe.code,
+                errorMessage: safe.message,
+            });
+            recordRunEvent({
+                runId: claimed.runId,
+                workflowRef: claimed.workflowName,
+                type: "launch_failed",
+                payload: { errorCode: safe.code, error: safe.message },
+            });
+            const content = `Workflow ${claimed.workflowName} failed to start (run ${claimed.runId}): ${safe.message}. Inspect the error and call workflow start again only after you correct the cause.`;
+            try {
+                queue.enqueueWorkflowNotification({
+                    runId: claimed.runId,
+                    nodeId: "$launch",
+                    attemptId: claimed.runId,
+                    notificationIndex: 1,
+                    targetSessionId: claimed.originSessionId ?? ctx.sessionManager.getSessionId(),
+                    kind: "launch_failure",
+                    content,
+                    notificationId: `launch-failure:${claimed.runId}`,
+                });
+            }
+            catch {
+                // A deterministic notification id makes duplicate insertion harmless.
+            }
+            notify(ctx, content, "error");
+            runSyncPass(ctx);
+            return false;
+        }
+    };
+    activationRecovery = (ctx) => {
+        if (activeRun !== null)
+            return;
+        const prepared = ensureRunQueueStore(ctx.cwd).findSessionReservation(ctx.sessionManager.getSessionId());
+        if (prepared !== undefined && ["queued", "starting"].includes(prepared.status)) {
+            void activatePreparedLaunch(ctx, prepared).catch(() => undefined);
+        }
     };
     pi.registerCommand("piw", {
         description: "Open the current workflow run in piw through Herdr",
@@ -1841,7 +2032,7 @@ export default function piWorkflows(pi) {
                     control = resumeWorkflowControl(ctx);
                     break;
                 case "cancel":
-                    control = await cancelWorkflowControl(ctx);
+                    control = await cancelWorkflowControl(ctx, params.runId);
                     break;
                 case "answer": {
                     const waiting = await resolveWaitingWorkflow(ctx, params.runId);
@@ -1951,7 +2142,13 @@ export default function piWorkflows(pi) {
             notify(ctx, `Could not recover human decisions: ${errorMessage(error)}`, "warning");
         }
         try {
-            await resumeParkedRun(ctx);
+            const prepared = ensureRunQueueStore(ctx.cwd).findSessionReservation(ctx.sessionManager.getSessionId());
+            if (prepared !== undefined && ["queued", "starting"].includes(prepared.status)) {
+                await activatePreparedLaunch(ctx, prepared);
+            }
+            else {
+                await resumeParkedRun(ctx);
+            }
         }
         catch (error) {
             notify(ctx, `Could not resume a parked workflow: ${errorMessage(error)}`, "warning");
@@ -2031,22 +2228,18 @@ export default function piWorkflows(pi) {
         activeRun?.recorder?.handleToolEnd(event);
     });
     pi.on("agent_settled", async (_event, ctx) => {
-        if (activeRun === null && pendingToolLaunch !== null) {
-            const launch = pendingToolLaunch;
-            pendingToolLaunch = null;
+        if (activeRun === null) {
             try {
-                const runId = await startRun(launch.ctx, launch.ref, launch.input, launch.options);
-                if (runId === undefined) {
-                    notify(launch.ctx, "The queued workflow could not start.", "error");
-                }
-                else if (launch.options?.parentRunId !== undefined) {
-                    lastWaitingRunId = null;
+                const prepared = ensureRunQueueStore(ctx.cwd).findSessionReservation(ctx.sessionManager.getSessionId());
+                if (prepared !== undefined && ["queued", "starting"].includes(prepared.status)) {
+                    await activatePreparedLaunch(ctx, prepared);
+                    return;
                 }
             }
             catch (error) {
-                notify(launch.ctx, `Could not start queued workflow: ${errorMessage(error)}`, "error");
+                notify(ctx, `Could not activate a queued workflow: ${safeLaunchError(error).message}`, "warning");
+                return;
             }
-            return;
         }
         const run = activeRun;
         if (!run) {
@@ -2076,7 +2269,6 @@ export default function piWorkflows(pi) {
         await run?.recorder?.stop().catch(() => undefined);
         await run?.completion?.catch(() => undefined);
         activeRun = null;
-        pendingToolLaunch = null;
         lastWaitingRunId = null;
         if (runSyncTimer !== null) {
             clearInterval(runSyncTimer);