@pixelbyte-software/pixcode 1.52.4 → 1.53.1

package/server/modules/orchestration/a2a/task-dispatcher.ts

@@ -0,0 +1,345 @@
+import crypto from 'node:crypto';
+
+import { adapterRegistry } from '@/modules/orchestration/a2a/adapter-registry.js';
+import { a2aBus } from '@/modules/orchestration/a2a/bus.js';
+import { a2aTaskStore } from '@/modules/orchestration/a2a/task-store.js';
+import type {
+  BusEvent,
+  Message,
+  SubmitTaskInput,
+  Task,
+  TaskState,
+} from '@/modules/orchestration/a2a/types.js';
+import type { TaskHandle } from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
+import { portWatcher } from '@/modules/orchestration/preview/port-watcher.js';
+import type { PreviewArtifactData } from '@/modules/orchestration/preview/types.js';
+import {
+  type PermissionPolicy,
+  type PermissionPolicyContext,
+} from '@/modules/orchestration/security/permission-policy.js';
+import { workspaceManager } from '@/modules/orchestration/workspace/workspace-manager.js';
+import type {
+  WorkspaceHandle,
+  WorkspaceKind,
+  WorkspaceMetadata,
+} from '@/modules/orchestration/workspace/types.js';
+import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
+
+type RoutingHints = {
+  preferredAdapterId?: string;
+  preferredProvider?: string;
+  preferredSkillId?: string;
+};
+
+const TERMINAL: TaskState[] = ['completed', 'canceled', 'failed'];
+const MAX_TASKS = 1000;
+const activeWorkspaces = new Map<string, WorkspaceHandle>();
+const activeHandles = new Map<string, TaskHandle>();
+const previewStops = new Map<string, () => void>();
+const taskUnsubs = new Map<string, () => void>();
+const finalizingTasks = new Set<string>();
+
+function newId(prefix: string): string {
+  return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
+}
+
+function isTerminalTaskState(state: TaskState): boolean {
+  return TERMINAL.includes(state);
+}
+
+function readRoutingHints(value: unknown): RoutingHints {
+  if (!value || typeof value !== 'object') {
+    return {};
+  }
+
+  const source = value as Record<string, unknown>;
+  return {
+    preferredAdapterId:
+      typeof source.preferredAdapterId === 'string' ? source.preferredAdapterId : undefined,
+    preferredProvider:
+      typeof source.preferredProvider === 'string' ? source.preferredProvider : undefined,
+    preferredSkillId:
+      typeof source.preferredSkillId === 'string' ? source.preferredSkillId : undefined,
+  };
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function readObject(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
+}
+
+function readWorkspaceKind(value: unknown): WorkspaceKind | undefined {
+  return value === 'host' || value === 'worktree' || value === 'docker' ? value : undefined;
+}
+
+function workspaceMetadata(workspace: WorkspaceHandle, keepAfterCompletion?: boolean): WorkspaceMetadata {
+  return {
+    id: workspace.id,
+    kind: workspace.kind,
+    path: workspace.path,
+    baseRef: workspace.baseRef,
+    branchName: workspace.branchName,
+    keepAfterCompletion,
+  };
+}
+
+function evictOldestTerminalTask(): boolean {
+  for (const [taskId, task] of a2aTaskStore.entries()) {
+    if (!isTerminalTaskState(task.state)) continue;
+    const unsub = taskUnsubs.get(taskId);
+    if (unsub) {
+      unsub();
+      taskUnsubs.delete(taskId);
+    }
+    a2aTaskStore.delete(taskId);
+    return true;
+  }
+  return false;
+}
+
+async function finalizeTerminalTask(task: Task): Promise<void> {
+  if (finalizingTasks.has(task.id)) return;
+  finalizingTasks.add(task.id);
+
+  const stopPreview = previewStops.get(task.id);
+  if (stopPreview) {
+    stopPreview();
+    previewStops.delete(task.id);
+  }
+
+  const workspace = activeWorkspaces.get(task.id);
+  try {
+    if (workspace) {
+      const diff = await workspace.diff();
+      if (diff.trim()) {
+        a2aBus.publish({
+          kind: 'artifact',
+          taskId: task.id,
+          artifact: {
+            artifactId: newId('art'),
+            type: 'file-diff',
+            parts: [{ kind: 'text', text: diff }],
+            metadata: {
+              source: 'workspace-diff',
+              workspaceId: workspace.id,
+              workspaceKind: workspace.kind,
+              baseRef: workspace.baseRef,
+            },
+          },
+        });
+      }
+
+      const keepAfterCompletion = task.metadata?.workspace &&
+        typeof task.metadata.workspace === 'object' &&
+        readBoolean((task.metadata.workspace as Record<string, unknown>).keepAfterCompletion);
+      if (workspace.kind !== 'host' && keepAfterCompletion !== true) {
+        await workspace.destroy();
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    task.metadata = {
+      ...task.metadata,
+      workspaceFinalizationError: message,
+    };
+    task.updatedAt = Date.now();
+    a2aTaskStore.set(task);
+  } finally {
+    activeWorkspaces.delete(task.id);
+    activeHandles.delete(task.id);
+    const unsub = taskUnsubs.get(task.id);
+    if (unsub) {
+      unsub();
+      taskUnsubs.delete(task.id);
+    }
+    finalizingTasks.delete(task.id);
+  }
+}
+
+function attachBusToTask(task: Task): void {
+  if (taskUnsubs.has(task.id)) return;
+
+  const unsubscribe = a2aBus.subscribe(task.id, (event: BusEvent) => {
+    if (event.kind === 'task-state') {
+      task.state = event.state;
+      if (event.error) task.error = event.error;
+      task.updatedAt = Date.now();
+      a2aTaskStore.set(task);
+      if (isTerminalTaskState(event.state)) {
+        void finalizeTerminalTask(task);
+      }
+    } else if (event.kind === 'message') {
+      task.history.push(event.message);
+      task.updatedAt = Date.now();
+      a2aTaskStore.set(task);
+    } else if (event.kind === 'artifact') {
+      task.artifacts.push(event.artifact);
+      task.updatedAt = Date.now();
+      a2aTaskStore.set(task);
+    }
+  });
+  taskUnsubs.set(task.id, unsubscribe);
+}
+
+export function getA2ATask(taskId: string): Task | undefined {
+  return a2aTaskStore.get(taskId);
+}
+
+export function listA2AAgentCards() {
+  return adapterRegistry.agentCards();
+}
+
+export async function submitA2ATask(input: SubmitTaskInput): Promise<Task> {
+  const metadata = input.metadata as Record<string, unknown> | undefined;
+  const routing = readRoutingHints(metadata?.routing);
+  const adapter = adapterRegistry.resolve(input.adapterId, routing);
+  if (!adapter) {
+    throw new Error(`ADAPTER_NOT_FOUND: ${input.adapterId}`);
+  }
+
+  if (a2aTaskStore.size >= MAX_TASKS && !evictOldestTerminalTask()) {
+    throw new Error(`TASK_LIMIT: task store at capacity (${MAX_TASKS})`);
+  }
+
+  const userMessage: Message = input.message;
+  const task: Task = {
+    id: newId('task'),
+    contextId: input.contextId,
+    state: 'submitted',
+    history: [{ ...userMessage, taskId: '' }],
+    artifacts: [],
+    metadata: {
+      ...metadata,
+      adapterId: adapter.id,
+      adapterSelector: input.adapterId,
+    },
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+  task.history[0] = { ...userMessage, taskId: task.id };
+  a2aTaskStore.set(task);
+  attachBusToTask(task);
+
+  const workspaceOptions = (metadata?.workspace && typeof metadata.workspace === 'object'
+    ? metadata.workspace
+    : {}) as Record<string, unknown>;
+  let workspace: WorkspaceHandle;
+  try {
+    workspace = await workspaceManager.create({
+      taskId: task.id,
+      projectPath: readString(workspaceOptions.projectPath) ?? process.cwd(),
+      kind: readWorkspaceKind(workspaceOptions.kind) ?? readWorkspaceKind(metadata?.isolation),
+      baseRef: readString(workspaceOptions.baseRef) ?? readString(metadata?.baseRef) ?? 'HEAD',
+      keepAfterCompletion: readBoolean(workspaceOptions.keepAfterCompletion),
+      metadata: workspaceOptions,
+    });
+  } catch (err) {
+    const workspaceError = err instanceof WorkspaceError ? err : undefined;
+    a2aBus.publish({
+      kind: 'task-state',
+      taskId: task.id,
+      state: 'failed',
+      error: {
+        code: workspaceError?.code ?? 'WORKSPACE_CREATE_FAILED',
+        message: err instanceof Error ? err.message : String(err),
+        details: workspaceError?.details,
+      },
+    });
+    return a2aTaskStore.get(task.id) ?? task;
+  }
+
+  activeWorkspaces.set(task.id, workspace);
+  task.metadata = {
+    ...task.metadata,
+    workspace: workspaceMetadata(workspace, readBoolean(workspaceOptions.keepAfterCompletion)),
+  };
+  task.updatedAt = Date.now();
+  a2aTaskStore.set(task);
+
+  previewStops.set(
+    task.id,
+    portWatcher.watch({
+      taskId: task.id,
+      workspace,
+      onPort: (event) => {
+        const data: PreviewArtifactData = {
+          url: event.url,
+          proxiedUrl: `/preview/${event.port}/`,
+          port: event.port,
+          host: event.host,
+          processName: event.processName,
+          confidence: event.confidence,
+        };
+        a2aBus.publish({
+          kind: 'artifact',
+          taskId: task.id,
+          artifact: {
+            artifactId: newId('art'),
+            type: 'preview-url',
+            parts: [{ kind: 'data', data: { ...data } }],
+            metadata: {
+              source: 'port-watcher',
+              workspaceId: workspace.id,
+            },
+          },
+        });
+      },
+    }),
+  );
+
+  try {
+    const handle = await adapter.submitTask(task, {
+      cwd: workspace.path,
+      workspace,
+      model: readString(metadata?.model),
+      permissionMode: readString(metadata?.permissionMode),
+      permissionPolicy: readObject(metadata?.permissionPolicy) as PermissionPolicy | undefined,
+      permissionPolicyContext: readObject(metadata?.permissionPolicyContext) as PermissionPolicyContext | undefined,
+      toolsSettings: readObject(metadata?.toolsSettings),
+    });
+    activeHandles.set(task.id, handle);
+    handle.finished.finally(() => {
+      activeHandles.delete(task.id);
+    }).catch(() => undefined);
+  } catch (err) {
+    a2aBus.publish({
+      kind: 'task-state',
+      taskId: task.id,
+      state: 'failed',
+      error: {
+        code: 'ADAPTER_SUBMIT_FAILED',
+        message: err instanceof Error ? err.message : String(err),
+      },
+    });
+  }
+
+  return a2aTaskStore.get(task.id) ?? task;
+}
+
+export async function cancelA2ATask(taskId: string, adapterId?: string): Promise<Task | undefined> {
+  const task = a2aTaskStore.get(taskId);
+  if (!task) return undefined;
+
+  const handle = activeHandles.get(taskId);
+  if (handle) {
+    await handle.cancel();
+    return a2aTaskStore.get(taskId) ?? task;
+  }
+
+  const resolvedAdapterId = adapterId ?? readString(task.metadata?.adapterId);
+  const adapter = resolvedAdapterId ? adapterRegistry.resolve(resolvedAdapterId) : undefined;
+  if (adapter) {
+    await adapter.cancelTask(task.id);
+    return a2aTaskStore.get(task.id) ?? task;
+  }
+
+  a2aBus.publish({ kind: 'task-state', taskId: task.id, state: 'canceled' });
+  return a2aTaskStore.get(task.id) ?? task;
+}

package/server/modules/orchestration/index.ts

@@ -3,7 +3,6 @@
 // All cross-module consumers must import from here per
 // eslint.config.js boundaries rules.
 
-export { createHermesTaskRouter } 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';
@@ -31,7 +30,6 @@ export {
 } from './security/permission-policy.js';
 export { createOrchestrationTaskRouter } from './tasks/orchestration-task.routes.js';
 export { orchestrationTaskService } from './tasks/orchestration-task.service.js';
-export { createHermesRouter } from './hermes/hermes.routes.js';
 export { createWorkflowRouter } from './workflows/workflow.routes.js';
 export {
   listPendingApprovals,

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

@@ -20,8 +20,8 @@ export class OrchestrationTaskStore {
     return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.id === id) ?? undefined;
   }
 
-  getByHermesTaskId(hermesTaskId: string): OrchestrationTask | undefined {
-    return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.hermesTaskId === hermesTaskId) ?? undefined;
+  getByA2ATaskId(a2aTaskId: string): OrchestrationTask | undefined {
+    return this.store.findWhere('orchestration_tasks', (r: OrchestrationTask) => r.a2aTaskId === a2aTaskId) ?? undefined;
   }
 
   list(projectId?: string): OrchestrationTask[] {

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

@@ -1,5 +1,9 @@
 import express, { type Router } from 'express';
 
+import {
+  getA2ATask,
+  listA2AAgentCards,
+} from '@/modules/orchestration/a2a/task-dispatcher.js';
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 
 export function createOrchestrationTaskRouter(): Router {
@@ -11,6 +15,19 @@ export function createOrchestrationTaskRouter(): Router {
     res.json({ tasks: orchestrationTaskService.list(projectId) });
   });
 
+  router.get('/agents', (_req, res) => {
+    res.json({ agents: listA2AAgentCards() });
+  });
+
+  router.get('/agent-tasks/:id', (req, res) => {
+    const task = getA2ATask(req.params.id);
+    if (!task) {
+      res.status(404).json({ error: { code: 'TASK_NOT_FOUND', message: req.params.id } });
+      return;
+    }
+    res.json(task);
+  });
+
   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() : '';

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

@@ -1,6 +1,7 @@
 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 { submitA2ATask } from '@/modules/orchestration/a2a/task-dispatcher.js';
 import type { TaskState } from '@/modules/orchestration/a2a/types.js';
 import type { WorkflowNodeRun, WorkflowRun } from '@/modules/orchestration/workflows/workflow.types.js';
 
@@ -93,35 +94,26 @@ class OrchestrationTaskService {
     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'}/hermes/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',
-          model: input.model,
-          permissionMode: input.permissionMode,
-          workspace: {
-            kind: input.isolation ?? 'worktree',
-            projectPath: input.projectPath,
-          },
-          orchestrationTaskId: task.id,
+    const a2aTask = await submitA2ATask({
+      adapterId: input.adapterId,
+      message: {
+        messageId: newId('msg'),
+        role: 'user',
+        parts: [{ kind: 'text', text: `${task.title}\n\n${task.description ?? ''}` }],
+      },
+      metadata: {
+        isolation: input.isolation ?? 'worktree',
+        model: input.model,
+        permissionMode: input.permissionMode,
+        workspace: {
+          kind: input.isolation ?? 'worktree',
+          projectPath: input.projectPath,
         },
-      }),
+        orchestrationTaskId: task.id,
+      },
     });
 
-    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.hermesTaskId = body.id;
+    task.a2aTaskId = a2aTask.id;
     task.adapterId = input.adapterId;
     task.adapterSelector = input.adapterId;
     task.workspaceKind = input.isolation ?? 'worktree';
@@ -181,7 +173,7 @@ class OrchestrationTaskService {
       if (event.kind !== 'task-state') return;
       if (!TERMINAL_A2A_STATES.includes(event.state)) return;
 
-      const orchTask = this.store.getByHermesTaskId(event.taskId);
+      const orchTask = this.store.getByA2ATaskId(event.taskId);
       if (!orchTask) return;
       if (orchTask.state === 'done' || orchTask.state === 'failed' || orchTask.state === 'canceled') return;
 

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

@@ -2,7 +2,7 @@ export type OrchestrationTaskState = 'todo' | 'in_progress' | 'in_review' | 'don
 
 export interface OrchestrationTask {
   id: string;
-  hermesTaskId?: string;
+  a2aTaskId?: string;
   workflowRunIds?: string[];
   projectId: string;
   title: string;
@@ -12,7 +12,7 @@ export interface OrchestrationTask {
     id: string;
     label: string;
     status: 'pending' | 'passed' | 'failed';
-    source: 'workflow' | 'hermes';
+    source: 'workflow' | 'agent';
   }>;
   changedFiles?: string[];
   adapterId?: string;

package/server/modules/orchestration/tasks/task-run-graph.ts

@@ -11,7 +11,7 @@ export interface TaskRunGraphCriterion {
   id: string;
   label: string;
   status: TaskRunGraphCriterionStatus;
-  source: 'workflow' | 'hermes';
+  source: 'workflow' | 'agent';
 }
 
 export interface TaskRunGraphRunSummary {