codex-cli-architect-mcp/dist/utils/codexExecutor.js

MCP server for OpenAI Codex CLI - Enable AI-powered coding assistance through Model Context Protocol

import { spawn } from 'node:child_process';
import { EXECUTION_TIMEOUT, OPENAI_API_KEY } from '../constants.js';
import logger from './logger.js';
export async function executeCodexCommand(prompt, options = {}) {
    const { model, timeout = EXECUTION_TIMEOUT } = options;
    // Build command arguments
    const args = ['exec'];
    if (model) {
        args.push('--model', model);
    }
    // Use read-only sandbox for MCP to only allow reading files
    args.push('--sandbox', 'read-only');
    // Run in full auto mode to prevent interactive prompts
    args.push('--full-auto');
    // Add the prompt as the last argument
    args.push(prompt);
    logger.info('Executing Codex command', {
        model,
        prompt: `${prompt.substring(0, 100)}...`,
        usingApiKey: !!OPENAI_API_KEY,
    });
    return new Promise((resolve) => {
        let output = '';
        let errorOutput = '';
        let timedOut = false;
        // Prepare environment variables
        const env = { ...process.env };
        if (OPENAI_API_KEY) {
            env.OPENAI_API_KEY = OPENAI_API_KEY;
        }
        const codexProcess = spawn('codex', args, {
            env,
        });
        const timeoutId = setTimeout(() => {
            timedOut = true;
            codexProcess.kill('SIGTERM');
        }, timeout);
        codexProcess.stdout.on('data', (data) => {
            output += data.toString();
        });
        codexProcess.stderr.on('data', (data) => {
            errorOutput += data.toString();
        });
        codexProcess.on('close', (code) => {
            clearTimeout(timeoutId);
            if (timedOut) {
                resolve({
                    success: false,
                    error: 'Command execution timed out',
                    output: output.trim(),
                });
                return;
            }
            if (code !== 0) {
                resolve({
                    success: false,
                    error: errorOutput.trim() || 'Codex command failed',
                    output: output.trim(),
                    exitCode: code || undefined,
                });
                return;
            }
            resolve({
                success: true,
                output: output.trim(),
                exitCode: 0,
            });
        });
        codexProcess.on('error', (error) => {
            clearTimeout(timeoutId);
            logger.error('Codex process error:', error);
            resolve({
                success: false,
                error: error.message,
            });
        });
    });
}
//# sourceMappingURL=codexExecutor.js.map