@pixelbyte-software/pixcode 1.41.1 → 1.41.3

package/scripts/smoke/run-state-refresh.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+
+const refreshUtilPath = 'src/utils/runStateRefresh.ts';
+assert.ok(existsSync(refreshUtilPath), 'Run state refresh utility should exist.');
+
+const refreshUtil = readFileSync(refreshUtilPath, 'utf8');
+const chatRealtime = readFileSync('src/components/chat/hooks/useChatRealtimeHandlers.ts', 'utf8');
+const chatSession = readFileSync('src/components/chat/hooks/useChatSessionState.ts', 'utf8');
+const chatInterface = readFileSync('src/components/chat/view/ChatInterface.tsx', 'utf8');
+const changedFilesHook = readFileSync('src/hooks/useChangedFilesMonitor.ts', 'utf8');
+const orchestrationPage = readFileSync('src/components/orchestration/OrchestrationPage.tsx', 'utf8');
+const runPanel = readFileSync('src/components/orchestration/workflows/WorkflowRunPanel.tsx', 'utf8');
+
+assert.ok(
+  refreshUtil.includes('PIXCODE_RUN_STATE_REFRESH_EVENT') && refreshUtil.includes('dispatchRunStateRefresh'),
+  'Run state refresh utility should expose a stable browser event and dispatcher.',
+);
+
+assert.ok(
+  chatRealtime.includes('onSessionSettled') && chatRealtime.includes('dispatchRunStateRefresh'),
+  'Chat realtime handlers should dispatch and callback on completion/failure so persisted messages are rehydrated.',
+);
+
+assert.ok(
+  chatSession.includes('refreshActiveSessionMessages') && chatSession.includes('refreshActiveSessionMessages,'),
+  'Chat session state should expose its canonical server refresh path to realtime handlers.',
+);
+
+assert.ok(
+  chatInterface.includes('handleSessionSettled') && chatInterface.includes('refreshActiveSessionMessages'),
+  'Chat interface should refresh the active session when a run settles.',
+);
+
+assert.ok(
+  changedFilesHook.includes('PIXCODE_RUN_STATE_REFRESH_EVENT') && changedFilesHook.includes("run-state"),
+  'Changed-files monitor should refresh on canonical run-state events.',
+);
+
+assert.ok(
+  orchestrationPage.includes('mergeRunSnapshot') && orchestrationPage.includes('dispatchRunStateRefresh'),
+  'Orchestration page should merge run snapshots and dispatch terminal refresh events.',
+);
+
+assert.ok(
+  runPanel.includes('onRunSnapshot') && runPanel.includes('onRunSnapshot?.(nextRun)'),
+  'Workflow run panel should push run snapshots back to the parent list.',
+);
+
+console.log('run state refresh smoke passed');

package/scripts/smoke/workflow-trace-timeline.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+
+function read(relativePath) {
+  return fs.readFileSync(path.join(root, relativePath), 'utf8');
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+const types = read('server/modules/orchestration/workflows/workflow.types.ts');
+assert(types.includes('WorkflowTraceEvent'), 'Workflow trace event type is missing.');
+assert(types.includes("type: 'run' | 'node' | 'provider' | 'message' | 'artifact' | 'file' | 'error'"), 'Trace event type taxonomy is missing.');
+assert(types.includes("severity: 'info' | 'warning' | 'error'"), 'Trace event severity taxonomy is missing.');
+
+const traceService = read('server/modules/orchestration/workflows/workflow-trace.ts');
+assert(traceService.includes('export function buildWorkflowTrace'), 'Workflow trace builder is missing.');
+assert(traceService.includes('redactTraceText'), 'Trace text redaction helper is missing.');
+assert(traceService.includes('file-diff'), 'Trace builder must surface file edit artifacts.');
+assert(traceService.includes('durationMs'), 'Trace builder must include event durations.');
+assert(traceService.includes('workflow.trace.runStarted'), 'Trace builder must emit stable trace title keys.');
+
+const routes = read('server/modules/orchestration/workflows/workflow.routes.ts');
+assert(routes.includes("'/workflows/runs/:runId/trace'"), 'Workflow trace API endpoint is missing.');
+assert(routes.includes('buildWorkflowTrace(run)'), 'Workflow trace route must use the shared trace builder.');
+
+const panel = read('src/components/orchestration/workflows/WorkflowRunPanel.tsx');
+assert(panel.includes('WorkflowTraceEvent'), 'Workflow run panel must type trace events.');
+assert(panel.includes('loadTrace'), 'Workflow run panel must load trace events from the API.');
+assert(panel.includes('traceFilters'), 'Workflow run panel must expose trace filters.');
+assert(panel.includes('traceTimelineId'), 'Workflow trace timeline tab is missing.');
+assert(panel.includes('orchestration.traceTimeline'), 'Workflow run panel must render the trace timeline label.');
+
+const en = read('src/i18n/locales/en/common.json');
+const tr = read('src/i18n/locales/tr/common.json');
+assert(en.includes('"traceTimeline"'), 'English trace timeline translation is missing.');
+assert(tr.includes('"traceTimeline"'), 'Turkish trace timeline translation is missing.');
+
+console.log(JSON.stringify({ ok: true, checked: 'workflow trace timeline' }, null, 2));

package/server/modules/orchestration/index.ts

@@ -55,6 +55,7 @@ export type {
   WorkflowNodeStatus,
   WorkflowRun,
   WorkflowRunStatus,
+  WorkflowTraceEvent,
 } from './workflows/workflow.types.js';
 export type {
   ExecResult,

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

@@ -1086,6 +1086,7 @@ function nodeRunFromNode(node: WorkflowNode): WorkflowNodeRun {
     agentInstanceId: node.agentInstanceId,
     agentLabel: node.agentLabel,
     assignment: node.assignment,
+    promptPreview: node.prompt,
     model: node.model,
     permissionMode: node.permissionMode,
     timeoutMs: node.timeoutMs,

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

@@ -0,0 +1,270 @@
+import os from 'node:os';
+
+import type {
+  WorkflowNodeRun,
+  WorkflowRun,
+  WorkflowTraceEvent,
+} from '@/modules/orchestration/workflows/workflow.types.js';
+
+const MAX_TRACE_TEXT_CHARS = 2_400;
+const TERMINAL_STATES = new Set(['completed', 'failed', 'canceled', 'skipped']);
+
+function traceId(parts: Array<string | number | undefined>): string {
+  return parts.filter((part) => part !== undefined && part !== '').join(':');
+}
+
+function durationMs(startedAt?: number, finishedAt?: number): number | undefined {
+  if (!startedAt || !finishedAt) return undefined;
+  return Math.max(0, finishedAt - startedAt);
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function redactionValues(run: WorkflowRun): string[] {
+  const metadata = run.metadata ?? {};
+  const workspaceTarget = metadata.workspaceTarget && typeof metadata.workspaceTarget === 'object'
+    ? metadata.workspaceTarget as Record<string, unknown>
+    : {};
+
+  return [
+    os.homedir(),
+    readString(metadata.projectPath),
+    readString(metadata.selectedProjectPath),
+    readString(workspaceTarget.path),
+    readString(workspaceTarget.projectPath),
+    readString(workspaceTarget.selectedProjectPath),
+  ].filter((value): value is string => Boolean(value && value.length > 2));
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function redactTraceText(value: string | undefined, run: WorkflowRun, maxLength = MAX_TRACE_TEXT_CHARS): string | undefined {
+  if (!value?.trim()) return undefined;
+
+  let text = value;
+  for (const secret of redactionValues(run)) {
+    text = text.replace(new RegExp(escapeRegExp(secret), 'g'), '[workspace]');
+  }
+
+  text = text
+    .replace(/\b(?:sk|ghp|github_pat|glpat|npm)_[A-Za-z0-9_=-]{12,}\b/gu, '[redacted-token]')
+    .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/gu, '[redacted-email]')
+    .trim();
+
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 32).trimEnd()}\n...[trace truncated]`;
+}
+
+function eventBase(
+  node: WorkflowNodeRun | undefined,
+): Pick<WorkflowTraceEvent, 'actor' | 'adapterId' | 'agentInstanceId' | 'agentLabel' | 'model' | 'nodeId'> {
+  if (!node) {
+    return { actor: 'Pixcode' };
+  }
+
+  return {
+    actor: node.agentLabel || node.adapterId || node.nodeId,
+    nodeId: node.nodeId,
+    adapterId: node.adapterId,
+    agentInstanceId: node.agentInstanceId,
+    agentLabel: node.agentLabel,
+    model: node.model,
+  };
+}
+
+function pushEvent(
+  events: WorkflowTraceEvent[],
+  event: WorkflowTraceEvent,
+): void {
+  events.push(event);
+}
+
+function artifactTitleKey(type: string): string {
+  if (type === 'file-diff') return 'workflow.trace.fileChanged';
+  if (type === 'preview-url') return 'workflow.trace.previewReady';
+  if (type === 'command-output') return 'workflow.trace.commandOutput';
+  return 'workflow.trace.artifact';
+}
+
+function artifactType(type: string): WorkflowTraceEvent['type'] {
+  return type === 'file-diff' ? 'file' : 'artifact';
+}
+
+function artifactTitle(type: string): string {
+  if (type === 'file-diff') return 'File changes captured';
+  if (type === 'preview-url') return 'Preview output captured';
+  if (type === 'command-output') return 'Command output captured';
+  return 'Artifact captured';
+}
+
+function artifactSummary(
+  artifact: NonNullable<WorkflowNodeRun['artifacts']>[number],
+  run: WorkflowRun,
+): string | undefined {
+  if (artifact.text?.trim()) {
+    return redactTraceText(artifact.text, run);
+  }
+  if (artifact.data && Object.keys(artifact.data).length > 0) {
+    return redactTraceText(JSON.stringify(artifact.data, null, 2), run);
+  }
+  return artifact.type;
+}
+
+function nodeTimestamp(run: WorkflowRun, node: WorkflowNodeRun, index: number): number {
+  return node.startedAt ?? run.startedAt + index;
+}
+
+export function buildWorkflowTrace(run: WorkflowRun): WorkflowTraceEvent[] {
+  const events: WorkflowTraceEvent[] = [];
+
+  pushEvent(events, {
+    id: traceId([run.id, 'run-started']),
+    type: 'run',
+    severity: 'info',
+    status: run.status,
+    timestamp: run.startedAt,
+    durationMs: durationMs(run.startedAt, run.finishedAt),
+    actor: 'Pixcode',
+    title: 'Workflow run started',
+    titleKey: 'workflow.trace.runStarted',
+    summary: redactTraceText(run.input, run),
+    metadata: {
+      workflowId: run.workflowId,
+      contextId: run.contextId,
+    },
+  });
+
+  run.nodeRuns.forEach((node, index) => {
+    const base = eventBase(node);
+    const timestamp = nodeTimestamp(run, node, index);
+    const nodeDuration = durationMs(node.startedAt, node.finishedAt);
+
+    pushEvent(events, {
+      id: traceId([run.id, node.nodeId, 'node']),
+      type: 'node',
+      severity: node.status === 'failed' ? 'error' : 'info',
+      status: node.status,
+      timestamp,
+      durationMs: nodeDuration,
+      ...base,
+      title: TERMINAL_STATES.has(node.status) ? 'Workflow step finished' : 'Workflow step started',
+      titleKey: TERMINAL_STATES.has(node.status) ? 'workflow.trace.nodeFinished' : 'workflow.trace.nodeStarted',
+      summary: redactTraceText(node.assignment, run),
+      metadata: {
+        stage: node.stage,
+        internal: node.internal,
+      },
+    });
+
+    if (node.promptPreview) {
+      pushEvent(events, {
+        id: traceId([run.id, node.nodeId, 'prompt']),
+        type: 'message',
+        severity: 'info',
+        status: node.status,
+        timestamp: timestamp + 1,
+        ...base,
+        title: 'Prompt prepared',
+        titleKey: 'workflow.trace.prompt',
+        summary: redactTraceText(node.promptPreview, run),
+      });
+    }
+
+    if (node.adapterId || node.model) {
+      pushEvent(events, {
+        id: traceId([run.id, node.nodeId, 'provider']),
+        type: 'provider',
+        severity: node.status === 'failed' ? 'error' : 'info',
+        status: node.a2aTaskId ? 'submitted' : node.status,
+        timestamp: timestamp + 2,
+        durationMs: nodeDuration,
+        ...base,
+        title: 'Provider call',
+        titleKey: 'workflow.trace.providerCall',
+        summary: [node.adapterId, node.model].filter(Boolean).join(' / '),
+        metadata: {
+          a2aTaskId: node.a2aTaskId,
+          permissionMode: node.permissionMode,
+          timeoutMs: node.timeoutMs,
+        },
+      });
+    }
+
+    (node.messages ?? [])
+      .filter((message) => message.role !== 'user' && message.text.trim())
+      .forEach((message, messageIndex) => {
+        pushEvent(events, {
+          id: traceId([run.id, node.nodeId, 'message', messageIndex]),
+          type: 'message',
+          severity: 'info',
+          status: node.status,
+          timestamp: message.createdAt ?? timestamp + 10 + messageIndex,
+          ...base,
+          title: 'Agent message',
+          titleKey: 'workflow.trace.agentMessage',
+          summary: redactTraceText(message.text, run),
+          metadata: {
+            role: message.role,
+          },
+        });
+      });
+
+    (node.artifacts ?? []).forEach((artifact, artifactIndex) => {
+      pushEvent(events, {
+        id: traceId([run.id, node.nodeId, 'artifact', artifactIndex]),
+        type: artifactType(artifact.type),
+        severity: 'info',
+        status: node.status,
+        timestamp: node.finishedAt ?? timestamp + 20 + artifactIndex,
+        ...base,
+        title: artifactTitle(artifact.type),
+        titleKey: artifactTitleKey(artifact.type),
+        summary: artifactSummary(artifact, run),
+        metadata: {
+          artifactType: artifact.type,
+          artifactMetadata: artifact.metadata,
+        },
+      });
+    });
+
+    if (node.error) {
+      pushEvent(events, {
+        id: traceId([run.id, node.nodeId, 'error']),
+        type: 'error',
+        severity: 'error',
+        status: node.status,
+        timestamp: node.finishedAt ?? timestamp + 30,
+        durationMs: nodeDuration,
+        ...base,
+        title: 'Step error',
+        titleKey: 'workflow.trace.error',
+        summary: redactTraceText(node.error, run),
+      });
+    }
+  });
+
+  if (run.finishedAt) {
+    pushEvent(events, {
+      id: traceId([run.id, 'run-finished']),
+      type: 'run',
+      severity: run.status === 'failed' ? 'error' : 'info',
+      status: run.status,
+      timestamp: run.finishedAt,
+      durationMs: durationMs(run.startedAt, run.finishedAt),
+      actor: 'Pixcode',
+      title: 'Workflow run finished',
+      titleKey: 'workflow.trace.runFinished',
+      summary: redactTraceText(readString(run.metadata?.error), run),
+      metadata: {
+        workflowId: run.workflowId,
+        contextId: run.contextId,
+      },
+    });
+  }
+
+  return events.sort((a, b) => a.timestamp - b.timestamp || a.id.localeCompare(b.id));
+}

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

@@ -3,6 +3,7 @@ import express from 'express';
 
 import { workflowRunner } from '@/modules/orchestration/workflows/workflow-runner.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';
 
 const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
@@ -120,6 +121,19 @@ export function createWorkflowRouter(): Router {
     });
   });
 
+  router.get('/workflows/runs/:runId/trace', (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;
+    }
+
+    res.json({
+      runId: run.id,
+      trace: buildWorkflowTrace(run),
+    });
+  });
+
   router.get('/workflows/runs/:runId', (req, res) => {
     const run = workflowStore.getRun(req.params.runId);
     if (!run) {

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

@@ -35,6 +35,7 @@ export interface WorkflowNodeRun {
   agentInstanceId?: string;
   agentLabel?: string;
   assignment?: string;
+  promptPreview?: string;
   model?: string;
   permissionMode?: string;
   timeoutMs?: number;
@@ -70,3 +71,23 @@ export interface WorkflowRun {
   finishedAt?: number;
   metadata?: Record<string, unknown>;
 }
+
+export interface WorkflowTraceEvent {
+  id: string;
+  type: 'run' | 'node' | 'provider' | 'message' | 'artifact' | 'file' | 'error';
+  severity: 'info' | 'warning' | 'error';
+  status: WorkflowRunStatus | WorkflowNodeStatus | 'submitted';
+  timestamp: number;
+  durationMs?: number;
+  actor: string;
+  title: string;
+  titleKey?: string;
+  summary?: string;
+  detail?: string;
+  nodeId?: string;
+  adapterId?: string;
+  agentInstanceId?: string;
+  agentLabel?: string;
+  model?: string;
+  metadata?: Record<string, unknown>;
+}