@jungjaehoon/mama-os 0.23.0 → 0.24.0

package/dist/agent/codex-mcp-process.js

@@ -1,748 +0,0 @@
-"use strict";
-/**
- * Codex MCP Process - Codex via MCP protocol
- *
- * Architecture:
- *   Chat → MCP Client → codex mcp-server → MCP → Chat
- *
- * Uses standard MCP protocol instead of app-server's JSON-RPC.
- * Benefits:
- * - Standard MCP protocol
- * - compact-prompt parameter for compaction control
- * - threadId-based session management
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexMCPProcess = void 0;
-const child_process_1 = require("child_process");
-const events_1 = require("events");
-const readline = __importStar(require("readline"));
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const config_manager_js_1 = require("../cli/config/config-manager.js");
-const process_tree_js_1 = require("./process-tree.js");
-const codex_auth_js_1 = require("./codex-auth.js");
-const codex_home_js_1 = require("./codex-home.js");
-const { DebugLogger } = debugLogger;
-const logger = new DebugLogger('CodexMCP');
-const DEFAULT_REQUEST_TIMEOUT_MS = () => (0, config_manager_js_1.getConfig)().timeouts?.codex_request_ms ?? 180_000;
-const DEFAULT_INITIALIZE_TIMEOUT_MS = () => (0, config_manager_js_1.getConfig)().timeouts?.initialize_ms ?? 60_000;
-class CodexMCPProcess extends events_1.EventEmitter {
-    process = null;
-    currentCallbacks = null;
-    options;
-    state = 'dead';
-    threadId = null;
-    requestId = 0;
-    pendingRequests = new Map();
-    rl = null;
-    lastAuthFailure = null;
-    constructor(options = {}) {
-        super();
-        this.options = options;
-    }
-    /**
-     * Start the Codex MCP server process
-     */
-    async start() {
-        if (this.state !== 'dead') {
-            logger.info(`Process already in state: ${this.state}`);
-            return;
-        }
-        this.state = 'starting';
-        this.lastAuthFailure = null;
-        let command;
-        try {
-            command = this.resolveCodexCommand();
-        }
-        catch (error) {
-            this.state = 'dead';
-            throw error;
-        }
-        logger.info(`Starting Codex MCP server with command: ${command}`);
-        // Use a MAMA-specific CODEX_HOME so we control MCP server wiring, while
-        // syncing auth from the user's global Codex home on every start.
-        const codexHome = this.options.codexHome || (0, path_1.join)((0, os_1.homedir)(), '.mama', '.codex');
-        try {
-            this.ensureCodexHome(codexHome);
-        }
-        catch (error) {
-            const bootstrapError = error instanceof Error ? error : new Error(String(error));
-            this.state = 'dead';
-            logger.error('Failed to prepare CODEX_HOME:', bootstrapError);
-            throw bootstrapError;
-        }
-        const spawnEnv = { ...process.env, CODEX_HOME: codexHome };
-        try {
-            this.process = (0, child_process_1.spawn)(command, ['mcp-server'], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                cwd: this.options.cwd,
-                env: spawnEnv,
-            });
-        }
-        catch (error) {
-            const startError = error instanceof Error ? error : new Error(String(error));
-            logger.error('Failed to start Codex MCP process:', startError);
-            this.state = 'dead';
-            this.process = null;
-            throw startError;
-        }
-        if (!this.process) {
-            const startError = new Error(`Failed to create Codex MCP process with command: ${command}`);
-            this.state = 'dead';
-            throw startError;
-        }
-        // Set up readline for JSON parsing
-        this.rl = readline.createInterface({
-            input: this.process.stdout,
-            crlfDelay: Infinity,
-        });
-        this.rl.on('line', (line) => this.handleLine(line));
-        this.process.stderr?.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text) {
-                const authFailure = (0, codex_auth_js_1.extractCodexAuthFailure)(text);
-                if (authFailure) {
-                    const error = new Error(authFailure);
-                    this.lastAuthFailure = error;
-                    logger.error('Codex auth failure detected:', authFailure);
-                    this.shutdown(error, true);
-                    return;
-                }
-                logger.warn('stderr:', text);
-            }
-        });
-        this.process.on('close', (code) => {
-            logger.info(`Process closed with code ${code}`);
-            this.shutdown(new Error(`Process closed with code ${code ?? 'unknown'}`), false);
-        });
-        // Wait for process to either start successfully or fail with spawn error
-        await new Promise((resolve, reject) => {
-            const onSpawnError = (error) => {
-                logger.error('Process spawn error:', error);
-                this.state = 'dead';
-                reject(error);
-            };
-            this.process.on('error', onSpawnError);
-            // Give process a moment to start; if no error fires, it spawned OK
-            setTimeout(() => {
-                this.process?.removeListener('error', onSpawnError);
-                this.process?.on('error', (error) => {
-                    logger.error('Process error:', error);
-                    if (this.listenerCount('error') > 0) {
-                        this.emit('error', error);
-                    }
-                    this.shutdown(error instanceof Error ? error : new Error(String(error)), true);
-                });
-                resolve();
-            }, 200);
-        });
-        try {
-            // MCP Initialize (bounded timeout to avoid dead startup)
-            await Promise.race([
-                this.sendRequest('initialize', {
-                    protocolVersion: '2024-11-05',
-                    capabilities: {},
-                    clientInfo: { name: 'MAMA', version: '1.0.0' },
-                }),
-                new Promise((_, reject) => {
-                    setTimeout(() => {
-                        reject(new Error(`MCP initialize timeout after ${DEFAULT_INITIALIZE_TIMEOUT_MS()}ms`));
-                    }, DEFAULT_INITIALIZE_TIMEOUT_MS());
-                }),
-            ]);
-            this.state = 'ready';
-            logger.info('Codex MCP server ready');
-        }
-        catch (error) {
-            logger.error('MCP initialization failed:', error);
-            this.cleanup('MCP initialization failed');
-            throw error;
-        }
-    }
-    /**
-     * Send a prompt and get response
-     */
-    async prompt(content, callbacks, options) {
-        // Ensure process is running (retry once on failure)
-        if (this.state === 'dead') {
-            try {
-                await this.start();
-            }
-            catch (err) {
-                logger.warn('First start attempt failed, retrying in 1s:', err);
-                this.cleanup('Process restart after failed start');
-                await new Promise((r) => setTimeout(r, 1000));
-                await this.start();
-            }
-        }
-        // Handle resumeSession option
-        if (options?.resumeSession === false) {
-            this.threadId = null;
-        }
-        // Override model if provided
-        const effectiveModel = options?.model || this.options.model;
-        // Wait if not ready (with timeout)
-        const maxWaitMs = this.options.timeoutMs ?? 120000;
-        const waitStart = Date.now();
-        while (this.state !== 'ready') {
-            if (this.state === 'dead') {
-                throw new Error('Process is not running');
-            }
-            if (Date.now() - waitStart > maxWaitMs) {
-                throw new Error('Timed out waiting for process to be ready');
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        this.state = 'busy';
-        this.currentCallbacks = callbacks || null;
-        try {
-            let result;
-            if (!this.threadId) {
-                // First message: use "codex" tool
-                const args = {
-                    prompt: content,
-                };
-                if (effectiveModel) {
-                    args.model = effectiveModel;
-                }
-                if (this.options.cwd) {
-                    args.cwd = this.options.cwd;
-                }
-                if (this.options.sandbox) {
-                    args.sandbox = this.options.sandbox;
-                }
-                const effectiveSystemPrompt = options?.systemPrompt ?? this.options.systemPrompt;
-                if (effectiveSystemPrompt) {
-                    args['developer-instructions'] = effectiveSystemPrompt;
-                }
-                if (this.options.compactPrompt) {
-                    args['compact-prompt'] = this.options.compactPrompt;
-                }
-                result = await this.callToolWithRetry('codex', args);
-                this.threadId = result.threadId;
-                logger.info(`Thread started: ${this.threadId}`);
-            }
-            else {
-                // Subsequent messages: use "codex-reply" tool
-                result = await this.callToolWithRetry('codex-reply', {
-                    threadId: this.threadId,
-                    prompt: content,
-                });
-            }
-            const response = result.content || '';
-            this.currentCallbacks = null;
-            callbacks?.onFinal?.({ content: response, toolUseBlocks: [] });
-            return {
-                response,
-                usage: {
-                    input_tokens: result.usage?.inputTokens ?? 0,
-                    output_tokens: result.usage?.outputTokens ?? 0,
-                    cached_input_tokens: result.usage?.cachedTokens ?? 0,
-                },
-                session_id: this.threadId || '',
-            };
-        }
-        finally {
-            // Only reset to ready if process is still alive (not crashed)
-            // Note: close handler may have set state to 'dead' asynchronously
-            if (this.process !== null && this.state !== 'dead') {
-                this.state = 'ready';
-            }
-        }
-    }
-    /**
-     * Reset the session
-     */
-    async resetSession() {
-        this.threadId = null;
-        logger.info('Session reset');
-    }
-    /**
-     * Get current session ID
-     */
-    getSessionId() {
-        return this.threadId ?? '';
-    }
-    /**
-     * Set session ID (for compatibility)
-     * Note: CodexMCPProcess manages its own threadId from Codex responses.
-     * External session IDs are ignored to prevent conflicts.
-     */
-    setSessionId(_sessionId) {
-        // Ignore external session IDs - Codex MCP manages threadId internally
-        // The threadId is set only from Codex 'codex' tool response
-        logger.debug(`setSessionId called but ignored (MCP manages threadId internally)`);
-    }
-    /**
-     * Set system prompt
-     */
-    setSystemPrompt(prompt) {
-        this.options.systemPrompt = prompt;
-    }
-    /**
-     * Stop the process
-     */
-    stop() {
-        this.cleanup('Process stopped');
-        logger.info('Process stopped');
-    }
-    cleanup(reason = 'Process terminated') {
-        this.shutdown(new Error(reason), true);
-    }
-    // ============================================================================
-    // Internal methods
-    // ============================================================================
-    async callTool(name, args) {
-        logger.info(`[CALL_START] ${name} thread=${this.threadId || 'none'} args=${Object.keys(args).join(',')}`);
-        const response = (await this.sendRequest('tools/call', {
-            name,
-            arguments: args,
-        }));
-        const keys = Object.keys(response);
-        logger.debug(`[RESPONSE_KEYS] ${keys.join(', ')}`);
-        // Extract token usage if available
-        const usage = response._meta?.usage;
-        if (usage) {
-            logger.debug(`[TOKENS] input: ${usage.inputTokens}, cached: ${usage.cachedTokens || 0}, output: ${usage.outputTokens}`);
-        }
-        // Check structuredContent first (preferred - has threadId)
-        if (response.structuredContent?.threadId) {
-            logger.info(`[CALL_DONE] ${name} thread=${response.structuredContent.threadId} content_len=${response.structuredContent.content?.length || 0}`);
-            return {
-                threadId: response.structuredContent.threadId,
-                content: response.structuredContent.content || '',
-                usage,
-            };
-        }
-        // Fallback: Extract from content array
-        if (response.content && Array.isArray(response.content)) {
-            const textContent = response.content.find((c) => c.type === 'text');
-            if (textContent?.text) {
-                try {
-                    const parsed = JSON.parse(textContent.text);
-                    logger.info(`[CALL_DONE] ${name} thread=${parsed.threadId || this.threadId || 'none'} content_len=${parsed.content?.length || textContent.text.length}`);
-                    return {
-                        threadId: parsed.threadId || this.threadId || '',
-                        content: parsed.content || textContent.text,
-                        usage,
-                    };
-                }
-                catch {
-                    logger.info(`[CALL_DONE] ${name} thread=${this.threadId || 'none'} content_len=${textContent.text.length}`);
-                    return { content: textContent.text, threadId: this.threadId || '', usage };
-                }
-            }
-        }
-        // Defensive fallback for unexpected response format
-        logger.warn(`Unexpected callTool response format: ${JSON.stringify(response)}`);
-        return { threadId: this.threadId || '', content: '', usage };
-    }
-    async callToolWithRetry(name, args) {
-        let attempt = 0;
-        while (attempt < 2) {
-            attempt += 1;
-            try {
-                logger.debug(`[CALL] ${name} (attempt=${attempt})`);
-                return await this.callTool(name, args);
-            }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                if (this.lastAuthFailure) {
-                    throw this.lastAuthFailure;
-                }
-                if (attempt >= 2 || !this.isRetryableToolError(err)) {
-                    logger.error(`Call failed: ${name} (attempt=${attempt})`, err);
-                    throw err;
-                }
-                logger.warn(`Retrying ${name} after recoverable tool error: ${err.message}`);
-                this.threadId = null;
-                this.cleanup();
-                await this.start();
-            }
-        }
-        throw new Error(`Tool call failed after ${attempt} attempts: ${name}`);
-    }
-    async sendRequest(method, params) {
-        if (!this.process?.stdin) {
-            throw new Error('Process not running');
-        }
-        const id = ++this.requestId;
-        const request = {
-            jsonrpc: '2.0',
-            id,
-            method,
-            params,
-        };
-        return new Promise((resolve, reject) => {
-            const timeoutMs = this.options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS();
-            // 0 = unlimited (no timeout)
-            const timeout = timeoutMs > 0
-                ? setTimeout(() => {
-                    const timeoutError = new Error(`Request timeout: ${method} (id=${id}, timeoutMs=${timeoutMs})`);
-                    this.failPendingRequest(id, timeoutError);
-                    this.shutdown(timeoutError, true);
-                }, timeoutMs)
-                : null;
-            this.pendingRequests.set(id, { resolve, reject, method, timeout });
-            const line = JSON.stringify(request) + '\n';
-            try {
-                this.process.stdin.write(line);
-                logger.debug(`Sent: ${method} (id=${id})`);
-            }
-            catch (error) {
-                const requestError = error instanceof Error ? error : new Error(String(error));
-                logger.error('Failed to write MCP request:', requestError);
-                this.failPendingRequest(id, requestError);
-                this.shutdown(requestError, true);
-                reject(requestError);
-            }
-        });
-    }
-    handleLine(line) {
-        if (!line.trim())
-            return;
-        try {
-            const msg = JSON.parse(line);
-            if ('id' in msg && msg.id !== undefined) {
-                const pending = this.pendingRequests.get(msg.id);
-                if (pending) {
-                    if (pending.timeout)
-                        clearTimeout(pending.timeout);
-                    this.pendingRequests.delete(msg.id);
-                    if (msg.error) {
-                        pending.reject(new Error(msg.error.message));
-                    }
-                    else {
-                        pending.resolve(msg.result);
-                    }
-                }
-            }
-            else if ('method' in msg) {
-                // Notification (no id) - parse Codex events for tool usage + streaming
-                const notification = msg;
-                this.handleNotification(notification);
-            }
-        }
-        catch {
-            logger.warn('Failed to parse line:', line.substring(0, 100));
-        }
-    }
-    /**
-     * Handle Codex MCP notifications (codex/event)
-     * Events: mcp_tool_call_begin, mcp_tool_call_end, agent_message_delta
-     */
-    handleNotification(notification) {
-        if (notification.method !== 'codex/event')
-            return;
-        const params = notification.params;
-        const msg = params?.msg;
-        if (!msg)
-            return;
-        const cb = this.currentCallbacks;
-        switch (msg.type) {
-            case 'mcp_tool_call_begin':
-                logger.info(`[EVENT] mcp_tool_call_begin thread=${params?._meta?.threadId || this.threadId || 'none'} server=${msg.invocation?.server || 'unknown'} tool=${msg.invocation?.tool || 'unknown'}`);
-                if (cb?.onToolUse && msg.invocation) {
-                    const toolName = msg.invocation.server
-                        ? `${msg.invocation.server}:${msg.invocation.tool}`
-                        : msg.invocation.tool || 'unknown';
-                    cb.onToolUse(toolName, msg.invocation.arguments || {});
-                    logger.info(`[TOOL_BEGIN] ${toolName}`);
-                }
-                break;
-            case 'mcp_tool_call_end':
-                logger.info(`[EVENT] mcp_tool_call_end thread=${params?._meta?.threadId || this.threadId || 'none'} server=${msg.invocation?.server || 'unknown'} tool=${msg.invocation?.tool || 'unknown'}`);
-                if (cb?.onToolComplete && msg.call_id) {
-                    const toolName = msg.invocation?.tool || 'unknown';
-                    const isError = false; // Codex doesn't indicate error in this event
-                    cb.onToolComplete(toolName, msg.call_id, isError);
-                    logger.info(`[TOOL_END] ${toolName}`);
-                }
-                break;
-            case 'agent_message_delta':
-                logger.debug(`[EVENT] agent_message_delta len=${typeof msg.delta === 'string' ? msg.delta.length : 0}`);
-                if (cb?.onDelta && typeof msg.delta === 'string') {
-                    cb.onDelta(msg.delta);
-                }
-                break;
-            // Codex built-in tools (Bash, Write, Read etc.) — not MCP tools
-            case 'function_call':
-                if (cb?.onToolUse) {
-                    const fnName = msg.name || 'unknown';
-                    let fnArgs = {};
-                    try {
-                        const raw = msg.arguments;
-                        if (raw)
-                            fnArgs = JSON.parse(raw);
-                    }
-                    catch {
-                        // arguments may not be valid JSON
-                    }
-                    cb.onToolUse(fnName, fnArgs);
-                    logger.info(`[TOOL_BEGIN] ${fnName} (builtin)`);
-                }
-                break;
-            case 'function_call_output':
-                if (cb?.onToolComplete) {
-                    const callId = msg.call_id || msg.id || 'unknown';
-                    cb.onToolComplete('builtin', callId, false);
-                    logger.info(`[TOOL_END] builtin (call_id=${callId})`);
-                }
-                break;
-            // raw_response_item wraps function_call for streaming
-            case 'raw_response_item': {
-                const item = msg.item;
-                if (!item)
-                    break;
-                if (item.type === 'function_call' && cb?.onToolUse) {
-                    const fnName = item.name || 'unknown';
-                    let fnArgs = {};
-                    try {
-                        if (item.arguments)
-                            fnArgs = JSON.parse(item.arguments);
-                    }
-                    catch {
-                        /* */
-                    }
-                    cb.onToolUse(fnName, fnArgs);
-                    logger.info(`[TOOL_BEGIN] ${fnName} (raw_response_item)`);
-                }
-                else if (item.type === 'function_call_output' && cb?.onToolComplete) {
-                    const callId = item.call_id || 'unknown';
-                    cb.onToolComplete('builtin', callId, false);
-                    logger.info(`[TOOL_END] builtin (raw_response_item, call_id=${callId})`);
-                }
-                break;
-            }
-        }
-    }
-    resolveCodexCommand() {
-        const configured = [
-            this.options.command,
-            process.env.MAMA_CODEX_COMMAND,
-            process.env.CODEX_COMMAND,
-        ];
-        for (const candidate of configured) {
-            if (!candidate) {
-                continue;
-            }
-            const trimmed = candidate.trim();
-            if (!trimmed) {
-                continue;
-            }
-            if (this.isExecutable(trimmed)) {
-                return trimmed;
-            }
-        }
-        const fromPath = this.findExecutableInPath('codex');
-        if (fromPath) {
-            return fromPath;
-        }
-        const home = (0, os_1.homedir)();
-        const fallbackCandidates = [
-            (0, path_1.join)(home, '.local', 'bin', 'codex'),
-            (0, path_1.join)(home, 'bin', 'codex'),
-            '/usr/local/bin/codex',
-            '/usr/bin/codex',
-            '/opt/homebrew/bin/codex',
-            '/bin/codex',
-        ];
-        for (const candidate of fallbackCandidates) {
-            if (this.isExecutable(candidate)) {
-                return candidate;
-            }
-        }
-        throw new Error('Codex command not found. Set MAMA_CODEX_COMMAND or CODEX_COMMAND to an executable path, or install codex in PATH.');
-    }
-    isExecutable(target) {
-        try {
-            (0, fs_1.accessSync)(target, fs_1.constants.X_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    ensureCodexHome(codexHome) {
-        if (!(0, fs_1.existsSync)(codexHome)) {
-            (0, fs_1.mkdirSync)(codexHome, { recursive: true, mode: 0o700 });
-        }
-        (0, fs_1.chmodSync)(codexHome, 0o700);
-        const configPath = (0, path_1.join)(codexHome, 'config.toml');
-        const configToml = (0, codex_home_js_1.buildMAMACodexConfig)(this.options.mcpConfigPath);
-        (0, fs_1.writeFileSync)(configPath, configToml, 'utf-8');
-        (0, fs_1.chmodSync)(configPath, 0o600);
-        const internalAuthPath = (0, path_1.join)(codexHome, 'auth.json');
-        const externalAuthPath = (0, path_1.join)((0, os_1.homedir)(), '.codex', 'auth.json');
-        if ((0, fs_1.existsSync)(externalAuthPath)) {
-            try {
-                (0, fs_1.copyFileSync)(externalAuthPath, internalAuthPath);
-                (0, fs_1.chmodSync)(internalAuthPath, 0o600);
-                logger.info(`Synced Codex auth into ${internalAuthPath}`);
-            }
-            catch (error) {
-                logger.warn(`Failed to sync Codex auth: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        else if ((0, fs_1.existsSync)(internalAuthPath)) {
-            try {
-                (0, fs_1.unlinkSync)(internalAuthPath);
-                logger.info('Removed stale internal Codex auth file (external auth deleted)');
-            }
-            catch (unlinkErr) {
-                logger.warn(`Failed to remove stale Codex auth: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
-            }
-        }
-    }
-    findExecutableInPath(commandName) {
-        const pathValue = process.env.PATH || '';
-        if (!pathValue) {
-            return null;
-        }
-        const pathEntries = pathValue
-            .split(path_1.delimiter)
-            .map((value) => value.trim())
-            .filter(Boolean);
-        for (const dir of pathEntries) {
-            const candidate = (0, path_1.join)(dir, commandName);
-            if (this.isExecutable(candidate)) {
-                return candidate;
-            }
-        }
-        return null;
-    }
-    failPendingRequest(id, error) {
-        const pending = this.pendingRequests.get(id);
-        if (!pending) {
-            return;
-        }
-        if (pending.timeout)
-            clearTimeout(pending.timeout);
-        this.pendingRequests.delete(id);
-        pending.reject(error);
-    }
-    clearPendingRequests(error) {
-        for (const [, pending] of this.pendingRequests) {
-            if (pending.timeout)
-                clearTimeout(pending.timeout);
-            pending.reject(new Error(`${error.message} (${pending.method})`));
-        }
-        this.pendingRequests.clear();
-    }
-    isRetryableToolError(error) {
-        const message = error.message.toLowerCase();
-        if ((0, codex_auth_js_1.extractCodexAuthFailure)(error.message)) {
-            return false;
-        }
-        return (!message.includes('request timeout') &&
-            (message.includes('process is not running') ||
-                message.includes('process closed with code') ||
-                message.includes('mcp initialize timeout') ||
-                message.includes('connection closed') ||
-                message.includes('econnreset')));
-    }
-    shutdown(error, shouldKillProcess) {
-        if (this.state === 'dead' && this.pendingRequests.size === 0 && !shouldKillProcess) {
-            return;
-        }
-        this.state = 'dead';
-        this.clearPendingRequests(error);
-        if (shouldKillProcess && this.process) {
-            const processToKill = this.process;
-            const rootPid = processToKill.pid;
-            if (!rootPid) {
-                this.rl?.close();
-                this.rl = null;
-                this.process = null;
-                this.threadId = null;
-                return;
-            }
-            const forceKillTimer = setTimeout(() => {
-                this.killProcessTree(rootPid, 'SIGKILL');
-            }, 1000);
-            forceKillTimer.unref();
-            processToKill.once('close', () => {
-                clearTimeout(forceKillTimer);
-            });
-            try {
-                this.killProcessTree(rootPid, 'SIGTERM');
-            }
-            catch {
-                clearTimeout(forceKillTimer);
-            }
-        }
-        if (this.rl) {
-            this.rl.close();
-            this.rl = null;
-        }
-        this.process = null;
-        this.threadId = null;
-    }
-    killProcessTree(rootPid, signal) {
-        const descendants = this.listDescendantPids(rootPid);
-        for (const pid of [...descendants.reverse(), rootPid]) {
-            try {
-                process.kill(pid, signal);
-            }
-            catch {
-                // Process may already be gone.
-            }
-        }
-    }
-    listDescendantPids(rootPid) {
-        try {
-            const output = (0, child_process_1.execFileSync)('ps', ['-Ao', 'pid=,ppid='], { encoding: 'utf8' });
-            const rows = output
-                .split('\n')
-                .map((line) => line.trim())
-                .filter(Boolean)
-                .map((line) => {
-                const [pid, ppid] = line.split(/\s+/);
-                return { pid: Number(pid), ppid: Number(ppid) };
-            })
-                .filter((row) => Number.isFinite(row.pid) && Number.isFinite(row.ppid));
-            return (0, process_tree_js_1.collectDescendantPids)(rootPid, rows);
-        }
-        catch (error) {
-            logger.warn(`Failed to inspect codex process descendants: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-}
-exports.CodexMCPProcess = CodexMCPProcess;
-//# sourceMappingURL=codex-mcp-process.js.map