@pixelbyte-software/pixcode 1.35.1 → 1.35.2

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

@@ -1,97 +1,97 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { builtInWorkflows } from '@/modules/orchestration/workflows/built-in-workflows.js';
-import type { Workflow, WorkflowRun } from '@/modules/orchestration/workflows/workflow.types.js';
-
-interface Document {
-  version: 1;
-  runs: WorkflowRun[];
-}
-
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
-const TERMINAL_NODE_STATES = new Set(['completed', 'failed', 'canceled', 'skipped']);
-
-export class WorkflowStore {
-  private readonly filePath = process.env.WORKFLOW_RUNS_PATH ??
-    path.join(os.homedir(), '.pixcode', 'workflow-runs.json');
-  private readonly tmpPath = `${this.filePath}.tmp`;
-  private readonly runs = new Map<string, WorkflowRun>();
-
-  constructor() {
-    this.load();
-  }
-
-  listWorkflows(): Workflow[] {
-    return builtInWorkflows;
-  }
-
-  getWorkflow(id: string): Workflow | undefined {
-    return builtInWorkflows.find((workflow) => workflow.id === id);
-  }
-
-  listRuns(): WorkflowRun[] {
-    return [...this.runs.values()].sort((a, b) => b.startedAt - a.startedAt);
-  }
-
-  getRun(id: string): WorkflowRun | undefined {
-    return this.runs.get(id);
-  }
-
-  setRun(run: WorkflowRun): void {
-    this.runs.set(run.id, run);
-    this.flush();
-  }
-
-  private load(): void {
-    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-    if (!fs.existsSync(this.filePath)) {
-      this.flush();
-      return;
-    }
-    let repaired = false;
-    try {
-      const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf8')) as Partial<Document>;
-      for (const run of Array.isArray(parsed.runs) ? parsed.runs : []) {
-        if (run && typeof run.id === 'string') {
-          if (!TERMINAL_RUN_STATES.has(run.status)) {
-            run.status = 'failed';
-            run.finishedAt = run.finishedAt ?? Date.now();
-            run.metadata = {
-              ...run.metadata,
-              error: 'Pixcode restarted before this workflow run reached a terminal state.',
-            };
-            for (const node of run.nodeRuns ?? []) {
-              if (!TERMINAL_NODE_STATES.has(node.status)) {
-                node.status = 'failed';
-                node.finishedAt = node.finishedAt ?? run.finishedAt;
-                node.error = node.error ?? 'Workflow runner stopped before this node reached a terminal state.';
-              }
-            }
-            repaired = true;
-          }
-          this.runs.set(run.id, run);
-        }
-      }
-    } catch {
-      this.flush();
-      return;
-    }
-
-    if (repaired) {
-      this.flush();
-    }
-  }
-
-  private flush(): void {
-    fs.writeFileSync(
-      this.tmpPath,
-      JSON.stringify({ version: 1, runs: [...this.runs.values()] }, null, 2),
-      'utf8',
-    );
-    fs.renameSync(this.tmpPath, this.filePath);
-  }
-}
-
-export const workflowStore = new WorkflowStore();
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { builtInWorkflows } from '@/modules/orchestration/workflows/built-in-workflows.js';
+import type { Workflow, WorkflowRun } from '@/modules/orchestration/workflows/workflow.types.js';
+
+interface Document {
+  version: 1;
+  runs: WorkflowRun[];
+}
+
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+const TERMINAL_NODE_STATES = new Set(['completed', 'failed', 'canceled', 'skipped']);
+
+export class WorkflowStore {
+  private readonly filePath = process.env.WORKFLOW_RUNS_PATH ??
+    path.join(os.homedir(), '.pixcode', 'workflow-runs.json');
+  private readonly tmpPath = `${this.filePath}.tmp`;
+  private readonly runs = new Map<string, WorkflowRun>();
+
+  constructor() {
+    this.load();
+  }
+
+  listWorkflows(): Workflow[] {
+    return builtInWorkflows;
+  }
+
+  getWorkflow(id: string): Workflow | undefined {
+    return builtInWorkflows.find((workflow) => workflow.id === id);
+  }
+
+  listRuns(): WorkflowRun[] {
+    return [...this.runs.values()].sort((a, b) => b.startedAt - a.startedAt);
+  }
+
+  getRun(id: string): WorkflowRun | undefined {
+    return this.runs.get(id);
+  }
+
+  setRun(run: WorkflowRun): void {
+    this.runs.set(run.id, run);
+    this.flush();
+  }
+
+  private load(): void {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    if (!fs.existsSync(this.filePath)) {
+      this.flush();
+      return;
+    }
+    let repaired = false;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf8')) as Partial<Document>;
+      for (const run of Array.isArray(parsed.runs) ? parsed.runs : []) {
+        if (run && typeof run.id === 'string') {
+          if (!TERMINAL_RUN_STATES.has(run.status)) {
+            run.status = 'failed';
+            run.finishedAt = run.finishedAt ?? Date.now();
+            run.metadata = {
+              ...run.metadata,
+              error: 'Pixcode restarted before this workflow run reached a terminal state.',
+            };
+            for (const node of run.nodeRuns ?? []) {
+              if (!TERMINAL_NODE_STATES.has(node.status)) {
+                node.status = 'failed';
+                node.finishedAt = node.finishedAt ?? run.finishedAt;
+                node.error = node.error ?? 'Workflow runner stopped before this node reached a terminal state.';
+              }
+            }
+            repaired = true;
+          }
+          this.runs.set(run.id, run);
+        }
+      }
+    } catch {
+      this.flush();
+      return;
+    }
+
+    if (repaired) {
+      this.flush();
+    }
+  }
+
+  private flush(): void {
+    fs.writeFileSync(
+      this.tmpPath,
+      JSON.stringify({ version: 1, runs: [...this.runs.values()] }, null, 2),
+      'utf8',
+    );
+    fs.renameSync(this.tmpPath, this.filePath);
+  }
+}
+
+export const workflowStore = new WorkflowStore();

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

@@ -1,169 +1,169 @@
-import type { Router } from 'express';
-import express from 'express';
-
-import { workflowRunner } from '@/modules/orchestration/workflows/workflow-runner.js';
-import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
-import { findPixcodeAppRoot } from '@/modules/orchestration/workflows/workspace-target.js';
-
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
-
-function readMetadata(body: unknown): Record<string, unknown> | undefined {
-  if (!body || typeof body !== 'object') return undefined;
-  const metadata = (body as Record<string, unknown>).metadata;
-  return metadata && typeof metadata === 'object' ? metadata as Record<string, unknown> : undefined;
-}
-
-function sendRunSnapshot(res: express.Response, runId: string): boolean {
-  const run = workflowStore.getRun(runId);
-  if (!run) {
-    res.write(`event: error\ndata: ${JSON.stringify({ error: { code: 'RUN_NOT_FOUND', message: runId } })}\n\n`);
-    return true;
-  }
-
-  res.write(`event: snapshot\ndata: ${JSON.stringify({ run })}\n\n`);
-  return TERMINAL_RUN_STATES.has(run.status);
-}
-
-export function createWorkflowRouter(): Router {
-  const router = express.Router();
-  router.use(express.json({ limit: '2mb' }));
-
-  router.get('/workflows', (_req, res) => {
-    res.json({ workflows: workflowStore.listWorkflows() });
-  });
-
-  router.get('/workflows/context', (_req, res) => {
-    res.json({
-      appRoot: findPixcodeAppRoot(),
-      defaultWorkspaceTarget: 'selected_project',
-      supportedWorkspaceTargets: ['selected_project', 'pixcode_app', 'custom'],
-    });
-  });
-
-  router.get('/workflows/runs', (req, res) => {
-    const projectId = typeof req.query.projectId === 'string' ? req.query.projectId : undefined;
-    const runs = projectId
-      ? workflowStore.listRuns().filter((run) => run.metadata?.projectId === projectId)
-      : workflowStore.listRuns();
-    res.json({ runs });
-  });
-
-  router.get('/workflows/runs/:runId/events', (req, res) => {
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Cache-Control', 'no-cache, no-transform');
-    res.setHeader('Connection', 'keep-alive');
-    res.setHeader('X-Accel-Buffering', 'no');
-    if (typeof res.flushHeaders === 'function') {
-      res.flushHeaders();
-    }
-    if (res.socket && typeof res.socket.setNoDelay === 'function') {
-      try {
-        res.socket.setNoDelay(true);
-      } catch {
-        // Non-fatal; SSE still works without disabling Nagle.
-      }
-    }
-
-    const terminal = sendRunSnapshot(res, req.params.runId);
-    if (terminal) {
-      res.end();
-      return;
-    }
-
-    const heartbeat = setInterval(() => {
-      res.write(': ping\n\n');
-    }, 15_000);
-    const timer = setInterval(() => {
-      const done = sendRunSnapshot(res, req.params.runId);
-      if (done) {
-        clearInterval(timer);
-        clearInterval(heartbeat);
-        res.end();
-      }
-    }, 1_000);
-
-    req.on('close', () => {
-      clearInterval(timer);
-      clearInterval(heartbeat);
-    });
-  });
-
-  router.get('/workflows/runs/:runId', (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(run);
-  });
-
-  router.post('/workflows/:id/preview', (req, res) => {
-    const workflow = workflowStore.getWorkflow(req.params.id);
-    if (!workflow) {
-      res.status(404).json({ error: { code: 'WORKFLOW_NOT_FOUND', message: req.params.id } });
-      return;
-    }
-    try {
-      const runtimeWorkflow = workflowRunner.preview(workflow, readMetadata(req.body));
-      res.json({
-        workflow: runtimeWorkflow,
-        nodeCount: runtimeWorkflow.nodes.length,
-        nodes: runtimeWorkflow.nodes.map((node) => ({
-          id: node.id,
-          adapterId: node.adapterId,
-          agentInstanceId: node.agentInstanceId,
-          agentLabel: node.agentLabel,
-          assignment: node.assignment,
-          stage: node.stage,
-          inputs: node.inputs,
-          onFail: node.onFail,
-          output: node.output,
-          model: node.model,
-          permissionMode: node.permissionMode,
-          timeoutMs: node.timeoutMs,
-        })),
-      });
-    } catch (error) {
-      res.status(400).json({
-        error: {
-          code: 'WORKFLOW_INVALID',
-          message: error instanceof Error ? error.message : String(error),
-        },
-      });
-    }
-  });
-
-  router.post('/workflows/runs/:runId/cancel', async (req, res) => {
-    const run = await workflowRunner.cancel(req.params.runId);
-    if (!run) {
-      res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
-      return;
-    }
-    res.json(run);
-  });
-
-  router.post('/workflows/:id/runs', (req, res) => {
-    const workflow = workflowStore.getWorkflow(req.params.id);
-    if (!workflow) {
-      res.status(404).json({ error: { code: 'WORKFLOW_NOT_FOUND', message: req.params.id } });
-      return;
-    }
-    try {
-      const run = workflowRunner.start(
-        workflow,
-        typeof req.body?.input === 'string' ? req.body.input : '',
-        readMetadata(req.body),
-      );
-      res.status(202).json(run);
-    } catch (error) {
-      res.status(400).json({
-        error: {
-          code: 'WORKFLOW_INVALID',
-          message: error instanceof Error ? error.message : String(error),
-        },
-      });
-    }
-  });
-
-  return router;
-}
+import type { Router } from 'express';
+import express from 'express';
+
+import { workflowRunner } from '@/modules/orchestration/workflows/workflow-runner.js';
+import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
+import { findPixcodeAppRoot } from '@/modules/orchestration/workflows/workspace-target.js';
+
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+
+function readMetadata(body: unknown): Record<string, unknown> | undefined {
+  if (!body || typeof body !== 'object') return undefined;
+  const metadata = (body as Record<string, unknown>).metadata;
+  return metadata && typeof metadata === 'object' ? metadata as Record<string, unknown> : undefined;
+}
+
+function sendRunSnapshot(res: express.Response, runId: string): boolean {
+  const run = workflowStore.getRun(runId);
+  if (!run) {
+    res.write(`event: error\ndata: ${JSON.stringify({ error: { code: 'RUN_NOT_FOUND', message: runId } })}\n\n`);
+    return true;
+  }
+
+  res.write(`event: snapshot\ndata: ${JSON.stringify({ run })}\n\n`);
+  return TERMINAL_RUN_STATES.has(run.status);
+}
+
+export function createWorkflowRouter(): Router {
+  const router = express.Router();
+  router.use(express.json({ limit: '2mb' }));
+
+  router.get('/workflows', (_req, res) => {
+    res.json({ workflows: workflowStore.listWorkflows() });
+  });
+
+  router.get('/workflows/context', (_req, res) => {
+    res.json({
+      appRoot: findPixcodeAppRoot(),
+      defaultWorkspaceTarget: 'selected_project',
+      supportedWorkspaceTargets: ['selected_project', 'pixcode_app', 'custom'],
+    });
+  });
+
+  router.get('/workflows/runs', (req, res) => {
+    const projectId = typeof req.query.projectId === 'string' ? req.query.projectId : undefined;
+    const runs = projectId
+      ? workflowStore.listRuns().filter((run) => run.metadata?.projectId === projectId)
+      : workflowStore.listRuns();
+    res.json({ runs });
+  });
+
+  router.get('/workflows/runs/:runId/events', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    if (typeof res.flushHeaders === 'function') {
+      res.flushHeaders();
+    }
+    if (res.socket && typeof res.socket.setNoDelay === 'function') {
+      try {
+        res.socket.setNoDelay(true);
+      } catch {
+        // Non-fatal; SSE still works without disabling Nagle.
+      }
+    }
+
+    const terminal = sendRunSnapshot(res, req.params.runId);
+    if (terminal) {
+      res.end();
+      return;
+    }
+
+    const heartbeat = setInterval(() => {
+      res.write(': ping\n\n');
+    }, 15_000);
+    const timer = setInterval(() => {
+      const done = sendRunSnapshot(res, req.params.runId);
+      if (done) {
+        clearInterval(timer);
+        clearInterval(heartbeat);
+        res.end();
+      }
+    }, 1_000);
+
+    req.on('close', () => {
+      clearInterval(timer);
+      clearInterval(heartbeat);
+    });
+  });
+
+  router.get('/workflows/runs/:runId', (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(run);
+  });
+
+  router.post('/workflows/:id/preview', (req, res) => {
+    const workflow = workflowStore.getWorkflow(req.params.id);
+    if (!workflow) {
+      res.status(404).json({ error: { code: 'WORKFLOW_NOT_FOUND', message: req.params.id } });
+      return;
+    }
+    try {
+      const runtimeWorkflow = workflowRunner.preview(workflow, readMetadata(req.body));
+      res.json({
+        workflow: runtimeWorkflow,
+        nodeCount: runtimeWorkflow.nodes.length,
+        nodes: runtimeWorkflow.nodes.map((node) => ({
+          id: node.id,
+          adapterId: node.adapterId,
+          agentInstanceId: node.agentInstanceId,
+          agentLabel: node.agentLabel,
+          assignment: node.assignment,
+          stage: node.stage,
+          inputs: node.inputs,
+          onFail: node.onFail,
+          output: node.output,
+          model: node.model,
+          permissionMode: node.permissionMode,
+          timeoutMs: node.timeoutMs,
+        })),
+      });
+    } catch (error) {
+      res.status(400).json({
+        error: {
+          code: 'WORKFLOW_INVALID',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  router.post('/workflows/runs/:runId/cancel', async (req, res) => {
+    const run = await workflowRunner.cancel(req.params.runId);
+    if (!run) {
+      res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
+      return;
+    }
+    res.json(run);
+  });
+
+  router.post('/workflows/:id/runs', (req, res) => {
+    const workflow = workflowStore.getWorkflow(req.params.id);
+    if (!workflow) {
+      res.status(404).json({ error: { code: 'WORKFLOW_NOT_FOUND', message: req.params.id } });
+      return;
+    }
+    try {
+      const run = workflowRunner.start(
+        workflow,
+        typeof req.body?.input === 'string' ? req.body.input : '',
+        readMetadata(req.body),
+      );
+      res.status(202).json(run);
+    } catch (error) {
+      res.status(400).json({
+        error: {
+          code: 'WORKFLOW_INVALID',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  return router;
+}

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

@@ -1,70 +1,70 @@
-export type WorkflowRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
-export type WorkflowNodeStatus = WorkflowRunStatus | 'skipped';
-
-export interface WorkflowNode {
-  id: string;
-  adapterId: string;
-  prompt: string;
-  inputs: string[];
-  output: 'message' | 'artifact' | 'both';
-  onFail: 'abort' | 'continue' | 'retry';
-  stage?: string;
-  agentInstanceId?: string;
-  agentLabel?: string;
-  assignment?: string;
-  model?: string;
-  permissionMode?: string;
-  toolsSettings?: Record<string, unknown>;
-  isolation?: 'host' | 'worktree' | 'docker';
-  timeoutMs?: number;
-}
-
-export interface Workflow {
-  id: string;
-  name: string;
-  description?: string;
-  trigger: 'manual' | 'on-task-create' | 'on-pr-open';
-  nodes: WorkflowNode[];
-  isBuiltin?: boolean;
-}
-
-export interface WorkflowNodeRun {
-  nodeId: string;
-  adapterId?: string;
-  agentInstanceId?: string;
-  agentLabel?: string;
-  assignment?: string;
-  model?: string;
-  permissionMode?: string;
-  timeoutMs?: number;
-  stage?: string;
-  status: WorkflowNodeStatus;
-  a2aTaskId?: string;
-  startedAt?: number;
-  finishedAt?: number;
-  error?: string;
-  outputText?: string;
-  messages?: Array<{
-    role: string;
-    text: string;
-    createdAt?: number;
-  }>;
-  artifacts?: Array<{
-    type: string;
-    text?: string;
-    data?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-  }>;
-}
-
-export interface WorkflowRun {
-  id: string;
-  workflowId: string;
-  contextId: string;
-  status: WorkflowRunStatus;
-  nodeRuns: WorkflowNodeRun[];
-  input?: string;
-  startedAt: number;
-  finishedAt?: number;
-  metadata?: Record<string, unknown>;
-}
+export type WorkflowRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+export type WorkflowNodeStatus = WorkflowRunStatus | 'skipped';
+
+export interface WorkflowNode {
+  id: string;
+  adapterId: string;
+  prompt: string;
+  inputs: string[];
+  output: 'message' | 'artifact' | 'both';
+  onFail: 'abort' | 'continue' | 'retry';
+  stage?: string;
+  agentInstanceId?: string;
+  agentLabel?: string;
+  assignment?: string;
+  model?: string;
+  permissionMode?: string;
+  toolsSettings?: Record<string, unknown>;
+  isolation?: 'host' | 'worktree' | 'docker';
+  timeoutMs?: number;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  trigger: 'manual' | 'on-task-create' | 'on-pr-open';
+  nodes: WorkflowNode[];
+  isBuiltin?: boolean;
+}
+
+export interface WorkflowNodeRun {
+  nodeId: string;
+  adapterId?: string;
+  agentInstanceId?: string;
+  agentLabel?: string;
+  assignment?: string;
+  model?: string;
+  permissionMode?: string;
+  timeoutMs?: number;
+  stage?: string;
+  status: WorkflowNodeStatus;
+  a2aTaskId?: string;
+  startedAt?: number;
+  finishedAt?: number;
+  error?: string;
+  outputText?: string;
+  messages?: Array<{
+    role: string;
+    text: string;
+    createdAt?: number;
+  }>;
+  artifacts?: Array<{
+    type: string;
+    text?: string;
+    data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+  }>;
+}
+
+export interface WorkflowRun {
+  id: string;
+  workflowId: string;
+  contextId: string;
+  status: WorkflowRunStatus;
+  nodeRuns: WorkflowNodeRun[];
+  input?: string;
+  startedAt: number;
+  finishedAt?: number;
+  metadata?: Record<string, unknown>;
+}