@pixelbyte-software/pixcode 1.49.7 → 1.49.9

package/scripts/smoke/hermes-rest-chat-api.mjs

@@ -0,0 +1,109 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  ensureHermesGateway,
+  runHermesGatewayPrompt,
+  stopHermesGateway,
+} from '../../server/services/hermes-gateway.js';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'pixcode-hermes-chat-api-'));
+const fakeHermes = path.join(tempRoot, 'hermes');
+const projectPath = path.join(tempRoot, 'project');
+const hermesHome = path.join(tempRoot, 'home');
+
+await fs.mkdir(projectPath, { recursive: true });
+await fs.writeFile(fakeHermes, `#!/usr/bin/env node
+import http from 'node:http';
+
+if (process.argv.includes('--version')) {
+  console.log('Hermes Agent v0.0.0 smoke');
+  process.exit(0);
+}
+
+if (!process.argv.includes('gateway')) {
+  console.error('expected gateway');
+  process.exit(2);
+}
+
+const host = process.env.API_SERVER_HOST || '127.0.0.1';
+const port = Number(process.env.API_SERVER_PORT || 8642);
+const key = process.env.API_SERVER_KEY || '';
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url || '/', 'http://127.0.0.1');
+  res.setHeader('content-type', 'application/json');
+  if (url.pathname !== '/health' && req.headers.authorization !== \`Bearer \${key}\`) {
+    res.statusCode = 401;
+    res.end(JSON.stringify({ error: 'bad auth' }));
+    return;
+  }
+  if (req.method === 'GET' && url.pathname === '/health') {
+    res.end(JSON.stringify({ ok: true }));
+    return;
+  }
+  if (req.method === 'GET' && url.pathname === '/v1/capabilities') {
+    res.end(JSON.stringify({ capabilities: ['chat'] }));
+    return;
+  }
+  if (req.method === 'GET' && url.pathname === '/v1/models') {
+    res.end(JSON.stringify({ data: [{ id: 'hermes-agent' }] }));
+    return;
+  }
+  if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
+    let body = '';
+    for await (const chunk of req) body += chunk.toString();
+    const parsed = body ? JSON.parse(body) : {};
+    res.end(JSON.stringify({
+      id: 'chatcmpl-smoke',
+      choices: [{
+        index: 0,
+        message: {
+          role: 'assistant',
+          content: \`pixcode-hermes-chat-ok via \${parsed.model}\`,
+        },
+        finish_reason: 'stop',
+      }],
+    }));
+    return;
+  }
+  res.statusCode = 404;
+  res.end(JSON.stringify({ error: url.pathname }));
+});
+server.listen(port, host);
+`, { mode: 0o755 });
+
+process.env.HERMES_CLI_PATH = fakeHermes;
+
+try {
+  const gateway = await ensureHermesGateway({
+    appRoot: repoRoot,
+    projectPath,
+    hermesHome,
+    pixcodeBaseUrl: 'http://127.0.0.1:9',
+    pixcodeApiKey: 'px_chat_api_smoke_key',
+    port: 18752,
+  });
+  if (!gateway.running || !gateway.probe?.ok) {
+    throw new Error(`Fake Hermes gateway did not start cleanly: ${JSON.stringify(gateway)}`);
+  }
+
+  const run = await runHermesGatewayPrompt(projectPath, {
+    input: 'selam',
+    timeoutMs: 10000,
+  });
+  if (!run.ok || run.transport !== 'chat.completions' || !String(run.message || '').includes('pixcode-hermes-chat-ok')) {
+    throw new Error(`Hermes REST chat did not use chat completions: ${JSON.stringify(run)}`);
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    transport: run.transport,
+    message: run.message,
+  }, null, 2));
+} finally {
+  stopHermesGateway(projectPath);
+  delete process.env.HERMES_CLI_PATH;
+}

package/scripts/smoke/hermes-rest-chat-live.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  ensureHermesGateway,
+  runHermesGatewayPrompt,
+  stopHermesGateway,
+} from '../../server/services/hermes-gateway.js';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const projectPath = path.resolve(process.argv[2] || repoRoot);
+
+try {
+  const gateway = await ensureHermesGateway({
+    appRoot: repoRoot,
+    projectPath,
+    pixcodeBaseUrl: 'http://127.0.0.1:9',
+    pixcodeApiKey: 'px_live_chat_smoke_key',
+    port: Number(process.env.PIXCODE_HERMES_LIVE_CHAT_PORT || 18652),
+  });
+  if (!gateway.running || !gateway.probe?.ok) {
+    throw new Error(`Hermes gateway did not start cleanly: ${JSON.stringify(gateway)}`);
+  }
+
+  const run = await runHermesGatewayPrompt(projectPath, {
+    input: 'Reply with exactly: pixcode-hermes-chat-ok',
+    timeoutMs: 90000,
+  });
+  if (!run.ok || !String(run.message || '').includes('pixcode-hermes-chat-ok')) {
+    throw new Error(`Hermes chat did not return the expected response: ${JSON.stringify(run)}`);
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    transport: run.transport,
+    status: run.status,
+    message: run.message,
+  }, null, 2));
+} finally {
+  stopHermesGateway(projectPath);
+}

package/scripts/smoke/hermes-rest-gateway.mjs

@@ -11,7 +11,10 @@ const settingsTab = read('src/components/settings/view/tabs/HermesSettingsTab.ts
 
 assert.match(service, /export async function ensureHermesGateway/, 'Pixcode should expose an API-managed Hermes gateway starter.');
 assert.match(service, /export async function probeHermesGateway/, 'Pixcode should probe Hermes through its REST API.');
+assert.match(service, /export async function runHermesGatewayPrompt/, 'Pixcode should submit Hermes prompts through the managed REST gateway.');
 assert.match(service, /export function stopHermesGateway/, 'Pixcode should be able to stop a managed Hermes gateway process.');
+assert.match(service, /\/v1\/chat\/completions/, 'Hermes UI chat should use the documented OpenAI-compatible chat completions endpoint first.');
+assert.match(service, /gatewayExitMessage/, 'Hermes gateway failures should include recent stderr/stdout instead of only exit code 1.');
 assert.match(service, /API_SERVER_ENABLED:\s*'true'/, 'Hermes gateway env should enable the API server.');
 assert.match(service, /API_SERVER_KEY/, 'Hermes gateway env should set a bearer key.');
 assert.match(service, /API_SERVER_PORT/, 'Hermes gateway env should choose a REST port.');
@@ -24,9 +27,11 @@ assert.match(service, /\/v1\/runs/, 'Gateway probe should support a real run sub
 assert.match(routes, /router\.get\('\/gateway\/status'/, 'Hermes router should expose gateway status.');
 assert.match(routes, /router\.post\('\/gateway\/start'/, 'Hermes router should expose gateway start.');
 assert.match(routes, /router\.post\('\/gateway\/probe'/, 'Hermes router should expose a REST probe endpoint.');
+assert.match(routes, /router\.post\('\/gateway\/chat'/, 'Hermes router should expose a REST chat endpoint.');
 assert.match(routes, /router\.post\('\/gateway\/stop'/, 'Hermes router should expose gateway stop.');
 assert.match(routes, /ensureHermesGateway/, 'Hermes router should use the managed gateway service.');
 assert.match(routes, /probeHermesGateway/, 'Hermes router should use the REST probe service.');
+assert.match(routes, /runHermesGatewayPrompt/, 'Hermes router should send chat prompts through the REST gateway service.');
 
 assert.match(mcpServer, /pixcode_get_hermes_gateway_status/, 'Pixcode MCP should let Hermes inspect gateway status.');
 assert.match(mcpServer, /pixcode_probe_hermes_gateway/, 'Pixcode MCP should let Hermes trigger a REST probe.');

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

@@ -17,6 +17,7 @@ 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');
+const hermesInstallJobs = read('server/services/hermes-install-jobs.js');
 const shellTerminal = read('src/components/shell/hooks/useShellTerminal.ts');
 const shellConnection = read('src/components/shell/hooks/useShellConnection.ts');
 const geminiCli = read('server/gemini-cli.js');
@@ -63,7 +64,11 @@ assert.match(workbench, /function WorkbenchBottomTerminal/, 'Terminal activity s
 assert.match(workbench, /BOTTOM_TERMINAL_MIN_HEIGHT/, 'Bottom terminal should support height resizing.');
 assert.match(workbench, /isBottomTerminalMinimized/, 'Bottom terminal should support minimizing without closing.');
 assert.match(workbench, /isPlainShell/, 'Bottom terminal should open the selected project folder without starting the selected AI CLI.');
-assert.match(workbench, /HERMES_AGENT_START_COMMAND/, 'Hermes Agent should launch from the bottom terminal through a server-side sentinel.');
+assert.doesNotMatch(workbench, /HERMES_AGENT_START_COMMAND/, 'Hermes Agent should not launch from the bottom terminal through a server-side sentinel.');
+assert.match(workbench, /HermesApiChatPanel/, 'Hermes Agent should render a REST-backed chat panel in the bottom area.');
+assert.match(workbench, /\/api\/orchestration\/hermes\/gateway\/chat/, 'Hermes chat panel should send prompts through the Pixcode gateway chat API.');
+assert.match(workbench, /terminal-launches\/stream/, 'Hermes CLI launch requests should arrive through an EventSource stream.');
+assert.doesNotMatch(workbench, /HERMES_TERMINAL_LAUNCH_POLL_MS|setInterval\([\s\S]*terminal-launches/, 'Hermes CLI launch requests should not be polled every few seconds.');
 assert.doesNotMatch(workbench, /Project-scoped agent terminal\. Installs Hermes when missing/, 'Right CLI panel should not show the old Hermes card.');
 assert.doesNotMatch(workbench, /vscodeWorkbench\.hermes\.docsShort|HERMES_AGENT_DOCS_URL/, 'Hermes terminal header should not include a docs shortcut.');
 assert.match(workbench, /shrinkCliPanel/, 'Right CLI panel should expose a shrink action.');
@@ -79,14 +84,12 @@ assert.match(workbench, /forceNewSession=\{terminalLaunch\.forceNewSession\}/, '
 assert.doesNotMatch(workbench, /suspendAutoConnect/, 'Right CLI provider starts should auto-connect directly instead of showing the shell continue overlay.');
 assert.match(serverIndex, /\/api\/shell\/sessions\/terminate/, 'Backend should expose an authenticated endpoint to terminate cached provider PTYs immediately.');
 assert.match(serverIndex, /isPlainShell && !initialCommand/, 'Backend should spawn an interactive plain shell when no terminal command is provided.');
-assert.match(serverIndex, /pixcode:hermes:start/, 'Backend should expand Hermes terminal sentinels on the server host.');
-assert.match(serverIndex, /Hermes Agent is starting/, 'Hermes terminal should show an immediate startup line before the interactive app draws.');
-assert.match(serverIndex, /"\$HERMES_CMD" chat/, 'POSIX Hermes terminal should start the interactive chat command explicitly.');
-assert.match(serverIndex, /& \$script:HermesCmd chat/, 'Windows Hermes terminal should start the interactive chat command explicitly.');
-assert.doesNotMatch(serverIndex, /iex \(irm https:\/\/raw\.githubusercontent\.com\/NousResearch\/hermes-agent\/main\/scripts\/install\.ps1\)/, 'Windows Hermes install should avoid the old inline iex pattern.');
-assert.doesNotMatch(serverIndex, /scriptblock\]::Create\(\(irm https:\/\/raw\.githubusercontent\.com\/NousResearch\/hermes-agent\/main\/scripts\/install\.ps1\)\)/, 'Windows Hermes install should avoid scriptblock Invoke-RestMethod eval patterns.');
-assert.match(serverIndex, /Invoke-WebRequest[\s\S]+install\.ps1[\s\S]+-OutFile/, 'Windows Hermes install should download the installer to a file before running it.');
-assert.match(serverIndex, /Resolve-HermesCommand|resolveHermesCommand/, 'Hermes start/install should resolve an existing hermes binary before installing.');
+assert.doesNotMatch(serverIndex, /pixcode:hermes:start/, 'Backend should not need a Hermes terminal sentinel for the workbench Hermes panel.');
+assert.doesNotMatch(serverIndex, /hermesCommand/, 'Provider shell starts should not reference the removed Hermes sentinel variable.');
+assert.doesNotMatch(hermesInstallJobs, /iex \(irm https:\/\/raw\.githubusercontent\.com\/NousResearch\/hermes-agent\/main\/scripts\/install\.ps1\)/, 'Windows Hermes install should avoid the old inline iex pattern.');
+assert.doesNotMatch(hermesInstallJobs, /scriptblock\]::Create\(\(irm https:\/\/raw\.githubusercontent\.com\/NousResearch\/hermes-agent\/main\/scripts\/install\.ps1\)\)/, 'Windows Hermes install should avoid scriptblock Invoke-RestMethod eval patterns.');
+assert.match(hermesInstallJobs, /downloadHermesInstaller/, 'Windows Hermes install should download the installer through backend API code before running it.');
+assert.match(hermesInstallJobs, /resolveHermesCommandCandidates|isUsableHermesCommand/, 'Hermes install/status should resolve and test an existing hermes binary before installing.');
 assert.match(serverIndex, /buildProviderShellCommand/, 'Provider terminal launch should centralize provider-specific permission flags.');
 assert.doesNotMatch(shellTerminal, /new WebglAddon\(\)/, 'Workbench terminal should use the stable xterm renderer.');
 assert.match(workbench, /setActivityPanel\('explorer'\)/, 'Selecting a project should return the side panel to Explorer.');
@@ -110,6 +113,9 @@ assert.match(serverIndex, /app\.use\('\/hermes', createHermesTaskRouter\(\)\)/,
 assert.doesNotMatch(serverIndex, /app\.use\('\/a2a'/, 'Server should not expose the old A2A route.');
 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, /terminal-launches\/stream/, 'Hermes MCP terminal launch requests should stream to the workbench over SSE.');
+assert.match(hermesRoutes, /hermesTerminalLaunchEmitter/, 'Hermes terminal launch stream should broadcast new events instead of relying on polling.');
+assert.match(hermesRoutes, /router\.post\('\/gateway\/chat'/, 'Hermes should expose a REST chat endpoint for the bottom panel.');
 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.');

package/scripts/smoke/vscode-workbench-polish.mjs

@@ -288,10 +288,16 @@ assert.match(
   'Workbench bottom terminal should run a plain shell in the selected project directory.',
 );
 
-assert.match(
+assert.doesNotMatch(
   workbench,
   /HERMES_AGENT_START_COMMAND/,
-  'Hermes Agent should launch through the bottom terminal with a server-side command sentinel.',
+  'Hermes Agent should not launch through the bottom terminal with a server-side command sentinel.',
+);
+
+assert.match(
+  workbench,
+  /HermesApiChatPanel/,
+  'Hermes Agent should use the REST chat panel in the bottom area.',
 );
 
 assert.doesNotMatch(

package/server/index.js

@@ -32,10 +32,6 @@ const SERVER_VERSION = (() => {
         return '0.0.0';
     }
 })();
-const HERMES_SHELL_COMMANDS = new Set([
-    'pixcode:hermes:start',
-    'pixcode:hermes:install',
-]);
 const DAEMON_COMMAND_CONTEXT = {
     appRoot: APP_ROOT,
     cliEntry: path.join(APP_ROOT, 'server', 'cli.js'),
@@ -328,14 +324,6 @@ function killProviderPtySessions(projectPath, provider) {
     return killed;
 }
 
-function shellQuotePosix(value) {
-    return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}
-
-function shellQuotePowerShell(value) {
-    return `'${String(value).replace(/'/g, "''")}'`;
-}
-
 function normalizeShellPermissionMode(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -421,104 +409,6 @@ function getOrCreateHermesApiKey(userId) {
     ]).apiKey;
 }
 
-function buildHermesShellCommand(kind, env) {
-    const configureScript = path.join(APP_ROOT, 'scripts', 'hermes', 'configure-pixcode-mcp.mjs');
-    const isWindows = os.platform() === 'win32';
-    const quote = isWindows ? shellQuotePowerShell : shellQuotePosix;
-
-    if (isWindows) {
-        const setEnv = [
-            `$env:PIXCODE_BASE_URL=${quote(env.PIXCODE_BASE_URL)}`,
-            `$env:PIXCODE_API_KEY=${quote(env.PIXCODE_API_KEY)}`,
-            `$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 {',
-            '$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) -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(' ');
-        const configure = [
-            'function Invoke-PixcodeHermesConfigure {',
-            `& node ${quote(configureScript)};`,
-            'if ($LASTEXITCODE -ne 0) { Write-Warning "Pixcode MCP configure failed; starting Hermes anyway."; $global:LASTEXITCODE = 0; }',
-            '}',
-        ].join(' ');
-        const installHermesIfMissing = [
-            'function Install-HermesIfMissing {',
-            '$script:HermesCmd = Resolve-HermesCommand;',
-            'if ($script:HermesCmd) { & $script:HermesCmd --version *> $null; return; }',
-            '$installer = Join-Path $env:TEMP "pixcode-hermes-install.ps1";',
-            'Invoke-WebRequest -Uri "https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1" -UseBasicParsing -OutFile $installer;',
-            '& powershell.exe -NoProfile -ExecutionPolicy Bypass -File $installer -SkipSetup -Branch main;',
-            'if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE; }',
-            '$env:Path = [Environment]::GetEnvironmentVariable("Path", "User") + ";" + [Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + $env:Path;',
-            '$script:HermesCmd = Resolve-HermesCommand;',
-            'if (-not $script:HermesCmd) { throw "Hermes installed, but the hermes command could not be found. Restart Pixcode or add Hermes to PATH."; }',
-            '}',
-        ].join(' ');
-        if (kind === 'pixcode:hermes:install') {
-            return `${setEnv}; ${resolveHermesCommand}; ${configure}; ${installHermesIfMissing}; Install-HermesIfMissing; Invoke-PixcodeHermesConfigure`;
-        }
-        return `${setEnv}; ${resolveHermesCommand}; ${configure}; ${installHermesIfMissing}; Install-HermesIfMissing; Write-Host "Hermes Agent is starting..."; Invoke-PixcodeHermesConfigure; & $script:HermesCmd chat`;
-    }
-
-    const setEnv = [
-        `PIXCODE_BASE_URL=${quote(env.PIXCODE_BASE_URL)}`,
-        `PIXCODE_API_KEY=${quote(env.PIXCODE_API_KEY)}`,
-        `PIXCODE_APP_ROOT=${quote(env.PIXCODE_APP_ROOT)}`,
-    ].join(' ');
-    const resolveHermesCommand = [
-        'testHermesCommand() {',
-        '[ -n "$1" ] && [ -x "$1" ] && "$1" --version >/dev/null 2>&1;',
-        '}',
-        'resolveHermesCommand() {',
-        '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 installHermesIfMissing = [
-        'installHermesIfMissing() {',
-        'HERMES_CMD="$(resolveHermesCommand 2>/dev/null || true)";',
-        'if [ -n "$HERMES_CMD" ]; then "$HERMES_CMD" --version >/dev/null 2>&1 || true; return 0; 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') {
-        return `${setEnv} sh -lc ${quote(`${resolveHermesCommand} ${installHermesIfMissing} installHermesIfMissing && { node ${shellQuotePosix(configureScript)} || echo "Pixcode MCP configure failed; continuing."; }`)}`;
-    }
-    return `${setEnv} sh -lc ${quote(`${resolveHermesCommand} ${installHermesIfMissing} installHermesIfMissing && printf "Hermes Agent is starting...\\n" && { node ${shellQuotePosix(configureScript)} || echo "Pixcode MCP configure failed; starting Hermes anyway."; } && exec "$HERMES_CMD" chat`)}`;
-}
-
 // Single WebSocket server that handles both paths
 const wss = new WebSocketServer({
     server,
@@ -2290,21 +2180,7 @@ function handleShellConnection(ws, request) {
                 const sessionId = data.sessionId;
                 const hasSession = data.hasSession;
                 const provider = data.provider || 'claude';
-                let initialCommand = data.initialCommand;
-                const hermesCommand = HERMES_SHELL_COMMANDS.has(initialCommand) ? initialCommand : null;
-                const isHermesShellSession = Boolean(hermesCommand);
-                if (hermesCommand) {
-                    const apiKey = getOrCreateHermesApiKey(request?.user?.id);
-                    if (!apiKey) {
-                        ws.send(JSON.stringify({ type: 'error', message: 'Hermes MCP could not create a Pixcode API key for this user.' }));
-                        return;
-                    }
-                    initialCommand = buildHermesShellCommand(hermesCommand, {
-                        PIXCODE_BASE_URL: resolvePublicBaseUrl(request),
-                        PIXCODE_API_KEY: apiKey,
-                        PIXCODE_APP_ROOT: APP_ROOT,
-                    });
-                }
+                const initialCommand = data.initialCommand;
                 const isPlainShell = data.isPlainShell || (!!initialCommand && !hasSession) || provider === 'plain-shell';
                 const forceNewSession = Boolean(data.forceNewSession);
                 const shellPermissionMode = normalizeShellPermissionMode(data.permissionMode);
@@ -2329,7 +2205,7 @@ function handleShellConnection(ws, request) {
 
                 // Include command hash in session key so different commands get separate sessions
                 const commandSuffix = isPlainShell && initialCommand
-                    ? (isHermesShellSession ? '_hermes' : `_cmd_${Buffer.from(initialCommand).toString('base64').slice(0, 16)}`)
+                    ? `_cmd_${Buffer.from(initialCommand).toString('base64').slice(0, 16)}`
                     : '';
                 // Include provider in the key so a fresh "new session" in OpenCode
                 // doesn't reattach to a cached Claude PTY for the same project (or
@@ -2390,7 +2266,7 @@ function handleShellConnection(ws, request) {
                 console.log('📋 Session info:', hasSession ? `Resume session ${sessionId}` : (isPlainShell ? 'Plain shell mode' : 'New session'));
                 console.log('🤖 Provider:', isPlainShell ? 'plain-shell' : provider);
                 if (initialCommand) {
-                    console.log('⚡ Initial command:', hermesCommand ? hermesCommand : initialCommand);
+                    console.log('⚡ Initial command:', initialCommand || 'interactive shell');
                 }
 
                 // First send a welcome message
@@ -2537,7 +2413,7 @@ function handleShellConnection(ws, request) {
                         }
                     }
 
-                    console.log('🔧 Executing shell command:', hermesCommand ? hermesCommand : (shellCommand || 'interactive shell'));
+                    console.log('🔧 Executing shell command:', shellCommand || 'interactive shell');
 
                     // Use appropriate shell based on platform
                     const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
@@ -2574,7 +2450,7 @@ function handleShellConnection(ws, request) {
                         sessionId,
                         provider,
                         isPlainShell,
-                        keepAliveUntilExit: isHermesShellSession,
+                        keepAliveUntilExit: false,
                     });
 
                     // Handle data output

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

@@ -1,4 +1,5 @@
 import os from 'node:os';
+import { EventEmitter } from 'node:events';
 
 import express, { type Request, type Response, type Router } from 'express';
 
@@ -15,11 +16,13 @@ import {
   ensureHermesGateway,
   getHermesGatewayStatus,
   probeHermesGateway,
+  runHermesGatewayPrompt,
   stopHermesGateway,
 } from '@/services/hermes-gateway.js';
 
 const HERMES_TERMINAL_LAUNCH_LIMIT = 100;
 const HERMES_TERMINAL_LAUNCH_PROVIDERS = new Set(['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode']);
+const HERMES_TERMINAL_LAUNCH_STREAM_HEARTBEAT_MS = 25000;
 
 type HermesTerminalLaunchEvent = {
   id: number;
@@ -45,6 +48,8 @@ type PixcodeRequest = Request & {
 
 let nextHermesTerminalLaunchId = 1;
 const hermesTerminalLaunches: HermesTerminalLaunchEvent[] = [];
+const hermesTerminalLaunchEmitter = new EventEmitter();
+hermesTerminalLaunchEmitter.setMaxListeners(200);
 
 function writeSse(res: Response, event: string, payload: unknown) {
   res.write(`event: ${event}\n`);
@@ -55,6 +60,19 @@ function readUserId(req: PixcodeRequest) {
   return req.user?.id ?? req.user?.userId ?? null;
 }
 
+function readAfterId(req: Request) {
+  const after = Number.parseInt(typeof req.query.after === 'string' ? req.query.after : '0', 10);
+  return Number.isFinite(after) ? after : 0;
+}
+
+function rememberHermesTerminalLaunch(event: HermesTerminalLaunchEvent) {
+  hermesTerminalLaunches.push(event);
+  if (hermesTerminalLaunches.length > HERMES_TERMINAL_LAUNCH_LIMIT) {
+    hermesTerminalLaunches.splice(0, hermesTerminalLaunches.length - HERMES_TERMINAL_LAUNCH_LIMIT);
+  }
+  hermesTerminalLaunchEmitter.emit('terminal-launch', event);
+}
+
 export function createHermesRouter(options: HermesRouterOptions = {}): Router {
   const router = express.Router();
 
@@ -171,6 +189,66 @@ export function createHermesRouter(options: HermesRouterOptions = {}): Router {
     }
   });
 
+  router.post('/gateway/chat', async (req: PixcodeRequest, res) => {
+    const body = (req.body ?? {}) as Record<string, unknown>;
+    const projectPath = typeof body.projectPath === 'string' && body.projectPath.trim()
+      ? body.projectPath.trim()
+      : undefined;
+    const input = typeof body.input === 'string' ? body.input.trim() : '';
+    const sessionId = typeof body.sessionId === 'string' && body.sessionId.trim()
+      ? body.sessionId.trim()
+      : undefined;
+
+    if (!input) {
+      res.status(400).json({
+        error: {
+          code: 'HERMES_PROMPT_REQUIRED',
+          message: 'Hermes prompt is required.',
+        },
+      });
+      return;
+    }
+
+    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;
+    }
+
+    try {
+      const gateway = await ensureHermesGateway({
+        appRoot: options.appRoot ?? process.cwd(),
+        pixcodeApiKey: apiKey,
+        pixcodeBaseUrl: options.resolvePublicBaseUrl?.(req) ?? `http://127.0.0.1:${process.env.SERVER_PORT ?? process.env.PORT ?? '3001'}`,
+        projectPath,
+      });
+      const run = await runHermesGatewayPrompt(projectPath, {
+        input,
+        sessionId,
+      });
+
+      res.status(run.ok ? 200 : 502).json({
+        ok: run.ok,
+        gateway,
+        run,
+        message: run.message,
+        error: run.error ?? null,
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: {
+          code: 'HERMES_GATEWAY_CHAT_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
   router.post('/gateway/stop', (req, res) => {
     const body = (req.body ?? {}) as Record<string, unknown>;
     const projectPath = typeof body.projectPath === 'string' ? body.projectPath : null;
@@ -297,13 +375,60 @@ export function createHermesRouter(options: HermesRouterOptions = {}): Router {
   });
 
   router.get('/terminal-launches', (req, res) => {
-    const after = Number.parseInt(typeof req.query.after === 'string' ? req.query.after : '0', 10);
-    const afterId = Number.isFinite(after) ? after : 0;
+    const afterId = readAfterId(req);
     res.json({
       events: hermesTerminalLaunches.filter((event) => event.id > afterId),
     });
   });
 
+  router.get('/terminal-launches/stream', (req, res) => {
+    const afterId = readAfterId(req);
+
+    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 replayed = hermesTerminalLaunches.filter((event) => event.id > afterId);
+    for (const event of replayed) {
+      safeWrite('terminal-launch', event);
+    }
+    safeWrite('ready', {
+      latestId: hermesTerminalLaunches[hermesTerminalLaunches.length - 1]?.id ?? afterId,
+      replayed: replayed.length,
+    });
+
+    const heartbeat = setInterval(() => {
+      if (closed) return;
+      try { res.write(': ping\n\n'); } catch { /* noop */ }
+    }, HERMES_TERMINAL_LAUNCH_STREAM_HEARTBEAT_MS);
+
+    const onTerminalLaunch = (event: HermesTerminalLaunchEvent) => {
+      safeWrite('terminal-launch', event);
+    };
+    hermesTerminalLaunchEmitter.on('terminal-launch', onTerminalLaunch);
+
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      clearInterval(heartbeat);
+      hermesTerminalLaunchEmitter.off('terminal-launch', onTerminalLaunch);
+    };
+
+    req.on('close', cleanup);
+  });
+
   router.post('/terminal-launches', (req, res) => {
     const body = (req.body ?? {}) as Record<string, unknown>;
     const provider = typeof body.provider === 'string' ? body.provider.trim() : '';
@@ -328,10 +453,7 @@ export function createHermesRouter(options: HermesRouterOptions = {}): Router {
       createdAt: new Date().toISOString(),
     };
     nextHermesTerminalLaunchId += 1;
-    hermesTerminalLaunches.push(event);
-    if (hermesTerminalLaunches.length > HERMES_TERMINAL_LAUNCH_LIMIT) {
-      hermesTerminalLaunches.splice(0, hermesTerminalLaunches.length - HERMES_TERMINAL_LAUNCH_LIMIT);
-    }
+    rememberHermesTerminalLaunch(event);
 
     res.status(201).json({ event });
   });