evolcore 0.0.23 → 0.0.25

package/dist/utils/cross-platform.js

@@ -1,12 +1,197 @@
 import path from 'path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createRequire } from 'module';
 import { execFileSync, execFile, spawn, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs';
 import { getProcessStartTime, parseCimDate } from './process-introspect.js';
 import { decodeWindowsOutput } from './windows-output.js';
 const execFileAsync = promisify(execFile);
+const CLI_PROBE_FAILURE_BACKOFF_MS = 5_000;
+const CLI_PROBE_PACKAGES = {
+    codex: '@openai/codex',
+    claude: '@anthropic-ai/claude-code',
+    gemini: '@google/gemini-cli',
+};
+const cliPathCache = new Map();
+const cliInstallationCache = new Map();
+const cliProbeCache = new Map();
 export const isWindows = process.platform === 'win32';
+/** Resolve a CLI executable without spawning where/which. */
+export function resolveProbePath(command) {
+    const pathKey = `${command}\0${process.cwd()}\0${process.env.PATH ?? ''}\0${process.env.PATHEXT ?? ''}`;
+    const cachedPath = cliPathCache.get(pathKey);
+    if (cachedPath && fs.existsSync(cachedPath))
+        return cachedPath;
+    cliPathCache.delete(pathKey);
+    const directories = (process.env.PATH ?? '').split(path.delimiter);
+    if (isWindows)
+        directories.unshift(process.cwd());
+    const extensions = isWindows
+        ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(ext => /\.(com|exe|bat|cmd)$/i.test(ext))
+        : [''];
+    for (const directory of directories) {
+        for (const extension of extensions) {
+            const candidate = path.resolve(directory.replace(/^"|"$/g, ''), command + extension);
+            try {
+                if (!fs.statSync(candidate).isFile())
+                    continue;
+                fs.accessSync(candidate, isWindows ? fs.constants.F_OK : fs.constants.X_OK);
+                cliPathCache.set(pathKey, candidate);
+                return candidate;
+            }
+            catch { /* Continue PATH lookup. */ }
+        }
+    }
+    return null;
+}
+function cliFileIdentity(file) {
+    try {
+        const real = fs.realpathSync(file);
+        const stat = fs.statSync(real);
+        return `${real}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+    }
+    catch {
+        return `${file}:missing`;
+    }
+}
+/** Return an installation fingerprint so probes refresh after CLI upgrades. */
+export function probeInstallationIdentity(command, executable) {
+    const cacheKey = `${command}\0${executable}`;
+    const cached = cliInstallationCache.get(cacheKey);
+    if (cached && cached.files.map(cliFileIdentity).join('|') === cached.identity)
+        return cached.identity;
+    const files = [executable];
+    const packageName = CLI_PROBE_PACKAGES[command];
+    if (packageName) {
+        files.push(path.join(path.dirname(executable), 'node_modules', packageName, 'package.json'));
+        try {
+            const real = fs.realpathSync(executable);
+            const require = createRequire(real);
+            const packageFile = require.resolve(`${packageName}/package.json`);
+            files.push(packageFile);
+            if (command === 'codex') {
+                const platformPackage = `@openai/codex-${process.platform}-${process.arch}`;
+                const platformFile = createRequire(packageFile).resolve(`${platformPackage}/package.json`);
+                files.push(platformFile);
+                const arch = process.arch === 'x64' ? 'x86_64' : 'aarch64';
+                const target = isWindows ? `${arch}-pc-windows-msvc`
+                    : process.platform === 'darwin' ? `${arch}-apple-darwin` : `${arch}-unknown-linux-musl`;
+                for (const root of [path.dirname(platformFile), path.dirname(packageFile)]) {
+                    files.push(path.join(root, 'vendor', target, 'bin', isWindows ? 'codex.exe' : 'codex'));
+                }
+            }
+        }
+        catch { /* Standalone executables have no npm package. */ }
+    }
+    const uniqueFiles = [...new Set(files)];
+    const identity = uniqueFiles.map(cliFileIdentity).join('|');
+    cliInstallationCache.set(cacheKey, { files: uniqueFiles, identity });
+    return identity;
+}
+/** Clear CLI probe caches after an in-process CLI installation. */
+export function invalidateCliProbes() {
+    cliPathCache.clear();
+    cliInstallationCache.clear();
+    cliProbeCache.clear();
+}
+function cliProbeTimeouts(command, options) {
+    return options.timeouts?.length ? options.timeouts : command === 'codex' ? [3_000, 15_000] : [3_000];
+}
+function prepareCliProbe(command, args) {
+    const executable = resolveProbePath(command);
+    if (!executable)
+        throw Object.assign(new Error(`${command} CLI not found`), { code: 'ENOENT' });
+    const identity = `${probeInstallationIdentity(command, executable)}|${process.env.ComSpec ?? ''}`;
+    const key = JSON.stringify([command, args]);
+    let entry = cliProbeCache.get(key);
+    if (!entry || entry.identity !== identity || (entry.retryAt !== undefined && Date.now() >= entry.retryAt)) {
+        entry = { identity };
+        cliProbeCache.set(key, entry);
+    }
+    const shim = isWindows && /\.(cmd|bat)$/i.test(executable);
+    return { entry, command: shim ? process.env.ComSpec ?? 'cmd.exe' : executable,
+        args: shim ? ['/d', '/s', '/c', executable, ...args] : args };
+}
+function failCliProbe(entry, error) {
+    entry.error = error;
+    entry.retryAt = Date.now() + CLI_PROBE_FAILURE_BACKOFF_MS;
+    throw error;
+}
+export function probeCliSync(command, args, options = {}) {
+    const request = prepareCliProbe(command, args);
+    if (request.entry.output !== undefined)
+        return request.entry.output;
+    if (request.entry.error !== undefined)
+        throw request.entry.error;
+    for (const [index, timeout] of cliProbeTimeouts(command, options).entries()) {
+        const startedAt = Date.now();
+        try {
+            return request.entry.output = execFileSync(request.command, request.args, { encoding: 'utf8', timeout, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (error) {
+            options.onFailure?.(args, startedAt, error, timeout);
+            if (error.code !== 'ETIMEDOUT' || index === cliProbeTimeouts(command, options).length - 1)
+                return failCliProbe(request.entry, error);
+        }
+    }
+    throw new Error('CLI probe exhausted');
+}
+export async function probeCli(command, args, options = {}) {
+    const request = prepareCliProbe(command, args);
+    if (request.entry.output !== undefined)
+        return request.entry.output;
+    if (request.entry.error !== undefined)
+        throw request.entry.error;
+    if (request.entry.pending)
+        return request.entry.pending;
+    const run = async () => {
+        const timeouts = cliProbeTimeouts(command, options);
+        for (const [index, timeout] of timeouts.entries()) {
+            const startedAt = Date.now();
+            try {
+                const output = await new Promise((resolve, reject) => {
+                    const child = execFile(request.command, request.args, { encoding: 'utf8', timeout, windowsHide: true }, (error, stdout, stderr) => {
+                        if (error) {
+                            if (error.killed && error.signal === 'SIGTERM' && error.code == null)
+                                error.code = 'ETIMEDOUT';
+                            Object.assign(error, { stdout, stderr, path: request.command, spawnargs: request.args });
+                            reject(error);
+                        }
+                        else
+                            resolve(stdout);
+                    });
+                    child.stdin?.end();
+                });
+                return request.entry.output = output;
+            }
+            catch (error) {
+                options.onFailure?.(args, startedAt, error, timeout);
+                if (error.code !== 'ETIMEDOUT' || index === timeouts.length - 1)
+                    return failCliProbe(request.entry, error);
+            }
+        }
+        throw new Error('CLI probe exhausted');
+    };
+    request.entry.pending = run();
+    try {
+        return await request.entry.pending;
+    }
+    finally {
+        request.entry.pending = undefined;
+    }
+}
+/** Non-blocking version lookup used by status menus. */
+export function cachedCliVersion(command) {
+    try {
+        const { entry } = prepareCliProbe(command, ['--version']);
+        if (entry.output !== undefined)
+            return entry.output.match(/\b\d+\.\d+\.\d+(?:[-+][\w.-]+)?/)?.[0] ?? null;
+        void probeCli(command, ['--version']).catch(() => { });
+    }
+    catch { /* Missing CLI. */ }
+    return null;
+}
 /**
  * Start a detached EvolCore Node process without creating a console window on
  * Windows. The child is unref'd here so callers cannot accidentally keep the
@@ -22,6 +207,256 @@ export function spawnDetachedNode(args, env = {}) {
     child.unref();
     return child;
 }
+/**
+ * Spawn the restart monitor and wait until it proves it is running.
+ *
+ * Every caller stops (or kills) the daemon right after this returns, so a
+ * monitor that dies while loading leaves nothing running and nobody watching.
+ * In a checkout the monitor is executed through tsx, where a syntax error
+ * anywhere in its import graph is fatal at load time — and the usual
+ * `stdio: 'ignore'` would throw that diagnostic away. So stderr is captured,
+ * and success requires the child to still be alive after it had a chance to
+ * fail, not merely to have been spawned.
+ *
+ * `isAliveInRegistry` lets the caller define proof-of-life without dragging the
+ * instance registry into this module.
+ */
+export async function launchMonitorAndConfirm(args, env, isAliveInRegistry, hasOtherLiveMonitor, timeoutMs = 15_000) {
+    const child = spawn(process.execPath, [...args], {
+        detached: true,
+        stdio: ['ignore', 'ignore', 'pipe'],
+        windowsHide: isWindows,
+        env: { ...process.env, ...env },
+    });
+    let stderrTail = '';
+    child.stderr?.on('data', (chunk) => {
+        stderrTail = (stderrTail + chunk.toString()).slice(-2000);
+    });
+    // Capturing stderr must not defeat detached-process semantics. A referenced
+    // pipe keeps the caller's event loop alive until the monitor exits, which
+    // makes restart commands wait for the monitor's full lifetime.
+    child.stderr?.unref?.();
+    let exitCode = null;
+    let spawnError = null;
+    child.on('exit', code => { exitCode = code; });
+    child.on('error', err => { spawnError = err.message; });
+    const childPid = child.pid;
+    child.unref();
+    if (!childPid)
+        return { ok: false, reason: 'spawn 未返回 PID' };
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, 300));
+        if (spawnError)
+            return { ok: false, reason: spawnError, stderrTail };
+        if (exitCode !== null) {
+            // Exiting cleanly is legitimate when another monitor already owns this
+            // restart (single-instance election) — that one is alive and in charge.
+            if (exitCode === 0 && hasOtherLiveMonitor(childPid))
+                return { ok: true };
+            return { ok: false, reason: `进程已退出，exit=${exitCode}`, stderrTail };
+        }
+        // Registering means the module graph loaded and the monitor started work.
+        if (isAliveInRegistry(childPid))
+            return { ok: true };
+    }
+    // Still running but not yet registered: a slow start is not a failure.
+    if (isProcessRunning(childPid))
+        return { ok: true };
+    return { ok: false, reason: '进程未登记且已消失', stderrTail };
+}
+/**
+ * Copy the monitor out of the package directory so an upgrade cannot replace it
+ * mid-flight.
+ *
+ * This is the installed-package counterpart of running the monitor from `src/`
+ * in a checkout: `npm install -g` swaps the whole package directory, and the
+ * monitor has ~170 lazy `await import()` sites, so a module it has not loaded
+ * yet would come from the new version while the rest is still the old one.
+ * Staging `dist/` elsewhere keeps its module graph on one consistent version.
+ *
+ * Only `dist/` and `package.json` are copied (a few MB). `node_modules` is
+ * linked, because copying it is hundreds of MB. The link degrades in steps so
+ * that no platform is left without a path forward:
+ *
+ *   1. symlink — `junction` on Windows (works without elevation, unlike a
+ *      `dir` symlink which needs admin or developer mode), plain dir symlink
+ *      elsewhere. Junctions cannot span volumes, hence the fallbacks.
+ *   2. full copy — slow but always permitted.
+ *   3. skip staging — caller runs the monitor in place, exactly as before.
+ *      Losing the upgrade isolation is much better than losing the restart.
+ */
+export function prepareMonitorStage(packageRoot, stageParent) {
+    const distSource = path.join(packageRoot, 'dist');
+    const modulesSource = path.join(packageRoot, 'node_modules');
+    if (!fs.existsSync(distSource)) {
+        return { stageDir: null, linkMode: 'none', note: 'dist/ 不存在，跳过 stage' };
+    }
+    // Clear stages left behind by a monitor that was killed before self-cleanup.
+    try {
+        const cutoff = Date.now() - 60 * 60 * 1000;
+        for (const entry of fs.readdirSync(stageParent, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const full = path.join(stageParent, entry.name);
+            if (fs.statSync(full).mtimeMs < cutoff)
+                fs.rmSync(full, { recursive: true, force: true });
+        }
+    }
+    catch { /* stageParent may not exist yet */ }
+    const stageDir = path.join(stageParent, `${process.pid}-${Date.now()}`);
+    try {
+        fs.mkdirSync(stageDir, { recursive: true });
+        fs.cpSync(distSource, path.join(stageDir, 'dist'), { recursive: true });
+        const pkgJson = path.join(packageRoot, 'package.json');
+        if (fs.existsSync(pkgJson))
+            fs.copyFileSync(pkgJson, path.join(stageDir, 'package.json'));
+    }
+    catch (error) {
+        try {
+            fs.rmSync(stageDir, { recursive: true, force: true });
+        }
+        catch { }
+        return { stageDir: null, linkMode: 'none', note: `复制 dist/ 失败：${error.message}` };
+    }
+    if (!fs.existsSync(modulesSource)) {
+        // Dependencies hoisted elsewhere; nothing to link, node resolves upward.
+        return { stageDir, linkMode: 'none' };
+    }
+    const stageModules = path.join(stageDir, 'node_modules');
+    try {
+        fs.symlinkSync(modulesSource, stageModules, isWindows ? 'junction' : 'dir');
+        // A junction to another volume is created but unusable, so prove it reads.
+        fs.readdirSync(stageModules);
+        return { stageDir, linkMode: 'symlink' };
+    }
+    catch (linkError) {
+        try {
+            fs.rmSync(stageModules, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            fs.cpSync(modulesSource, stageModules, { recursive: true });
+            return {
+                stageDir,
+                linkMode: 'copy',
+                note: `链接 node_modules 失败（${linkError.code ?? 'unknown'}），已改为完整复制`,
+            };
+        }
+        catch (copyError) {
+            try {
+                fs.rmSync(stageDir, { recursive: true, force: true });
+            }
+            catch { }
+            return {
+                stageDir: null,
+                linkMode: 'none',
+                note: `无法准备 stage（link: ${linkError.message}; copy: ${copyError.message}）`,
+            };
+        }
+    }
+}
+/** Remove a staging directory created by prepareMonitorStage. */
+export function cleanupMonitorStage(stageDir) {
+    try {
+        // Remove the link itself, never what it points at.
+        const modules = path.join(stageDir, 'node_modules');
+        const stat = fs.lstatSync(modules, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            fs.unlinkSync(modules);
+    }
+    catch { /* fall through to the recursive removal */ }
+    try {
+        fs.rmSync(stageDir, { recursive: true, force: true });
+    }
+    catch { }
+}
+/** True when the current process may write into `dir`. */
+export function isDirWritable(dir) {
+    try {
+        fs.accessSync(dir, fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the launch argv for the restart monitor, staging it out of the
+ * package directory when that package can be replaced underneath it.
+ *
+ * Checkout: `resolveCliEntry` already points at `src/` via tsx, which no build
+ * can delete — nothing to stage.
+ *
+ * Installed: the monitor lives in the very directory `npm install -g` swaps,
+ * so it is copied to `stageParent` first and told where the real package is
+ * through `EVOLCORE_TARGET_PACKAGE_ROOT`. If staging cannot be done we fall
+ * back to launching in place: losing upgrade isolation is far better than
+ * losing the ability to restart.
+ */
+export function resolveMonitorLaunch(packageRoot, stageParent) {
+    const resolved = resolveCliEntry(packageRoot);
+    if (resolved.usingSource) {
+        return { args: resolved.args, entry: resolved.entry, env: {}, stageDir: null };
+    }
+    const stage = prepareMonitorStage(packageRoot, stageParent);
+    if (!stage.stageDir) {
+        return {
+            args: resolved.args,
+            entry: resolved.entry,
+            env: {},
+            stageDir: null,
+            note: stage.note ? `${stage.note}；本次未启用 stage 隔离` : undefined,
+        };
+    }
+    const stagedEntry = path.join(stage.stageDir, 'dist', 'cli', 'index.js');
+    if (!fs.existsSync(stagedEntry)) {
+        cleanupMonitorStage(stage.stageDir);
+        return { args: resolved.args, entry: resolved.entry, env: {}, stageDir: null, note: 'stage 缺少入口，已退回原地启动' };
+    }
+    return {
+        args: [stagedEntry],
+        entry: stagedEntry,
+        env: {
+            EVOLCORE_TARGET_PACKAGE_ROOT: packageRoot,
+            EVOLCORE_MONITOR_STAGE: stage.stageDir,
+        },
+        stageDir: stage.stageDir,
+        note: stage.note,
+    };
+}
+/**
+ * Resolve how to launch the EvolCore CLI (`restart`, `restart-monitor`, ...).
+ *
+ * In a development checkout the compiled `dist/` is deleted and rebuilt by
+ * `npm run build`, so anything spawned from `dist/cli/index.js` disappears
+ * exactly when a build is in flight. The restart monitor is the watchdog that
+ * has to outlive that window, so it must not live inside the artifact it
+ * supervises: when sources and tsx are both available we run the monitor
+ * straight from `src/`, mirroring what `bin/ec.js` already does for the CLI.
+ *
+ * An npm-installed package ships `dist/` without `src/` and without tsx (a
+ * devDependency), so both checks fail and the caller keeps the previous
+ * behaviour byte for byte.
+ */
+export function resolveCliEntry(packageRoot) {
+    const sourceEntry = path.join(packageRoot, 'src', 'cli', 'index.ts');
+    const distEntry = path.join(packageRoot, 'dist', 'cli', 'index.js');
+    if (fs.existsSync(sourceEntry)) {
+        // tsx is a devDependency: present in a checkout, absent from the published
+        // package. Resolve it relative to the target root so `ec mode` switching
+        // between roots cannot borrow the wrong copy.
+        try {
+            const require = createRequire(path.join(packageRoot, 'package.json'));
+            const tsxUrl = pathToFileURL(require.resolve('tsx')).href;
+            return { args: ['--import', tsxUrl, sourceEntry], usingSource: true, entry: sourceEntry };
+        }
+        catch {
+            // tsx missing (e.g. `npm prune --production`): fall through to dist.
+        }
+    }
+    return { args: [distEntry], usingSource: false, entry: distEntry };
+}
 const ENCODE_PATH_MAX = 200;
 function encodePathHash(s) {
     let h = 0;