@pixelbyte-software/pixcode 1.49.6 → 1.49.8

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; Invoke-PixcodeHermesConfigure; & $script:HermesCmd`;
-    }
-
-    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 && { node ${shellQuotePosix(configureScript)} || echo "Pixcode MCP configure failed; starting Hermes anyway."; } && "$HERMES_CMD"`)}`;
-}
-
 // 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
@@ -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 });
   });

package/server/services/hermes-gateway.js

@@ -15,6 +15,8 @@ const DEFAULT_PORT = 8642;
 const PORT_SCAN_LIMIT = 80;
 const STARTUP_TIMEOUT_MS = 30000;
 const FETCH_TIMEOUT_MS = 5000;
+const RUN_TIMEOUT_MS = 120000;
+const RUN_POLL_INTERVAL_MS = 1000;
 const LOG_LIMIT = 800;
 
 const gateways = new Map();
@@ -47,6 +49,10 @@ function makeApiServerKey() {
     return `pixcode-hermes-${randomBytes(24).toString('hex')}`;
 }
 
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function buildHermesGatewayEnv(baseEnv = process.env, options = {}) {
     const host = options.host || DEFAULT_HOST;
     const port = String(options.port || DEFAULT_PORT);
@@ -124,6 +130,62 @@ async function callGateway(gateway, endpoint, options = {}) {
     });
 }
 
+function extractRunId(body) {
+    if (!body || typeof body !== 'object') return null;
+    return body.run_id || body.runId || body.id || body.run?.id || null;
+}
+
+function extractRunStatus(body) {
+    if (!body || typeof body !== 'object') return null;
+    return body.status || body.state || body.run?.status || body.run?.state || null;
+}
+
+function extractTextFromValue(value) {
+    if (typeof value === 'string') return value;
+    if (!value) return null;
+
+    if (Array.isArray(value)) {
+        return value
+            .map(extractTextFromValue)
+            .filter(Boolean)
+            .join('\n')
+            .trim() || null;
+    }
+
+    if (typeof value === 'object') {
+        for (const key of ['text', 'content', 'message', 'output', 'response', 'result', 'final']) {
+            const text = extractTextFromValue(value[key]);
+            if (text) return text;
+        }
+    }
+
+    return null;
+}
+
+function extractRunOutput(body) {
+    if (!body || typeof body !== 'object') return null;
+
+    for (const key of ['output_text', 'output', 'response', 'result', 'message', 'messages', 'events', 'final']) {
+        const text = extractTextFromValue(body[key]);
+        if (text) return text;
+    }
+
+    return null;
+}
+
+function makeRunRequest(options) {
+    const input = String(options.input || '').trim();
+    return {
+        session_id: options.sessionId || `pixcode-hermes-chat-${Date.now()}-${randomBytes(4).toString('hex')}`,
+        input,
+        instructions: options.instructions || [
+            'You are Hermes Agent running inside Pixcode.',
+            'Use Pixcode MCP tools when they help inspect projects, launch CLIs, or perform workspace actions.',
+            'Keep answers concise and include concrete next steps when work is blocked.',
+        ].join(' '),
+    };
+}
+
 async function waitForGatewayReady(gateway) {
     const started = Date.now();
     let lastError = null;
@@ -382,6 +444,81 @@ export async function probeHermesGateway(projectPath, options = {}) {
     return result;
 }
 
+export async function runHermesGatewayPrompt(projectPath, options = {}) {
+    const gateway = projectPath
+        ? gateways.get(normalizeProjectPath(projectPath))
+        : Array.from(gateways.values()).find(isGatewayRunning);
+
+    if (!isGatewayRunning(gateway)) {
+        throw new Error('Hermes gateway is not running.');
+    }
+
+    const input = String(options.input || '').trim();
+    if (!input) {
+        throw new Error('Hermes prompt is required.');
+    }
+
+    const request = makeRunRequest({ ...options, input });
+    const create = await callGateway(gateway, '/v1/runs', {
+        method: 'POST',
+        body: JSON.stringify(request),
+        timeoutMs: options.createTimeoutMs || 15000,
+    });
+
+    if (!create.ok) {
+        throw new Error(`Hermes /v1/runs failed with HTTP ${create.status}: ${JSON.stringify(create.body)}`);
+    }
+
+    const runId = extractRunId(create.body);
+    const initialStatus = extractRunStatus(create.body);
+    if (!runId) {
+        return {
+            ok: true,
+            projectPath: gateway.projectPath,
+            baseUrl: gateway.baseUrl,
+            sessionId: request.session_id,
+            runId: null,
+            status: initialStatus || 'completed',
+            message: extractRunOutput(create.body),
+            raw: create.body,
+        };
+    }
+
+    const terminalStatuses = new Set(['completed', 'failed', 'cancelled', 'canceled']);
+    const started = Date.now();
+    let latest = create.body;
+    let status = initialStatus || 'queued';
+
+    while (!terminalStatuses.has(String(status)) && Date.now() - started < (options.timeoutMs || RUN_TIMEOUT_MS)) {
+        await sleep(options.pollIntervalMs || RUN_POLL_INTERVAL_MS);
+        const poll = await callGateway(gateway, `/v1/runs/${encodeURIComponent(runId)}`, {
+            timeoutMs: options.pollTimeoutMs || 15000,
+        });
+        if (!poll.ok) {
+            throw new Error(`Hermes /v1/runs/${runId} failed with HTTP ${poll.status}: ${JSON.stringify(poll.body)}`);
+        }
+        latest = poll.body;
+        status = extractRunStatus(latest) || status;
+    }
+
+    if (!terminalStatuses.has(String(status))) {
+        throw new Error(`Hermes run did not finish within ${Math.round((options.timeoutMs || RUN_TIMEOUT_MS) / 1000)}s: ${runId}`);
+    }
+
+    const message = extractRunOutput(latest);
+    return {
+        ok: status === 'completed',
+        projectPath: gateway.projectPath,
+        baseUrl: gateway.baseUrl,
+        sessionId: request.session_id,
+        runId,
+        status,
+        message,
+        error: status === 'completed' ? null : extractTextFromValue(latest?.error) || message || 'Hermes run failed.',
+        raw: latest,
+    };
+}
+
 export function stopHermesGateway(projectPath) {
     const targets = projectPath
         ? [gateways.get(normalizeProjectPath(projectPath))].filter(Boolean)