@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/adapters/codex/src/protocol/incoming.js

@@ -0,0 +1,299 @@
+import { uuid } from '@vibe-forge/utils/uuid';
+/**
+ * Prefix a tool name with the adapter namespace so the core framework can
+ * route tool-use / tool-result events to the correct adapter.
+ */
+export const prefixToolName = (name) => name.startsWith('adapter:codex:') ? name : `adapter:codex:${name}`;
+/**
+ * Accumulator for in-flight agent messages while the turn is active.
+ * We buffer text deltas and flush on `item/completed`.
+ */
+export class AgentMessageAccumulator {
+    textBuffer = new Map();
+    append(itemId, delta) {
+        const current = this.textBuffer.get(itemId) ?? '';
+        this.textBuffer.set(itemId, current + delta);
+    }
+    get(itemId) {
+        return this.textBuffer.get(itemId) ?? '';
+    }
+    delete(itemId) {
+        this.textBuffer.delete(itemId);
+    }
+    clear() {
+        this.textBuffer.clear();
+    }
+}
+/**
+ * Accumulator for in-flight command output deltas.
+ */
+export class CommandOutputAccumulator {
+    outputBuffer = new Map();
+    append(itemId, delta) {
+        const current = this.outputBuffer.get(itemId) ?? '';
+        this.outputBuffer.set(itemId, current + delta);
+    }
+    get(itemId) {
+        return this.outputBuffer.get(itemId) ?? '';
+    }
+    delete(itemId) {
+        this.outputBuffer.delete(itemId);
+    }
+    clear() {
+        this.outputBuffer.clear();
+    }
+}
+/**
+ * Handle a single incoming Codex notification and translate it into
+ * the vibe-forge `AdapterOutputEvent` model.
+ *
+ * @param method   - The JSON-RPC notification method name
+ * @param params   - The notification params (as raw Record)
+ * @param rpc      - The RPC client (used to respond to server-initiated approval requests)
+ * @param onEvent  - The event emitter from `AdapterQueryOptions`
+ * @param msgAcc   - Agent message text accumulator
+ * @param cmdAcc   - Command output accumulator
+ * @param approvalPolicy - 'never' | 'unlessTrusted' | 'onRequest'
+ */
+export const handleIncomingNotification = (method, params, rpc, onEvent, msgAcc, cmdAcc, approvalPolicy = 'unlessTrusted') => {
+    const formatTurnErrorMessage = (error) => {
+        const parts = [
+            error?.message?.trim(),
+            error?.codexErrorInfo?.trim(),
+            error?.additionalDetails?.trim()
+        ].filter((part) => typeof part === 'string' && part.length > 0);
+        return parts.length > 0 ? parts.join('\n') : 'Turn failed';
+    };
+    // ── Agent message delta ───────────────────────────────────────────────────
+    if (method === 'item/agentMessage/delta') {
+        const p = params;
+        msgAcc.append(p.itemId, p.delta);
+        return;
+    }
+    // ── Command output delta ──────────────────────────────────────────────────
+    if (method === 'item/commandExecution/outputDelta') {
+        const p = params;
+        cmdAcc.append(p.itemId, p.delta);
+        return;
+    }
+    // ── Item started ──────────────────────────────────────────────────────────
+    if (method === 'item/started') {
+        const { item } = params;
+        if (item.type === 'commandExecution') {
+            const cmdItem = item;
+            // Emit a tool_use event so the client sees the command being kicked off
+            const msg = {
+                id: cmdItem.id,
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: cmdItem.id,
+                        name: prefixToolName('Bash'),
+                        input: {
+                            command: cmdItem.command.join(' '),
+                            cwd: cmdItem.cwd
+                        }
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: msg });
+        }
+        if (item.type === 'webSearch') {
+            const wsItem = item;
+            const msg = {
+                id: wsItem.id,
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: wsItem.id,
+                        name: prefixToolName('WebSearch'),
+                        input: { query: wsItem.query }
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: msg });
+        }
+        if (item.type === 'mcpToolCall') {
+            const mcpItem = item;
+            const msg = {
+                id: mcpItem.id,
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: mcpItem.id,
+                        name: prefixToolName(`mcp:${mcpItem.server}:${mcpItem.tool}`),
+                        input: mcpItem.arguments ?? {}
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: msg });
+        }
+        return;
+    }
+    // ── Item completed ────────────────────────────────────────────────────────
+    if (method === 'item/completed') {
+        const { item } = params;
+        if (item.type === 'agentMessage') {
+            const agentItem = item;
+            // Use accumulated text if present, otherwise fall back to item.text
+            const text = msgAcc.get(agentItem.id) || agentItem.text;
+            msgAcc.delete(agentItem.id);
+            if (text) {
+                const msg = {
+                    id: agentItem.id,
+                    role: 'assistant',
+                    content: text,
+                    createdAt: Date.now()
+                };
+                onEvent({ type: 'message', data: msg });
+            }
+        }
+        if (item.type === 'commandExecution') {
+            const cmdItem = item;
+            const output = cmdAcc.get(cmdItem.id) || cmdItem.aggregatedOutput || '';
+            cmdAcc.delete(cmdItem.id);
+            const resultMsg = {
+                id: uuid(),
+                role: 'assistant',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: cmdItem.id,
+                        content: output !== ''
+                            ? output
+                            : `[exited ${cmdItem.exitCode ?? 0}]`,
+                        is_error: cmdItem.exitCode != null && cmdItem.exitCode !== 0
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: resultMsg });
+        }
+        if (item.type === 'fileChange') {
+            const fcItem = item;
+            const summary = fcItem.changes
+                .map(c => `${c.kind} ${c.path}`)
+                .join('\n');
+            const resultMsg = {
+                id: uuid(),
+                role: 'assistant',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: fcItem.id,
+                        content: summary || `[file changes ${fcItem.status}]`,
+                        is_error: fcItem.status === 'failed' || fcItem.status === 'declined'
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: resultMsg });
+        }
+        if (item.type === 'mcpToolCall') {
+            const mcpItem = item;
+            const resultMsg = {
+                id: uuid(),
+                role: 'assistant',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: mcpItem.id,
+                        content: mcpItem.result ?? (mcpItem.error ? String(mcpItem.error) : '[done]'),
+                        is_error: mcpItem.status === 'failed'
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: resultMsg });
+        }
+        return;
+    }
+    // ── Command execution approval ─────────────────────────────────────────────
+    if (method === 'item/commandExecution/requestApproval') {
+        const p = params;
+        // If the approval policy is 'never', auto-accept
+        if (approvalPolicy === 'never') {
+            // Codex expects us to respond to the server request
+            // The approval request comes in as a server-initiated JSON-RPC request
+            // with an `id`. We use the rpc.respond() method.
+            if (typeof params.id === 'number') {
+                rpc.respond(params.id, 'accept');
+            }
+            return;
+        }
+        // For other policies, emit an ask_user_question event via the tool mechanism
+        const commandStr = p.command?.join(' ') ?? '[command]';
+        const msg = {
+            id: uuid(),
+            role: 'assistant',
+            content: [{
+                    type: 'tool_use',
+                    id: `approval:${p.itemId}`,
+                    name: 'ask_user_question',
+                    input: {
+                        question: `Allow command execution?\n\`${commandStr}\`\n${p.reason ? `Reason: ${p.reason}` : ''}`.trim(),
+                        options: [
+                            { label: 'Accept', description: 'Run this command' },
+                            { label: 'Accept for session', description: 'Auto-accept similar commands this session' },
+                            { label: 'Decline', description: 'Skip this command' }
+                        ]
+                    }
+                }],
+            createdAt: Date.now()
+        };
+        onEvent({ type: 'message', data: msg });
+        return;
+    }
+    // ── File change approval ───────────────────────────────────────────────────
+    if (method === 'item/fileChange/requestApproval') {
+        const p = params;
+        if (approvalPolicy === 'never') {
+            if (typeof params.id === 'number') {
+                rpc.respond(params.id, 'accept');
+            }
+            return;
+        }
+        const msg = {
+            id: uuid(),
+            role: 'assistant',
+            content: [{
+                    type: 'tool_use',
+                    id: `approval:${p.itemId}`,
+                    name: 'ask_user_question',
+                    input: {
+                        question: `Allow file changes?${p.reason ? `\nReason: ${p.reason}` : ''}`,
+                        options: [
+                            { label: 'Accept', description: 'Apply these file changes' },
+                            { label: 'Accept for session', description: 'Auto-accept all file changes this session' },
+                            { label: 'Decline', description: 'Skip these file changes' }
+                        ]
+                    }
+                }],
+            createdAt: Date.now()
+        };
+        onEvent({ type: 'message', data: msg });
+        return;
+    }
+    // ── Turn completed ────────────────────────────────────────────────────────
+    if (method === 'turn/completed') {
+        const { turn } = params;
+        const status = turn.status;
+        if (status === 'completed' || status === 'interrupted') {
+            msgAcc.clear();
+            cmdAcc.clear();
+            onEvent({ type: 'stop', data: undefined });
+        }
+        else if (status === 'failed') {
+            const errorMsg = formatTurnErrorMessage(turn.error);
+            onEvent({
+                type: 'error',
+                data: {
+                    message: errorMsg,
+                    details: turn.error,
+                    fatal: true
+                }
+            });
+            const data = {
+                id: uuid(),
+                role: 'assistant',
+                content: errorMsg,
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'stop', data });
+        }
+    }
+};

package/dist/packages/adapters/codex/src/protocol/rpc.d.ts

@@ -0,0 +1,45 @@
+import type { ChildProcess } from 'node:child_process';
+import type { Logger } from '@vibe-forge/utils/create-logger';
+export declare class CodexRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+type NotificationHandler = (method: string, params: Record<string, unknown>) => void;
+/**
+ * Minimal JSON-RPC 2.0 client over a Node.js ChildProcess stdio transport.
+ *
+ * Codex app-server omits the `"jsonrpc":"2.0"` header on the wire and uses
+ * newline-delimited JSON (JSONL) over stdio.
+ */
+export declare class CodexRpcClient {
+    private readonly proc;
+    private readonly logger;
+    private idCounter;
+    private pending;
+    private notificationHandlers;
+    private rl;
+    constructor(proc: ChildProcess, logger: Logger);
+    /**
+     * Send a JSON-RPC request and wait for the response.
+     */
+    request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    /**
+     * Send a JSON-RPC notification (fire-and-forget, no `id`).
+     */
+    notify(method: string, params?: Record<string, unknown>): void;
+    /**
+     * Respond to a server-initiated request (approvals, token refresh, etc.).
+     * Codex sends these with an `id` and expects a matching `{ id, result }`.
+     */
+    respond(id: number, result: unknown): void;
+    /**
+     * Register a handler for all incoming notifications.
+     */
+    onNotification(handler: NotificationHandler): void;
+    /**
+     * Remove all pending requests and close the readline interface.
+     */
+    destroy(reason?: string): void;
+}
+export {};

package/dist/packages/adapters/codex/src/protocol/rpc.js

@@ -0,0 +1,128 @@
+import readline from 'node:readline';
+export class CodexRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(`[${code}] ${message}`);
+        this.name = 'CodexRpcError';
+        this.code = code;
+        this.data = data;
+    }
+}
+/**
+ * Minimal JSON-RPC 2.0 client over a Node.js ChildProcess stdio transport.
+ *
+ * Codex app-server omits the `"jsonrpc":"2.0"` header on the wire and uses
+ * newline-delimited JSON (JSONL) over stdio.
+ */
+export class CodexRpcClient {
+    proc;
+    logger;
+    idCounter = 0;
+    pending = new Map();
+    notificationHandlers = [];
+    rl;
+    constructor(proc, logger) {
+        this.proc = proc;
+        this.logger = logger;
+        this.rl = readline.createInterface({ input: proc.stdout });
+        this.rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            this.logger.debug('[codex rpc] recv:', { line: trimmed });
+            try {
+                const msg = JSON.parse(trimmed);
+                if ('id' in msg && msg.id != null) {
+                    // It's a response
+                    const response = msg;
+                    const pending = this.pending.get(response.id);
+                    if (!pending) {
+                        this.logger.warn('[codex rpc] received response for unknown id', { id: response.id });
+                        return;
+                    }
+                    this.pending.delete(response.id);
+                    if (response.error) {
+                        pending.reject(new CodexRpcError(response.error.code, response.error.message, response.error.data));
+                    }
+                    else {
+                        pending.resolve(response.result);
+                    }
+                }
+                else {
+                    // It's a notification
+                    const notification = msg;
+                    const params = (notification.params ?? {});
+                    for (const handler of this.notificationHandlers) {
+                        try {
+                            handler(notification.method, params);
+                        }
+                        catch (err) {
+                            this.logger.error('[codex rpc] notification handler error', { err });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.error('[codex rpc] failed to parse line', { line: trimmed, err });
+            }
+        });
+    }
+    /**
+     * Send a JSON-RPC request and wait for the response.
+     */
+    request(method, params) {
+        const id = ++this.idCounter;
+        const msg = { method, id, ...(params != null ? { params } : {}) };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: resolve,
+                reject
+            });
+            const line = `${JSON.stringify(msg)}\n`;
+            this.logger.debug('[codex rpc] send:', { line: line.trim() });
+            this.proc.stdin.write(line, (err) => {
+                if (err) {
+                    this.pending.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Send a JSON-RPC notification (fire-and-forget, no `id`).
+     */
+    notify(method, params) {
+        const msg = { method, ...(params != null ? { params } : {}) };
+        const line = `${JSON.stringify(msg)}\n`;
+        this.logger.debug('[codex rpc] notify:', { line: line.trim() });
+        this.proc.stdin.write(line);
+    }
+    /**
+     * Respond to a server-initiated request (approvals, token refresh, etc.).
+     * Codex sends these with an `id` and expects a matching `{ id, result }`.
+     */
+    respond(id, result) {
+        const msg = { id, result };
+        const line = `${JSON.stringify(msg)}\n`;
+        this.logger.debug('[codex rpc] respond:', { line: line.trim() });
+        this.proc.stdin.write(line);
+    }
+    /**
+     * Register a handler for all incoming notifications.
+     */
+    onNotification(handler) {
+        this.notificationHandlers.push(handler);
+    }
+    /**
+     * Remove all pending requests and close the readline interface.
+     */
+    destroy(reason = 'client destroyed') {
+        this.rl.close();
+        const err = new Error(reason);
+        for (const pending of this.pending.values()) {
+            pending.reject(err);
+        }
+        this.pending.clear();
+    }
+}

package/dist/packages/adapters/codex/src/runtime/direct.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+import type { CodexSessionBase } from './session-common';
+/**
+ * Spawn `codex [prompt?]` or `codex resume [SESSION_ID|--last] [prompt?]` with
+ * `stdio: 'inherit'`, handing the terminal directly to the user.
+ * `emit()` is a no-op in this mode.
+ */
+export declare function createDirectCodexSession(base: CodexSessionBase, options: AdapterQueryOptions): {
+    kill: () => boolean;
+    emit: () => void;
+    pid: number | undefined;
+};

package/dist/packages/adapters/codex/src/runtime/direct.js

@@ -0,0 +1,93 @@
+import { spawn } from 'node:child_process';
+import { buildFeatureArgs, toCodexOutboundApprovalPolicy } from './session-common';
+/**
+ * Spawn `codex [prompt?]` or `codex resume [SESSION_ID|--last] [prompt?]` with
+ * `stdio: 'inherit'`, handing the terminal directly to the user.
+ * `emit()` is a no-op in this mode.
+ */
+export function createDirectCodexSession(base, options) {
+    const { logger, cwd, binaryPath, spawnEnv, useYolo, approvalPolicy, sandboxPolicy, features, configOverrideArgs, resolvedModel, cachedThreadId } = base;
+    const { onEvent, description, extraOptions, type: sessionType } = options;
+    const isResume = sessionType === 'resume';
+    const approvalFlag = toCodexOutboundApprovalPolicy(approvalPolicy);
+    const args = [];
+    if (useYolo) {
+        args.push('--yolo');
+    }
+    if (isResume) {
+        args.push('resume');
+    }
+    args.push(...configOverrideArgs);
+    if (resolvedModel) {
+        args.push('--model', resolvedModel);
+    }
+    const sandboxFlag = sandboxPolicy.type === 'workspaceWrite'
+        ? 'workspace-write'
+        : sandboxPolicy.type === 'readOnly'
+            ? 'read-only'
+            : sandboxPolicy.type === 'dangerFullAccess'
+                ? 'danger-full-access'
+                : undefined;
+    if (!useYolo && sandboxFlag) {
+        args.push('--sandbox', sandboxFlag);
+    }
+    if (!useYolo) {
+        args.push('--ask-for-approval', approvalFlag);
+    }
+    args.push(...buildFeatureArgs(features));
+    if (extraOptions?.length) {
+        args.push(...extraOptions);
+    }
+    if (isResume) {
+        if (cachedThreadId) {
+            args.push(cachedThreadId);
+        }
+        else {
+            args.push('--last');
+        }
+    }
+    if (description) {
+        args.push(description);
+    }
+    logger.info('[codex session] spawning CLI (direct mode)', { binaryPath, args, cwd });
+    const proc = spawn(String(binaryPath), args, { env: spawnEnv, cwd, stdio: 'inherit' });
+    let didEmitExit = false;
+    const emitExit = (data) => {
+        if (didEmitExit)
+            return;
+        didEmitExit = true;
+        onEvent({ type: 'exit', data });
+    };
+    proc.on('error', (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        onEvent({
+            type: 'error',
+            data: {
+                message,
+                details: err,
+                fatal: true
+            }
+        });
+        emitExit({ exitCode: 1, stderr: message });
+    });
+    proc.on('exit', (code) => {
+        if ((code ?? 0) !== 0) {
+            onEvent({
+                type: 'error',
+                data: {
+                    message: `Process exited with code ${code ?? 1}`,
+                    details: { exitCode: code ?? 1 },
+                    fatal: true
+                }
+            });
+        }
+        emitExit({ exitCode: code ?? undefined });
+    });
+    return {
+        kill: () => proc.kill(),
+        emit: () => {
+            logger.warn('[codex session] emit() is not supported in direct mode');
+        },
+        pid: proc.pid
+    };
+}

package/dist/packages/adapters/codex/src/runtime/init.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+/**
+ * Initialize the Codex adapter.
+ *
+ * Unlike the claude-code adapter (which generates a CCR config.json and
+ * restarts a router), the Codex adapter manages its own `~/.codex/config.toml`
+ * and accepts all configuration as per-connection or per-turn overrides in the
+ * JSON-RPC protocol.
+ *
+ * This init step:
+ *   1. Verifies that the `codex` binary is reachable.
+ *   2. Symlinks the real `~/.codex/auth.json` into the mock HOME directory so
+ *      authentication works under HOME isolation.
+ *   3. Installs a workspace-local native hooks bridge into the mock Codex home.
+ */
+export declare const initCodexAdapter: (ctx: AdapterCtx) => Promise<void>;

package/dist/packages/adapters/codex/src/runtime/init.js

@@ -0,0 +1,63 @@
+import { execFile } from 'node:child_process';
+import { access, mkdir, symlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import process from 'node:process';
+import { promisify } from 'node:util';
+import { resolveCodexBinaryPath } from '#~/paths.js';
+import { ensureCodexNativeHooksInstalled } from './native-hooks';
+const execFileAsync = promisify(execFile);
+/**
+ * Symlink `<home>/.codex/auth.json` into `<aiHome>/.codex/auth.json` so
+ * the codex process can authenticate when HOME is redirected to `.ai/.mock`.
+ */
+async function linkAuthFile(home) {
+    const realAuth = join(home, '.codex', 'auth.json');
+    const aiCodexDir = join(process.env.HOME, '.codex');
+    const aiAuth = join(aiCodexDir, 'auth.json');
+    // Ensure the .codex directory exists inside the AI home
+    await mkdir(aiCodexDir, { recursive: true });
+    // Check if the real auth.json exists
+    try {
+        await access(realAuth);
+    }
+    catch {
+        return;
+    }
+    // Check if the target already exists (symlink or file)
+    try {
+        await access(aiAuth);
+        return;
+    }
+    catch {
+        // Doesn't exist yet — create the symlink
+    }
+    await symlink(realAuth, aiAuth);
+}
+/**
+ * Initialize the Codex adapter.
+ *
+ * Unlike the claude-code adapter (which generates a CCR config.json and
+ * restarts a router), the Codex adapter manages its own `~/.codex/config.toml`
+ * and accepts all configuration as per-connection or per-turn overrides in the
+ * JSON-RPC protocol.
+ *
+ * This init step:
+ *   1. Verifies that the `codex` binary is reachable.
+ *   2. Symlinks the real `~/.codex/auth.json` into the mock HOME directory so
+ *      authentication works under HOME isolation.
+ *   3. Installs a workspace-local native hooks bridge into the mock Codex home.
+ */
+export const initCodexAdapter = async (ctx) => {
+    const { env } = ctx;
+    const home = process.env.__VF_PROJECT_REAL_HOME__;
+    const binaryPath = resolveCodexBinaryPath(env);
+    try {
+        await execFileAsync(String(binaryPath), ['--version']);
+    }
+    catch {
+        // Non-fatal: the binary might not be installed globally, or it might be
+        // installed but the --version flag might not exist in older builds.
+    }
+    await linkAuthFile(home);
+    await ensureCodexNativeHooksInstalled(ctx);
+};

package/dist/packages/adapters/codex/src/runtime/native-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export declare const CODEX_NATIVE_HOOK_EVENTS: readonly ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"];
+export declare const ensureCodexNativeHooksInstalled: (ctx: Pick<AdapterCtx, "cwd" | "env" | "logger" | "assets">) => Promise<boolean>;