@pixelbyte-software/pixcode 1.34.0 → 1.35.1

package/server/modules/orchestration/a2a/types.ts

@@ -76,6 +76,20 @@ export interface Task {
   updatedAt: number;
 }
 
+export interface TaskSummary {
+  id: string;
+  contextId?: string;
+  state: TaskState;
+  adapterId?: string;
+  adapterSelector?: string;
+  error?: TaskError;
+  createdAt: number;
+  updatedAt: number;
+  messageCount: number;
+  artifactCount: number;
+  lastMessage?: Message;
+}
+
 export interface AgentSkill {
   id: string;
   description: string;

package/server/modules/orchestration/a2a/validator.ts

@@ -21,6 +21,19 @@ function assertNonEmptyString(value: unknown, path: string): asserts value is st
   }
 }
 
+function assertOptionalNonEmptyString(value: unknown, path: string): void {
+  if (value === undefined) {
+    return;
+  }
+  assertNonEmptyString(value, path);
+}
+
+function assertPlainObject(value: unknown, path: string): void {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new A2AValidationError('expected plain object', path);
+  }
+}
+
 function assertPart(value: unknown, path: string): asserts value is Part {
   if (!value || typeof value !== 'object') {
     throw new A2AValidationError('expected object', path);
@@ -48,7 +61,7 @@ export function assertMessage(value: unknown, path = '$'): asserts value is Mess
   if (!value || typeof value !== 'object') {
     throw new A2AValidationError('expected object', path);
   }
-  const m = value as { messageId?: unknown; role?: unknown; parts?: unknown };
+  const m = value as { messageId?: unknown; role?: unknown; parts?: unknown; taskId?: unknown };
   assertNonEmptyString(m.messageId, `${path}.messageId`);
   if (m.role !== 'user' && m.role !== 'agent') {
     throw new A2AValidationError('role must be user|agent', `${path}.role`);
@@ -56,6 +69,7 @@ export function assertMessage(value: unknown, path = '$'): asserts value is Mess
   if (!Array.isArray(m.parts) || m.parts.length === 0) {
     throw new A2AValidationError('parts must be non-empty array', `${path}.parts`);
   }
+  assertOptionalNonEmptyString(m.taskId, `${path}.taskId`);
   m.parts.forEach((p, i) => assertPart(p, `${path}.parts[${i}]`));
 }
 
@@ -63,9 +77,18 @@ export function assertSubmitTaskInput(value: unknown): asserts value is SubmitTa
   if (!value || typeof value !== 'object') {
     throw new A2AValidationError('expected object', '$');
   }
-  const v = value as { message?: unknown; adapterId?: unknown };
+  const v = value as {
+    message?: unknown;
+    adapterId?: unknown;
+    contextId?: unknown;
+    metadata?: unknown;
+  };
   assertMessage(v.message, '$.message');
   assertNonEmptyString(v.adapterId, '$.adapterId');
+  assertOptionalNonEmptyString(v.contextId, '$.contextId');
+  if (v.metadata !== undefined) {
+    assertPlainObject(v.metadata, '$.metadata');
+  }
 }
 
 export function assertAgentCard(value: unknown): asserts value is AgentCard {

package/server/modules/orchestration/index.ts

@@ -6,12 +6,25 @@
 export { createA2ARouter } from './a2a/routes.js';
 export { adapterRegistry } from './a2a/adapter-registry.js';
 export { ClaudeCodeA2AAdapter } from './a2a/adapters/claude-code.adapter.js';
+export { CodexA2AAdapter } from './a2a/adapters/codex.adapter.js';
+export { CursorA2AAdapter } from './a2a/adapters/cursor.adapter.js';
+export { GeminiA2AAdapter } from './a2a/adapters/gemini.adapter.js';
+export { QwenA2AAdapter } from './a2a/adapters/qwen.adapter.js';
+export { OpenCodeA2AAdapter } from './a2a/adapters/opencode.adapter.js';
 export type {
   AdapterContext,
   TaskHandle,
 } from './a2a/adapters/abstract-a2a.adapter.js';
 export { AbstractA2AAdapter } from './a2a/adapters/abstract-a2a.adapter.js';
 export { a2aBus } from './a2a/bus.js';
+export { portWatcher } from './preview/port-watcher.js';
+export { createPreviewProxyRouter } from './preview/preview-proxy.js';
+export { createOrchestrationTaskRouter } from './tasks/orchestration-task.routes.js';
+export { orchestrationTaskService } from './tasks/orchestration-task.service.js';
+export { createWorkflowRouter } from './workflows/workflow.routes.js';
+export { workflowRunner } from './workflows/workflow-runner.js';
+export { workflowStore } from './workflows/workflow-store.js';
+export { workspaceManager } from './workspace/workspace-manager.js';
 export type {
   AgentCard,
   Artifact,
@@ -21,6 +34,33 @@ export type {
   Part,
   SubmitTaskInput,
   Task,
+  TaskSummary,
   TaskError,
   TaskState,
 } from './a2a/types.js';
+export type {
+  PortEvent,
+  PreviewArtifactData,
+} from './preview/types.js';
+export type {
+  CreateOrchestrationTaskInput,
+  DispatchOrchestrationTaskInput,
+  OrchestrationTask,
+  OrchestrationTaskState,
+} from './tasks/orchestration-task.types.js';
+export type {
+  Workflow,
+  WorkflowNode,
+  WorkflowNodeRun,
+  WorkflowNodeStatus,
+  WorkflowRun,
+  WorkflowRunStatus,
+} from './workflows/workflow.types.js';
+export type {
+  ExecResult,
+  WorkspaceHandle,
+  WorkspaceKind,
+  WorkspaceMetadata,
+  WorkspaceRequest,
+} from './workspace/types.js';
+export { WorkspaceError } from './workspace/types.js';

package/server/modules/orchestration/preview/port-watcher.ts

@@ -0,0 +1,112 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import type { PortEvent } from '@/modules/orchestration/preview/types.js';
+import type { WorkspaceHandle } from '@/modules/orchestration/workspace/types.js';
+
+const execFileAsync = promisify(execFile);
+
+interface WatchOptions {
+  taskId: string;
+  workspace: WorkspaceHandle;
+  intervalMs?: number;
+  onPort(event: PortEvent): void;
+}
+
+interface ListeningPort {
+  port: number;
+  host: string;
+  processName?: string;
+}
+
+const knownPreviewPorts = new Map<number, PortEvent>();
+
+function parseAddress(address: string): { host: string; port: number } | null {
+  const normalized = address.trim();
+  const idx = normalized.lastIndexOf(':');
+  if (idx === -1) return null;
+  const port = Number.parseInt(normalized.slice(idx + 1), 10);
+  if (!Number.isFinite(port) || port <= 0) return null;
+  const host = normalized.slice(0, idx).replace(/^\[|\]$/g, '') || '127.0.0.1';
+  return { host: host === '*' || host === '0.0.0.0' ? '127.0.0.1' : host, port };
+}
+
+function parseSs(output: string): ListeningPort[] {
+  const ports: ListeningPort[] = [];
+  for (const line of output.split('\n')) {
+    if (!line.includes('LISTEN')) continue;
+    const parts = line.trim().split(/\s+/);
+    const address = parts[3] ?? parts[4];
+    const parsed = address ? parseAddress(address) : null;
+    if (!parsed) continue;
+    const processMatch = line.match(/users:\(\("([^"]+)"/);
+    ports.push({
+      ...parsed,
+      processName: processMatch?.[1],
+    });
+  }
+  return ports;
+}
+
+async function readListeningPorts(): Promise<ListeningPort[]> {
+  try {
+    const { stdout } = await execFileAsync('ss', ['-ltnp'], {
+      maxBuffer: 1024 * 1024,
+    });
+    return parseSs(String(stdout));
+  } catch {
+    return [];
+  }
+}
+
+export function getKnownPreviewPort(port: number): PortEvent | undefined {
+  return knownPreviewPorts.get(port);
+}
+
+export class PortWatcher {
+  watch(options: WatchOptions): () => void {
+    const {
+      taskId,
+      workspace,
+      intervalMs = 1000,
+      onPort,
+    } = options;
+    const seen = new Set<number>();
+    let stopped = false;
+    let timer: NodeJS.Timeout | undefined;
+    let initialized = false;
+
+    const tick = async () => {
+      if (stopped) return;
+      const ports = await readListeningPorts();
+      for (const port of ports) {
+        if (seen.has(port.port)) continue;
+        seen.add(port.port);
+        if (!initialized) continue;
+        const event: PortEvent = {
+          taskId,
+          workspaceId: workspace.id,
+          port: port.port,
+          host: port.host,
+          url: `http://${port.host}:${port.port}`,
+          processName: port.processName,
+          confidence: 'low',
+          detectedAt: Date.now(),
+        };
+        knownPreviewPorts.set(port.port, event);
+        onPort(event);
+      }
+      initialized = true;
+      timer = setTimeout(tick, intervalMs);
+    };
+
+    void tick();
+
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }
+}
+
+export const portWatcher = new PortWatcher();

package/server/modules/orchestration/preview/preview-proxy.ts

@@ -0,0 +1,60 @@
+import type { RequestHandler, Router } from 'express';
+import express from 'express';
+
+import { getKnownPreviewPort } from '@/modules/orchestration/preview/port-watcher.js';
+
+function buildTargetUrl(port: number, path: string): string {
+  const event = getKnownPreviewPort(port);
+  const host = event?.host ?? '127.0.0.1';
+  return `http://${host}:${port}${path}`;
+}
+
+function proxyHandler(): RequestHandler {
+  return async (req, res) => {
+    const portParam = req.params.port ?? req.params[0];
+    const rawPort = Array.isArray(portParam) ? portParam[0] : portParam;
+    const port = Number.parseInt(rawPort, 10);
+    if (!Number.isFinite(port) || port <= 0 || !getKnownPreviewPort(port)) {
+      res.status(404).json({
+        error: {
+          code: 'PREVIEW_PORT_NOT_FOUND',
+          message: 'Preview port is not registered for an orchestration task.',
+        },
+      });
+      return;
+    }
+
+    const path = req.originalUrl.replace(/^\/preview\/\d+/, '') || '/';
+    const target = buildTargetUrl(port, path);
+    try {
+      const upstream = await fetch(target, {
+        method: req.method,
+        headers: {
+          accept: req.header('accept') ?? '*/*',
+          'user-agent': req.header('user-agent') ?? 'pixcode-preview-proxy',
+        },
+      });
+      res.status(upstream.status);
+      upstream.headers.forEach((value, key) => {
+        const lower = key.toLowerCase();
+        if (lower === 'content-encoding' || lower === 'content-length') return;
+        if (lower === 'x-frame-options' || lower === 'content-security-policy') return;
+        res.setHeader(key, value);
+      });
+      res.send(Buffer.from(await upstream.arrayBuffer()));
+    } catch (error) {
+      res.status(502).json({
+        error: {
+          code: 'PREVIEW_PROXY_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  };
+}
+
+export function createPreviewProxyRouter(): Router {
+  const router = express.Router();
+  router.use(/^\/(\d+)(?:\/.*)?$/, proxyHandler());
+  return router;
+}

package/server/modules/orchestration/preview/types.ts

@@ -0,0 +1,19 @@
+export interface PortEvent {
+  taskId: string;
+  workspaceId?: string;
+  port: number;
+  host: string;
+  url: string;
+  processName?: string;
+  confidence: 'low' | 'medium' | 'high';
+  detectedAt: number;
+}
+
+export interface PreviewArtifactData {
+  url: string;
+  proxiedUrl: string;
+  port: number;
+  host: string;
+  processName?: string;
+  confidence: 'low' | 'medium' | 'high';
+}

package/server/modules/orchestration/tasks/orchestration-task-store.ts

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import os from 'node:os';
+
+import { JsonStore } from '@/database/json-store.js';
+import type { OrchestrationTask } from '@/modules/orchestration/tasks/orchestration-task.types.js';
+
+function defaultPath(): string {
+  return process.env.ORCHESTRATION_TASKS_PATH ??
+    path.join(os.homedir(), '.pixcode', 'orchestration-tasks.json');
+}
+
+export class OrchestrationTaskStore {
+  private store: JsonStore;
+
+  constructor(filePath = defaultPath()) {
+    this.store = new JsonStore(filePath, { orchestration_tasks: [] });
+  }
+
+  get(id: string): OrchestrationTask | undefined {
+    return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.id === id) ?? undefined;
+  }
+
+  getByA2ATaskId(a2aTaskId: string): OrchestrationTask | undefined {
+    return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.a2aTaskId === a2aTaskId) ?? undefined;
+  }
+
+  getByTaskMasterId(taskmasterId: string): OrchestrationTask | undefined {
+    return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.taskmasterId === taskmasterId) ?? undefined;
+  }
+
+  list(projectId?: string): OrchestrationTask[] {
+    const tasks = this.store.filterWhere('orchestration_tasks', () => true) as OrchestrationTask[];
+    const sorted = tasks.sort((a, b) => b.createdAt - a.createdAt);
+    return projectId ? sorted.filter((task) => task.projectId === projectId) : sorted;
+  }
+
+  set(task: OrchestrationTask): void {
+    const existing = this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.id === task.id);
+    if (existing) {
+      this.store.updateWhere('orchestration_tasks', (r: OrchestrationTask) => r.id === task.id, task);
+    } else {
+      this.store.insert('orchestration_tasks', task, { autoId: false });
+    }
+  }
+}

package/server/modules/orchestration/tasks/orchestration-task.routes.ts

@@ -0,0 +1,73 @@
+import express, { type Router } from 'express';
+import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
+
+export function createOrchestrationTaskRouter(): Router {
+  const router = express.Router();
+  router.use(express.json({ limit: '2mb' }));
+
+  router.get('/tasks', (req, res) => {
+    const projectId = typeof req.query.projectId === 'string' ? req.query.projectId : undefined;
+    res.json({ tasks: orchestrationTaskService.list(projectId) });
+  });
+
+  router.post('/tasks', (req, res) => {
+    const projectId = typeof req.body?.projectId === 'string' ? req.body.projectId : 'default';
+    const title = typeof req.body?.title === 'string' ? req.body.title.trim() : '';
+    const description = typeof req.body?.description === 'string' ? req.body.description : undefined;
+    const taskmasterId = typeof req.body?.taskmasterId === 'string' ? req.body.taskmasterId : undefined;
+
+    if (!title) {
+      res.status(400).json({ error: { code: 'TITLE_REQUIRED', message: 'title is required' } });
+      return;
+    }
+
+    const task = orchestrationTaskService.create({ projectId, title, description, taskmasterId });
+    res.status(201).json(task);
+  });
+
+  router.post('/tasks/import-taskmaster', (req, res) => {
+    const projectId = typeof req.body?.projectId === 'string' ? req.body.projectId : 'default';
+    const entries = Array.isArray(req.body?.tasks) ? req.body.tasks : [];
+    const imported = entries
+      .map((entry: unknown) => {
+        if (!entry || typeof entry !== 'object') return null;
+        const record = entry as Record<string, unknown>;
+        const taskmasterId = typeof record.id === 'string' ? record.id : undefined;
+        const title = typeof record.title === 'string' ? record.title : undefined;
+        const description = typeof record.description === 'string' ? record.description : undefined;
+        if (!taskmasterId || !title) return null;
+        return orchestrationTaskService.upsertFromTaskMaster({ projectId, title, description, taskmasterId });
+      })
+      .filter(Boolean);
+
+    res.json({ tasks: imported, count: imported.length });
+  });
+
+  router.post('/tasks/:id/dispatch', async (req, res) => {
+    try {
+      const adapterId = typeof req.body?.adapterId === 'string' ? req.body.adapterId : '';
+      const isolation = req.body?.isolation;
+      if (!adapterId) {
+        res.status(400).json({ error: { code: 'ADAPTER_REQUIRED', message: 'adapterId is required' } });
+        return;
+      }
+      const task = await orchestrationTaskService.dispatch(req.params.id, { adapterId, isolation });
+      res.json(task);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message === 'TASK_NOT_FOUND' ? 404 : 400;
+      res.status(status).json({ error: { code: 'DISPATCH_FAILED', message } });
+    }
+  });
+
+  router.post('/tasks/:id/cancel', (req, res) => {
+    try {
+      const task = orchestrationTaskService.cancel(req.params.id);
+      res.json(task);
+    } catch {
+      res.status(404).json({ error: { code: 'TASK_NOT_FOUND', message: req.params.id } });
+    }
+  });
+
+  return router;
+}

package/server/modules/orchestration/tasks/orchestration-task.service.ts

@@ -0,0 +1,145 @@
+import { OrchestrationTaskStore } from '@/modules/orchestration/tasks/orchestration-task-store.js';
+import type { CreateOrchestrationTaskInput, DispatchOrchestrationTaskInput, OrchestrationTask } from '@/modules/orchestration/tasks/orchestration-task.types.js';
+import { a2aBus } from '@/modules/orchestration/a2a/bus.js';
+import type { TaskState } from '@/modules/orchestration/a2a/types.js';
+
+function newId(prefix: string): string {
+  return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+const TERMINAL_A2A_STATES: TaskState[] = ['completed', 'canceled', 'failed'];
+
+class OrchestrationTaskService {
+  private store: OrchestrationTaskStore;
+
+  constructor(store?: OrchestrationTaskStore) {
+    this.store = store ?? new OrchestrationTaskStore();
+    this.watchA2ATerminalStates();
+  }
+
+  list(projectId?: string): OrchestrationTask[] {
+    return this.store.list(projectId);
+  }
+
+  get(id: string): OrchestrationTask | undefined {
+    return this.store.get(id);
+  }
+
+  create(input: CreateOrchestrationTaskInput): OrchestrationTask {
+    const now = Date.now();
+    const task: OrchestrationTask = {
+      id: newId('otask'),
+      projectId: input.projectId,
+      title: input.title,
+      description: input.description,
+      taskmasterId: input.taskmasterId,
+      state: 'todo',
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.store.set(task);
+    return task;
+  }
+
+  upsertFromTaskMaster(input: CreateOrchestrationTaskInput): OrchestrationTask {
+    const existing = this.store.list(input.projectId).find((task) =>
+      task.taskmasterId === input.taskmasterId,
+    );
+    if (existing) {
+      existing.title = input.title;
+      existing.description = input.description;
+      existing.updatedAt = Date.now();
+      this.store.set(existing);
+      return existing;
+    }
+    return this.create(input);
+  }
+
+  async dispatch(taskId: string, input: DispatchOrchestrationTaskInput): Promise<OrchestrationTask> {
+    const task = this.store.get(taskId);
+    if (!task) throw new Error('TASK_NOT_FOUND');
+
+    const a2aResponse = await fetch(`http://127.0.0.1:${process.env.SERVER_PORT ?? '3001'}/a2a/tasks`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        adapterId: input.adapterId,
+        message: {
+          messageId: newId('msg'),
+          role: 'user',
+          parts: [{ kind: 'text', text: `${task.title}\n\n${task.description ?? ''}` }],
+        },
+        metadata: {
+          isolation: input.isolation ?? 'worktree',
+          orchestrationTaskId: task.id,
+          taskmasterId: task.taskmasterId,
+        },
+      }),
+    });
+
+    const body = await a2aResponse.json().catch(() => null) as { id?: string; error?: { message?: string } } | null;
+    if (!a2aResponse.ok || typeof body?.id !== 'string') {
+      throw new Error(body?.error?.message ?? 'DISPATCH_FAILED');
+    }
+
+    task.a2aTaskId = body.id;
+    task.adapterId = input.adapterId;
+    task.adapterSelector = input.adapterId;
+    task.workspaceKind = input.isolation ?? 'worktree';
+    task.state = 'in_progress';
+    task.updatedAt = Date.now();
+    this.store.set(task);
+    return task;
+  }
+
+  updateState(taskId: string, state: OrchestrationTask['state']): OrchestrationTask | undefined {
+    const task = this.store.get(taskId);
+    if (!task) return undefined;
+    task.state = state;
+    task.updatedAt = Date.now();
+    this.store.set(task);
+    return task;
+  }
+
+  private watchA2ATerminalStates(): void {
+    a2aBus.subscribeAll((event) => {
+      if (event.kind !== 'task-state') return;
+      if (!TERMINAL_A2A_STATES.includes(event.state)) return;
+
+      const orchTask = this.store.getByA2ATaskId(event.taskId);
+      if (!orchTask) return;
+      if (orchTask.state === 'done' || orchTask.state === 'failed' || orchTask.state === 'canceled') return;
+
+      const mapped = event.state === 'completed' ? 'done'
+        : event.state === 'failed' ? 'failed'
+        : 'canceled';
+
+      orchTask.state = mapped;
+      orchTask.updatedAt = Date.now();
+      this.store.set(orchTask);
+
+      if (orchTask.taskmasterId && mapped === 'done') {
+        this.syncTaskMasterStatus(orchTask.taskmasterId, 'done');
+      }
+    });
+  }
+
+  private syncTaskMasterStatus(taskmasterId: string, status: string): void {
+    const { spawn } = require('node:child_process') as typeof import('node:child_process');
+    spawn('task-master', ['set-status', '--id', taskmasterId, '--status', status], {
+      stdio: 'ignore',
+      detached: true,
+    }).unref();
+  }
+
+  cancel(taskId: string): OrchestrationTask {
+    const task = this.store.get(taskId);
+    if (!task) throw new Error('TASK_NOT_FOUND');
+    task.state = 'canceled';
+    task.updatedAt = Date.now();
+    this.store.set(task);
+    return task;
+  }
+}
+
+export const orchestrationTaskService = new OrchestrationTaskService();

package/server/modules/orchestration/tasks/orchestration-task.types.ts

@@ -0,0 +1,29 @@
+export type OrchestrationTaskState = 'todo' | 'in_progress' | 'in_review' | 'done' | 'failed' | 'canceled';
+
+export interface OrchestrationTask {
+  id: string;
+  a2aTaskId?: string;
+  taskmasterId?: string;
+  projectId: string;
+  title: string;
+  description?: string;
+  state: OrchestrationTaskState;
+  adapterId?: string;
+  adapterSelector?: string;
+  workspaceKind?: 'host' | 'worktree' | 'docker';
+  workspacePath?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CreateOrchestrationTaskInput {
+  projectId: string;
+  title: string;
+  description?: string;
+  taskmasterId?: string;
+}
+
+export interface DispatchOrchestrationTaskInput {
+  adapterId: string;
+  isolation?: 'host' | 'worktree' | 'docker';
+}