@pixelbyte-software/pixcode 1.42.1 → 1.42.2

package/server/modules/orchestration/workflows/workflow-trace.ts

@@ -22,6 +22,10 @@ function readString(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim() ? value : undefined;
 }
 
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
+}
+
 function redactionValues(run: WorkflowRun): string[] {
   const metadata = run.metadata ?? {};
   const workspaceTarget = metadata.workspaceTarget && typeof metadata.workspaceTarget === 'object'
@@ -140,6 +144,78 @@ export function buildWorkflowTrace(run: WorkflowRun): WorkflowTraceEvent[] {
     },
   });
 
+  const replay = readRecord(run.metadata?.replay);
+  if (replay) {
+    pushEvent(events, {
+      id: traceId([run.id, 'replay']),
+      type: 'run',
+      severity: replay.requiresApproval ? 'warning' : 'info',
+      status: run.status,
+      timestamp: run.startedAt + 0.25,
+      actor: 'Pixcode',
+      title: 'Workflow replay prepared',
+      titleKey: 'workflow.trace.replay',
+      summary: redactTraceText([
+        `Source run: ${readString(replay.sourceRunId) ?? 'unknown'}`,
+        `Scope: ${readString(replay.scope) ?? 'unknown'}`,
+        Array.isArray(replay.selectedNodeIds) ? `Selected steps: ${replay.selectedNodeIds.join(', ')}` : undefined,
+        replay.requiresApproval ? 'Replay required approval for prior shell, network, or file-write activity.' : undefined,
+      ].filter(Boolean).join('\n'), run),
+      metadata: replay,
+    });
+  }
+
+  const fallbackEvents = Array.isArray(run.metadata?.fallbackEvents)
+    ? run.metadata.fallbackEvents
+    : [];
+  fallbackEvents.forEach((event, index) => {
+    const record = readRecord(event);
+    if (!record) return;
+    pushEvent(events, {
+      id: traceId([run.id, 'fallback', index]),
+      type: 'node',
+      severity: 'warning',
+      status: 'submitted',
+      timestamp: typeof record.startedAt === 'number' ? record.startedAt : run.startedAt + 0.5 + index,
+      actor: 'Pixcode',
+      nodeId: readString(record.nodeId),
+      title: 'Fallback agent started',
+      titleKey: 'workflow.trace.fallback',
+      summary: redactTraceText([
+        `Trigger: ${readString(record.trigger) ?? 'unknown'}`,
+        `Source node: ${readString(record.nodeId) ?? 'unknown'}`,
+        `Fallback node: ${readString(record.fallbackNodeId) ?? 'unknown'}`,
+        readString(record.reason) ? `Reason: ${readString(record.reason)}` : undefined,
+      ].filter(Boolean).join('\n'), run),
+      metadata: record,
+    });
+  });
+
+  const fallbackSkippedEvents = Array.isArray(run.metadata?.fallbackSkippedEvents)
+    ? run.metadata.fallbackSkippedEvents
+    : [];
+  fallbackSkippedEvents.forEach((event, index) => {
+    const record = readRecord(event);
+    if (!record) return;
+    pushEvent(events, {
+      id: traceId([run.id, 'fallback-skipped', index]),
+      type: 'node',
+      severity: 'info',
+      status: 'skipped',
+      timestamp: typeof record.createdAt === 'number' ? record.createdAt : run.startedAt + 0.75 + index,
+      actor: 'Pixcode',
+      nodeId: readString(record.nodeId),
+      title: 'Fallback skipped',
+      titleKey: 'workflow.trace.fallback',
+      summary: redactTraceText([
+        `Trigger: ${readString(record.trigger) ?? 'unknown'}`,
+        `Skipped: ${readString(record.skippedReason) ?? 'policy did not allow fallback'}`,
+        readString(record.reason) ? `Reason: ${readString(record.reason)}` : undefined,
+      ].filter(Boolean).join('\n'), run),
+      metadata: record,
+    });
+  });
+
   run.nodeRuns.forEach((node, index) => {
     const base = eventBase(node);
     const timestamp = nodeTimestamp(run, node, index);

package/server/modules/orchestration/workflows/workflow.routes.ts

@@ -2,6 +2,10 @@ import type { Router } from 'express';
 import express from 'express';
 
 import { workflowRunner } from '@/modules/orchestration/workflows/workflow-runner.js';
+import {
+  type WorkflowReplayScope,
+  buildWorkflowReplayPlan,
+} from '@/modules/orchestration/workflows/workflow-replay.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
 import { buildWorkflowTrace } from '@/modules/orchestration/workflows/workflow-trace.js';
 import { findPixcodeAppRoot } from '@/modules/orchestration/workflows/workspace-target.js';
@@ -45,6 +49,30 @@ function readRequestUserId(req: express.Request): string | number | null {
   return user?.id ?? user?.userId ?? null;
 }
 
+function readReplayScope(value: unknown): WorkflowReplayScope {
+  return value === 'run' ? 'run' : 'node';
+}
+
+function readOptionalString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readBooleanFlag(value: unknown): boolean {
+  return value === true || value === 'true' || value === '1';
+}
+
+function replayOptions(req: express.Request): {
+  scope: WorkflowReplayScope;
+  fromNodeId?: string;
+  approveReplay: boolean;
+} {
+  return {
+    scope: readReplayScope(req.body?.scope ?? req.query.scope),
+    fromNodeId: readOptionalString(req.body?.fromNodeId ?? req.query.fromNodeId),
+    approveReplay: readBooleanFlag(req.body?.approveReplay ?? req.query.approveReplay),
+  };
+}
+
 function sendRunSnapshot(res: express.Response, runId: string): boolean {
   const run = workflowStore.getRun(runId);
   if (!run) {
@@ -134,6 +162,85 @@ export function createWorkflowRouter(): Router {
     });
   });
 
+  router.get('/workflows/runs/:runId/replay-plan', (req, res) => {
+    const run = workflowStore.getRun(req.params.runId);
+    if (!run) {
+      res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
+      return;
+    }
+
+    try {
+      const options = replayOptions(req);
+      res.json({
+        replayPlan: buildWorkflowReplayPlan(run, {
+          scope: options.scope,
+          fromNodeId: options.fromNodeId,
+        }),
+      });
+    } catch (error) {
+      res.status(400).json({
+        error: {
+          code: 'REPLAY_PLAN_INVALID',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  router.post('/workflows/runs/:runId/replay', (req, res) => {
+    const run = workflowStore.getRun(req.params.runId);
+    if (!run) {
+      res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
+      return;
+    }
+
+    try {
+      const options = replayOptions(req);
+      const replayPlan = buildWorkflowReplayPlan(run, {
+        scope: options.scope,
+        fromNodeId: options.fromNodeId,
+      });
+
+      if (replayPlan.requiresApproval && !options.approveReplay) {
+        res.status(409).json({
+          error: {
+            code: 'REPLAY_APPROVAL_REQUIRED',
+            message: 'Replay requires explicit approval because prior shell, network, or file-write activity was detected.',
+          },
+          replayPlan,
+        });
+        return;
+      }
+
+      const replayRun = workflowRunner.start(
+        replayPlan.workflow,
+        replayPlan.input,
+        {
+          ...replayPlan.metadata,
+          userId: readRequestUserId(req) ?? run.metadata?.userId,
+          replay: {
+            ...(replayPlan.metadata.replay && typeof replayPlan.metadata.replay === 'object'
+              ? replayPlan.metadata.replay as Record<string, unknown>
+              : {}),
+            approved: options.approveReplay,
+            approvedAt: options.approveReplay ? Date.now() : undefined,
+          },
+        },
+      );
+      res.status(202).json({
+        run: replayRun,
+        replayPlan,
+      });
+    } catch (error) {
+      res.status(400).json({
+        error: {
+          code: 'REPLAY_START_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
   router.get('/workflows/runs/:runId', (req, res) => {
     const run = workflowStore.getRun(req.params.runId);
     if (!run) {

package/server/modules/orchestration/workflows/workflow.types.ts

@@ -1,4 +1,5 @@
 import type { WorkflowContextPacket } from '@/modules/orchestration/workflows/context-packet.js';
+import type { WorkflowFallbackTrigger } from '@/modules/orchestration/workflows/workflow-fallback-policy.js';
 import type { WorkflowHandoffArtifact } from '@/modules/orchestration/workflows/handoff-artifact.js';
 
 export type WorkflowRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
@@ -21,6 +22,8 @@ export interface WorkflowNode {
   isolation?: 'host' | 'worktree' | 'docker';
   timeoutMs?: number;
   internal?: boolean;
+  fallbackTrigger?: WorkflowFallbackTrigger;
+  fallbackSourceNodeId?: string;
 }
 
 export interface Workflow {
@@ -44,6 +47,8 @@ export interface WorkflowNodeRun {
   timeoutMs?: number;
   stage?: string;
   internal?: boolean;
+  fallbackTrigger?: WorkflowFallbackTrigger;
+  fallbackSourceNodeId?: string;
   status: WorkflowNodeStatus;
   a2aTaskId?: string;
   startedAt?: number;