@pixelbyte-software/pixcode 1.49.4 → 1.49.6

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

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+
+const read = (path) => fs.readFileSync(path, 'utf8');
+
+const service = read('server/services/hermes-gateway.js');
+const routes = read('server/modules/orchestration/hermes/hermes.routes.ts');
+const mcpServer = read('scripts/hermes/pixcode-mcp-server.mjs');
+const configureMcp = read('scripts/hermes/configure-pixcode-mcp.mjs');
+const settingsTab = read('src/components/settings/view/tabs/HermesSettingsTab.tsx');
+
+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 function stopHermesGateway/, 'Pixcode should be able to stop a managed Hermes gateway process.');
+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.');
+assert.match(service, /spawn\(installStatus\.command,\s*\['gateway'\]/, 'Pixcode should start Hermes with `hermes gateway` for REST control.');
+assert.match(service, /\/health/, 'Gateway probe should call Hermes health.');
+assert.match(service, /\/v1\/capabilities/, 'Gateway probe should verify Hermes capabilities.');
+assert.match(service, /\/v1\/models/, 'Gateway probe should verify OpenAI-compatible model discovery.');
+assert.match(service, /\/v1\/runs/, 'Gateway probe should support a real run submission when requested.');
+
+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\/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(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.');
+assert.match(configureMcp, /pixcode_get_hermes_gateway_status/, 'Hermes MCP config should include gateway status tool.');
+assert.match(configureMcp, /pixcode_probe_hermes_gateway/, 'Hermes MCP config should include gateway probe tool.');
+
+assert.match(settingsTab, /gateway\/status/, 'Hermes settings should read gateway status.');
+assert.match(settingsTab, /gateway\/start/, 'Hermes settings should start the REST gateway via API.');
+assert.match(settingsTab, /gateway\/probe/, 'Hermes settings should run REST probe via API.');
+
+console.log('hermes REST gateway smoke passed');

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

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  ensureHermesGateway,
+  probeHermesGateway,
+  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);
+const hermesHome = await fs.mkdtemp(path.join(os.tmpdir(), 'pixcode-hermes-rest-live-'));
+
+try {
+  const gateway = await ensureHermesGateway({
+    appRoot: repoRoot,
+    projectPath,
+    hermesHome,
+    pixcodeBaseUrl: 'http://127.0.0.1:9',
+    pixcodeApiKey: 'px_live_smoke_key',
+    port: Number(process.env.PIXCODE_HERMES_LIVE_PORT || 18642),
+  });
+  if (!gateway.running || !gateway.probe?.ok) {
+    throw new Error(`Hermes gateway did not start cleanly: ${JSON.stringify(gateway)}`);
+  }
+
+  const probe = await probeHermesGateway(projectPath);
+  if (!probe.ok) {
+    throw new Error(`Hermes REST probe failed: ${JSON.stringify(probe)}`);
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    baseUrl: probe.baseUrl,
+    projectPath: probe.projectPath,
+    checks: Object.fromEntries(Object.entries(probe.checks).map(([name, check]) => [name, check.status])),
+  }, null, 2));
+} finally {
+  stopHermesGateway(projectPath);
+}

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

@@ -107,6 +107,8 @@ assert.match(hermesRoutes, /terminal-launches/, 'Hermes MCP should be able to re
 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(workbench, /terminalStartupInput/, 'Hermes terminal launch prompts should be passed into the selected CLI.');
+assert.match(read('src/components/shell/hooks/useShellConnection.ts'), /startupInputRef/, 'Shell connections should support one-shot startup input for Hermes-triggered CLI work.');
 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.');
 

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

@@ -56,10 +56,35 @@ for (const token of [
   'vscodeWorkbench.welcome.cloneProject',
   'vscodeWorkbench.welcome.startHermes',
   'DarkModeToggle',
+  'welcomeActionCards',
+  'welcomeAppearancePanel',
 ]) {
   assert.match(workbench, new RegExp(token.replaceAll('.', '\\.')), `Workbench welcome should include ${token}.`);
 }
 
+const welcomeSource = workbench.slice(
+  workbench.indexOf('function WorkbenchProjectLanding'),
+  workbench.indexOf('const cliProviders'),
+);
+
+assert.doesNotMatch(
+  welcomeSource,
+  /lg:grid-cols-\[minmax\(0,1fr\)_18rem\]/,
+  'Workbench welcome should not reserve a right column that squeezes the three start actions.',
+);
+
+assert.match(
+  welcomeSource,
+  /welcomeAppearancePanel[\s\S]*?recentProjects/,
+  'Appearance controls should sit below the three primary welcome actions and above recent projects.',
+);
+
+assert.match(
+  welcomeSource,
+  /gridTemplateColumns:\s*'repeat\(auto-fit, minmax\(min\(100%, 13rem\), 1fr\)\)'/,
+  'Workbench welcome action cards should auto-wrap responsively instead of staying cramped.',
+);
+
 assert.match(
   workbench,
   /function WorkbenchCliPanel/,

package/server/index.js

@@ -414,6 +414,7 @@ function getOrCreateHermesApiKey(userId) {
 
     return apiKeysDb.createApiKey(userId, 'Hermes Agent MCP', [
         'hermes:mcp',
+        'hermes:gateway',
         'projects:read',
         'providers:read',
         'terminal:launch',
@@ -424,7 +425,6 @@ 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;
-    const configure = `node ${quote(configureScript)}`;
 
     if (isWindows) {
         const setEnv = [
@@ -462,10 +462,16 @@ function buildHermesShellCommand(kind, env) {
             '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) { Write-Host "Hermes already installed:"; & $script:HermesCmd --version; return; }',
+            '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;',
@@ -476,9 +482,9 @@ function buildHermesShellCommand(kind, env) {
             '}',
         ].join(' ');
         if (kind === 'pixcode:hermes:install') {
-            return `${setEnv}; ${resolveHermesCommand}; ${installHermesIfMissing}; Install-HermesIfMissing; ${configure}`;
+            return `${setEnv}; ${resolveHermesCommand}; ${configure}; ${installHermesIfMissing}; Install-HermesIfMissing; Invoke-PixcodeHermesConfigure`;
         }
-        return `${setEnv}; ${resolveHermesCommand}; ${installHermesIfMissing}; Install-HermesIfMissing; ${configure}; & $script:HermesCmd chat --toolsets "hermes-cli,mcp-pixcode"`;
+        return `${setEnv}; ${resolveHermesCommand}; ${configure}; ${installHermesIfMissing}; Install-HermesIfMissing; Invoke-PixcodeHermesConfigure; & $script:HermesCmd`;
     }
 
     const setEnv = [
@@ -502,15 +508,15 @@ function buildHermesShellCommand(kind, env) {
     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;',
+        '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)}`)}`;
+        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)} && "$HERMES_CMD" chat --toolsets "hermes-cli,mcp-pixcode"`)}`;
+    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
@@ -2286,6 +2292,7 @@ function handleShellConnection(ws, request) {
                 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) {
@@ -2322,7 +2329,7 @@ function handleShellConnection(ws, request) {
 
                 // Include command hash in session key so different commands get separate sessions
                 const commandSuffix = isPlainShell && initialCommand
-                    ? `_cmd_${Buffer.from(initialCommand).toString('base64').slice(0, 16)}`
+                    ? (isHermesShellSession ? '_hermes' : `_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
@@ -2566,7 +2573,8 @@ function handleShellConnection(ws, request) {
                         projectPath,
                         sessionId,
                         provider,
-                        isPlainShell
+                        isPlainShell,
+                        keepAliveUntilExit: isHermesShellSession,
                     });
 
                     // Handle data output
@@ -2694,6 +2702,12 @@ function handleShellConnection(ws, request) {
         if (ptySessionKey) {
             const session = ptySessionsMap.get(ptySessionKey);
             if (session) {
+                if (session.keepAliveUntilExit) {
+                    console.log('⏳ PTY session kept alive until process exit:', ptySessionKey);
+                    session.ws = null;
+                    return;
+                }
+
                 console.log('⏳ PTY session kept alive, will timeout in 30 minutes:', ptySessionKey);
                 session.ws = null;
 

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

@@ -11,6 +11,12 @@ import {
   readHermesInstallStatus,
   snapshotHermesInstallDonePayload,
 } from '@/services/hermes-install-jobs.js';
+import {
+  ensureHermesGateway,
+  getHermesGatewayStatus,
+  probeHermesGateway,
+  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']);
@@ -91,6 +97,86 @@ export function createHermesRouter(options: HermesRouterOptions = {}): Router {
     res.json(readHermesInstallStatus());
   });
 
+  router.get('/gateway/status', (req, res) => {
+    const projectPath = typeof req.query.projectPath === 'string' ? req.query.projectPath : null;
+    res.json(getHermesGatewayStatus(projectPath));
+  });
+
+  router.post('/gateway/start', async (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>;
+    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: typeof body.projectPath === 'string' ? body.projectPath : undefined,
+      });
+      res.status(202).json(gateway);
+    } catch (error) {
+      res.status(500).json({
+        error: {
+          code: 'HERMES_GATEWAY_START_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  router.post('/gateway/probe', async (req: PixcodeRequest, res) => {
+    const body = (req.body ?? {}) as Record<string, unknown>;
+    const projectPath = typeof body.projectPath === 'string' ? body.projectPath : null;
+    const input = typeof body.input === 'string' ? body.input : undefined;
+    const shouldStart = body.startIfNeeded === true;
+
+    try {
+      if (shouldStart) {
+        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;
+        }
+        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: projectPath ?? undefined,
+        });
+      }
+
+      const probe = await probeHermesGateway(projectPath, { input });
+      res.status(probe.ok ? 200 : 503).json(probe);
+    } catch (error) {
+      res.status(500).json({
+        error: {
+          code: 'HERMES_GATEWAY_PROBE_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;
+    res.json(stopHermesGateway(projectPath));
+  });
+
   router.post('/install', (req: PixcodeRequest, res) => {
     const apiKey = options.createHermesApiKey?.(readUserId(req)) ?? null;
     if (!apiKey) {