@pixelbyte-software/pixcode 1.49.1 → 1.49.3

package/scripts/smoke/hermes-api-install.mjs

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+const read = (relativePath) => fs.readFileSync(path.join(repoRoot, relativePath), 'utf8');
+
+const hermesRoutes = read('server/modules/orchestration/hermes/hermes.routes.ts');
+const hermesInstallJobs = fs.existsSync(path.join(repoRoot, 'server/services/hermes-install-jobs.js'))
+  ? read('server/services/hermes-install-jobs.js')
+  : '';
+const workbench = read('src/components/vscode-workbench/view/VSCodeWorkbench.tsx');
+const serverIndex = read('server/index.js');
+const smoke = read('scripts/smoke/pixcode-workbench-1-48.mjs');
+
+assert.match(hermesRoutes, /createHermesInstallJob/, 'Hermes API should start backend install jobs.');
+assert.match(hermesRoutes, /router\.post\('\/install'/, 'Hermes should expose POST /api/orchestration/hermes/install.');
+assert.match(hermesRoutes, /router\.get\('\/install\/:jobId\/stream'/, 'Hermes install jobs should expose an EventSource stream.');
+assert.match(hermesRoutes, /router\.delete\('\/install\/:jobId'/, 'Hermes install jobs should be cancellable.');
+assert.match(hermesInstallJobs, /downloadHermesInstaller/, 'Hermes installer should be downloaded by backend code, not pasted into the terminal.');
+assert.match(hermesInstallJobs, /--skip-setup/, 'POSIX Hermes API install should skip the interactive setup wizard.');
+assert.match(hermesInstallJobs, /--skip-browser/, 'Hermes API install should skip browser downloads by default for reliable headless installs.');
+assert.doesNotMatch(hermesInstallJobs, /curl -fsSL .* \| bash/, 'Hermes API install must not pipe curl directly into bash.');
+assert.match(workbench, /\/api\/orchestration\/hermes\/install/, 'Workbench Hermes install button should call the Hermes install API.');
+assert.doesNotMatch(workbench, /HERMES_AGENT_INSTALL_COMMAND/, 'Workbench should not launch Hermes install through a terminal command.');
+assert.match(hermesInstallJobs, /formatHermesVersionOutput/, 'Hermes install status should collapse multi-line --version output before showing it in UI badges.');
+assert.match(hermesInstallJobs, /repairHermesCommandLaunchers/, 'Hermes installer should repair stale or text launcher shims after install/status checks.');
+assert.match(hermesInstallJobs, /hermes\.cmd/, 'Windows Hermes repair should create or prefer a hermes.cmd shim so typing hermes does not open the Python launcher as text.');
+assert.match(hermesInstallJobs, /isUsableHermesCommand/, 'Hermes status should verify candidates before treating them as installed.');
+assert.match(serverIndex, /Test-HermesCommand/, 'Hermes terminal start should verify a resolved command before running it.');
+assert.doesNotMatch(serverIndex, /if command -v hermes >\/dev\/null 2>&1; then command -v hermes; return 0; fi;/, 'POSIX Hermes start must not accept a stale PATH shim without testing it.');
+assert.match(workbench, /HermesActivityButton/, 'Workbench activity rail should expose a dedicated Hermes H button under Terminal.');
+assert.match(workbench, /installLogRef/, 'Hermes install log panel should keep a scroll ref.');
+assert.match(workbench, /scrollTop = installLogRef\.current\.scrollHeight/, 'Hermes install logs should auto-scroll to the latest line.');
+assert.match(workbench, /suspendAutoConnect/, 'Right CLI auto-connect should be suspendable while Hermes opens in the bottom terminal.');
+assert.match(smoke, /hermes-api-install\.mjs/, 'Main workbench smoke should mention the dedicated Hermes API install smoke.');
+
+console.log('hermes API install smoke passed');

package/scripts/smoke/pixcode-workbench-1-48.mjs

@@ -13,6 +13,7 @@ const settingsSidebar = read('src/components/settings/view/SettingsSidebar.tsx')
 const settingsMainTabs = read('src/components/settings/view/SettingsMainTabs.tsx');
 const settingsTypes = read('src/components/settings/types/types.ts');
 const settingsController = read('src/components/settings/hooks/useSettingsController.ts');
+const settings = read('src/components/settings/view/Settings.tsx');
 const app = read('src/App.tsx');
 const serverIndex = read('server/index.js');
 const hermesRoutes = read('server/modules/orchestration/hermes/hermes.routes.ts');
@@ -104,12 +105,17 @@ assert.doesNotMatch(serverIndex, /app\.use\('\/a2a'/, 'Server should not expose
 assert.match(hermesRoutes, /createHermesRouter/, 'Hermes should have a dedicated orchestration API router.');
 assert.match(hermesRoutes, /terminal-launches/, 'Hermes MCP should be able to request visible Pixcode CLI terminal launches.');
 assert.match(hermesRoutes, /install-status/, 'Hermes settings and terminal UI should have an install-status endpoint.');
+assert.match(hermesRoutes, /router\.post\('\/install'/, 'Hermes should install through the backend API instead of terminal command paste.');
+assert.match(read('scripts/smoke/hermes-api-install.mjs'), /hermes API install smoke passed/, 'Hermes API install behavior should have a focused smoke test.');
 assert.match(serverIndex, /forceNewSession/, 'Shell backend should support explicit fresh-session launches from the workbench.');
 assert.match(serverIndex, /killProviderPtySessions/, 'Shell backend should terminate old provider PTYs when a fresh CLI session is requested.');
 
-assert.match(settingsTypes, /'hermes'/, 'Settings Agents should support Hermes Agent as a first-class agent.');
-assert.match(agentSettings, /'hermes'/, 'Settings Agents should list Hermes Agent.');
+assert.match(settingsTypes, /'hermes'/, 'Settings should support Hermes Agent as a first-class tab.');
+assert.match(settingsSidebar, /id: 'hermes'/, 'Settings sidebar should show Hermes Agent as its own page instead of hiding it at the end of Agents.');
+assert.match(settings, /<HermesSettingsTab/, 'Settings should render the dedicated Hermes Agent page.');
+assert.doesNotMatch(agentSettings, /'hermes'/, 'Settings Agents picker should not bury Hermes Agent at the end of the provider list.');
 assert.match(workbench, /hermesInstallStatus/, 'Workbench should hide Hermes install actions when Hermes is already installed.');
+assert.match(workbench, /HermesActivityButton/, 'Workbench activity rail should include a dedicated Hermes launcher button.');
 assert.match(shellConnection, /cursor-tools-settings/, 'Cursor shell launches should read Cursor permission settings, not Claude settings.');
 assert.match(shellConnection, /permissionMode/, 'Shell websocket init should send provider permission mode to the backend.');
 assert.match(serverIndex, /--dangerously-bypass-approvals-and-sandbox/, 'Codex terminal bypass mode should use the Codex CLI bypass flag.');

package/server/index.js

@@ -432,16 +432,32 @@ function buildHermesShellCommand(kind, env) {
             `$env:PIXCODE_APP_ROOT=${quote(env.PIXCODE_APP_ROOT)}`,
         ].join('; ');
         const resolveHermesCommand = [
+            'function Test-HermesCommand($candidate) {',
+            'if (-not $candidate) { return $false; }',
+            'try {',
+            '& $candidate --version *> $null;',
+            'return $LASTEXITCODE -eq 0;',
+            '} catch { return $false; }',
+            '}',
             'function Resolve-HermesCommand {',
-            '$cmd = Get-Command hermes -ErrorAction SilentlyContinue;',
-            'if ($cmd) { return $cmd.Source; }',
             '$candidates = @(',
             '$env:HERMES_CLI_PATH,',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\bin\\hermes.cmd"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\bin\\hermes.bat"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\bin\\hermes.exe"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\venv\\Scripts\\hermes.cmd"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\venv\\Scripts\\hermes.bat"),',
             '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\venv\\Scripts\\hermes.exe"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\.venv\\Scripts\\hermes.cmd"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\.venv\\Scripts\\hermes.bat"),',
             '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\.venv\\Scripts\\hermes.exe"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\hermes.cmd"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\hermes.bat"),',
             '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\hermes.exe")',
             ');',
-            'foreach ($candidate in $candidates) { if ($candidate -and (Test-Path $candidate)) { return $candidate; } }',
+            'foreach ($candidate in $candidates) { if ($candidate -and (Test-Path $candidate) -and (Test-HermesCommand $candidate)) { return $candidate; } }',
+            '$cmd = Get-Command hermes -ErrorAction SilentlyContinue;',
+            'if ($cmd -and (Test-HermesCommand $cmd.Source)) { return $cmd.Source; }',
             'return $null;',
             '}',
         ].join(' ');
@@ -470,23 +486,24 @@ function buildHermesShellCommand(kind, env) {
         `PIXCODE_APP_ROOT=${quote(env.PIXCODE_APP_ROOT)}`,
     ].join(' ');
     const resolveHermesCommand = [
+        'testHermesCommand() {',
+        '[ -n "$1" ] && [ -x "$1" ] && "$1" --version >/dev/null 2>&1;',
+        '}',
         'resolveHermesCommand() {',
-        'if command -v hermes >/dev/null 2>&1; then command -v hermes; return 0; fi;',
-        'if [ -n "${HERMES_CLI_PATH:-}" ] && [ -x "$HERMES_CLI_PATH" ]; then printf "%s\\n" "$HERMES_CLI_PATH"; return 0; fi;',
-        'if [ -x "$HOME/.local/bin/hermes" ]; then printf "%s\\n" "$HOME/.local/bin/hermes"; return 0; fi;',
-        'if [ -x "$HOME/.hermes/hermes-agent/venv/bin/hermes" ]; then printf "%s\\n" "$HOME/.hermes/hermes-agent/venv/bin/hermes"; return 0; fi;',
-        'if [ -x "/usr/local/bin/hermes" ]; then printf "%s\\n" "/usr/local/bin/hermes"; return 0; fi;',
+        'for candidate in "${HERMES_CLI_PATH:-}" "$HOME/.local/bin/hermes" "$HOME/.hermes/hermes-agent/venv/bin/hermes" "$HOME/.hermes/hermes-agent/.venv/bin/hermes" "/usr/local/bin/hermes" "/usr/local/lib/hermes-agent/venv/bin/hermes"; do',
+        'if testHermesCommand "$candidate"; then printf "%s\\n" "$candidate"; return 0; fi;',
+        'done;',
+        'candidate="$(command -v hermes 2>/dev/null || true)";',
+        'if testHermesCommand "$candidate"; then printf "%s\\n" "$candidate"; return 0; fi;',
         'return 1;',
         '}',
     ].join(' ');
-    const install = 'curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash';
     const installHermesIfMissing = [
         'installHermesIfMissing() {',
         'HERMES_CMD="$(resolveHermesCommand 2>/dev/null || true)";',
         'if [ -n "$HERMES_CMD" ]; then echo "Hermes already installed:"; "$HERMES_CMD" --version 2>/dev/null || true; return 0; fi;',
-        `${install};`,
-        'HERMES_CMD="$(resolveHermesCommand 2>/dev/null || true)";',
-        'if [ -z "$HERMES_CMD" ]; then echo "Hermes installed, but the hermes command could not be found. Reload PATH and retry." >&2; exit 127; fi;',
+        'echo "Hermes is not installed. Use Pixcode Settings > Hermes Agent > Install or repair, then start again." >&2;',
+        'exit 127;',
         '}',
     ].join(' ');
     if (kind === 'pixcode:hermes:install') {
@@ -651,7 +668,11 @@ adapterRegistry.register(new OpenCodeA2AAdapter());
 app.use('/hermes', createHermesTaskRouter());
 app.use('/preview', authenticateToken, createPreviewProxyRouter());
 app.use('/api/orchestration', authenticateToken, createOrchestrationTaskRouter());
-app.use('/api/orchestration/hermes', authenticateToken, createHermesRouter());
+app.use('/api/orchestration/hermes', authenticateToken, createHermesRouter({
+    appRoot: APP_ROOT,
+    createHermesApiKey: getOrCreateHermesApiKey,
+    resolvePublicBaseUrl,
+}));
 app.use('/api/orchestration', authenticateToken, createWorkflowRouter());
 app.use('/live', createLiveViewPublicRouter());
 

package/server/modules/orchestration/hermes/hermes.routes.ts

@@ -1,12 +1,16 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
 
-import express, { type Router } from 'express';
+import express, { type Request, type Response, type Router } from 'express';
 
 import { adapterRegistry } from '@/modules/orchestration/a2a/adapter-registry.js';
 import { a2aTaskStore as hermesTaskStore } from '@/modules/orchestration/a2a/task-store.js';
+import {
+  cancelHermesInstallJob,
+  createHermesInstallJob,
+  getHermesInstallJob,
+  readHermesInstallStatus,
+  snapshotHermesInstallDonePayload,
+} from '@/services/hermes-install-jobs.js';
 
 const HERMES_TERMINAL_LAUNCH_LIMIT = 100;
 const HERMES_TERMINAL_LAUNCH_PROVIDERS = new Set(['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode']);
@@ -20,67 +24,32 @@ type HermesTerminalLaunchEvent = {
   createdAt: string;
 };
 
+type HermesRouterOptions = {
+  appRoot?: string;
+  createHermesApiKey?: (userId: number | string | null | undefined) => string | null;
+  resolvePublicBaseUrl?: (req: Request) => string;
+};
+
+type PixcodeRequest = Request & {
+  user?: {
+    id?: number | string;
+    userId?: number | string;
+  };
+};
+
 let nextHermesTerminalLaunchId = 1;
 const hermesTerminalLaunches: HermesTerminalLaunchEvent[] = [];
 
-function hermesCommandCandidates(): string[] {
-  const candidates = [process.env.HERMES_CLI_PATH, 'hermes'].filter((candidate): candidate is string => (
-    typeof candidate === 'string' && candidate.trim().length > 0
-  ));
-
-  if (process.platform === 'win32') {
-    const localAppData = process.env.LOCALAPPDATA;
-    if (localAppData) {
-      candidates.push(
-        path.join(localAppData, 'hermes', 'hermes-agent', 'venv', 'Scripts', 'hermes.exe'),
-        path.join(localAppData, 'hermes', 'hermes-agent', '.venv', 'Scripts', 'hermes.exe'),
-        path.join(localAppData, 'hermes', 'hermes-agent', 'hermes.exe'),
-      );
-    }
-  } else {
-    candidates.push(
-      path.join(os.homedir(), '.local', 'bin', 'hermes'),
-      path.join(os.homedir(), '.hermes', 'hermes-agent', 'venv', 'bin', 'hermes'),
-      '/usr/local/bin/hermes',
-    );
-  }
-
-  return [...new Set(candidates)];
+function writeSse(res: Response, event: string, payload: unknown) {
+  res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
 }
 
-function readHermesInstallStatus() {
-  for (const candidate of hermesCommandCandidates()) {
-    const isBareCommand = candidate === 'hermes';
-    if (!isBareCommand && !existsSync(candidate)) {
-      continue;
-    }
-
-    const result = spawnSync(candidate, ['--version'], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: 5000,
-      shell: false,
-    });
-    if (!result.error && result.status === 0) {
-      const version = `${result.stdout || result.stderr || ''}`.trim() || null;
-      return {
-        installed: true,
-        command: candidate,
-        version,
-        error: null,
-      };
-    }
-  }
-
-  return {
-    installed: false,
-    command: null,
-    version: null,
-    error: 'Hermes Agent CLI is not installed or is not on PATH.',
-  };
+function readUserId(req: PixcodeRequest) {
+  return req.user?.id ?? req.user?.userId ?? null;
 }
 
-export function createHermesRouter(): Router {
+export function createHermesRouter(options: HermesRouterOptions = {}): Router {
   const router = express.Router();
 
   router.get('/status', (_req, res) => {
@@ -122,6 +91,115 @@ export function createHermesRouter(): Router {
     res.json(readHermesInstallStatus());
   });
 
+  router.post('/install', (req: PixcodeRequest, res) => {
+    const apiKey = options.createHermesApiKey?.(readUserId(req)) ?? null;
+    if (!apiKey) {
+      res.status(500).json({
+        error: {
+          code: 'HERMES_API_KEY_UNAVAILABLE',
+          message: 'Pixcode could not create a Hermes MCP API key for this user.',
+        },
+      });
+      return;
+    }
+
+    const body = (req.body ?? {}) as Record<string, unknown>;
+    const job = createHermesInstallJob({
+      appRoot: options.appRoot ?? process.cwd(),
+      force: Boolean(body.force),
+      pixcodeApiKey: apiKey,
+      pixcodeBaseUrl: options.resolvePublicBaseUrl?.(req) ?? `http://127.0.0.1:${process.env.SERVER_PORT ?? process.env.PORT ?? '3001'}`,
+      skipBrowser: body.skipBrowser !== false,
+    });
+
+    res.status(202).json({
+      jobId: job.id,
+      provider: 'hermes',
+      status: job.status,
+      startedAt: job.startedAt,
+    });
+  });
+
+  router.get('/install/:jobId/stream', (req, res) => {
+    const job = getHermesInstallJob(req.params.jobId);
+    if (!job) {
+      res.status(404).json({
+        error: {
+          code: 'HERMES_INSTALL_JOB_NOT_FOUND',
+          message: 'Hermes install job not found or already expired.',
+        },
+      });
+      return;
+    }
+
+    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();
+    try {
+      (res.socket as NodeJS.Socket & { setNoDelay?: (on: boolean) => void })?.setNoDelay?.(true);
+    } catch { /* noop */ }
+
+    let closed = false;
+    const safeWrite = (event: string, payload: unknown) => {
+      if (closed) return;
+      try { writeSse(res, event, payload); } catch { /* socket gone */ }
+    };
+
+    try { res.write(': start\n\n'); } catch { /* noop */ }
+    const heartbeat = setInterval(() => {
+      if (closed) return;
+      try { res.write(': ping\n\n'); } catch { /* noop */ }
+    }, 5000);
+
+    for (const entry of job.logs) {
+      safeWrite('log', { stream: entry.stream, chunk: entry.chunk });
+    }
+
+    const onLog = (entry: { stream: string; chunk: string }) => {
+      safeWrite('log', { stream: entry.stream, chunk: entry.chunk });
+    };
+    const onDone = (payload: Record<string, unknown>) => {
+      safeWrite('done', payload);
+      cleanup();
+      try { res.end(); } catch { /* noop */ }
+    };
+    function cleanup() {
+      if (closed) return;
+      closed = true;
+      clearInterval(heartbeat);
+      job.emitter.off('log', onLog);
+      job.emitter.off('done', onDone);
+    }
+
+    if (job.status !== 'running') {
+      safeWrite('done', snapshotHermesInstallDonePayload(job));
+      cleanup();
+      try { res.end(); } catch { /* noop */ }
+      return;
+    }
+
+    job.emitter.on('log', onLog);
+    job.emitter.once('done', onDone);
+    req.on('close', cleanup);
+  });
+
+  router.delete('/install/:jobId', (req, res) => {
+    const job = getHermesInstallJob(req.params.jobId);
+    if (!job) {
+      res.status(404).json({
+        error: {
+          code: 'HERMES_INSTALL_JOB_NOT_FOUND',
+          message: 'Hermes install job not found.',
+        },
+      });
+      return;
+    }
+
+    res.json({ cancelled: cancelHermesInstallJob(req.params.jobId) });
+  });
+
   router.get('/agents', (_req, res) => {
     res.json({
       agent: 'hermes',