@evomap/evolver 1.89.14 → 1.89.17

package/src/ops/lifecycle.js

@@ -7,6 +7,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execFileSync, execSync, spawn } = require('child_process');
+const { readSettings } = require('../proxy/server/settings');
 // 10 MB — prevents RangeError on large child process output (e.g. git log/diff
 // on large repos). See GHSA reports / issue #451.
 const MAX_EXEC_BUFFER = 10 * 1024 * 1024;
@@ -46,7 +47,30 @@ function execFileText(file, args) {
     });
 }
 
+// --- Test-only process-table injection -------------------------------------
+// Lets the lifecycle proxy-health tests run hermetically on a host that already
+// has REAL `node index.js --loop` processes (CI runners, or a live agent box).
+// Without it, getRunningPids()/checkHealth()/stopOwnedLoops() read the actual
+// process table via ps/proc and would (a) fail their "not_running" assertions
+// against unrelated real loops and (b) risk SIGTERM-ing real production loops.
+// Production never installs a table; listProcesses()/getPidCwd()/isPidRunning()
+// consult it only when one has been set. Entries are { pid, args, cwd }.
+var _processTableForTest = null;
+function _setProcessTableForTest(table) {
+    _processTableForTest = Array.isArray(table) ? table.map(function (p) {
+        return {
+            pid: parseInt(p.pid, 10),
+            args: String(p.args || ''),
+            cwd: p.cwd != null ? String(p.cwd) : null,
+        };
+    }) : null;
+}
+function _resetProcessTableForTest() { _processTableForTest = null; }
+
 function listProcesses() {
+    if (_processTableForTest) {
+        return _processTableForTest.map(function (p) { return { pid: p.pid, args: p.args }; });
+    }
     if (process.platform === 'win32') {
         var out = execFileText('powershell', [
             '-NoProfile',
@@ -101,9 +125,225 @@ function getRunningPids() {
 }
 
 function isPidRunning(pid) {
+    if (_processTableForTest) {
+        var spRun = parseInt(pid, 10);
+        return _processTableForTest.some(function (p) { return p.pid === spRun; });
+    }
     try { process.kill(pid, 0); return true; } catch (e) { return false; }
 }
 
+function boolEnv(value) {
+    var raw = String(value || '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
+function isLoopbackProxyUrl(value) {
+    var raw = String(value || '').trim().replace(/\/+$/, '');
+    if (!raw) return false;
+    try {
+        var parsed = new URL(raw);
+        if (parsed.protocol !== 'http:') return false;
+        var host = parsed.hostname.toLowerCase();
+        return host === '127.0.0.1' || host === 'localhost' || host === '::1' || host === '[::1]';
+    } catch (_) {
+        return false;
+    }
+}
+
+function readJsonFile(file) {
+    try {
+        if (!file || !fs.existsSync(file)) return null;
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch (_) {
+        return null;
+    }
+}
+
+function getClaudeSettingsFile(env) {
+    var e = env || process.env;
+    var explicit = String(e.CLAUDE_SETTINGS_FILE || e.EVOMAP_CLAUDE_SETTINGS_FILE || '').trim();
+    if (explicit) return explicit;
+    var home = e.HOME || os.homedir();
+    return home ? path.join(home, '.claude', 'settings.json') : null;
+}
+
+function getCodexConfigFile(env) {
+    var e = env || process.env;
+    var explicit = String(e.CODEX_CONFIG_FILE || e.EVOMAP_CODEX_CONFIG_FILE || '').trim();
+    if (explicit) return explicit;
+    var home = e.HOME || os.homedir();
+    return home ? path.join(home, '.codex', 'config.toml') : null;
+}
+
+function stripTomlComment(line) {
+    var out = '';
+    var quote = null;
+    var escaped = false;
+    for (var i = 0; i < String(line || '').length; i++) {
+        var ch = line[i];
+        if (escaped) {
+            out += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && quote === '"') {
+            out += ch;
+            escaped = true;
+            continue;
+        }
+        if ((ch === '"' || ch === "'") && !quote) {
+            quote = ch;
+            out += ch;
+            continue;
+        }
+        if (ch === quote) {
+            quote = null;
+            out += ch;
+            continue;
+        }
+        if (ch === '#' && !quote) break;
+        out += ch;
+    }
+    return out.trim();
+}
+
+function readTomlStringValue(value) {
+    var raw = stripTomlComment(value);
+    var match = raw.match(/^(['"])([\s\S]*)\1$/);
+    if (match) return match[2];
+    return raw.trim();
+}
+
+function codexConfigExpectsProxy(env) {
+    var file = getCodexConfigFile(env);
+    if (!file || !fs.existsSync(file)) return false;
+    var selectedProvider = null;
+    var section = '';
+    var providerUrls = {};
+    try {
+        var content = fs.readFileSync(file, 'utf8');
+        for (var line of content.split(/\r?\n/)) {
+            var clean = stripTomlComment(line);
+            if (!clean) continue;
+            var sectionMatch = clean.match(/^\[([^\]]+)\]$/);
+            if (sectionMatch) {
+                section = sectionMatch[1].trim();
+                continue;
+            }
+            var kv = clean.match(/^([A-Za-z0-9_.-]+)\s*=\s*([\s\S]+)$/);
+            if (!kv) continue;
+            var key = kv[1].trim();
+            var val = readTomlStringValue(kv[2]);
+            if (!section && key === 'model_provider') {
+                selectedProvider = val;
+                continue;
+            }
+            var providerMatch = section.match(/^model_providers\.([A-Za-z0-9_.-]+)$/);
+            if (providerMatch && key === 'base_url') {
+                providerUrls[providerMatch[1]] = val;
+                continue;
+            }
+            if (!section && key === 'base_url' && isLoopbackProxyUrl(val)) {
+                return true;
+            }
+        }
+    } catch (_) {
+        return false;
+    }
+    if (selectedProvider && isLoopbackProxyUrl(providerUrls[selectedProvider])) return true;
+    return Object.keys(providerUrls).some(function(name) {
+        return /(?:evomap|proxy)/i.test(name) && isLoopbackProxyUrl(providerUrls[name]);
+    });
+}
+
+function clientSettingsExpectProxy(env) {
+    var settings = readJsonFile(getClaudeSettingsFile(env));
+    var cfg = settings && settings.env;
+    if (!cfg || typeof cfg !== 'object') return false;
+    if (isLoopbackProxyUrl(cfg.EVOMAP_PROXY_URL)) return true;
+    if (String(cfg.EVOMAP_PROXY_AUTO_INJECTED || '') === '1' && isLoopbackProxyUrl(cfg.ANTHROPIC_BASE_URL)) return true;
+    return !!(settings._evomap_proxy_client_env && settings._evomap_proxy_client_env.managed_by === 'evomap-proxy'
+        && isLoopbackProxyUrl(cfg.ANTHROPIC_BASE_URL));
+}
+
+function expectsProxy(env) {
+    var e = env || process.env;
+    if (boolEnv(e.EVOMAP_PROXY)) return true;
+    if (String(e.A2A_TRANSPORT || '').trim().toLowerCase() === 'mailbox') return true;
+    if (isLoopbackProxyUrl(e.EVOMAP_PROXY_URL) || isLoopbackProxyUrl(e.ANTHROPIC_BASE_URL)) return true;
+    if (codexConfigExpectsProxy(e)) return true;
+    return clientSettingsExpectProxy(e);
+}
+
+function prepareStartEnv(env) {
+    var next = Object.assign({}, env || process.env);
+    if (expectsProxy(next)) {
+        next.EVOMAP_PROXY = '1';
+    }
+    return next;
+}
+
+function isProxyUrlReachable(url, token) {
+    if (!url || !token) return false;
+    try {
+        execFileSync(process.execPath, ['-e', `
+const fs = require('fs');
+const http = require('http');
+const url = process.argv[1];
+const token = fs.readFileSync(0, 'utf8').trim();
+if (!token) process.exit(1);
+const req = http.get(url.replace(/\\/+$/, '') + '/proxy/status', {
+  headers: { Authorization: 'Bearer ' + token },
+}, (res) => {
+  let body = '';
+  res.setEncoding('utf8');
+  res.on('data', (chunk) => {
+    body += chunk;
+    if (body.length > 1024 * 1024) req.destroy(new Error('response too large'));
+  });
+  res.on('end', () => {
+    if (res.statusCode < 200 || res.statusCode >= 300) process.exit(1);
+    let parsed;
+    try { parsed = JSON.parse(body); } catch (_) { process.exit(1); }
+    if (parsed && parsed.status === 'running' && (parsed.proxy_protocol_version || parsed.schema_version || parsed.node_id != null)) {
+      process.exit(0);
+    }
+    process.exit(1);
+  });
+});
+req.setTimeout(800, () => { req.destroy(new Error('timeout')); });
+req.on('error', () => process.exit(1));
+`, url], { input: String(token), stdio: ['pipe', 'ignore', 'ignore'], timeout: 1500, windowsHide: true });
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+function checkProxyHealth(env) {
+    if (!expectsProxy(env)) return { healthy: true, expected: false };
+    var proxy = readSettings().proxy || {};
+    if (!proxy.url) {
+        return { healthy: false, expected: true, reason: 'proxy_not_configured' };
+    }
+    if (proxy.pid && !isPidRunning(proxy.pid)) {
+        return { healthy: false, expected: true, reason: 'proxy_pid_stale', proxyPid: proxy.pid, proxyUrl: proxy.url };
+    }
+    if (!proxy.token) {
+        return { healthy: false, expected: true, reason: 'proxy_token_missing', proxyPid: proxy.pid, proxyUrl: proxy.url };
+    }
+    if (!isProxyUrlReachable(proxy.url, proxy.token)) {
+        return { healthy: false, expected: true, reason: 'proxy_unreachable', proxyPid: proxy.pid, proxyUrl: proxy.url };
+    }
+    return { healthy: true, expected: true, proxyPid: proxy.pid, proxyUrl: proxy.url };
+}
+
+function shouldRestartForProxy(pids, env) {
+    if (!pids || pids.length === 0) return false;
+    var proxyHealth = checkProxyHealth(env);
+    return proxyHealth.expected === true && proxyHealth.healthy === false;
+}
+
 function getCmdLine(pid) {
     try {
         const safePid = parseInt(pid, 10);
@@ -115,14 +355,235 @@ function getCmdLine(pid) {
     }
 }
 
+function getPidCwd(pid) {
+    const safePid = parseInt(pid, 10);
+    if (!Number.isFinite(safePid) || safePid <= 0) return null;
+    if (_processTableForTest) {
+        var cwdEntry = _processTableForTest.find(function (p) { return p.pid === safePid; });
+        return cwdEntry ? cwdEntry.cwd : null;
+    }
+    if (process.platform === 'win32') return null;
+    if (process.platform === 'linux') {
+        try { return fs.realpathSync('/proc/' + safePid + '/cwd'); } catch (_) {}
+    }
+    try {
+        var lsofOut = execFileSync('lsof', ['-a', '-p', String(safePid), '-d', 'cwd', '-Fn'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: MAX_EXEC_BUFFER,
+            timeout: 1000,
+            windowsHide: true
+        });
+        for (var line of lsofOut.split(/\r?\n/)) {
+            if (line && line[0] === 'n') {
+                try { return fs.realpathSync(line.slice(1)); } catch (_) { return path.resolve(line.slice(1)); }
+            }
+        }
+    } catch (_) {}
+    try {
+        var pwdxOut = execFileText('pwdx', [String(safePid)]).trim();
+        var match = pwdxOut.match(/^\d+:\s*(.+)$/);
+        if (match) {
+            try { return fs.realpathSync(match[1]); } catch (_) { return path.resolve(match[1]); }
+        }
+    } catch (_) {}
+    return null;
+}
+
+function commandIncludesPath(cmd, targetPath) {
+    if (!cmd || !targetPath) return false;
+    var cmdNorm = String(cmd).replace(/\\/g, '/');
+    var candidates = [targetPath];
+    try { candidates.push(fs.realpathSync(targetPath)); } catch (_) {}
+    return candidates.some(function(candidate) {
+        var normalized = path.resolve(candidate).replace(/\\/g, '/');
+        return normalized && cmdNorm.includes(normalized);
+    });
+}
+
+function splitCommandLine(cmd) {
+    var tokens = [];
+    var current = '';
+    var quote = null;
+    var escaped = false;
+    var raw = String(cmd || '');
+    for (var i = 0; i < raw.length; i++) {
+        var ch = raw[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if ((ch === '"' || ch === "'") && !quote) {
+            quote = ch;
+            continue;
+        }
+        if (ch === quote) {
+            quote = null;
+            continue;
+        }
+        if (/\s/.test(ch) && !quote) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escaped) current += '\\';
+    if (current) tokens.push(current);
+    return tokens;
+}
+
+function looksLikeNodeToken(token) {
+    var base = path.basename(String(token || '').replace(/\\/g, '/')).toLowerCase();
+    return base === 'node' || base === 'node.exe';
+}
+
+function nodeOptionTakesValue(option) {
+    var name = String(option || '').split('=')[0];
+    return name === '-r' || name === '--require' ||
+        name === '--import' ||
+        name === '--loader' || name === '--experimental-loader' ||
+        name === '--icu-data-dir' ||
+        name === '--openssl-config' ||
+        name === '--redirect-warnings';
+}
+
+function nodeOptionIsEvalMode(option) {
+    var name = String(option || '').split('=')[0];
+    return name === '-e' || name === '--eval' ||
+        name === '-p' || name === '--print' ||
+        name === '-c' || name === '--check';
+}
+
+function getNodeScriptToken(tokens) {
+    for (var i = 0; i < tokens.length; i++) {
+        if (!looksLikeNodeToken(tokens[i])) continue;
+        for (var j = i + 1; j < tokens.length; j++) {
+            var token = tokens[j];
+            if (!token) continue;
+            if (token === '--') return tokens[j + 1] || null;
+            if (token[0] === '-') {
+                if (nodeOptionIsEvalMode(token)) return null;
+                if (nodeOptionTakesValue(token) && !token.includes('=')) j++;
+                continue;
+            }
+            return token;
+        }
+    }
+    return null;
+}
+
+function sameRealPath(left, right) {
+    try {
+        return fs.realpathSync(left) === fs.realpathSync(right);
+    } catch (_) {
+        return false;
+    }
+}
+
+function commandUsesCurrentRepoRelativeIndex(cmd, cwd) {
+    if (!cwd) return false;
+    var script = getNodeScriptToken(splitCommandLine(cmd));
+    if (!script || path.isAbsolute(script)) return false;
+    if (path.basename(script.replace(/\\/g, '/')).toLowerCase() !== 'index.js') return false;
+    return sameRealPath(path.resolve(cwd, script), path.join(getRepoRoot(), 'index.js'));
+}
+
+function isCurrentLoopCommand(cmd, cwd) {
+    var raw = String(cmd || '');
+    var lower = raw.toLowerCase();
+    if (!lower.includes('node') || !lower.includes('--loop')) return false;
+    if (commandIncludesPath(raw, getLoopScript())) return true;
+    if (commandIncludesPath(raw, path.join(getRepoRoot(), 'index.js'))) return true;
+    return commandUsesCurrentRepoRelativeIndex(raw, cwd);
+}
+
+function readPidFile(file) {
+    try {
+        if (!file || !fs.existsSync(file)) return null;
+        var raw = fs.readFileSync(file, 'utf8').trim();
+        var pid = parseInt(raw, 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    } catch (_) {
+        return null;
+    }
+}
+
+function getOwnedLoopPids(discoveredPids) {
+    var candidates = new Set();
+    function addPid(pid) {
+        var parsed = parseInt(pid, 10);
+        if (Number.isFinite(parsed) && parsed > 0) candidates.add(parsed);
+    }
+    (discoveredPids || []).forEach(addPid);
+    addPid(readPidFile(PID_FILE));
+    try {
+        var proxyPid = (readSettings().proxy || {}).pid;
+        addPid(proxyPid);
+    } catch (_) {}
+    return Array.from(candidates).filter(function(pid) {
+        if (!isPidRunning(pid)) return false;
+        var cmd = getCmdLine(pid);
+        if (isCurrentLoopCommand(cmd)) return true;
+        return isCurrentLoopCommand(cmd, getPidCwd(pid));
+    });
+}
+
+function stopPids(pids, options) {
+    var targets = Array.from(new Set(pids || [])).map(function(pid) {
+        return parseInt(pid, 10);
+    }).filter(Number.isFinite);
+    for (var i = 0; i < targets.length; i++) {
+        console.log('[Lifecycle] Stopping PID ' + targets[i] + '...');
+        try { process.kill(targets[i], 'SIGTERM'); } catch (e) {}
+    }
+    var attempts = 0;
+    while (targets.some(isPidRunning) && attempts < 10) {
+        sleepMs(500);
+        attempts++;
+    }
+    var remaining = targets.filter(isPidRunning);
+    for (var j = 0; j < remaining.length; j++) {
+        console.log('[Lifecycle] Force-killing PID ' + remaining[j]);
+        if (process.platform === 'win32') {
+            try { execFileSync('taskkill', ['/F', '/PID', String(remaining[j])], { stdio: 'ignore', windowsHide: true }); } catch (e) {}
+        } else {
+            try { process.kill(remaining[j], 'SIGKILL'); } catch (e) {}
+        }
+    }
+    if (options && options.unlinkPidFile) {
+        try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch (_) {}
+    }
+    if (options && options.unlinkLock) {
+        var evolverLock = path.join(getRepoRoot(), 'evolver.pid');
+        try { if (fs.existsSync(evolverLock)) fs.unlinkSync(evolverLock); } catch (_) {}
+    }
+    return { status: 'stopped', killed: targets };
+}
+
 // --- Lifecycle ---
 
 function start(options) {
     var delayMs = (options && options.delayMs) || 0;
     var pids = getRunningPids();
-    if (pids.length > 0) {
-        console.log('[Lifecycle] Already running (PIDs: ' + pids.join(', ') + ').');
-        return { status: 'already_running', pids: pids };
+    var ownedPids = getOwnedLoopPids(pids);
+    if (ownedPids.length > 0) {
+        if (shouldRestartForProxy(ownedPids, process.env)) {
+            console.log('[Lifecycle] Loop running but proxy is unhealthy; restarting.');
+            stopPids(ownedPids, { unlinkPidFile: true, unlinkLock: true });
+            ownedPids = getOwnedLoopPids(getRunningPids());
+        }
+    }
+    if (ownedPids.length > 0) {
+        console.log('[Lifecycle] Already running (PIDs: ' + ownedPids.join(', ') + ').');
+        return { status: 'already_running', pids: ownedPids };
     }
     if (delayMs > 0) {
         sleepMs(delayMs);
@@ -134,7 +595,7 @@ function start(options) {
     var out = fs.openSync(LOG_FILE, 'a');
     var err = fs.openSync(LOG_FILE, 'a');
 
-    var env = Object.assign({}, process.env);
+    var env = prepareStartEnv(process.env);
     // .npm-global/bin is a Unix-only convention; skip the PATH injection on Windows
     // to avoid polluting the environment with a path that does not exist.
     if (process.platform !== 'win32') {
@@ -162,36 +623,23 @@ function stop() {
         try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch (_) {}
         return { status: 'not_running' };
     }
-    for (var i = 0; i < pids.length; i++) {
-        console.log('[Lifecycle] Stopping PID ' + pids[i] + '...');
-        try { process.kill(pids[i], 'SIGTERM'); } catch (e) {}
-    }
-    var attempts = 0;
-    while (getRunningPids().length > 0 && attempts < 10) {
-        sleepMs(500);
-        attempts++;
-    }
-    var remaining = getRunningPids();
-    for (var j = 0; j < remaining.length; j++) {
-        console.log('[Lifecycle] Force-killing PID ' + remaining[j]);
-        // Windows does not support SIGKILL; use taskkill /F instead.
-        if (process.platform === 'win32') {
-            try { execFileSync('taskkill', ['/F', '/PID', String(remaining[j])], { stdio: 'ignore', windowsHide: true }); } catch (e) {}
-        } else {
-            try { process.kill(remaining[j], 'SIGKILL'); } catch (e) {}
-        }
-    }
-    // Wrap in try/catch: on Windows a just-killed process may still hold its
-    // file handles open for a brief moment, causing EBUSY on unlinkSync.
-    try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch (_) {}
-    var evolverLock = path.join(getRepoRoot(), 'evolver.pid');
-    try { if (fs.existsSync(evolverLock)) fs.unlinkSync(evolverLock); } catch (_) {}
+    // Preserve the existing CLI stop semantics: stop every discoverable loop.
+    stopPids(pids, { unlinkPidFile: true, unlinkLock: true });
     console.log('[Lifecycle] All stopped.');
     return { status: 'stopped', killed: pids };
 }
 
+function stopOwnedLoops() {
+    var ownedPids = getOwnedLoopPids(getRunningPids());
+    if (ownedPids.length === 0) {
+        try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch (_) {}
+        return { status: 'not_running' };
+    }
+    return stopPids(ownedPids, { unlinkPidFile: true, unlinkLock: true });
+}
+
 function restart(options) {
-    stop();
+    stopOwnedLoops();
     return start(Object.assign({ delayMs: 2000 }, options || {}));
 }
 
@@ -241,8 +689,12 @@ function tailLog(lines) {
 }
 
 function checkHealth() {
-    var pids = getRunningPids();
+    var pids = getOwnedLoopPids(getRunningPids());
     if (pids.length === 0) return { healthy: false, reason: 'not_running' };
+    var proxyHealth = checkProxyHealth(process.env);
+    if (!proxyHealth.healthy) {
+        return Object.assign({ healthy: false }, proxyHealth);
+    }
     if (fs.existsSync(LOG_FILE)) {
         var silenceMs = Date.now() - fs.statSync(LOG_FILE).mtimeMs;
         if (silenceMs > MAX_SILENCE_MS) {
@@ -325,4 +777,22 @@ if (require.main === module) {
     }
 }
 
-module.exports = { start, stop, restart, status, tailLog, checkHealth, getRunningPids };
+module.exports = {
+    start,
+    stop,
+    restart,
+    status,
+    tailLog,
+    checkHealth,
+    getRunningPids,
+    expectsProxy,
+    prepareStartEnv,
+    checkProxyHealth,
+    shouldRestartForProxy,
+    isProxyUrlReachable,
+    isCurrentLoopCommand,
+    getOwnedLoopPids,
+    stopOwnedLoops,
+    _setProcessTableForTest,
+    _resetProcessTableForTest,
+};