@kb-labs/workflow-daemon 2.88.0 → 2.93.0

package/dist/index.js

@@ -25,7 +25,8 @@ async function createWorkflowWorker(options) {
     workspaceRoot,
     concurrency = 5,
     defaultTimeout = 12e4,
-    analytics
+    analytics,
+    debugMode = process.env["WORKFLOW_DEBUG"] === "true"
   } = options;
   let isRunning = false;
   let stopRequested = false;
@@ -33,8 +34,9 @@ async function createWorkflowWorker(options) {
   const claimedJobs = /* @__PURE__ */ new Set();
   const executionBackend = platform2.executionBackend;
   const runner = new SandboxRunner({
+    // IExecutionBackend<unknown> (core-contracts) is structurally compatible with
+    // ExecutionBackend (plugin-execution) — both expose the same execute/health/stats/shutdown API.
     backend: executionBackend,
-    // ExecutionBackend type from plugin-execution
     cliApi,
     workspaceRoot,
     defaultTimeout
@@ -166,6 +168,10 @@ async function createWorkflowWorker(options) {
                   exprCtx.steps[s.spec.id] = {
                     outputs: s.outputs ?? {}
                   };
+                } else if (s.status === "failed" && s.spec.uses === "builtin:approval" && s.spec.id && s.outputs) {
+                  exprCtx.steps[s.spec.id] = {
+                    outputs: s.outputs
+                  };
                 }
               }
             }
@@ -185,7 +191,29 @@ async function createWorkflowWorker(options) {
               continue;
             }
           }
+          if (debugMode) {
+            jobLogger.info("[debug] Expression context for step", {
+              runId: run.id,
+              jobId: job.id,
+              stepId: step.id,
+              stepUses: step.spec.uses,
+              exprCtx: {
+                inputs: exprCtx.inputs,
+                steps: exprCtx.steps,
+                env: exprCtx.env
+              }
+            });
+          }
           const interpolatedWith = step.spec.with ? interpolateObject(step.spec.with, exprCtx) : void 0;
+          if (debugMode && step.spec.with) {
+            jobLogger.info("[debug] Step input interpolation", {
+              runId: run.id,
+              jobId: job.id,
+              stepId: step.id,
+              rawWith: step.spec.with,
+              resolvedWith: interpolatedWith
+            });
+          }
           const stepExecutionId = `wf-${run.id}-${job.id}-${step.id}-${Date.now()}`;
           const stepLogger = jobLogger.child({
             operation: "workflow.step",
@@ -195,20 +223,31 @@ async function createWorkflowWorker(options) {
             spanId: stepExecutionId,
             invocationId: stepExecutionId
           });
+          if (interpolatedWith) {
+            const stateStore = engine.getStateStore();
+            await stateStore.updateStep(run.id, job.id, step.id, (draft) => {
+              draft.resolvedInputs = interpolatedWith;
+            });
+          }
           stepLogger.info("Executing step", {
             runId: run.id,
             jobId: job.id,
             stepId: step.id,
-            uses: step.spec.uses
+            uses: step.spec.uses,
+            // Log resolved inputs so failures are debuggable without a debug flag.
+            // Sensitive values (tokens, secrets) will appear here — acceptable for
+            // server-side structured logs; do not surface in public UI.
+            inputs: interpolatedWith
           });
           if (step.spec.uses === "builtin:approval") {
+            if (step.status === "failed") {
+              stepLogger.info("Approval already rejected \u2014 skipping to gate", {
+                runId: run.id,
+                stepId: step.id
+              });
+              continue;
+            }
             if (step.status !== "waiting_approval") {
-              if (interpolatedWith) {
-                const stateStore = engine.getStateStore();
-                await stateStore.updateStep(run.id, job.id, step.id, (draft) => {
-                  draft.spec = { ...draft.spec, with: interpolatedWith };
-                });
-              }
               await engine.markStepWaitingApproval(run.id, job.id, step.id);
             }
             stepLogger.info("Waiting for approval", {
@@ -227,9 +266,8 @@ async function createWorkflowWorker(options) {
                 break;
               }
               if (currentStep.status === "failed") {
-                const rejectMsg = currentStep.error?.message ?? "Approval rejected";
                 stepLogger.info("Approval rejected", { runId: run.id, stepId: step.id });
-                throw new Error(rejectMsg);
+                break;
               }
             }
             if (stopRequested) {
@@ -388,12 +426,21 @@ async function createWorkflowWorker(options) {
             });
             throw error;
           }
-          await engine.markStepCompleted(run.id, job.id, step.id, result.status === "success" ? result.outputs : void 0);
+          const stepOutputs = result.status === "success" ? result.outputs : void 0;
+          await engine.markStepCompleted(run.id, job.id, step.id, stepOutputs);
           stepLogger.info("Step completed", {
             runId: run.id,
             jobId: job.id,
             stepId: step.id
           });
+          if (debugMode && stepOutputs) {
+            stepLogger.info("[debug] Step outputs", {
+              runId: run.id,
+              jobId: job.id,
+              stepId: step.id,
+              outputs: stepOutputs
+            });
+          }
         }
         await engine.markJobCompleted(run.id, job.id);
         const jobDuration = Date.now() - jobStartTime;
@@ -631,12 +678,25 @@ var JobBroker = class {
     await this.engine.cancelRun(runId);
     this.logger.info("Job cancelled", { runId });
   }
+  /**
+   * Query logs for a specific run, with optional step-level filtering.
+   * Used by GET /api/v1/runs/:runId/logs?stepId=...
+   */
+  async getRunLogs(runId, options) {
+    return this._queryLogs(runId, options);
+  }
   /**
    * Get job logs by run ID.
    * Returns execution logs with optional filtering by level and pagination.
    * Uses platform.logs service to query logs by runId metadata.
    */
   async getJobLogs(runId, options) {
+    return this._queryLogs(runId, options);
+  }
+  /**
+   * Internal: query + filter logs for a given run (optionally narrow to one step).
+   */
+  async _queryLogs(runId, options) {
     const run = await this.engine.getRun(runId);
     if (!run) {
       return [];
@@ -652,18 +712,22 @@ var JobBroker = class {
         level: options?.level && options.level !== "all" ? options.level : void 0
       },
       {
-        limit: 1e3,
-        // Query more logs, then filter in-memory
+        limit: 2e3,
         offset: 0
       }
     );
-    const filteredLogs = queryResult.logs.filter((log) => {
-      return log.fields.runId === runId || log.fields.executionId === runId || // Also check jobId and stepId for drill-down capability
-      log.fields.jobId?.toString().startsWith(runId);
+    const filtered = queryResult.logs.filter((log) => {
+      if (log.fields["runId"] !== runId) {
+        return false;
+      }
+      if (options?.stepId && log.fields["stepId"] !== options.stepId) {
+        return false;
+      }
+      return true;
     });
-    const sortedLogs = filteredLogs.sort((a, b) => b.timestamp - a.timestamp);
-    const paginatedLogs = sortedLogs.slice(offset, offset + limit);
-    return paginatedLogs.map((log) => ({
+    filtered.sort((a, b) => a.timestamp - b.timestamp);
+    const page = filtered.slice(offset, offset + limit);
+    return page.map((log) => ({
       timestamp: new Date(log.timestamp).toISOString(),
       level: log.level,
       message: log.message,
@@ -1284,6 +1348,10 @@ var WorkflowHostService = class {
     const logs = await this.options.jobBroker.getJobLogs(jobId, options);
     return logs;
   }
+  async getRunLogs(runId, options) {
+    const logs = await this.options.jobBroker.getRunLogs(runId, options);
+    return logs;
+  }
   async cancelJob(tenantId, jobId) {
     await this.options.engine.cancelRun(jobId);
     this.options.logger.info("Job cancelled", { jobId, tenantId });
@@ -1360,7 +1428,7 @@ var WorkflowHostService = class {
     };
     const triggerType = request.trigger?.type === "cron" ? "schedule" : request.trigger?.type === "api" ? "webhook" : "manual";
     const specInputDefs = specInput["inputs"] ?? {};
-    const userInputs = request.input && typeof request.input === "object" ? request.input : {};
+    const userInputs = request.inputs ?? (request.input && typeof request.input === "object" ? request.input : {});
     const resolvedInputs = {};
     for (const [key, def] of Object.entries(specInputDefs)) {
       resolvedInputs[key] = key in userInputs ? userInputs[key] : def.default;
@@ -1706,113 +1774,131 @@ function registerJobsAPI(options) {
 // src/api/cron-api.ts
 function registerCronAPI(options) {
   const { server, hostService, logger, observability } = options;
-  const registerCronHandler = async (request, reply) => {
-    const tenantId = request.headers["x-tenant-id"] ?? "default";
-    try {
-      const data = await observability.observeOperation(
-        "workflow.cron.register",
-        () => Promise.resolve(hostService.registerCron(tenantId, request.body))
-      );
-      return ok(data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to register cron job";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
-      }
-      if (message.startsWith("Missing required fields")) {
-        return fail(reply, 400, message);
+  server.post(
+    "/api/v1/crons",
+    { schema: { tags: ["Cron"], summary: "Register a cron job" } },
+    async (request, reply) => {
+      const tenantId = request.headers["x-tenant-id"] ?? "default";
+      try {
+        const data = await observability.observeOperation(
+          "workflow.cron.register",
+          () => Promise.resolve(hostService.registerCron(tenantId, request.body))
+        );
+        return ok(data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to register cron job";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        if (message.startsWith("Missing required fields")) {
+          return fail(reply, 400, message);
+        }
+        logger.error("Failed to register cron job", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to register cron job", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  const listCronHandler = async (_request, reply) => {
-    try {
-      return ok(await observability.observeOperation("workflow.cron.list", () => Promise.resolve(hostService.listCron())));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to list cron jobs";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
+  );
+  server.get(
+    "/api/v1/crons",
+    { schema: { tags: ["Cron"], summary: "List cron jobs" } },
+    async (_request, reply) => {
+      try {
+        return ok(await observability.observeOperation("workflow.cron.list", () => Promise.resolve(hostService.listCron())));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to list cron jobs";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        logger.error("Failed to list cron jobs", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to list cron jobs", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  const unregisterCronHandler = async (request, reply) => {
-    const { id } = request.params;
-    const tenantId = request.headers["x-tenant-id"] ?? "default";
-    try {
-      const data = await observability.observeOperation(
-        "workflow.cron.unregister",
-        () => Promise.resolve(hostService.unregisterCron(tenantId, id))
-      );
-      return ok(data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to unregister cron job";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
+  );
+  server.delete(
+    "/api/v1/crons/:id",
+    { schema: { tags: ["Cron"], summary: "Unregister a cron job" } },
+    async (request, reply) => {
+      const { id } = request.params;
+      const tenantId = request.headers["x-tenant-id"] ?? "default";
+      try {
+        const data = await observability.observeOperation(
+          "workflow.cron.unregister",
+          () => Promise.resolve(hostService.unregisterCron(tenantId, id))
+        );
+        return ok(data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to unregister cron job";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        logger.error("Failed to unregister cron job", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to unregister cron job", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  const triggerCronHandler = async (request, reply) => {
-    const { id } = request.params;
-    const tenantId = request.headers["x-tenant-id"] ?? "default";
-    try {
-      const data = await observability.observeOperation("workflow.cron.trigger", () => hostService.triggerCron(tenantId, id));
-      return ok(data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to trigger cron job";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
+  );
+  server.post(
+    "/api/v1/crons/:id/trigger",
+    { schema: { tags: ["Cron"], summary: "Trigger a cron job immediately" } },
+    async (request, reply) => {
+      const { id } = request.params;
+      const tenantId = request.headers["x-tenant-id"] ?? "default";
+      try {
+        const data = await observability.observeOperation("workflow.cron.trigger", () => hostService.triggerCron(tenantId, id));
+        return ok(data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to trigger cron job";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        logger.error("Failed to trigger cron job", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to trigger cron job", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  const pauseCronHandler = async (request, reply) => {
-    const { id } = request.params;
-    const tenantId = request.headers["x-tenant-id"] ?? "default";
-    try {
-      const data = await observability.observeOperation(
-        "workflow.cron.pause",
-        () => Promise.resolve(hostService.pauseCron(tenantId, id))
-      );
-      return ok(data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to pause cron job";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
+  );
+  server.post(
+    "/api/v1/crons/:id/pause",
+    { schema: { tags: ["Cron"], summary: "Pause a cron job" } },
+    async (request, reply) => {
+      const { id } = request.params;
+      const tenantId = request.headers["x-tenant-id"] ?? "default";
+      try {
+        const data = await observability.observeOperation(
+          "workflow.cron.pause",
+          () => Promise.resolve(hostService.pauseCron(tenantId, id))
+        );
+        return ok(data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to pause cron job";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        logger.error("Failed to pause cron job", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to pause cron job", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  const resumeCronHandler = async (request, reply) => {
-    const { id } = request.params;
-    const tenantId = request.headers["x-tenant-id"] ?? "default";
-    try {
-      const data = await observability.observeOperation(
-        "workflow.cron.resume",
-        () => Promise.resolve(hostService.resumeCron(tenantId, id))
-      );
-      return ok(data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to resume cron job";
-      if (message === "Cron scheduler not available") {
-        return fail(reply, 503, message);
+  );
+  server.post(
+    "/api/v1/crons/:id/resume",
+    { schema: { tags: ["Cron"], summary: "Resume a cron job" } },
+    async (request, reply) => {
+      const { id } = request.params;
+      const tenantId = request.headers["x-tenant-id"] ?? "default";
+      try {
+        const data = await observability.observeOperation(
+          "workflow.cron.resume",
+          () => Promise.resolve(hostService.resumeCron(tenantId, id))
+        );
+        return ok(data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to resume cron job";
+        if (message === "Cron scheduler not available") {
+          return fail(reply, 503, message);
+        }
+        logger.error("Failed to resume cron job", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
       }
-      logger.error("Failed to resume cron job", error instanceof Error ? error : void 0);
-      return fail(reply, 500, message);
     }
-  };
-  server.post("/api/v1/crons", { schema: { tags: ["Cron"], summary: "Register a cron job" } }, registerCronHandler);
-  server.get("/api/v1/crons", { schema: { tags: ["Cron"], summary: "List cron jobs" } }, listCronHandler);
-  server.delete("/api/v1/crons/:id", { schema: { tags: ["Cron"], summary: "Unregister a cron job" } }, unregisterCronHandler);
-  server.post("/api/v1/crons/:id/trigger", { schema: { tags: ["Cron"], summary: "Trigger a cron job immediately" } }, triggerCronHandler);
-  server.post("/api/v1/crons/:id/pause", { schema: { tags: ["Cron"], summary: "Pause a cron job" } }, pauseCronHandler);
-  server.post("/api/v1/crons/:id/resume", { schema: { tags: ["Cron"], summary: "Resume a cron job" } }, resumeCronHandler);
+  );
 }
 
 // src/api/workflows-api.ts
@@ -1939,6 +2025,33 @@ function registerWorkflowsAPI(options) {
       return fail(reply, 500, error instanceof Error ? error.message : "Failed to get run");
     }
   });
+  server.get(
+    "/api/v1/runs/:runId/logs",
+    { schema: { tags: ["Runs"], summary: "Get execution logs for a run" } },
+    async (request, reply) => {
+      const { runId } = request.params;
+      const { stepId, level, limit, offset } = request.query;
+      try {
+        const logs = await observability.observeOperation(
+          "workflow.run.logs",
+          () => hostService.getRunLogs(runId, {
+            stepId,
+            level,
+            limit: limit ? parseInt(limit, 10) : void 0,
+            offset: offset ? parseInt(offset, 10) : void 0
+          })
+        );
+        return ok({ logs, runId, stepId });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to get run logs";
+        if (message === "Run not found") {
+          return fail(reply, 404, message);
+        }
+        logger.error("[workflows-api] Error getting run logs", error instanceof Error ? error : void 0);
+        return fail(reply, 500, message);
+      }
+    }
+  );
   server.get("/api/v1/runs/:runId/events", { schema: { hide: true } }, async (request, reply) => {
     const { runId } = request.params;
     const run = await observability.observeOperation("workflow.run.events", () => engine.getRun(runId));
@@ -2281,7 +2394,7 @@ async function createServer(options) {
   });
   server.get("/ready", async () => {
     const metrics = await hostService.getMetrics();
-    const checks = buildWorkflowChecks({ workflowService, cronScheduler, metrics });
+    const checks = buildWorkflowReadinessChecks({ workflowService, cronScheduler, metrics });
     const hasErrors = checks.some((entry) => entry.status === "error");
     const hasWarnings = checks.some((entry) => entry.status === "warn");
     return createServiceReadyResponse({
@@ -2333,6 +2446,16 @@ function resolveWorkflowHealthStatus(metrics) {
   return "healthy";
 }
 function buildWorkflowChecks(input) {
+  return [
+    ...buildWorkflowReadinessChecks(input),
+    {
+      id: "workflow-failures",
+      status: input.metrics.runs.failed > 0 || input.metrics.jobs.failed > 0 ? "warn" : "ok",
+      message: input.metrics.runs.failed > 0 || input.metrics.jobs.failed > 0 ? `${input.metrics.runs.failed} failed runs, ${input.metrics.jobs.failed} failed jobs retained in history` : "No failed workflow runs or jobs in retained history"
+    }
+  ];
+}
+function buildWorkflowReadinessChecks(input) {
   return [
     {
       id: "workflow-engine",
@@ -2348,11 +2471,6 @@ function buildWorkflowChecks(input) {
       id: "cron-scheduler",
       status: input.cronScheduler ? "ok" : "warn",
       message: input.cronScheduler ? "Cron scheduler available" : "Cron scheduler not configured"
-    },
-    {
-      id: "workflow-failures",
-      status: input.metrics.runs.failed > 0 || input.metrics.jobs.failed > 0 ? "warn" : "ok",
-      message: input.metrics.runs.failed > 0 || input.metrics.jobs.failed > 0 ? `${input.metrics.runs.failed} failed runs, ${input.metrics.jobs.failed} failed jobs retained in history` : "No failed workflow runs or jobs in retained history"
     }
   ];
 }
@@ -2429,7 +2547,13 @@ async function bootstrap(cwd = process.cwd()) {
       executionId: startupSpanId
     }
   });
-  bootstrapLogger.info("Workflow daemon starting", { repoRoot, projectRoot });
+  const debugMode = process.env["WORKFLOW_DEBUG"] === "true";
+  bootstrapLogger.info("Workflow daemon starting", { repoRoot, projectRoot, debugMode });
+  if (debugMode) {
+    bootstrapLogger.warn(
+      "[WORKFLOW_DEBUG=true] Verbose debug logging is ON \u2014 step inputs, outputs, and expr contexts will be logged. Disable in production (unset WORKFLOW_DEBUG or set to false)."
+    );
+  }
   const createWorkflowLogger = (service, operation, bindings) => createCorrelatedLogger(platform.logger, {
     serviceId: "workflow",
     logsSource: "workflow",
@@ -2499,7 +2623,7 @@ async function bootstrap(cwd = process.cwd()) {
     logger: createWorkflowLogger("api", "workflow.api")
   });
   const port = parseInt(process.env.WORKFLOW_PORT || "7778", 10);
-  await server.listen({ port, host: "0.0.0.0" });
+  await server.listen({ port, host: process.env.WORKFLOW_HOST ?? "0.0.0.0" });
   bootstrapLogger.info("HTTP API listening", { port });
   serverInstance = server;
   bootstrapLogger.info("Creating WorkflowWorker");
@@ -2510,7 +2634,8 @@ async function bootstrap(cwd = process.cwd()) {
     analytics: platform.analytics,
     platform,
     workspaceRoot: projectRoot,
-    concurrency: parseInt(process.env.WORKFLOW_CONCURRENCY || "5", 10)
+    concurrency: parseInt(process.env.WORKFLOW_CONCURRENCY || "5", 10),
+    debugMode
   });
   workerInstance = worker;
   bootstrapLogger.info("Starting WorkflowWorker");