@kb-labs/workflow-daemon 2.96.0 → 2.100.0

package/dist/index.js

@@ -165,6 +165,7 @@ async function createWorkflowWorker(options) {
     }
     const jobPromise = (async () => {
       try {
+        let wasCancelled = false;
         for (const step of job.steps) {
           if (step.status === "success") {
             continue;
@@ -175,6 +176,7 @@ async function createWorkflowWorker(options) {
               runId: run.id,
               jobId: job.id
             });
+            wasCancelled = true;
             break;
           }
           const exprCtx = {
@@ -476,6 +478,14 @@ async function createWorkflowWorker(options) {
             });
           }
         }
+        if (wasCancelled) {
+          await engine.markJobInterrupted(run.id, job.id);
+          jobLogger.info("Job interrupted due to run cancellation", {
+            runId: run.id,
+            jobId: job.id
+          });
+          return;
+        }
         await engine.markJobCompleted(run.id, job.id);
         const jobDuration = Date.now() - jobStartTime;
         jobLogger.info("Job completed successfully", {
@@ -716,8 +726,12 @@ async function applyGateSkip(engine, run, job, step, decision, stepLogger) {
       pastGate = true;
       continue;
     }
-    if (!pastGate) continue;
-    if (s.spec.id === skipTo || s.id === skipTo) break;
+    if (!pastGate) {
+      continue;
+    }
+    if (s.spec.id === skipTo || s.id === skipTo) {
+      break;
+    }
     await stateStore.updateStep(run.id, job.id, s.id, (draft) => {
       draft.status = "success";
       draft.outputs = { skipped: true };
@@ -1830,6 +1844,9 @@ var WorkflowHostService = class {
     if (!sourceRun) {
       throw new Error("Run not found");
     }
+    if (request.failedOnly) {
+      return this.rerunFailedOnly(sourceRun.id, sourceRun);
+    }
     const workflowId = sourceRun.metadata?.["workflowId"] ?? sourceRun.name;
     const workflowService = this.requireWorkflowService();
     const workflow = await workflowService.get(workflowId);
@@ -1837,26 +1854,9 @@ var WorkflowHostService = class {
       throw new Error("Workflow not found");
     }
     const specInput = workflow.input;
-    let spec = {
+    const spec = {
       ...specInput
     };
-    if (request.failedOnly) {
-      const failedJobNames = new Set(
-        (sourceRun.jobs ?? []).filter((job) => job.status === "failed" || job.status === "interrupted").map((job) => job.jobName)
-      );
-      if (failedJobNames.size === 0) {
-        throw new Error("No failed jobs to rerun");
-      }
-      const filteredJobs = {};
-      for (const [name, jobSpec] of Object.entries(spec.jobs)) {
-        if (failedJobNames.has(name)) {
-          const js = jobSpec;
-          const needs = Array.isArray(js["needs"]) ? js["needs"].filter((dep) => failedJobNames.has(dep)) : void 0;
-          filteredJobs[name] = needs !== void 0 && needs.length < js["needs"].length ? { ...js, needs } : js;
-        }
-      }
-      spec = { ...spec, jobs: filteredJobs };
-    }
     const resolvedInputs = sourceRun.inputs ?? {};
     const run = await this.options.engine.runFromSpec(spec, {
       trigger: {
@@ -1871,14 +1871,55 @@ var WorkflowHostService = class {
       status: run.status
     };
   }
+  /**
+   * failedOnly reruns resume from the source run's snapshot instead of
+   * starting a brand-new run (via runFromSpec + a job-filtered spec), so
+   * completed step outputs from jobs that are not being rerun are carried
+   * forward into the interpolation context instead of being discarded
+   * (see issue #263: `rerun --failed-only` used to redo the whole run).
+   */
+  async rerunFailedOnly(resolvedRunId, sourceRun) {
+    const failedJobNames = new Set(
+      (sourceRun.jobs ?? []).filter((job) => job.status === "failed" || job.status === "interrupted").map((job) => job.jobName)
+    );
+    if (failedJobNames.size === 0) {
+      throw new Error("No failed jobs to rerun");
+    }
+    let fromStepId;
+    for (const job of sourceRun.jobs ?? []) {
+      if (!failedJobNames.has(job.jobName)) {
+        continue;
+      }
+      const unfinishedStep = (job.steps ?? []).find(
+        (s) => s.status !== "success" && s.status !== "skipped"
+      );
+      if (unfinishedStep) {
+        fromStepId = unfinishedStep.id;
+        break;
+      }
+    }
+    if (!fromStepId) {
+      throw new Error(`Cannot determine resume point: no failed step found in run ${sourceRun.id}`);
+    }
+    const run = await this.options.engine.replayRun(resolvedRunId, { fromStepId });
+    if (!run) {
+      throw new Error(
+        `No replay snapshot for run ${resolvedRunId} \u2014 cannot rerun failed steps only. Snapshots are created when a run finishes; check the workflow daemon logs for "Failed to create run snapshot" around that time.`
+      );
+    }
+    return {
+      runId: run.id,
+      status: run.status
+    };
+  }
   async restartRun(runId, request) {
     const resolved = await this.resolveRunId(runId);
     if (!resolved) {
-      throw new Error("Run not found or snapshot not available");
+      throw new Error(`Run not found: ${runId}`);
     }
     const currentRun = await this.options.engine.getRun(resolved);
     if (!currentRun) {
-      throw new Error("Run not found or snapshot not available");
+      throw new Error(`Run not found: ${resolved}`);
     }
     if (currentRun.status === "running" || currentRun.status === "queued") {
       throw new Error(
@@ -1890,7 +1931,9 @@ var WorkflowHostService = class {
       env: request.env
     });
     if (!run) {
-      throw new Error("Run not found or snapshot not available");
+      throw new Error(
+        `No replay snapshot for run ${resolved} (status: ${currentRun.status}, finished: ${currentRun.finishedAt ?? "n/a"}). Snapshots are created when a run finishes; if this run finished but has no snapshot, check the workflow daemon logs for "Failed to create run snapshot" around that time.`
+      );
     }
     return {
       runId: run.id,