@pixelbyte-software/pixcode 1.48.6 → 1.49.1

package/server/index.js

@@ -32,6 +32,10 @@ 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'),
@@ -105,7 +109,7 @@ import {
 } from './services/provider-credentials.js';
 import { primeCliBinPath } from './services/install-jobs.js';
 import { startEnabledPluginServers, stopAllPlugins, getPluginPort } from './utils/plugin-process-manager.js';
-import { initializeDatabase, sessionNamesDb, applyCustomSessionNames } from './database/db.js';
+import { initializeDatabase, sessionNamesDb, applyCustomSessionNames, apiKeysDb } from './database/db.js';
 import { setNotificationWebSocketServer } from './services/notification-orchestrator.js';
 import { configureWebPush } from './services/vapid-keys.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
@@ -323,6 +327,174 @@ 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() : '';
+}
+
+function shouldBypassShellPermissions(permissionMode, skipPermissions) {
+    return Boolean(skipPermissions) || permissionMode === 'bypassPermissions' || permissionMode === 'acceptEdits' || permissionMode === 'yolo';
+}
+
+function buildProviderShellPermissionFlags(provider, permissionMode, skipPermissions) {
+    const mode = normalizeShellPermissionMode(permissionMode);
+    const bypass = shouldBypassShellPermissions(mode, skipPermissions);
+
+    if (provider === 'codex') {
+        if (mode === 'bypassPermissions' || mode === 'yolo') {
+            return ['--dangerously-bypass-approvals-and-sandbox'];
+        }
+        if (mode === 'acceptEdits' || mode === 'auto_edit' || bypass) {
+            return ['--sandbox', 'workspace-write', '--ask-for-approval', 'never'];
+        }
+        return [];
+    }
+
+    if (provider === 'gemini' || provider === 'qwen') {
+        if (bypass) {
+            return ['--yolo'];
+        }
+        if (mode === 'auto_edit') {
+            return ['--approval-mode', 'auto_edit'];
+        }
+        if (mode === 'plan') {
+            return ['--approval-mode', 'plan'];
+        }
+        return [];
+    }
+
+    if (provider === 'cursor') {
+        return bypass ? ['-f'] : [];
+    }
+
+    if (provider === 'opencode') {
+        if (mode === 'plan') {
+            return ['--agent', 'plan'];
+        }
+        return bypass ? ['--dangerously-skip-permissions'] : [];
+    }
+
+    if (provider === 'claude') {
+        return bypass ? ['--dangerously-skip-permissions'] : [];
+    }
+
+    return [];
+}
+
+function buildProviderShellCommand(command, permissionFlags = []) {
+    const flags = Array.isArray(permissionFlags) ? permissionFlags.filter(Boolean) : [];
+    return flags.length > 0 ? `${command} ${flags.join(' ')}` : command;
+}
+
+function resolvePublicBaseUrl(request) {
+    const headers = request?.headers || {};
+    const forwardedProto = String(headers['x-forwarded-proto'] || '').split(',')[0].trim();
+    const proto = forwardedProto || (request?.socket?.encrypted ? 'https' : 'http');
+    const host = headers['x-forwarded-host'] || headers.host || `127.0.0.1:${process.env.SERVER_PORT || process.env.PORT || '3001'}`;
+    return `${proto}://${String(host).split(',')[0].trim()}`;
+}
+
+function getOrCreateHermesApiKey(userId) {
+    if (!userId) return null;
+
+    const existing = apiKeysDb
+        .getApiKeys(userId)
+        .find((key) => key.key_name === 'Hermes Agent MCP' && key.is_active);
+    if (existing?.api_key) {
+        return existing.api_key;
+    }
+
+    return apiKeysDb.createApiKey(userId, 'Hermes Agent MCP', [
+        'hermes:mcp',
+        'projects:read',
+        'providers:read',
+        'terminal:launch',
+    ]).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;
+    const configure = `node ${quote(configureScript)}`;
+
+    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 Resolve-HermesCommand {',
+            '$cmd = Get-Command hermes -ErrorAction SilentlyContinue;',
+            'if ($cmd) { return $cmd.Source; }',
+            '$candidates = @(',
+            '$env:HERMES_CLI_PATH,',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\venv\\Scripts\\hermes.exe"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\.venv\\Scripts\\hermes.exe"),',
+            '(Join-Path $env:LOCALAPPDATA "hermes\\hermes-agent\\hermes.exe")',
+            ');',
+            'foreach ($candidate in $candidates) { if ($candidate -and (Test-Path $candidate)) { return $candidate; } }',
+            'return $null;',
+            '}',
+        ].join(' ');
+        const installHermesIfMissing = [
+            'function Install-HermesIfMissing {',
+            '$script:HermesCmd = Resolve-HermesCommand;',
+            'if ($script:HermesCmd) { Write-Host "Hermes already installed:"; & $script:HermesCmd --version; 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}; ${installHermesIfMissing}; Install-HermesIfMissing; ${configure}`;
+        }
+        return `${setEnv}; ${resolveHermesCommand}; ${installHermesIfMissing}; Install-HermesIfMissing; ${configure}; & $script:HermesCmd chat --toolsets "hermes-cli,mcp-pixcode"`;
+    }
+
+    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 = [
+        '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;',
+        '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;',
+        '}',
+    ].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)} && "$HERMES_CMD" chat --toolsets "hermes-cli,mcp-pixcode"`)}`;
+}
+
 // Single WebSocket server that handles both paths
 const wss = new WebSocketServer({
     server,
@@ -1851,7 +2023,7 @@ wss.on('connection', (ws, request) => {
     const pathname = urlObj.pathname;
 
     if (pathname === '/shell') {
-        handleShellConnection(ws);
+        handleShellConnection(ws, request);
     } else if (pathname === '/ws') {
         handleChatConnection(ws, request);
     } else if (pathname.startsWith('/plugin-ws/')) {
@@ -2060,7 +2232,7 @@ function handleChatConnection(ws, request) {
 }
 
 // Handle shell WebSocket connections
-function handleShellConnection(ws) {
+function handleShellConnection(ws, request) {
     console.log('🐚 Shell client connected');
     let shellProcess = null;
     let ptySessionKey = null;
@@ -2090,9 +2262,25 @@ function handleShellConnection(ws) {
                 const sessionId = data.sessionId;
                 const hasSession = data.hasSession;
                 const provider = data.provider || 'claude';
-                const initialCommand = data.initialCommand;
+                let initialCommand = data.initialCommand;
+                const hermesCommand = HERMES_SHELL_COMMANDS.has(initialCommand) ? initialCommand : null;
+                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 isPlainShell = data.isPlainShell || (!!initialCommand && !hasSession) || provider === 'plain-shell';
                 const forceNewSession = Boolean(data.forceNewSession);
+                const shellPermissionMode = normalizeShellPermissionMode(data.permissionMode);
+                const shellSkipPermissions = Boolean(data.skipPermissions);
+                const shellPermissionFlags = buildProviderShellPermissionFlags(provider, shellPermissionMode, shellSkipPermissions);
                 urlDetectionBuffer = '';
                 announcedAuthUrls.clear();
 
@@ -2173,7 +2361,7 @@ function handleShellConnection(ws) {
                 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:', initialCommand);
+                    console.log('⚡ Initial command:', hermesCommand ? hermesCommand : initialCommand);
                 }
 
                 // First send a welcome message
@@ -2223,25 +2411,27 @@ function handleShellConnection(ws) {
                         // Plain shell mode without an initial command must stay interactive.
                         shellCommand = initialCommand || null;
                     } else if (provider === 'cursor') {
+                        const command = buildProviderShellCommand('cursor-agent', shellPermissionFlags);
                         if (hasSession && sessionId) {
-                            shellCommand = `cursor-agent --resume="${sessionId}"`;
+                            shellCommand = `${command} --resume="${sessionId}"`;
                         } else {
-                            shellCommand = 'cursor-agent';
+                            shellCommand = command;
                         }
                     } else if (provider === 'codex') {
                         // Use codex command; attempt to resume and fall back to a new session when the resume fails.
+                        const command = buildProviderShellCommand('codex', shellPermissionFlags);
                         if (hasSession && sessionId) {
                             if (os.platform() === 'win32') {
                                 // PowerShell syntax for fallback
-                                shellCommand = `codex resume "${sessionId}"; if ($LASTEXITCODE -ne 0) { codex }`;
+                                shellCommand = `${command} resume "${sessionId}"; if ($LASTEXITCODE -ne 0) { ${command} }`;
                             } else {
-                                shellCommand = `codex resume "${sessionId}" || codex`;
+                                shellCommand = `${command} resume "${sessionId}" || ${command}`;
                             }
                         } else {
-                            shellCommand = 'codex';
+                            shellCommand = command;
                         }
                     } else if (provider === 'gemini') {
-                        const command = initialCommand || 'gemini';
+                        const command = buildProviderShellCommand(initialCommand || 'gemini', shellPermissionFlags);
                         let resumeId = sessionId;
                         if (hasSession && sessionId) {
                             try {
@@ -2270,7 +2460,7 @@ function handleShellConnection(ws) {
                         // Qwen Code shares Gemini CLI's --resume semantics (it's a fork),
                         // so the resume path resolves the backend-tracked cliSessionId the
                         // same way. Falls back to a fresh session when the ID can't be found.
-                        const command = initialCommand || 'qwen';
+                        const command = buildProviderShellCommand(initialCommand || 'qwen', shellPermissionFlags);
                         let resumeId = sessionId;
                         if (hasSession && sessionId) {
                             try {
@@ -2298,7 +2488,7 @@ function handleShellConnection(ws) {
                         // we pass them straight through without a cliSessionId
                         // mapping layer — OpenCode doesn't renumber IDs the way
                         // Gemini does.
-                        const command = initialCommand || 'opencode';
+                        const command = buildProviderShellCommand(initialCommand || 'opencode', shellPermissionFlags);
                         if (hasSession && sessionId && safeSessionIdPattern.test(sessionId)) {
                             shellCommand = `${command} --session "${sessionId}"`;
                         } else {
@@ -2306,19 +2496,19 @@ function handleShellConnection(ws) {
                         }
                     } else {
                         // Claude (default provider)
-                        const command = initialCommand || 'claude';
+                        const command = buildProviderShellCommand(initialCommand || 'claude', shellPermissionFlags);
                         if (hasSession && sessionId) {
                             if (os.platform() === 'win32') {
-                                shellCommand = `claude --resume "${sessionId}"; if ($LASTEXITCODE -ne 0) { claude }`;
+                                shellCommand = `${command} --resume "${sessionId}"; if ($LASTEXITCODE -ne 0) { ${command} }`;
                             } else {
-                                shellCommand = `claude --resume "${sessionId}" || claude`;
+                                shellCommand = `${command} --resume "${sessionId}" || ${command}`;
                             }
                         } else {
                             shellCommand = command;
                         }
                     }
 
-                    console.log('🔧 Executing shell command:', shellCommand || 'interactive shell');
+                    console.log('🔧 Executing shell command:', hermesCommand ? hermesCommand : (shellCommand || 'interactive shell'));
 
                     // Use appropriate shell based on platform
                     const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';

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

@@ -1,10 +1,85 @@
+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 { adapterRegistry } from '@/modules/orchestration/a2a/adapter-registry.js';
 import { a2aTaskStore as hermesTaskStore } from '@/modules/orchestration/a2a/task-store.js';
 
+const HERMES_TERMINAL_LAUNCH_LIMIT = 100;
+const HERMES_TERMINAL_LAUNCH_PROVIDERS = new Set(['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode']);
+
+type HermesTerminalLaunchEvent = {
+  id: number;
+  provider: string;
+  projectPath: string | null;
+  prompt: string | null;
+  source: string;
+  createdAt: 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 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.',
+  };
+}
+
 export function createHermesRouter(): Router {
   const router = express.Router();
 
@@ -43,6 +118,10 @@ export function createHermesRouter(): Router {
     });
   });
 
+  router.get('/install-status', (_req, res) => {
+    res.json(readHermesInstallStatus());
+  });
+
   router.get('/agents', (_req, res) => {
     res.json({
       agent: 'hermes',
@@ -53,6 +132,46 @@ export function createHermesRouter(): 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;
+    res.json({
+      events: hermesTerminalLaunches.filter((event) => event.id > afterId),
+    });
+  });
+
+  router.post('/terminal-launches', (req, res) => {
+    const body = (req.body ?? {}) as Record<string, unknown>;
+    const provider = typeof body.provider === 'string' ? body.provider.trim() : '';
+    if (!HERMES_TERMINAL_LAUNCH_PROVIDERS.has(provider)) {
+      res.status(400).json({ error: { code: 'INVALID_PROVIDER', message: provider || 'provider is required' } });
+      return;
+    }
+
+    const projectPath = typeof body.projectPath === 'string' && body.projectPath.trim()
+      ? body.projectPath.trim()
+      : null;
+    const prompt = typeof body.prompt === 'string' && body.prompt.trim()
+      ? body.prompt.trim()
+      : null;
+
+    const event: HermesTerminalLaunchEvent = {
+      id: nextHermesTerminalLaunchId,
+      provider,
+      projectPath,
+      prompt,
+      source: 'hermes-mcp',
+      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);
+    }
+
+    res.status(201).json({ event });
+  });
+
   router.get('/tasks/:id', (req, res) => {
     const task = hermesTaskStore.get(req.params.id);
     if (!task) {

package/server/qwen-code-cli.js

@@ -102,7 +102,13 @@ async function spawnQwen(command, options = {}, ws) {
     args.push('--model', modelToUse);
     args.push('--output-format', 'stream-json');
 
-    if (settings.skipPermissions || options.skipPermissions || permissionMode === 'yolo') {
+    if (
+        settings.skipPermissions ||
+        options.skipPermissions ||
+        permissionMode === 'yolo' ||
+        permissionMode === 'bypassPermissions' ||
+        permissionMode === 'acceptEdits'
+    ) {
         args.push('--yolo');
     } else if (permissionMode === 'auto_edit') {
         args.push('--approval-mode', 'auto_edit');