@atolis-hq/wake 0.1.11 → 0.1.13

package/dist/src/core/projection-updater.js

@@ -1,8 +1,9 @@
 import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord, } from '../domain/schema.js';
 import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
-import { builtInDefaultWorkflowDefinition, defaultWorkflowName, workflowStageVocabulary, } from '../domain/workflows.js';
+import { builtInDefaultWorkflowDefinition, defaultWorkflowName, selectWorkflowForEvent, workflowStageVocabulary, } from '../domain/workflows.js';
 import { isCustomCommandAction } from '../domain/custom-commands.js';
 import { createEventEnvelope } from '../lib/event-log.js';
+const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
 function stringArrayFromPayload(value) {
     return Array.isArray(value)
         ? value.filter((entry) => typeof entry === 'string')
@@ -37,6 +38,33 @@ function createProjectionFromIssueEvent(event, config) {
         context: {},
     });
 }
+async function pinSelectedWorkflow(projection, event, ctx, config) {
+    const context = projection.context;
+    if (config === undefined || typeof context.workflow === 'string') {
+        return projection;
+    }
+    const workflow = selectWorkflowForEvent(event, config);
+    if (workflow === null) {
+        return projection;
+    }
+    const selectedEvent = await ctx.appendEvent(createEventEnvelope({
+        eventId: `workflow-selected-${projection.workItemKey}`,
+        workItemKey: projection.workItemKey,
+        streamScope: 'work-item',
+        direction: 'internal',
+        sourceSystem: 'wake',
+        sourceEventType: WORKFLOW_SELECTED_EVENT,
+        sourceRefs: event.sourceRefs,
+        occurredAt: event.occurredAt,
+        ingestedAt: event.ingestedAt,
+        trigger: 'context-only',
+        payload: {
+            workflow,
+            selectedFromEventId: event.eventId,
+        },
+    }));
+    return applyEvent(projection, selectedEvent, ctx, config);
+}
 async function applyEvent(current, event, ctx, config) {
     // The shared sentinel for events whose resource failed mint qualification
     // (tick-runner.ts's resolveInboundEvent, spec D1'). These are durable and
@@ -55,11 +83,11 @@ async function applyEvent(current, event, ctx, config) {
             return current;
         }
         if (current === null) {
-            return next;
+            return pinSelectedWorkflow(next, event, ctx, config);
         }
         const nextStageFromLabels = stageFromLabels(next.issue.labels, configuredStagesForLabels(config));
         const shouldReconcileStage = nextStageFromLabels !== undefined && nextStageFromLabels !== current.wake.stage;
-        return parseIssueStateRecord({
+        const updated = parseIssueStateRecord({
             ...current,
             origin: current.origin,
             issue: next.issue,
@@ -80,10 +108,29 @@ async function applyEvent(current, event, ctx, config) {
                 recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
             },
         });
+        return pinSelectedWorkflow(updated, event, ctx, config);
     }
     if (current === null) {
         return null;
     }
+    if (event.sourceEventType === WORKFLOW_SELECTED_EVENT) {
+        const workflow = event.payload.workflow;
+        if (typeof workflow !== 'string') {
+            return current;
+        }
+        return parseIssueStateRecord({
+            ...current,
+            context: {
+                ...current.context,
+                workflow,
+            },
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
     if (event.sourceEventType === 'fake.issue.comment.created' ||
         event.sourceEventType === 'ticket.comment.created' ||
         event.sourceEventType === 'ticket.comment.updated' ||
@@ -156,31 +203,38 @@ async function applyEvent(current, event, ctx, config) {
             config !== undefined &&
             isCustomCommandAction(payload.action, config);
         const shouldClearSession = isForwardProgression || isFailed;
+        const nextContext = {
+            ...current.context,
+            lastFailureClass: payload.failureClass,
+            ...(payload.handledCommentId === undefined
+                ? {}
+                : { lastHandledCommentId: payload.handledCommentId }),
+            ...(payload.sentinel === undefined || isCompletedCustomCommand
+                ? {}
+                : { lastRunSentinel: payload.sentinel }),
+            ...(payload.action === undefined || isCompletedCustomCommand
+                ? {}
+                : { lastRunAction: payload.action }),
+            ...(payload.sentinel === doneRunnerSentinel &&
+                payload.action !== undefined &&
+                !isCompletedCustomCommand
+                ? { lastCompletedAction: payload.action }
+                : {}),
+            // Remembered so the approval path knows which action to resume or
+            // skip when a human posts /approved.
+            ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
+                ? { pendingApprovalAction: payload.action }
+                : {}),
+        };
+        if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
+            nextContext.blockedFromStage = current.wake.stage;
+        }
+        else if (payload.sentinel !== undefined) {
+            delete nextContext.blockedFromStage;
+        }
         return parseIssueStateRecord({
             ...current,
-            context: {
-                ...current.context,
-                lastFailureClass: payload.failureClass,
-                ...(payload.handledCommentId === undefined
-                    ? {}
-                    : { lastHandledCommentId: payload.handledCommentId }),
-                ...(payload.sentinel === undefined || isCompletedCustomCommand
-                    ? {}
-                    : { lastRunSentinel: payload.sentinel }),
-                ...(payload.action === undefined || isCompletedCustomCommand
-                    ? {}
-                    : { lastRunAction: payload.action }),
-                ...(payload.sentinel === doneRunnerSentinel &&
-                    payload.action !== undefined &&
-                    !isCompletedCustomCommand
-                    ? { lastCompletedAction: payload.action }
-                    : {}),
-                // Remembered so the approval path knows which action to resume or
-                // skip when a human posts /approved.
-                ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
-                    ? { pendingApprovalAction: payload.action }
-                    : {}),
-            },
+            context: nextContext,
             wake: {
                 ...current.wake,
                 stage: payload.nextStage ?? current.wake.stage,

package/dist/src/core/stale-run-reconciler.js

@@ -0,0 +1,102 @@
+import { createLabelsEvent } from './event-builders.js';
+import { stageLabelForStage } from '../domain/stages.js';
+import { workflowLabelForWorkflowName, workflowNameForProjection } from '../domain/workflows.js';
+import { createEventEnvelope } from '../lib/event-log.js';
+// Reconciles run records still marked `running` past the runner timeout: a
+// record whose work item has already moved on is superseded, otherwise it is
+// failed and a completion event replayed so the projection stops waiting on it.
+// `deliverOutboundEvent` is injected rather than imported so this module does
+// not depend on the outbox module directly.
+export function createStaleRunReconciler(deps) {
+    function isStaleRunningRecord(record, now) {
+        if (record.status !== 'running') {
+            return false;
+        }
+        const startedAtMs = Date.parse(record.startedAt);
+        if (!Number.isFinite(startedAtMs)) {
+            return true;
+        }
+        return now.getTime() - startedAtMs >= deps.runnerTimeoutMs();
+    }
+    async function reconcileStaleRunningRecords(now) {
+        const finishedAt = now.toISOString();
+        const runRecords = await deps.stateStore.listRunRecords();
+        const staleRecords = runRecords.filter((record) => isStaleRunningRecord(record, now));
+        for (const record of staleRecords) {
+            // Run records carry the work item they belong to, so this is a direct
+            // O(1) read — no scan, no index, no source ambiguity. The record's
+            // repo/issueNumber are representation content and take no part in it.
+            const projection = await deps.stateStore.readIssueState(record.workItemKey);
+            const newerCompletedRun = runRecords.some((candidate) => candidate.workItemKey === record.workItemKey &&
+                candidate.runId !== record.runId &&
+                candidate.status !== 'running' &&
+                Date.parse(candidate.startedAt) > Date.parse(record.startedAt));
+            // Equivalent to the previous `projection?.wake.lastRunId !== record.runId`,
+            // spelled out so the non-null projection is available below for its
+            // workItemKey.
+            if (projection === null || projection.wake.lastRunId !== record.runId || newerCompletedRun) {
+                await deps.stateStore.writeRunRecord({
+                    ...record,
+                    status: 'superseded',
+                    finishedAt,
+                    summary: 'Stale running record was superseded by a newer run.',
+                    metadata: {
+                        ...record.metadata,
+                        reconciledBy: 'stale-running-record',
+                        supersededBy: projection?.wake.lastRunId,
+                    },
+                });
+                continue;
+            }
+            await deps.stateStore.writeRunRecord({
+                ...record,
+                status: 'failed',
+                finishedAt,
+                sentinel: 'FAILED',
+                summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
+                metadata: {
+                    ...record.metadata,
+                    reconciledBy: 'stale-running-record',
+                    timeoutMs: deps.runnerTimeoutMs(),
+                },
+            });
+            const runCompletedEvent = createEventEnvelope({
+                eventId: `${record.runId}-stale-reconciled`,
+                workItemKey: projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.run.completed',
+                sourceRefs: {
+                    repo: record.repo,
+                    issueNumber: record.issueNumber,
+                    runId: record.runId,
+                },
+                occurredAt: finishedAt,
+                ingestedAt: finishedAt,
+                trigger: 'immediate',
+                payload: {
+                    action: record.action,
+                    sentinel: 'FAILED',
+                    runId: record.runId,
+                    reason: 'runner:stale-timeout',
+                    ...(record.routing === undefined ? {} : { routing: record.routing }),
+                },
+            });
+            await deps.stateStore.appendEventEnvelope(runCompletedEvent);
+            await deps.projectionUpdater.rebuildFromEvents([runCompletedEvent]);
+            const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
+            if (updatedProjection !== null) {
+                await deps.deliverOutboundEvent(createLabelsEvent({
+                    projection: updatedProjection,
+                    runId: record.runId,
+                    statusLabel: 'wake:status.failed',
+                    stageLabel: stageLabelForStage(updatedProjection.wake.stage),
+                    workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(updatedProjection, deps.config)),
+                    occurredAt: finishedAt,
+                }));
+            }
+        }
+    }
+    return { reconcileStaleRunningRecords };
+}