evolcore 0.0.11 → 0.0.13

package/dist/agents/codex-app-server-client.js

@@ -5,6 +5,11 @@ import { buildHClassGuardCommand } from '../core/permission/sandbox-runtime.js';
 import { resolveCodexLaunchCommand } from '../utils/codex-cli.js';
 import { createHash } from 'crypto';
 import { sanitizeShellExecutionEnvironment } from '../core/permission/shell-environment.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { registerCodexAppServerProcess, unregisterCodexAppServerProcess, } from '../utils/codex-app-server-registry.js';
 const BUILT_IN_CODEX_PROVIDER_IDS = new Set(['openai']);
 function tomlProviderKey(value) {
     if (!value || /[\0\r\n]/.test(value)) {
@@ -25,6 +30,22 @@ function runtimeProviderId(baseUrl) {
     const digest = createHash('sha256').update(baseUrl || 'default').digest('hex').slice(0, 12);
     return `evolcore_runtime_${digest}`;
 }
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'undefined';
+}
+function serverRequestFingerprint(request) {
+    return createHash('sha256')
+        .update(`${request.method}\n${stableJson(request.params)}`)
+        .digest('hex');
+}
 function hasPermissionProfile(config) {
     if (!config || typeof config.default_permissions !== 'string' || !config.default_permissions)
         return false;
@@ -36,11 +57,14 @@ export class CodexAppServerClient {
     options;
     proc = null;
     pending = new Map();
+    serverRequestReplays = new Map();
     notificationHandlers = new Set();
     nextId = 1;
     initialized = false;
     initializing = null;
     stderrBuffer = [];
+    managedHookRuntimeDir = null;
+    processRegistrationPath = null;
     constructor(options) {
         this.options = options;
     }
@@ -298,25 +322,34 @@ export class CodexAppServerClient {
             pending.reject(new Error('Codex app-server closed'));
         }
         this.pending.clear();
-        if (!proc)
+        this.serverRequestReplays.clear();
+        if (!proc) {
+            this.cleanupManagedHookRuntime();
             return;
+        }
         // 优雅关闭：先关闭 stdin，然后发送 SIGTERM，等待进程退出
         proc.stdin.end();
         proc.kill('SIGTERM');
         // 等待进程退出，最多等待 5 秒
         await new Promise((resolve) => {
+            let exited = false;
             const timeout = setTimeout(() => {
-                if (!proc.killed) {
-                    logger.warn('[CodexAppServer] Process did not exit after SIGTERM, sending SIGKILL');
+                if (exited)
+                    return;
+                logger.warn('[CodexAppServer] Process did not exit after SIGTERM, sending SIGKILL');
+                try {
                     proc.kill('SIGKILL');
                 }
+                catch { }
                 resolve();
             }, 5000);
             proc.once('exit', () => {
+                exited = true;
                 clearTimeout(timeout);
                 resolve();
             });
         });
+        this.cleanupManagedHookRuntime();
     }
     async ensureStarted() {
         if (this.initialized)
@@ -352,22 +385,56 @@ export class CodexAppServerClient {
         const launchCommand = resolveCodexLaunchCommand(args);
         if (!launchCommand)
             throw new Error('Codex CLI not found');
-        const guardedCommand = buildHClassGuardCommand(launchCommand.command, launchCommand.args);
-        if (process.platform === 'linux' && !guardedCommand) {
-            throw new Error('Codex 缺少 EvolCore H 类路径隔离运行时，已拒绝启动 app-server');
-        }
-        this.proc = spawn(guardedCommand?.command ?? launchCommand.command, guardedCommand?.args ?? launchCommand.args, {
-            cwd: this.options.cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
+        try {
+            let command = launchCommand.command;
+            let commandArgs = launchCommand.args;
+            if (process.platform === 'linux') {
+                const managedRequirements = this.ensureManagedHookRuntime();
+                const guardedCommand = buildHClassGuardCommand(command, commandArgs, undefined, {
+                    managedCodexRequirements: managedRequirements,
+                });
+                if (!guardedCommand) {
+                    throw new Error('Codex 缺少 EvolCore managed-hook 隔离运行时，已拒绝启动 app-server');
+                }
+                command = guardedCommand.command;
+                commandArgs = guardedCommand.args;
+            }
+            this.proc = spawn(command, commandArgs, {
+                cwd: this.options.cwd,
+                env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: process.platform === 'win32',
+            });
+            try {
+                this.processRegistrationPath = registerCodexAppServerProcess(this.proc.pid);
+            }
+            catch (error) {
+                logger.warn(`[CodexAppServer] failed to register owned process pid=${this.proc.pid ?? '<unknown>'}: ${error}`);
+            }
+        }
+        catch (error) {
+            this.cleanupManagedHookRuntime();
+            throw error;
+        }
+        const proc = this.proc;
+        const processRegistrationPath = this.processRegistrationPath;
+        proc.once('error', error => {
+            unregisterCodexAppServerProcess(processRegistrationPath);
+            if (this.processRegistrationPath === processRegistrationPath) {
+                this.processRegistrationPath = null;
+            }
+            this.failAll(error);
         });
-        this.proc.once('error', error => this.failAll(error));
-        this.proc.once('exit', (code, signal) => {
+        proc.once('exit', (code, signal) => {
+            unregisterCodexAppServerProcess(processRegistrationPath);
+            if (this.processRegistrationPath === processRegistrationPath) {
+                this.processRegistrationPath = null;
+            }
             this.failAll(new Error(`Codex app-server exited: code=${code ?? 'null'} signal=${signal ?? 'null'}`));
         });
-        const rl = readline.createInterface({ input: this.proc.stdout, crlfDelay: Infinity });
+        const rl = readline.createInterface({ input: proc.stdout, crlfDelay: Infinity });
         rl.on('line', line => this.handleLine(line));
-        this.proc.stderr.on('data', chunk => {
+        proc.stderr.on('data', chunk => {
             const text = String(chunk).trim();
             if (!text)
                 return;
@@ -377,6 +444,62 @@ export class CodexAppServerClient {
             logger.debug(`[CodexAppServer] ${text}`);
         });
     }
+    ensureManagedHookRuntime() {
+        if (this.managedHookRuntimeDir) {
+            return path.join(this.managedHookRuntimeDir, 'requirements.toml');
+        }
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'evolcore-codex-hooks-'));
+        try {
+            fs.chmodSync(directory, 0o700);
+            const hookPath = path.join(directory, 'pre-tool-use.mjs');
+            const sourcePath = path.join(getPackageRoot(), 'bin', 'codex-managed-hook.mjs');
+            fs.copyFileSync(sourcePath, hookPath, fs.constants.COPYFILE_EXCL);
+            fs.chmodSync(hookPath, 0o500);
+            const command = `${this.shellQuote(process.execPath)} ${this.shellQuote(hookPath)} ${this.shellQuote(resolvePaths().instanceSocket)}`;
+            const requirementsPath = path.join(directory, 'requirements.toml');
+            fs.writeFileSync(requirementsPath, [
+                'allow_managed_hooks_only = true',
+                '',
+                '[features]',
+                'hooks = true',
+                '',
+                '[hooks]',
+                `managed_dir = ${JSON.stringify(directory)}`,
+                '',
+                '[[hooks.PreToolUse]]',
+                'matcher = "*"',
+                '',
+                '[[hooks.PreToolUse.hooks]]',
+                'type = "command"',
+                `command = ${JSON.stringify(command)}`,
+                'timeout = 3',
+                'statusMessage = "Checking EvolCore session policy"',
+                '',
+            ].join('\n'), { mode: 0o400, flag: 'wx' });
+            this.managedHookRuntimeDir = directory;
+            return requirementsPath;
+        }
+        catch (error) {
+            try {
+                fs.rmSync(directory, { recursive: true, force: true });
+            }
+            catch { }
+            throw error;
+        }
+    }
+    shellQuote(value) {
+        return `'${value.replace(/'/g, `'"'"'`)}'`;
+    }
+    cleanupManagedHookRuntime() {
+        const directory = this.managedHookRuntimeDir;
+        this.managedHookRuntimeDir = null;
+        if (!directory || !path.basename(directory).startsWith('evolcore-codex-hooks-'))
+            return;
+        try {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+        catch { }
+    }
     buildProcessEnvironment() {
         const env = sanitizeShellExecutionEnvironment({
             ...process.env,
@@ -522,15 +645,44 @@ export class CodexAppServerClient {
             this.respondError(request.id, new Error('Unsupported Codex app-server request: ' + request.method));
             return;
         }
-        Promise.resolve(handler(request))
+        const replayKey = String(request.id);
+        const fingerprint = serverRequestFingerprint(request);
+        const previous = this.serverRequestReplays.get(replayKey);
+        if (previous) {
+            if (previous.fingerprint !== fingerprint) {
+                const conflict = new Error(`Conflicting Codex app-server request payload for id=${request.id}`);
+                logger.warn(`[CodexAppServer] server request ID conflict id=${request.id} method=${request.method}`);
+                this.respondError(request.id, conflict);
+                return;
+            }
+            // A retry must receive a response too, but must never invoke the
+            // approval handler a second time.
+            this.respondFromPromise(request.id, request.method, previous.response);
+            return;
+        }
+        let response;
+        try {
+            // Invoke synchronously so existing app-server latency stays unchanged,
+            // while the explicit catch still turns a synchronous handler throw into
+            // the same replayable rejected response as an async failure.
+            response = Promise.resolve(handler(request));
+        }
+        catch (error) {
+            response = Promise.reject(error);
+        }
+        this.serverRequestReplays.set(replayKey, { fingerprint, response });
+        this.respondFromPromise(request.id, request.method, response);
+    }
+    respondFromPromise(id, method, response) {
+        response
             .then(result => {
-            logger.info(`[CodexAppServer] server response id=${request.id} method=${request.method} result=${JSON.stringify(result ?? null)}`);
-            this.respond(request.id, result ?? null);
+            logger.info(`[CodexAppServer] server response id=${id} method=${method} result=${JSON.stringify(result ?? null)}`);
+            this.respond(id, result ?? null);
         })
             .catch(error => {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.warn(`[CodexAppServer] server request failed id=${request.id} method=${request.method}: ${err.message}`);
-            this.respondError(request.id, err);
+            logger.warn(`[CodexAppServer] server request failed id=${id} method=${method}: ${err.message}`);
+            this.respondError(id, err);
         });
     }
     emitNotification(notification) {
@@ -571,5 +723,7 @@ export class CodexAppServerClient {
             pending.reject(error);
         }
         this.pending.clear();
+        this.serverRequestReplays.clear();
+        this.cleanupManagedHookRuntime();
     }
 }