@yu_robotics/remote-cli 1.6.26 → 1.6.32

package/dist/executor/CodexExecutor.js

@@ -1,789 +0,0 @@
-"use strict";
-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.CodexExecutor = void 0;
-const child_process_1 = require("child_process");
-const string_decoder_1 = require("string_decoder");
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const compactHandoff_1 = require("./compactHandoff");
-const CodexAppServerClient_1 = require("./CodexAppServerClient");
-/** Default inactivity timeout (ms) — a silent codex process fails the command. */
-const DEFAULT_INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
-/** Default grace period (ms) before SIGTERM escalates to SIGKILL. */
-const DEFAULT_KILL_ESCALATION_MS = 3_000;
-/** How much stderr (chars) to keep for error diagnostics. */
-const STDERR_TAIL_LIMIT = 4_000;
-/** How much of the stderr tail (chars) to include in error messages. */
-const STDERR_TAIL_IN_ERROR = 500;
-/**
- * IExecutor implementation for the OpenAI Codex CLI (`codex`), exec mode.
- *
- * Unlike AgyExecutor (one persistent process per conversation), codex exec
- * is one-shot per command: each execute() spawns
- *   codex exec --json --skip-git-repo-check [--dangerously-bypass-approvals-and-sandbox] [-m model] "<prompt>"
- * and resolves when the process exits. Context continuity is achieved by
- * persisting the thread_id from `thread.started` and passing it to
- *   codex exec resume --skip-git-repo-check --json ... <thread_id> "<prompt>"
- * on subsequent commands.
- *
- * Caveats (verified against codex-cli 0.153.4):
- *  - stdin must be ended immediately after spawn — codex reads piped stdin
- *    to EOF before starting ("Reading additional input from stdin...").
- *  - `codex exec resume` does NOT accept the --sandbox flag (usage error).
- *    We only ever pass --dangerously-bypass-approvals-and-sandbox, which is
- *    accepted on both first run and resume.
- *  - item type "error" is non-fatal (e.g. model-metadata fallback warnings);
- *    turn.failed / top-level error events are the fatal ones.
- *
- * Note: exec mode accepts text prompts only — image attachments are silently
- * dropped (with a log line).
- */
-class CodexExecutor {
-    directoryGuard;
-    currentWorkingDirectory;
-    /** Model for the next spawn. Mutable: setModel() updates it in place. */
-    model;
-    effort;
-    autoApprove;
-    codexCommand;
-    threadId;
-    proc = null;
-    codexThreadId = null;
-    sessionFilePath;
-    commandQueue = [];
-    isProcessing = false;
-    isDestroyed = false;
-    activeCommand = null;
-    currentOutputBuffer = [];
-    stdoutBuffer = '';
-    stderrTail = '';
-    decoder = new string_decoder_1.StringDecoder('utf8');
-    inactivityTimer = null;
-    inactivityTimeoutMs;
-    killEscalationMs;
-    modelCatalogClientFactory;
-    attachmentWarningShown = false;
-    /** Handoff summary from compactWhenFull, wrapped into the next prompt (consumed once). */
-    pendingContextSeed = null;
-    constructor(directoryGuard, options = {}) {
-        this.directoryGuard = directoryGuard;
-        this.model = options.model;
-        this.effort = options.effort;
-        this.autoApprove = options.autoApprove ?? true;
-        this.codexCommand = options.codexCommand ?? 'codex';
-        this.threadId = options.threadId;
-        this.inactivityTimeoutMs = options.inactivityTimeoutMs ?? DEFAULT_INACTIVITY_TIMEOUT_MS;
-        this.killEscalationMs = options.killEscalationMs ?? DEFAULT_KILL_ESCALATION_MS;
-        this.modelCatalogClientFactory = options.modelCatalogClientFactory
-            ?? ((cwd) => new CodexAppServerClient_1.CodexAppServerClient({ command: this.codexCommand, cwd }));
-        if (options.initialWorkingDirectory) {
-            try {
-                this.currentWorkingDirectory = this.directoryGuard.resolveWorkingDirectory(options.initialWorkingDirectory);
-            }
-            catch (error) {
-                console.warn(`[CodexExecutor] Failed to use initial working directory: ${options.initialWorkingDirectory}`, error);
-                this.currentWorkingDirectory = process.cwd();
-            }
-        }
-        else {
-            this.currentWorkingDirectory = process.cwd();
-        }
-        if (this.threadId) {
-            const sessionsDir = path.join(os.homedir(), '.remote-cli', 'codex-sessions');
-            fs.mkdirSync(sessionsDir, { recursive: true });
-            this.sessionFilePath = path.join(sessionsDir, `${this.threadId}.json`);
-        }
-        else {
-            // Legacy: session file in working directory
-            this.sessionFilePath = path.join(this.currentWorkingDirectory, '.codex-session');
-        }
-        this.loadThreadId();
-    }
-    // ─── IExecutor required ───────────────────────────────────────────────────
-    async execute(prompt, options = {}) {
-        if (this.isDestroyed) {
-            return Promise.reject(new Error('Executor has been destroyed'));
-        }
-        return new Promise((resolve, reject) => {
-            this.commandQueue.push({ prompt, options, resolve, reject });
-            void this.processQueue();
-        });
-    }
-    getCurrentWorkingDirectory() {
-        return this.currentWorkingDirectory;
-    }
-    async setWorkingDirectory(targetPath) {
-        // One-shot processes: only the next spawn uses the new directory; a
-        // running command keeps its own cwd.
-        this.currentWorkingDirectory = this.directoryGuard.resolveWorkingDirectory(targetPath);
-    }
-    resetContext() {
-        this.killProcess('Context reset');
-        this.clearThreadId();
-        // /clear means a real fresh start — drop any carried-over compact seed
-        this.pendingContextSeed = null;
-    }
-    async abort() {
-        if (!this.proc || !this.activeCommand)
-            return false;
-        // codex exec has no cancel request in exec mode — abort = kill the
-        // process. The thread id survives, so the next command resumes context.
-        console.log('[CodexExecutor] Aborting: killing codex process');
-        this.killProcess('Aborted by user');
-        return true;
-    }
-    async destroy() {
-        if (this.isDestroyed)
-            return;
-        this.isDestroyed = true;
-        // Reject everything still queued — nothing may spawn after destroy
-        const queued = this.commandQueue.splice(0);
-        for (const command of queued) {
-            command.reject(new Error('Executor has been destroyed'));
-        }
-        const proc = this.proc;
-        if (proc) {
-            try {
-                proc.stdin?.end();
-            }
-            catch { /* already closed */ }
-        }
-        this.killProcess('Executor destroyed');
-    }
-    // ─── IExecutor optional ───────────────────────────────────────────────────
-    isProcessRunning() {
-        return this.proc !== null;
-    }
-    getSessionId() {
-        return this.codexThreadId;
-    }
-    /**
-     * Switch the model for future commands. codex exec is one-shot per command
-     * and takes -m at spawn, so the running command (if any) is undisturbed and
-     * the next spawn picks the new model up. MessageHandler persists the choice
-     * on the thread; ThreadExecutorPool passes it back via the factory.
-     */
-    async listModels() {
-        const client = this.modelCatalogClientFactory(this.currentWorkingDirectory);
-        const models = [];
-        let cursor = null;
-        try {
-            do {
-                const response = await client.request('model/list', {
-                    cursor,
-                    limit: 100,
-                    includeHidden: false,
-                });
-                for (const model of Array.isArray(response?.data) ? response.data : []) {
-                    if (typeof model?.id !== 'string')
-                        continue;
-                    models.push({
-                        id: model.id,
-                        displayName: model.displayName ?? model.id,
-                        description: model.description,
-                        isDefault: model.isDefault === true,
-                        supportedReasoningEfforts: Array.isArray(model.supportedReasoningEfforts)
-                            ? model.supportedReasoningEfforts.map((entry) => entry?.reasoningEffort).filter(Boolean)
-                            : undefined,
-                        defaultReasoningEffort: typeof model.defaultReasoningEffort === 'string'
-                            ? model.defaultReasoningEffort
-                            : undefined,
-                        inputModalities: Array.isArray(model.inputModalities) ? model.inputModalities : undefined,
-                    });
-                }
-                cursor = typeof response?.nextCursor === 'string' ? response.nextCursor : null;
-            } while (cursor);
-            return models;
-        }
-        finally {
-            await client.stop();
-        }
-    }
-    async setModel(model, _onStream) {
-        try {
-            const models = await this.listModels();
-            if (!models.some((entry) => entry.id === model)) {
-                return { success: false, error: `Unknown Codex model: ${model}. Use /model to list available models.` };
-            }
-            this.model = model;
-            console.log(`[CodexExecutor] Model set to ${model} (applies from the next command)`);
-            return {
-                success: true,
-                output: `Model set to ${model}. Takes effect on the next command.`,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Could not validate Codex model: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    clearModel() {
-        this.model = undefined;
-    }
-    async setEffort(effort) {
-        const normalized = effort.trim().toLowerCase();
-        if (normalized === 'auto') {
-            this.effort = undefined;
-            return { success: true, output: 'Reasoning effort restored to the Codex default.' };
-        }
-        try {
-            const models = await this.listModels();
-            const activeModel = models.find((entry) => entry.id === this.model)
-                ?? models.find((entry) => entry.isDefault)
-                ?? models[0];
-            const supported = activeModel?.supportedReasoningEfforts ?? [];
-            if (!supported.includes(normalized)) {
-                return {
-                    success: false,
-                    error: `Unsupported reasoning effort for ${activeModel?.id ?? 'the active Codex model'}: ${effort}. Supported values: ${supported.join(', ') || 'unavailable'}.`,
-                };
-            }
-            this.effort = normalized;
-            return { success: true, output: `Reasoning effort set to ${normalized}. Takes effect on the next command.` };
-        }
-        catch (error) {
-            return { success: false, error: `Could not validate Codex reasoning effort: ${error instanceof Error ? error.message : String(error)}` };
-        }
-    }
-    /**
-     * Compact via summarize-then-reset. codex has compaction in its interactive
-     * TUI (plus internal auto-compaction at the token limit), but in exec mode
-     * a '/compact' prompt reaches the model as plain text (verified live against
-     * codex-cli 0.153.4). So we:
-     *   1. ask the current thread for a dense handoff summary,
-     *   2. reset the thread,
-     *   3. wrap the summary into the next user prompt (consumed once).
-     * If the summary turn fails (e.g. context already too full), fall back to
-     * a plain reset and say so honestly.
-     */
-    async compactWhenFull(onStream) {
-        if (!this.proc && !this.codexThreadId) {
-            return { success: true, output: 'No active conversation to compact.' };
-        }
-        onStream?.('Summarizing the conversation before resetting...\n');
-        let summary = null;
-        try {
-            const r = await this.execute(compactHandoff_1.COMPACT_HANDOFF_PROMPT, onStream ? { onStream } : {});
-            if (r.success && r.output?.trim())
-                summary = r.output.trim();
-        }
-        catch (error) {
-            console.warn('[CodexExecutor] Handoff summary failed, falling back to plain reset:', error);
-        }
-        this.resetContext();
-        if (summary) {
-            this.pendingContextSeed = summary;
-            return {
-                success: true,
-                output: '✅ Context compacted: the conversation was summarized and carried over to a fresh session.',
-            };
-        }
-        return {
-            success: true,
-            output: '⚠️ Handoff summary failed — the conversation was reset without carryover. Context starts fresh.',
-        };
-    }
-    /**
-     * Delete per-thread session state. Only removes OUR stored thread id
-     * mapping — codex's own session store (~/.codex/sessions) is left untouched.
-     */
-    async deleteThreadData(_threadId) {
-        await this.destroy();
-        this.clearThreadId();
-    }
-    // ─── Queue processing ─────────────────────────────────────────────────────
-    async processQueue() {
-        if (this.isProcessing || this.isDestroyed || this.commandQueue.length === 0)
-            return;
-        const command = this.commandQueue.shift();
-        if (!command)
-            return;
-        this.isProcessing = true;
-        try {
-            const result = await this.executeQueued(command.prompt, command.options);
-            command.resolve(result);
-        }
-        catch (error) {
-            command.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-        finally {
-            this.isProcessing = false;
-            void this.processQueue();
-        }
-    }
-    executeQueued(prompt, options) {
-        return new Promise((resolve) => {
-            if (options.attachments?.length && !this.attachmentWarningShown) {
-                this.attachmentWarningShown = true;
-                console.warn('[CodexExecutor] codex exec mode accepts text prompts only — attachments were dropped');
-            }
-            let proc;
-            try {
-                // A carried-over compact summary wraps the first prompt after a reset
-                const finalPrompt = this.pendingContextSeed
-                    ? (0, compactHandoff_1.seedPromptWithHandoff)(this.pendingContextSeed, prompt)
-                    : prompt;
-                this.pendingContextSeed = null;
-                proc = this.spawnProcess(finalPrompt);
-            }
-            catch (error) {
-                resolve({
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return;
-            }
-            const active = { options, resolve };
-            if (options.timeout && options.timeout > 0) {
-                active.timeoutTimer = setTimeout(() => {
-                    console.warn(`[CodexExecutor] Command timed out after ${options.timeout}ms, killing process`);
-                    this.killProcess(`Command timed out after ${options.timeout}ms`);
-                }, options.timeout);
-            }
-            this.activeCommand = active;
-            this.currentOutputBuffer = [];
-            this.armInactivityTimer();
-        });
-    }
-    completeActiveCommand(result) {
-        const active = this.activeCommand;
-        if (!active)
-            return;
-        this.activeCommand = null;
-        this.clearInactivityTimer();
-        if (active.timeoutTimer)
-            clearTimeout(active.timeoutTimer);
-        if (result.success && result.output === undefined) {
-            result.output = this.currentOutputBuffer.join('');
-        }
-        if (result.success) {
-            result.sessionAbbr = this.codexThreadId?.slice(0, 8);
-        }
-        active.resolve(result);
-    }
-    /**
-     * Arm the inactivity watchdog: any stdout line counts as activity. If codex
-     * goes silent mid-command for longer than the limit, fail the command and
-     * kill the process (the thread resumes on the next command).
-     */
-    armInactivityTimer() {
-        this.clearInactivityTimer();
-        this.inactivityTimer = setTimeout(() => {
-            console.warn(`[CodexExecutor] No output for ${this.inactivityTimeoutMs}ms, killing process`);
-            this.killProcess(`No output from codex for ${this.inactivityTimeoutMs}ms (inactivity timeout)`);
-        }, this.inactivityTimeoutMs);
-    }
-    clearInactivityTimer() {
-        if (this.inactivityTimer !== null) {
-            clearTimeout(this.inactivityTimer);
-            this.inactivityTimer = null;
-        }
-    }
-    // ─── Process lifecycle ────────────────────────────────────────────────────
-    spawnProcess(prompt) {
-        if (this.isDestroyed) {
-            throw new Error('Executor has been destroyed');
-        }
-        const args = this.buildArgs(prompt);
-        console.log(`[CodexExecutor] Spawning: ${this.codexCommand} ${args.join(' ')} (cwd: ${this.currentWorkingDirectory})`);
-        // Fresh stream state for the new process
-        this.stdoutBuffer = '';
-        this.stderrTail = '';
-        this.decoder = new string_decoder_1.StringDecoder('utf8');
-        const proc = (0, child_process_1.spawn)(this.codexCommand, args, {
-            cwd: this.currentWorkingDirectory,
-            env: { ...process.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        proc.stdout.on('data', (data) => this.handleStdout(proc, data));
-        proc.stderr.on('data', (data) => {
-            if (proc !== this.proc)
-                return; // stale process — don't pollute the next command's diagnostics
-            const text = data.toString();
-            // Keep a bounded tail for error diagnostics (usage errors, auth failures)
-            this.stderrTail = (this.stderrTail + text).slice(-STDERR_TAIL_LIMIT);
-            console.log(`[CodexExecutor stderr] ${text.trim().slice(0, 300)}`);
-        });
-        // Async stdin socket errors (e.g. EPIPE if codex exits early) must not
-        // crash the whole CLI process — the exit/error handler reports the failure.
-        proc.stdin.on('error', (error) => {
-            console.warn(`[CodexExecutor] stdin error: ${error.message}`);
-        });
-        proc.on('error', (error) => {
-            if (proc !== this.proc)
-                return;
-            console.error('[CodexExecutor] Process error:', error);
-            this.proc = null;
-            const friendly = error.message.includes('ENOENT')
-                ? 'Codex CLI (codex) is not installed or not found on PATH. Install it with `npm i -g @openai/codex`, or use /backend to switch to another backend.'
-                : `codex process error: ${error.message}`;
-            this.completeActiveCommand({ success: false, error: friendly });
-        });
-        proc.on('exit', (code, signal) => {
-            if (proc !== this.proc)
-                return;
-            // 'exit' fires when the process terminates, but its stdio streams may
-            // still hold undelivered data — terminal resolution happens on 'close'
-            // (all stdio flushed) so the final turn.completed line is never lost.
-            console.log(`[CodexExecutor] Process exited (code=${code}, signal=${signal})`);
-        });
-        proc.on('close', (code, signal) => {
-            if (proc !== this.proc)
-                return;
-            this.proc = null;
-            // Flush the decoder and any unterminated trailing line before judging
-            // the outcome — a crash mid-write can leave a complete final event
-            // (e.g. turn.failed with the real error) without a trailing newline.
-            this.stdoutBuffer += this.decoder.end();
-            const remaining = this.stdoutBuffer;
-            this.stdoutBuffer = '';
-            for (const line of remaining.split('\n')) {
-                if (line.trim())
-                    this.handleLine(line);
-            }
-            if (this.activeCommand) {
-                const recorded = this.activeCommand.result;
-                if (recorded) {
-                    // A terminal event (turn.completed / turn.failed / error) already
-                    // determined the outcome — trust it over the exit code.
-                    this.completeActiveCommand(recorded);
-                }
-                else {
-                    console.error(`[CodexExecutor] Process exited without a terminal event (code=${code}, signal=${signal})`);
-                    const tail = this.stderrTail.trim().slice(-STDERR_TAIL_IN_ERROR);
-                    this.completeActiveCommand({
-                        success: false,
-                        error: `codex process exited unexpectedly (code ${code ?? signal})${tail ? `: ${tail}` : ''}`,
-                    });
-                }
-            }
-        });
-        this.proc = proc;
-        // codex exec reads piped stdin to EOF before starting — end it immediately.
-        try {
-            proc.stdin.end();
-        }
-        catch { /* already closed */ }
-        return proc;
-    }
-    buildArgs(prompt) {
-        const args = ['exec'];
-        if (this.codexThreadId) {
-            // NOTE: `codex exec resume` rejects --sandbox (usage error in 0.153.4).
-            // --dangerously-bypass-approvals-and-sandbox IS accepted on resume.
-            args.push('resume', '--skip-git-repo-check', '--json');
-            if (this.autoApprove) {
-                args.push('--dangerously-bypass-approvals-and-sandbox');
-            }
-            if (this.model) {
-                args.push('-m', this.model);
-            }
-            if (this.effort) {
-                args.push('-c', `model_reasoning_effort="${this.effort}"`);
-            }
-            // `--` guards prompts that start with a dash from clap's flag parser
-            args.push(this.codexThreadId, '--', prompt);
-            return args;
-        }
-        args.push('--json', '--skip-git-repo-check');
-        if (this.autoApprove) {
-            args.push('--dangerously-bypass-approvals-and-sandbox');
-        }
-        if (this.model) {
-            args.push('-m', this.model);
-        }
-        if (this.effort) {
-            args.push('-c', `model_reasoning_effort="${this.effort}"`);
-        }
-        args.push('--', prompt);
-        return args;
-    }
-    killProcess(reason) {
-        const proc = this.proc;
-        this.proc = null;
-        if (proc) {
-            let exited = false;
-            proc.once('exit', () => { exited = true; });
-            proc.kill(); // SIGTERM
-            // Escalate to SIGKILL if the process ignores SIGTERM — a lingering
-            // process would share the thread rollout store with the next spawn.
-            const escalate = setTimeout(() => {
-                if (!exited) {
-                    console.warn('[CodexExecutor] Process ignored SIGTERM, escalating to SIGKILL');
-                    proc.kill('SIGKILL');
-                }
-            }, this.killEscalationMs);
-            // Never let the watchdog hold the event loop open by itself
-            if (typeof escalate.unref === 'function')
-                escalate.unref();
-        }
-        // Never leave an in-flight command hanging when its process dies. If a
-        // terminal event already recorded an outcome (e.g. turn.completed arrived
-        // but the process then hung), prefer it over the kill reason.
-        if (this.activeCommand) {
-            this.completeActiveCommand(this.activeCommand.result ?? {
-                success: false,
-                error: reason ?? 'codex process was terminated mid-command',
-            });
-        }
-    }
-    // ─── Wire protocol parsing ────────────────────────────────────────────────
-    handleStdout(proc, data) {
-        if (proc !== this.proc)
-            return; // stale process
-        // StringDecoder handles multi-byte UTF-8 characters split across chunks
-        this.stdoutBuffer += this.decoder.write(data);
-        const lines = this.stdoutBuffer.split('\n');
-        this.stdoutBuffer = lines.pop() ?? '';
-        for (const line of lines) {
-            if (line.trim())
-                this.handleLine(line);
-        }
-    }
-    handleLine(line) {
-        let message;
-        try {
-            message = JSON.parse(line);
-        }
-        catch {
-            console.warn(`[CodexExecutor] Skipping malformed NDJSON line: ${line.slice(0, 120)}`);
-            return;
-        }
-        // Any valid line counts as activity for the inactivity watchdog
-        if (this.activeCommand)
-            this.armInactivityTimer();
-        switch (message.type) {
-            case 'thread.started': {
-                const threadId = message.thread_id;
-                if (typeof threadId === 'string' && threadId) {
-                    if (threadId !== this.codexThreadId) {
-                        console.log(`[CodexExecutor] Thread started: ${threadId}`);
-                        this.setThreadId(threadId);
-                    }
-                }
-                break;
-            }
-            case 'turn.started':
-                // Marks the start of model work for this turn — nothing to emit
-                break;
-            case 'item.started':
-                this.handleItemStarted(message.item);
-                break;
-            case 'item.completed':
-                this.handleItemCompleted(message.item);
-                break;
-            case 'turn.completed':
-                if (this.activeCommand) {
-                    this.activeCommand.result = {
-                        success: true,
-                        output: this.currentOutputBuffer.join(''),
-                    };
-                }
-                break;
-            case 'turn.failed': {
-                const errMsg = message.error?.message || 'turn failed (no details)';
-                if (this.activeCommand) {
-                    this.activeCommand.result = { success: false, error: errMsg };
-                }
-                break;
-            }
-            case 'error': {
-                const errMsg = typeof message.message === 'string' ? message.message : 'codex error';
-                // Transient reconnect/fallback notices are informational only
-                if (/Reconnecting|Falling back/i.test(errMsg)) {
-                    console.warn(`[CodexExecutor] Transient error event: ${errMsg}`);
-                    break;
-                }
-                if (this.activeCommand) {
-                    this.activeCommand.result = { success: false, error: errMsg };
-                }
-                break;
-            }
-            default:
-                // Unknown events are safely ignored (codex may add new ones)
-                console.warn(`[CodexExecutor] Ignoring unknown event: ${message.type}`);
-        }
-    }
-    handleItemStarted(item) {
-        if (!item || !this.activeCommand)
-            return;
-        const { options } = this.activeCommand;
-        // command_execution has its full command string at start; other tool
-        // types (web_search etc.) have empty fields until item.completed.
-        if (item.type === 'command_execution' && typeof item.id === 'string') {
-            options.onToolUse?.({
-                id: item.id,
-                name: 'Bash',
-                input: { command: item.command ?? '' },
-            });
-        }
-    }
-    handleItemCompleted(item) {
-        if (!item || !this.activeCommand)
-            return;
-        const { options } = this.activeCommand;
-        const itemId = typeof item.id === 'string' ? item.id : 'codex-item';
-        switch (item.type) {
-            case 'agent_message':
-            case 'message': {
-                const text = item.text;
-                if (typeof text === 'string' && text.length > 0) {
-                    this.currentOutputBuffer.push(text);
-                    options.onStream?.(text);
-                }
-                return;
-            }
-            case 'command_execution': {
-                const output = typeof item.aggregated_output === 'string' ? item.aggregated_output : '';
-                const isError = !codexItemSucceeded(item.status, item.exit_code);
-                options.onToolResult?.({ tool_use_id: itemId, content: output, is_error: isError });
-                return;
-            }
-            case 'file_change': {
-                const changes = Array.isArray(item.changes) ? item.changes : [];
-                const firstPath = changes[0]?.path ?? '';
-                const kinds = changes.map((c) => c?.kind).filter(Boolean).join(', ');
-                const diffs = changes
-                    .map((change) => typeof change?.diff === 'string' ? change.diff : '')
-                    .filter(Boolean)
-                    .join('\n');
-                const status = typeof item.status === 'string' ? item.status : '';
-                options.onToolUse?.({ id: itemId, name: 'Edit', input: { file_path: firstPath, ...(diffs ? { diff: diffs } : {}) } });
-                options.onToolResult?.({
-                    tool_use_id: itemId,
-                    content: `file_change (${kinds || 'unknown'}): ${status}`,
-                    ...(diffs ? { diff: diffs } : {}),
-                    is_error: !codexItemSucceeded(item.status, null),
-                });
-                return;
-            }
-            case 'web_search': {
-                const query = item.query ?? item.action?.queries?.[0] ?? '';
-                options.onToolUse?.({ id: itemId, name: 'WebSearch', input: { query } });
-                options.onToolResult?.({ tool_use_id: itemId, content: '', is_error: false });
-                return;
-            }
-            case 'reasoning': {
-                // Surface model reasoning summaries as streamed thinking text
-                // (aligned with the Claude backend, which streams thinking through
-                // the same channel) — but keep it out of the final result output.
-                const summary = Array.isArray(item.summary) ? item.summary : [];
-                const text = summary
-                    .map((s) => (typeof s?.text === 'string' ? s.text : ''))
-                    .filter(Boolean)
-                    .join('\n');
-                if (text)
-                    options.onStream?.(text);
-                return;
-            }
-            case 'function_call_output':
-                // Companion record of a function_call — already rendered by it
-                return;
-            case 'error':
-                // Non-fatal item-level error (e.g. model-metadata fallback warnings)
-                console.warn(`[CodexExecutor] Item error: ${item.message ?? '(no message)'}`);
-                return;
-            default: {
-                // Unknown tool-ish items (mcp_tool_call, file_search, future types):
-                // render a generic card with the raw type as the tool name — same
-                // pass-through policy as the AGY backend.
-                const { id: _id, type, status, result: itemResult, error: itemError, ...rest } = item;
-                options.onToolUse?.({ id: itemId, name: type, input: rest });
-                const isError = !!itemError ||
-                    (typeof status === 'string' && !codexItemSucceeded(status, null));
-                const content = typeof itemResult === 'string' ? itemResult
-                    : itemResult !== undefined ? JSON.stringify(itemResult).slice(0, 500)
-                        : (itemError?.message ?? '');
-                options.onToolResult?.({ tool_use_id: itemId, content, is_error: isError });
-                return;
-            }
-        }
-    }
-    // ─── Thread persistence ───────────────────────────────────────────────────
-    loadThreadId() {
-        try {
-            if (fs.existsSync(this.sessionFilePath)) {
-                const data = fs.readFileSync(this.sessionFilePath, 'utf-8');
-                const session = JSON.parse(data);
-                if (session.id) {
-                    this.codexThreadId = session.id;
-                    console.log(`[CodexExecutor] Loaded thread ID: ${this.codexThreadId}`);
-                }
-            }
-        }
-        catch (error) {
-            console.error('[CodexExecutor] Failed to load thread ID:', error);
-            this.codexThreadId = null;
-        }
-    }
-    setThreadId(threadId) {
-        this.codexThreadId = threadId;
-        try {
-            const data = JSON.stringify({ id: threadId, savedAt: new Date().toISOString() });
-            fs.writeFileSync(this.sessionFilePath, data, 'utf-8');
-        }
-        catch (error) {
-            console.error('[CodexExecutor] Failed to save thread ID:', error);
-        }
-    }
-    clearThreadId() {
-        this.codexThreadId = null;
-        try {
-            if (fs.existsSync(this.sessionFilePath)) {
-                fs.unlinkSync(this.sessionFilePath);
-            }
-        }
-        catch (error) {
-            console.error('[CodexExecutor] Failed to delete session file:', error);
-        }
-    }
-}
-exports.CodexExecutor = CodexExecutor;
-/**
- * A command_execution / file_change item succeeded when its exit code is 0
- * (if present) or its status is a success word.
- */
-function codexItemSucceeded(status, exitCode) {
-    if (typeof exitCode === 'number') {
-        return exitCode === 0;
-    }
-    const s = typeof status === 'string' ? status.trim().toLowerCase() : '';
-    return s === 'completed' || s === 'success' || s === 'succeeded' || s === 'ok';
-}
-//# sourceMappingURL=CodexExecutor.js.map