@pixelbyte-software/pixcode 1.49.10 → 1.50.0

package/server/services/hermes-gateway.js

@@ -1,4 +1,5 @@
 import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
@@ -18,6 +19,27 @@ const FETCH_TIMEOUT_MS = 5000;
 const RUN_TIMEOUT_MS = 120000;
 const RUN_POLL_INTERVAL_MS = 1000;
 const LOG_LIMIT = 800;
+const PIXCODE_MANAGED_HERMES_ENV_PREFIXES = [
+    'API_SERVER_',
+    'BLUEBUBBLES_',
+    'DINGTALK_',
+    'DISCORD_',
+    'EMAIL_',
+    'FEISHU_',
+    'MATTERMOST_',
+    'MATRIX_',
+    'MSGRAPH_',
+    'QQ_',
+    'SIGNAL_',
+    'SLACK_',
+    'SMS_',
+    'TELEGRAM_',
+    'TWILIO_',
+    'WECOM_',
+    'WEIXIN_',
+    'WHATSAPP_',
+    'YUANBAO_',
+];
 
 const gateways = new Map();
 
@@ -53,6 +75,96 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function resolveSourceHermesHome(env = process.env) {
+    if (env.HERMES_HOME?.trim()) {
+        return path.resolve(env.HERMES_HOME);
+    }
+
+    const defaultHome = path.join(os.homedir(), '.hermes');
+    try {
+        const activeProfile = fs.readFileSync(path.join(defaultHome, 'active_profile'), 'utf8').trim();
+        if (activeProfile && activeProfile !== 'default' && /^[a-z0-9][a-z0-9_-]{0,63}$/.test(activeProfile)) {
+            return path.join(defaultHome, 'profiles', activeProfile);
+        }
+    } catch {
+        // Default Hermes profile is fine when no sticky active profile exists.
+    }
+
+    return defaultHome;
+}
+
+function resolveHermesGatewayHome(env = process.env, options = {}) {
+    const configured = options.hermesHome || env.PIXCODE_HERMES_GATEWAY_HOME;
+    if (configured) {
+        return path.resolve(configured);
+    }
+
+    return path.join(os.homedir(), '.hermes', 'profiles', 'pixcode');
+}
+
+function copyHermesProfileFile(sourceHome, targetHome, fileName, options = {}) {
+    const source = path.join(sourceHome, fileName);
+    const target = path.join(targetHome, fileName);
+    if (!fs.existsSync(source)) return false;
+    if (!options.overwrite && fs.existsSync(target)) return false;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(source, target);
+    return true;
+}
+
+function shouldStripManagedGatewayEnvLine(line) {
+    const match = String(line || '').match(/^\s*(?:export\s+)?([A-Z0-9_]+)\s*=/);
+    if (!match) return false;
+    return PIXCODE_MANAGED_HERMES_ENV_PREFIXES.some((prefix) => match[1].startsWith(prefix));
+}
+
+function copyHermesProfileEnv(sourceHome, targetHome) {
+    const source = path.join(sourceHome, '.env');
+    const target = path.join(targetHome, '.env');
+    if (!fs.existsSync(source)) return false;
+
+    const sourceText = fs.readFileSync(source, 'utf8');
+    const sanitized = sourceText
+        .split(/\r?\n/)
+        .filter((line) => !shouldStripManagedGatewayEnvLine(line))
+        .join('\n')
+        .replace(/\s*$/, '\n');
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, sanitized);
+    return true;
+}
+
+function seedHermesGatewayHome({ sourceHome, targetHome, gateway }) {
+    fs.mkdirSync(targetHome, { recursive: true });
+    if (path.resolve(sourceHome) === path.resolve(targetHome)) {
+        appendGatewayLog(gateway, 'meta', `Using Hermes gateway profile at ${targetHome}\n`);
+        return;
+    }
+
+    const copied = [];
+    for (const file of ['config.yaml', 'SOUL.md']) {
+        if (copyHermesProfileFile(sourceHome, targetHome, file, { overwrite: false })) {
+            copied.push(file);
+        }
+    }
+    if (copyHermesProfileEnv(sourceHome, targetHome)) {
+        copied.push('.env (without messaging platform credentials)');
+    }
+    for (const file of ['auth.json']) {
+        if (copyHermesProfileFile(sourceHome, targetHome, file, { overwrite: true })) {
+            copied.push(file);
+        }
+    }
+
+    appendGatewayLog(
+        gateway,
+        'meta',
+        copied.length > 0
+            ? `Seeded Pixcode Hermes gateway profile from ${sourceHome}: ${copied.join(', ')}\n`
+            : `Using Pixcode Hermes gateway profile at ${targetHome}\n`,
+    );
+}
+
 export function buildHermesGatewayEnv(baseEnv = process.env, options = {}) {
     const host = options.host || DEFAULT_HOST;
     const port = String(options.port || DEFAULT_PORT);
@@ -345,6 +457,7 @@ function snapshotGateway(gateway) {
             running: false,
             projectPath: null,
             baseUrl: null,
+            hermesHome: null,
             host: null,
             port: null,
             pid: null,
@@ -362,6 +475,7 @@ function snapshotGateway(gateway) {
         running: isGatewayRunning(gateway),
         projectPath: gateway.projectPath,
         baseUrl: gateway.baseUrl,
+        hermesHome: gateway.hermesHome,
         host: gateway.host,
         port: gateway.port,
         pid: gateway.child?.pid ?? null,
@@ -391,16 +505,24 @@ export async function ensureHermesGateway(options = {}) {
     const projectPath = normalizeProjectPath(options.projectPath);
     const existing = gateways.get(projectPath);
     if (isGatewayRunning(existing)) {
+        if (options.probeExisting !== true) {
+            return {
+                ...snapshotGateway(existing),
+                probe: existing.lastProbe,
+            };
+        }
+
         const probe = await probeHermesGateway(projectPath, { requireRunning: true }).catch((error) => ({
             ok: false,
             error: error instanceof Error ? error.message : String(error),
         }));
-        if (probe.ok) {
+        if (probe.ok || options.replaceUnhealthy !== true) {
             return {
                 ...snapshotGateway(existing),
                 probe,
             };
         }
+
         stopHermesGateway(projectPath);
     }
 
@@ -408,12 +530,15 @@ export async function ensureHermesGateway(options = {}) {
     const port = await findAvailablePort(Number(options.port || process.env.HERMES_API_SERVER_PORT || DEFAULT_PORT), host);
     const apiServerKey = options.apiServerKey || makeApiServerKey();
     const appRoot = options.appRoot || process.cwd();
+    const sourceHermesHome = options.sourceHermesHome || resolveSourceHermesHome(process.env);
+    const hermesHome = resolveHermesGatewayHome(process.env, options);
     const env = buildHermesGatewayEnv(process.env, {
         ...options,
         host,
         port,
         apiServerKey,
         appRoot,
+        hermesHome,
     });
     const installStatus = readHermesInstallStatus(env, {
         allowSmokeHermes: options.allowSmokeHermes === true,
@@ -429,6 +554,7 @@ export async function ensureHermesGateway(options = {}) {
         host,
         port,
         baseUrl: gatewayBaseUrl(host, port),
+        hermesHome,
         apiServerKey,
         command: installStatus.command,
         child: null,
@@ -442,6 +568,7 @@ export async function ensureHermesGateway(options = {}) {
     };
     gateways.set(projectPath, gateway);
 
+    seedHermesGatewayHome({ sourceHome: sourceHermesHome, targetHome: hermesHome, gateway });
     await configurePixcodeMcp({ appRoot, env, gateway });
 
     const gatewayArgs = options.gatewayArgs || ['gateway', 'run', '--replace'];

package/server/services/hermes-install-jobs.js

@@ -12,6 +12,7 @@ const POSIX_INSTALLER_URL = 'https://raw.githubusercontent.com/NousResearch/herm
 const WINDOWS_INSTALLER_URL = 'https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1';
 const FINISHED_TTL_MS = 10 * 60 * 1000;
 const HARD_TIMEOUT_MS = 20 * 60 * 1000;
+const HERMES_VERSION_TIMEOUT_MS = 20 * 1000;
 const jobs = new Map();
 
 function pathSeparator() {
@@ -125,13 +126,22 @@ function pushHermesCommandFiles(candidates, dir) {
     }
 }
 
+function hermesVersionTimeoutMs(env = process.env) {
+    const configured = Number(env.HERMES_VERSION_TIMEOUT_MS);
+    if (Number.isFinite(configured) && configured >= 1000) {
+        return configured;
+    }
+
+    return HERMES_VERSION_TIMEOUT_MS;
+}
+
 function runHermesVersion(candidate, env) {
     try {
         const result = spawn.sync(candidate, ['--version'], {
             encoding: 'utf8',
             env,
             stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: 5000,
+            timeout: hermesVersionTimeoutMs(env),
             windowsHide: true,
         });
         if (result.error || result.status !== 0) {