@voxagent/bridge 0.1.0

package/dist/drivers/codex.js

@@ -0,0 +1,652 @@
+/**
+ * @file Codex driver — drives `codex app-server` over line-delimited JSON-RPC 2.0.
+ *
+ * Why app-server instead of `codex exec --json`:
+ *   `exec --json` does not support pause/resume approvals — when an action
+ *   would normally trigger a prompt, exec mode treats it as a hard failure.
+ *   The app-server transport (`codex app-server`, default stdio) is a proper
+ *   JSON-RPC 2.0 channel where Codex sends server-initiated approval
+ *   requests (`item/commandExecution/requestApproval`,
+ *   `item/fileChange/requestApproval`) that we respond to via the same
+ *   JSON-RPC envelope. That lets us route approvals through the bridge's
+ *   PermissionBroker to a meeting-side Allow / Deny modal.
+ *
+ * Lifecycle:
+ *   - One long-lived `codex app-server` subprocess per CodexDriver instance.
+ *     Spawned lazily on the first run() so capabilities() stays cheap.
+ *   - `initialize` request once, `thread/start` on the first run, then
+ *     `turn/start` for each subsequent run() call (threadId reused so Codex
+ *     keeps conversation context across turns).
+ *   - On run abort: `turn/interrupt` for the active turn.
+ *   - On close(): SIGTERM the process and reject pending requests.
+ *
+ * The streaming JSON-RPC types and notification methods are taken from
+ * `codex app-server generate-ts` output (see /tmp/codex-protocol).
+ */
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { log } from '../logging.js';
+const BRIDGE_VERSION = '0.1.0';
+export class CodexDriver {
+    options;
+    backend = 'codex';
+    proc = null;
+    threadId = null;
+    nextRequestId = 1;
+    pending = new Map();
+    activeTurn = null;
+    rxBuffer = '';
+    serverStartFailed = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async capabilities(cwd) {
+        const mcpServers = await this.discoverMcpServers();
+        return {
+            backend: 'codex',
+            skills: [],
+            plugins: [],
+            mcpServers,
+            cwd,
+            bridgeVersion: BRIDGE_VERSION,
+        };
+    }
+    async *run(input, signal) {
+        const runId = randomUUID();
+        const startedAtMs = Date.now();
+        yield { type: 'run_start', runId, startedAtMs };
+        try {
+            await this.ensureServer();
+        }
+        catch (error) {
+            yield {
+                type: 'run_end',
+                runId,
+                reason: 'error',
+                message: error instanceof Error ? error.message : String(error),
+                totalLatencyMs: Date.now() - startedAtMs,
+            };
+            return;
+        }
+        if (!this.threadId) {
+            try {
+                // Codex 0.104's CLI-side default leaks `gpt-5.5` into thread/start,
+                // which the live server rejects. The codex-suffixed flagships
+                // (gpt-5.2-codex etc.) require API-key auth and fail under
+                // ChatGPT-account auth. Default to `gpt-5.4` which the server
+                // advertises in `model/list` and accepts under both auth modes.
+                // Users with API keys can override via --llm-model.
+                const model = this.options.model ?? 'gpt-5.4';
+                const result = (await this.sendRequest('thread/start', {
+                    cwd: input.cwd,
+                    approvalPolicy: this.options.fullAccess ? 'never' : 'on-request',
+                    sandbox: this.options.fullAccess ? 'danger-full-access' : 'workspace-write',
+                    model,
+                    experimentalRawEvents: false,
+                    persistExtendedHistory: false,
+                }));
+                this.threadId = result.thread?.id ?? null;
+            }
+            catch (error) {
+                yield {
+                    type: 'run_end',
+                    runId,
+                    reason: 'error',
+                    message: `thread/start failed: ${error instanceof Error ? error.message : String(error)}`,
+                    totalLatencyMs: Date.now() - startedAtMs,
+                };
+                return;
+            }
+        }
+        if (!this.threadId) {
+            yield {
+                type: 'run_end',
+                runId,
+                reason: 'error',
+                message: 'Codex did not return a thread ID.',
+                totalLatencyMs: Date.now() - startedAtMs,
+            };
+            return;
+        }
+        // Build a queue + iterator pair driven by handleNotification + handleServerRequest.
+        const queue = [];
+        const waiters = [];
+        let ended = false;
+        const push = (event) => {
+            if (ended)
+                return;
+            const waiter = waiters.shift();
+            if (waiter)
+                waiter({ value: event, done: false });
+            else
+                queue.push(event);
+        };
+        const end = (reason, message) => {
+            if (ended)
+                return;
+            ended = true;
+            const totalLatencyMs = Date.now() - startedAtMs;
+            const evt = message
+                ? { type: 'run_end', runId, reason, message, totalLatencyMs }
+                : { type: 'run_end', runId, reason, totalLatencyMs };
+            const waiter = waiters.shift();
+            if (waiter)
+                waiter({ value: evt, done: false });
+            else
+                queue.push(evt);
+            // Then signal exhaustion.
+            const final = waiters.shift();
+            if (final)
+                final({ value: undefined, done: true });
+        };
+        const turn = {
+            turnId: null,
+            push,
+            end,
+            startedAtMs,
+            itemStarts: new Map(),
+            runId,
+            signal,
+            finalText: '',
+        };
+        this.activeTurn = turn;
+        let promptText = input.prompt;
+        if (input.systemPromptAddendum) {
+            promptText = `${input.systemPromptAddendum}\n\n---\n\n${promptText}`;
+        }
+        const onAbort = () => {
+            if (!turn.turnId)
+                return;
+            void this.sendRequest('turn/interrupt', { threadId: this.threadId, turnId: turn.turnId }).catch(() => undefined);
+        };
+        if (signal.aborted)
+            onAbort();
+        else
+            signal.addEventListener('abort', onAbort, { once: true });
+        // Kick off the turn — don't await, let notifications stream while we wait.
+        void this.sendRequest('turn/start', {
+            threadId: this.threadId,
+            input: [{ type: 'text', text: promptText }],
+        })
+            .then((result) => {
+            const r = result;
+            if (r.turn?.id)
+                turn.turnId = r.turn.id;
+        })
+            .catch((error) => {
+            end('error', `turn/start failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        try {
+            while (true) {
+                if (queue.length > 0) {
+                    const evt = queue.shift();
+                    yield evt;
+                    if (evt.type === 'run_end')
+                        return;
+                    continue;
+                }
+                if (ended && queue.length === 0)
+                    return;
+                const next = await new Promise((resolve) => {
+                    waiters.push(resolve);
+                });
+                if (next.done)
+                    return;
+                yield next.value;
+                if (next.value.type === 'run_end')
+                    return;
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+            if (this.activeTurn === turn)
+                this.activeTurn = null;
+        }
+    }
+    async close() {
+        if (this.activeTurn) {
+            this.activeTurn.end('interrupted');
+            this.activeTurn = null;
+        }
+        for (const [, entry] of this.pending) {
+            entry.reject(new Error('Codex driver closed.'));
+        }
+        this.pending.clear();
+        if (this.proc && !this.proc.killed) {
+            this.proc.kill('SIGTERM');
+        }
+        this.proc = null;
+        this.threadId = null;
+    }
+    async ensureServer() {
+        if (this.proc)
+            return;
+        if (this.serverStartFailed) {
+            throw new Error('codex app-server previously failed to start.');
+        }
+        const child = spawn('codex', ['app-server'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.proc = child;
+        child.stdout.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => this.onStdout(chunk));
+        child.stderr.setEncoding('utf-8');
+        child.stderr.on('data', (chunk) => {
+            log.debug('codex_stderr', { chunk: chunk.slice(0, 240) });
+        });
+        child.once('exit', (code, signal) => {
+            log.info('codex_app_server_exited', { code, signal });
+            const wasActive = this.activeTurn;
+            this.proc = null;
+            for (const [, entry] of this.pending) {
+                entry.reject(new Error('codex app-server exited.'));
+            }
+            this.pending.clear();
+            if (wasActive) {
+                wasActive.end('error', 'codex app-server exited unexpectedly.');
+                this.activeTurn = null;
+            }
+        });
+        try {
+            await this.sendRequest('initialize', {
+                clientInfo: { name: 'voxagent-bridge', title: 'VoxAgent Bridge', version: BRIDGE_VERSION },
+                capabilities: { experimentalApi: false },
+            });
+        }
+        catch (error) {
+            this.serverStartFailed = true;
+            child.kill('SIGTERM');
+            this.proc = null;
+            throw new Error(`codex initialize failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    onStdout(chunk) {
+        this.rxBuffer += chunk;
+        let idx;
+        while ((idx = this.rxBuffer.indexOf('\n')) !== -1) {
+            const line = this.rxBuffer.slice(0, idx).trim();
+            this.rxBuffer = this.rxBuffer.slice(idx + 1);
+            if (line.length === 0)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                log.warn('codex_unparseable_line', { line: line.slice(0, 200) });
+                continue;
+            }
+            this.dispatch(parsed);
+        }
+    }
+    dispatch(msg) {
+        if ('id' in msg && msg.result !== undefined) {
+            this.handleResponse(msg);
+            return;
+        }
+        if ('id' in msg && msg.error !== undefined) {
+            this.handleResponse(msg);
+            return;
+        }
+        if ('id' in msg && 'method' in msg) {
+            this.handleServerRequest(msg);
+            return;
+        }
+        if ('method' in msg) {
+            this.handleNotification(msg);
+            return;
+        }
+    }
+    handleResponse(resp) {
+        if (typeof resp.id !== 'number')
+            return;
+        const entry = this.pending.get(resp.id);
+        if (!entry)
+            return;
+        this.pending.delete(resp.id);
+        if (resp.error) {
+            entry.reject(new Error(`${resp.error.code}: ${resp.error.message}`));
+        }
+        else {
+            entry.resolve(resp.result ?? null);
+        }
+    }
+    handleServerRequest(req) {
+        const params = (req.params ?? {});
+        if (req.method === 'item/commandExecution/requestApproval') {
+            void this.handleApproval('Bash', req.id, params);
+            return;
+        }
+        if (req.method === 'item/fileChange/requestApproval') {
+            void this.handleApproval('Edit', req.id, params);
+            return;
+        }
+        // For server requests we don't recognize, decline politely so Codex doesn't hang.
+        log.debug('codex_unknown_server_request', { method: req.method });
+        this.sendResponse(req.id, { error: { code: -32601, message: 'Not implemented in bridge.' } });
+    }
+    async handleApproval(surface, requestId, params) {
+        const resolver = this.options.permissionResolver;
+        if (this.options.fullAccess || !resolver) {
+            this.sendResponse(requestId, { result: { decision: 'accept' } });
+            return;
+        }
+        try {
+            const result = await resolver.decide({
+                runId: this.activeTurn?.runId ?? 'unknown',
+                toolName: surface,
+                toolInput: params,
+            });
+            this.sendResponse(requestId, {
+                result: { decision: result.decision === 'allow' ? 'accept' : 'decline' },
+            });
+        }
+        catch (error) {
+            log.warn('codex_approval_resolver_failed', {
+                message: error instanceof Error ? error.message : String(error),
+            });
+            this.sendResponse(requestId, { result: { decision: 'decline' } });
+        }
+    }
+    handleNotification(notif) {
+        const turn = this.activeTurn;
+        const params = (notif.params ?? {});
+        switch (notif.method) {
+            case 'turn/started': {
+                if (!turn)
+                    return;
+                const p = params;
+                turn.turnId = p.turn.id;
+                return;
+            }
+            case 'turn/completed': {
+                if (!turn)
+                    return;
+                const p = params;
+                if (p.turn?.id && turn.turnId && p.turn.id !== turn.turnId)
+                    return;
+                if (turn.finalText) {
+                    turn.push({ type: 'text_done', runId: turn.runId, text: turn.finalText });
+                }
+                const failed = p.turn?.status === 'failed' || p.turn?.status === 'error';
+                const reason = turn.signal.aborted
+                    ? 'interrupted'
+                    : failed
+                        ? 'error'
+                        : 'completed';
+                const errorMessage = parseTurnErrorMessage(p.turn?.error?.message);
+                if (failed && errorMessage) {
+                    // Surface the failure to the room so the user sees why the agent
+                    // went idle rather than just watching status drop silently.
+                    turn.push({
+                        type: 'text_done',
+                        runId: turn.runId,
+                        text: `Codex couldn't complete the turn: ${errorMessage}`,
+                    });
+                }
+                turn.end(reason, errorMessage ?? undefined);
+                return;
+            }
+            case 'item/started': {
+                if (!turn)
+                    return;
+                const p = params;
+                this.handleItemStarted(turn, p);
+                return;
+            }
+            case 'item/completed': {
+                if (!turn)
+                    return;
+                const p = params;
+                this.handleItemCompleted(turn, p);
+                return;
+            }
+            case 'item/agentMessage/delta': {
+                if (!turn)
+                    return;
+                const p = params;
+                if (p.delta && p.delta.length > 0) {
+                    turn.finalText += p.delta;
+                    turn.push({ type: 'text_delta', runId: turn.runId, delta: p.delta });
+                }
+                return;
+            }
+            case 'item/commandExecution/outputDelta': {
+                if (!turn)
+                    return;
+                const p = params;
+                const text = p.text ?? p.chunk ?? '';
+                if (text.length > 0) {
+                    turn.push({
+                        type: 'tool_use_progress',
+                        runId: turn.runId,
+                        toolUseId: p.itemId,
+                        chunk: text,
+                    });
+                }
+                return;
+            }
+            case 'item/reasoning/textDelta':
+            case 'item/reasoning/summaryTextDelta': {
+                if (!turn)
+                    return;
+                const p = params;
+                if (p.delta) {
+                    turn.push({ type: 'thinking_delta', runId: turn.runId, delta: p.delta });
+                }
+                return;
+            }
+            case 'error': {
+                if (!turn)
+                    return;
+                const errMessage = typeof params.error?.message === 'string'
+                    ? parseTurnErrorMessage(params.error.message)
+                    : null;
+                const message = errMessage ?? (typeof params.message === 'string' ? params.message : 'Codex error.');
+                turn.push({
+                    type: 'text_done',
+                    runId: turn.runId,
+                    text: `Codex error: ${message}`,
+                });
+                turn.end('error', message);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    handleItemStarted(turn, params) {
+        const item = params.item;
+        if (item.type === 'commandExecution') {
+            const ce = item;
+            turn.itemStarts.set(item.id, Date.now());
+            turn.push({
+                type: 'tool_use_start',
+                runId: turn.runId,
+                toolUseId: item.id,
+                name: 'Bash',
+                input: { command: ce.command, cwd: ce.cwd },
+            });
+            return;
+        }
+        if (item.type === 'fileChange') {
+            const fc = item;
+            turn.itemStarts.set(item.id, Date.now());
+            turn.push({
+                type: 'tool_use_start',
+                runId: turn.runId,
+                toolUseId: item.id,
+                name: 'Edit',
+                input: { changes: fc.changes },
+            });
+            return;
+        }
+        if (item.type === 'mcpToolCall') {
+            const mc = item;
+            turn.itemStarts.set(item.id, Date.now());
+            turn.push({
+                type: 'tool_use_start',
+                runId: turn.runId,
+                toolUseId: item.id,
+                name: `${mc.server}:${mc.tool}`,
+                input: mc.arguments,
+            });
+            return;
+        }
+        if (item.type === 'webSearch') {
+            const ws = item;
+            turn.itemStarts.set(item.id, Date.now());
+            turn.push({
+                type: 'tool_use_start',
+                runId: turn.runId,
+                toolUseId: item.id,
+                name: 'WebSearch',
+                input: { query: ws.query },
+            });
+        }
+    }
+    handleItemCompleted(turn, params) {
+        const item = params.item;
+        const startedAt = turn.itemStarts.get(item.id);
+        const latencyMs = startedAt ? Date.now() - startedAt : undefined;
+        if (item.type === 'agentMessage') {
+            const am = item;
+            // Final assistant text — prefer the streamed accumulator, fall back to am.text.
+            if (!turn.finalText && am.text)
+                turn.finalText = am.text;
+            return;
+        }
+        if (item.type === 'commandExecution') {
+            const ce = item;
+            const status = ce.exitCode === 0 ? 'success' : 'error';
+            turn.push({
+                type: 'tool_use_end',
+                runId: turn.runId,
+                toolUseId: item.id,
+                status,
+                output: {
+                    command: ce.command,
+                    aggregatedOutput: ce.aggregatedOutput,
+                    exitCode: ce.exitCode,
+                    durationMs: ce.durationMs,
+                },
+                ...(latencyMs !== undefined ? { latencyMs } : {}),
+            });
+            turn.itemStarts.delete(item.id);
+            return;
+        }
+        if (item.type === 'fileChange') {
+            const fc = item;
+            turn.push({
+                type: 'tool_use_end',
+                runId: turn.runId,
+                toolUseId: item.id,
+                status: fc.status === 'success' || fc.status === 'completed' ? 'success' : 'error',
+                output: { changes: fc.changes, status: fc.status },
+                ...(latencyMs !== undefined ? { latencyMs } : {}),
+            });
+            turn.itemStarts.delete(item.id);
+            return;
+        }
+        if (item.type === 'mcpToolCall') {
+            const mc = item;
+            turn.push({
+                type: 'tool_use_end',
+                runId: turn.runId,
+                toolUseId: item.id,
+                status: mc.error ? 'error' : 'success',
+                output: { result: mc.result, error: mc.error },
+                ...(latencyMs !== undefined ? { latencyMs } : {}),
+            });
+            turn.itemStarts.delete(item.id);
+            return;
+        }
+        if (item.type === 'webSearch') {
+            turn.push({
+                type: 'tool_use_end',
+                runId: turn.runId,
+                toolUseId: item.id,
+                status: 'success',
+                output: item,
+                ...(latencyMs !== undefined ? { latencyMs } : {}),
+            });
+            turn.itemStarts.delete(item.id);
+        }
+    }
+    sendRequest(method, params) {
+        if (!this.proc) {
+            return Promise.reject(new Error('codex app-server is not running.'));
+        }
+        const id = this.nextRequestId++;
+        const message = { jsonrpc: '2.0', id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.proc.stdin.write(`${JSON.stringify(message)}\n`);
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    sendResponse(id, body) {
+        if (!this.proc)
+            return;
+        const envelope = { jsonrpc: '2.0', id, ...body };
+        try {
+            this.proc.stdin.write(`${JSON.stringify(envelope)}\n`);
+        }
+        catch (error) {
+            log.warn('codex_send_response_failed', {
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async discoverMcpServers() {
+        const configPath = join(homedir(), '.codex', 'config.toml');
+        try {
+            const text = await readFile(configPath, 'utf-8');
+            const found = new Set();
+            const sectionRegex = /^\s*\[mcp_servers\.([^\]\s]+)\]/gm;
+            let match;
+            while ((match = sectionRegex.exec(text)) !== null) {
+                if (match[1])
+                    found.add(match[1]);
+            }
+            return [...found].sort();
+        }
+        catch {
+            return [];
+        }
+    }
+}
+/**
+ * Codex sometimes wraps its server-side errors as a JSON string inside
+ * `turn.error.message` — e.g. `'{"detail":"…"}'`. Pull out the human-readable
+ * sentence so we don't dump raw JSON into the meeting UI.
+ */
+function parseTurnErrorMessage(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const detail = parsed.detail ?? parsed.message;
+            if (typeof detail === 'string' && detail.length > 0)
+                return detail;
+        }
+        catch {
+            // fall through to raw string
+        }
+    }
+    return trimmed;
+}
+//# sourceMappingURL=codex.js.map