@pixelbyte-software/pixcode 1.52.4 → 1.53.1

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

@@ -36,6 +36,11 @@ import {
 } from '@/modules/orchestration/workflows/workspace-target.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
+import {
+  cancelA2ATask,
+  getA2ATask,
+  submitA2ATask,
+} from '@/modules/orchestration/a2a/task-dispatcher.js';
 // @ts-ignore — plain-JS service
 import {
   getDefaultProviderModel,
@@ -101,10 +106,6 @@ function newId(prefix: string): string {
   return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
 }
 
-function localHermesBaseUrl(): string {
-  return `http://127.0.0.1:${process.env.SERVER_PORT ?? process.env.PORT ?? '3001'}/hermes`;
-}
-
 function validateWorkflow(workflow: Workflow): void {
   if (workflow.nodes.length > 64) {
     throw new Error('Workflow node limit exceeded.');
@@ -133,6 +134,7 @@ type TaskResult = {
 };
 
 type RawTask = {
+  id: string;
   state?: string;
   error?: { code?: string; message?: string };
   history?: Array<{ role?: string; parts?: Array<{ kind?: string; text?: string; data?: Record<string, unknown> }> }>;
@@ -505,7 +507,7 @@ function handoffPrompt(agent: AgentAssignment, role: AgentRole): string {
   return [
     `You are ${agent.label} in a Pixcode CLI team.`,
     `Your inferred stage is: ${role}.`,
-    'This is a bounded Hermes handoff task, not the full implementation.',
+    'This is a bounded Pixcode handoff task, not the full implementation.',
     'Read the original user goal and coordinator plan, then publish a compact contract for downstream agents.',
     agent.instruction ? `Your explicit assignment from the user is: ${agent.instruction}` : '',
     handoffArtifactInstructions('ready'),
@@ -1102,10 +1104,6 @@ function expandWorkflowForRun(workflow: Workflow, metadata?: Record<string, unkn
   };
 }
 
-async function cancelHermesTask(taskId: string): Promise<void> {
-  await fetch(`${localHermesBaseUrl()}/tasks/${taskId}/cancel`, { method: 'POST' }).catch(() => undefined);
-}
-
 function readTaskResult(task: RawTask): TaskResult {
   const messages = (task.history ?? []).map((message) => ({
     role: typeof message.role === 'string' ? message.role : 'agent',
@@ -1156,8 +1154,10 @@ async function waitForTask(
     if (deadline && Date.now() >= deadline) {
       throw new WorkflowNodeTimeoutError(timeout ?? 0);
     }
-    const response = await fetch(`${localHermesBaseUrl()}/tasks/${taskId}`);
-    const task = await response.json() as RawTask;
+    const task = getA2ATask(taskId);
+    if (!task) {
+      throw new Error(`Agent task ${taskId} was not found.`);
+    }
     const snapshot = readTaskResult(task);
     onSnapshot?.(snapshot);
     if (task.state && TERMINAL.has(task.state)) {
@@ -1307,13 +1307,13 @@ class WorkflowRunner {
 
     this.cancelingRuns.add(run.id);
     const taskIds = run.nodeRuns
-      .filter((node) => node.hermesTaskId && (node.status === 'running' || node.status === 'queued'))
-      .map((node) => node.hermesTaskId as string);
+      .filter((node) => node.a2aTaskId && (node.status === 'running' || node.status === 'queued'))
+      .map((node) => node.a2aTaskId as string);
 
     this.markCanceled(run);
     workflowStore.setRun(run);
 
-    await Promise.all(taskIds.map((taskId) => cancelHermesTask(taskId)));
+    await Promise.all(taskIds.map((taskId) => cancelA2ATask(taskId)));
 
     return workflowStore.getRun(run.id) ?? run;
   }
@@ -1836,52 +1836,44 @@ class WorkflowRunner {
       }
       throw new Error(permissionDecision.message);
     }
-    let body: { id?: string; error?: { message?: string } };
+    let submittedTask: RawTask;
     try {
-      const submit = await fetch(`${localHermesBaseUrl()}/tasks`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          adapterId: node.adapterId,
-          contextId: run.contextId,
-          message: {
-            messageId: newId('msg'),
-            role: 'user',
-            parts: [{ kind: 'text', text: prompt }],
-          },
-          metadata: {
-            workflowRunId: run.id,
-            workflowNodeId: node.id,
-            agentInstanceId: node.agentInstanceId,
+      submittedTask = await submitA2ATask({
+        adapterId: node.adapterId,
+        contextId: run.contextId,
+        message: {
+          messageId: newId('msg'),
+          role: 'user',
+          parts: [{ kind: 'text', text: prompt }],
+        },
+        metadata: {
+          workflowRunId: run.id,
+          workflowNodeId: node.id,
+          agentInstanceId: node.agentInstanceId,
+          agentLabel: node.agentLabel,
+          assignment: node.assignment,
+          model: effectiveModel,
+          permissionMode: effectivePermissionMode,
+          permissionPolicy,
+          permissionPolicyContext: {
+            runId: run.id,
+            nodeId: node.id,
+            workflowId: run.workflowId,
+            adapterId: node.adapterId,
             agentLabel: node.agentLabel,
-            assignment: node.assignment,
-            model: effectiveModel,
-            permissionMode: effectivePermissionMode,
-            permissionPolicy,
-            permissionPolicyContext: {
-              runId: run.id,
-              nodeId: node.id,
-              workflowId: run.workflowId,
-              adapterId: node.adapterId,
-              agentLabel: node.agentLabel,
-              userId: readNotificationUserId(run.metadata),
-            },
-            toolsSettings: node.toolsSettings,
+            userId: readNotificationUserId(run.metadata),
+          },
+          toolsSettings: node.toolsSettings,
+          projectPath,
+          workspaceTarget: workspaceTargetMetadata(workspaceTarget),
+          workspace: {
+            kind: isolation,
             projectPath,
-            workspaceTarget: workspaceTargetMetadata(workspaceTarget),
-            workspace: {
-              kind: isolation,
-              projectPath,
-              baseRef,
-              keepAfterCompletion,
-            },
+            baseRef,
+            keepAfterCompletion,
           },
-        }),
+        },
       });
-      body = await submit.json() as { id?: string; error?: { message?: string } };
-      if (!submit.ok || !body.id) {
-        throw new Error(body.error?.message ?? `Workflow node ${node.id} submit failed.`);
-      }
     } catch (error) {
       nodeRun.finishedAt = Date.now();
       nodeRun.status = 'failed';
@@ -1910,11 +1902,11 @@ class WorkflowRunner {
       }
       throw error;
     }
-    nodeRun.hermesTaskId = body.id;
+    nodeRun.a2aTaskId = submittedTask.id;
     workflowStore.setRun(run);
 
     if (this.isCanceling(run.id)) {
-      await cancelHermesTask(body.id);
+      await cancelA2ATask(submittedTask.id);
       nodeRun.status = 'canceled';
       nodeRun.finishedAt = Date.now();
       workflowStore.setRun(run);
@@ -1924,7 +1916,7 @@ class WorkflowRunner {
     let result: TaskResult;
     try {
       result = await waitForTask(
-        body.id,
+        submittedTask.id,
         () => this.isCanceling(run.id),
         (snapshot) => {
           nodeRun.outputText = snapshot.text || nodeRun.outputText;
@@ -1940,7 +1932,7 @@ class WorkflowRunner {
         throw error;
       }
 
-      await cancelHermesTask(body.id);
+      await cancelA2ATask(submittedTask.id);
       nodeRun.finishedAt = Date.now();
       nodeRun.status = 'failed';
       nodeRun.error = error.message;
@@ -2037,7 +2029,7 @@ class WorkflowRunner {
     }
 
     nodeRun.status = 'failed';
-    nodeRun.error = result.error ?? `Hermes task ended with ${result.state}`;
+    nodeRun.error = result.error ?? `Agent task ended with ${result.state}`;
     workflowStore.setRun(run);
     if (isExternalDirectoryPermissionError(`${nodeRun.error}\n${nodeRun.outputText ?? ''}`)) {
       completeNodeWithPermissionFallback(nodeRun, node, outputs, completed, nodeRun.error, workspaceTarget);

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

@@ -333,7 +333,7 @@ export function buildWorkflowTrace(run: WorkflowRun): WorkflowTraceEvent[] {
         id: traceId([run.id, node.nodeId, 'provider']),
         type: 'provider',
         severity: node.status === 'failed' ? 'error' : 'info',
-        status: node.hermesTaskId ? 'submitted' : node.status,
+        status: node.a2aTaskId ? 'submitted' : node.status,
         timestamp: timestamp + 2,
         durationMs: nodeDuration,
         ...base,
@@ -341,7 +341,7 @@ export function buildWorkflowTrace(run: WorkflowRun): WorkflowTraceEvent[] {
         titleKey: 'workflow.trace.providerCall',
         summary: [node.adapterId, node.model].filter(Boolean).join(' / '),
         metadata: {
-          hermesTaskId: node.hermesTaskId,
+          a2aTaskId: node.a2aTaskId,
           permissionMode: node.permissionMode,
           timeoutMs: node.timeoutMs,
         },

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

@@ -58,7 +58,7 @@ export interface WorkflowNodeRun {
   fallbackTrigger?: WorkflowFallbackTrigger;
   fallbackSourceNodeId?: string;
   status: WorkflowNodeStatus;
-  hermesTaskId?: string;
+  a2aTaskId?: string;
   startedAt?: number;
   finishedAt?: number;
   error?: string;

package/server/routes/git.js

@@ -380,6 +380,27 @@ function normalizeRepositoryRelativeFilePath(filePath) {
     .trim();
 }
 
+function normalizeRequestedRepositoryFilePath(repositoryRootPath, filePath) {
+  const rawFilePath = String(filePath || '').replace(/\\/g, '/').trim();
+  if (!rawFilePath) {
+    return '';
+  }
+
+  if (path.isAbsolute(rawFilePath)) {
+    const resolvedFilePath = path.resolve(rawFilePath);
+    const resolvedRepositoryRoot = path.resolve(repositoryRootPath);
+    const relativePath = path.relative(resolvedRepositoryRoot, resolvedFilePath);
+
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+      throw new Error('Invalid file path: outside repository');
+    }
+
+    return normalizeRepositoryRelativeFilePath(relativePath);
+  }
+
+  return normalizeRepositoryRelativeFilePath(rawFilePath);
+}
+
 function parseStatusFilePaths(statusOutput) {
   return statusOutput
     .split('\n')
@@ -394,7 +415,7 @@ function parseStatusFilePaths(statusOutput) {
 }
 
 function buildFilePathCandidates(projectPath, repositoryRootPath, filePath) {
-  const normalizedFilePath = normalizeRepositoryRelativeFilePath(filePath);
+  const normalizedFilePath = normalizeRequestedRepositoryFilePath(repositoryRootPath, filePath);
   const projectRelativePath = normalizeRepositoryRelativeFilePath(path.relative(repositoryRootPath, projectPath));
   const candidates = [normalizedFilePath];
 
@@ -629,53 +650,93 @@ router.get('/file-with-diff', async (req, res) => {
       repositoryRelativeFilePath,
     } = await resolveRepositoryFilePath(projectPath, file);
 
+    const readFileFromIndex = async () => {
+      const { stdout } = await spawnAsync(
+        'git',
+        ['show', `:${repositoryRelativeFilePath}`],
+        { cwd: repositoryRootPath },
+      );
+      return stdout;
+    };
+    const readFileFromHead = async () => {
+      const { stdout } = await spawnAsync(
+        'git',
+        ['show', `HEAD:${repositoryRelativeFilePath}`],
+        { cwd: repositoryRootPath },
+      );
+      return stdout;
+    };
+
     // Check file status
     const { stdout: statusOutput } = await spawnAsync(
       'git',
       ['status', '--porcelain', '--', repositoryRelativeFilePath],
       { cwd: repositoryRootPath },
     );
-    const isUntracked = statusOutput.startsWith('??');
-    const isDeleted = statusOutput.trim().startsWith('D ') || statusOutput.trim().startsWith(' D');
+    const statusLine = statusOutput.split('\n').find((line) => line.trim()) || '';
+    const indexStatus = statusLine[0] || ' ';
+    const worktreeStatus = statusLine[1] || ' ';
+    const isUntracked = statusLine.startsWith('??');
+    const hasUnstagedChange = !isUntracked && worktreeStatus !== ' ';
+    const hasStagedChange = !isUntracked && indexStatus !== ' ';
+    const isDeleted = worktreeStatus === 'D' || (!hasUnstagedChange && indexStatus === 'D');
 
     let currentContent = '';
     let oldContent = '';
 
-    if (isDeleted) {
-      // For deleted files, get content from HEAD
-      const { stdout: headContent } = await spawnAsync(
-        'git',
-        ['show', `HEAD:${repositoryRelativeFilePath}`],
-        { cwd: repositoryRootPath },
-      );
-      oldContent = headContent;
-      currentContent = headContent; // Show the deleted content in editor
-    } else {
-      // Get current file content
+    if (hasUnstagedChange) {
+      try {
+        oldContent = await readFileFromIndex();
+      } catch {
+        oldContent = '';
+      }
+
+      if (worktreeStatus === 'D') {
+        currentContent = '';
+      } else {
+        const filePath = path.join(repositoryRootPath, repositoryRelativeFilePath);
+        const stats = await fs.stat(filePath);
+        if (stats.isDirectory()) {
+          return res.status(400).json({ error: 'Cannot show diff for directories' });
+        }
+        currentContent = await fs.readFile(filePath, 'utf-8');
+      }
+    } else if (hasStagedChange) {
+      try {
+        oldContent = await readFileFromHead();
+      } catch {
+        // A staged add has no HEAD copy; showing the whole file as added is correct.
+        oldContent = '';
+      }
+
+      if (indexStatus === 'D') {
+        currentContent = '';
+      } else {
+        try {
+          currentContent = await readFileFromIndex();
+        } catch {
+          currentContent = '';
+        }
+      }
+    } else if (isUntracked) {
       const filePath = path.join(repositoryRootPath, repositoryRelativeFilePath);
       const stats = await fs.stat(filePath);
 
       if (stats.isDirectory()) {
-        // Cannot show content for directories
         return res.status(400).json({ error: 'Cannot show diff for directories' });
       }
 
       currentContent = await fs.readFile(filePath, 'utf-8');
+    } else {
+      const filePath = path.join(repositoryRootPath, repositoryRelativeFilePath);
+      const stats = await fs.stat(filePath);
 
-      if (!isUntracked) {
-        // Get the old content from HEAD for tracked files
-        try {
-          const { stdout: headContent } = await spawnAsync(
-            'git',
-            ['show', `HEAD:${repositoryRelativeFilePath}`],
-            { cwd: repositoryRootPath },
-          );
-          oldContent = headContent;
-        } catch (error) {
-          // File might be newly added to git (staged but not committed)
-          oldContent = '';
-        }
+      if (stats.isDirectory()) {
+        return res.status(400).json({ error: 'Cannot show diff for directories' });
       }
+
+      currentContent = await fs.readFile(filePath, 'utf-8');
+      oldContent = currentContent;
     }
 
     res.json({

package/server/services/public-api-manifest.js

@@ -4,7 +4,6 @@ const API_GROUPS = [
   { id: 'sessions', title: 'Sessions and messages', basePath: '/api/sessions', scopes: ['sessions:read', 'sessions:write'] },
   { id: 'providers', title: 'CLI providers', basePath: '/api/providers', scopes: ['providers:read', 'providers:write'] },
   { id: 'terminal', title: 'Visible terminal sessions', basePath: '/api/shell/sessions', scopes: ['terminal:launch'] },
-  { id: 'hermes', title: 'Hermes Agent control', basePath: '/api/orchestration/hermes', scopes: ['hermes:mcp', 'hermes:gateway', 'terminal:launch'] },
   { id: 'orchestration', title: 'Orchestration runs', basePath: '/api/orchestration', scopes: ['orchestration:read', 'orchestration:write'] },
   { id: 'notifications', title: 'Notifications', basePath: '/api/settings/notifications', scopes: ['notifications:read', 'notifications:write'] },
   { id: 'files', title: 'Files', basePath: '/api/projects/:projectName/files', scopes: ['files:read', 'files:write'] },
@@ -46,10 +45,6 @@ export function buildPublicApiManifest({ baseUrl = '' } = {}) {
         title: 'Fetch diagnostics bundle',
         curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/diagnostics/bundle`,
       },
-      {
-        title: 'Read Hermes control plane',
-        curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/orchestration/hermes/control-plane`,
-      },
       {
         title: 'Read the mobile remote control room',
         curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/remote/control-room`,
@@ -139,10 +134,6 @@ export function buildCurlCookbook({ baseUrl = '' } = {}) {
         title: 'List pending approvals',
         command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/orchestration/workflows/approvals"`,
       },
-      {
-        title: 'Read Hermes control plane',
-        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/orchestration/hermes/control-plane"`,
-      },
       {
         title: 'Approve a pending action',
         command: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: $PIXCODE_API_KEY" -d '{"allow":true,"source":"api"}' "$PIXCODE_URL/api/orchestration/workflows/approvals/approval_id"`,