evolcore 0.0.10 → 0.0.12

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

@@ -4,6 +4,13 @@ import { logger } from '../utils/logger.js';
 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)) {
         throw new Error(`Invalid Codex provider name: ${value}`);
@@ -19,6 +26,10 @@ function codexHeaderEnvName(headerName) {
     const digest = createHash('sha256').update(headerName).digest('hex').slice(0, 16).toUpperCase();
     return `EVOLCORE_CODEX_HEADER_${digest}`;
 }
+function runtimeProviderId(baseUrl) {
+    const digest = createHash('sha256').update(baseUrl || 'default').digest('hex').slice(0, 12);
+    return `evolcore_runtime_${digest}`;
+}
 function hasPermissionProfile(config) {
     if (!config || typeof config.default_permissions !== 'string' || !config.default_permissions)
         return false;
@@ -35,6 +46,8 @@ export class CodexAppServerClient {
     initialized = false;
     initializing = null;
     stderrBuffer = [];
+    managedHookRuntimeDir = null;
+    processRegistrationPath = null;
     constructor(options) {
         this.options = options;
     }
@@ -292,25 +305,33 @@ export class CodexAppServerClient {
             pending.reject(new Error('Codex app-server closed'));
         }
         this.pending.clear();
-        if (!proc)
+        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)
@@ -341,34 +362,61 @@ export class CodexAppServerClient {
         }
     }
     startProcess() {
-        const env = { ...process.env, ...this.options.env };
-        env.CODEX_API_KEY = this.options.apiKey;
-        for (const [name, value] of Object.entries(this.options.headers ?? {})) {
-            env[codexHeaderEnvName(name)] = value;
-        }
-        if (this.options.baseUrl) {
-            env.OPENAI_BASE_URL = this.options.baseUrl;
-        }
+        const env = this.buildProcessEnvironment();
         const args = this.buildProcessArgs();
         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');
+        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;
         }
-        this.proc = spawn(guardedCommand?.command ?? launchCommand.command, guardedCommand?.args ?? launchCommand.args, {
-            cwd: this.options.cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
+        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;
@@ -378,6 +426,76 @@ 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,
+            ...this.options.env,
+        });
+        env.CODEX_API_KEY = this.options.apiKey;
+        for (const [name, value] of Object.entries(this.options.headers ?? {})) {
+            env[codexHeaderEnvName(name)] = value;
+        }
+        if (this.options.baseUrl) {
+            env.OPENAI_BASE_URL = this.options.baseUrl;
+        }
+        return env;
+    }
     buildProcessArgs() {
         const args = ['app-server', '--listen', 'stdio://'];
         if (this.options.enableRequestUserInput !== false) {
@@ -390,7 +508,18 @@ export class CodexAppServerClient {
         const hasHeaders = Object.keys(headerEnvNames).length > 0;
         const hasQueryParams = Object.keys(this.options.queryParams ?? {}).length > 0;
         if (hasHeaders || hasQueryParams) {
-            const provider = tomlProviderKey(this.options.provider || 'openai');
+            const configuredProvider = this.options.provider?.trim();
+            const useRuntimeProvider = !configuredProvider || BUILT_IN_CODEX_PROVIDER_IDS.has(configuredProvider.toLowerCase());
+            const providerName = !useRuntimeProvider
+                ? configuredProvider
+                : runtimeProviderId(this.options.baseUrl);
+            const provider = tomlProviderKey(providerName);
+            args.push('--config', `model_provider=${JSON.stringify(providerName)}`);
+            args.push('--config', `model_providers.${provider}.name=${JSON.stringify('EvolCore runtime gateway')}`);
+            args.push('--config', `model_providers.${provider}.wire_api=${JSON.stringify('responses')}`);
+            if (useRuntimeProvider || this.options.baseUrl) {
+                args.push('--config', `model_providers.${provider}.base_url=${JSON.stringify(this.options.baseUrl || 'https://api.openai.com/v1')}`);
+            }
             if (hasHeaders) {
                 args.push('--config', `model_providers.${provider}.env_http_headers=${tomlInlineStringTable(headerEnvNames)}`);
             }
@@ -547,5 +676,6 @@ export class CodexAppServerClient {
             pending.reject(error);
         }
         this.pending.clear();
+        this.cleanupManagedHookRuntime();
     }
 }