@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/adapters/codex/__tests__/session.spec.js

@@ -0,0 +1,179 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { resolveCodexBinaryPath } from '#~/paths.js';
+import { createCodexSession } from '#~/runtime/session.js';
+// ─── Availability check ───────────────────────────────────────────────────────
+const codexAvailable = (() => {
+    try {
+        execFileSync('codex', ['--version'], { stdio: 'ignore', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+// ─── Path utilities ───────────────────────────────────────────────────────────
+describe('resolveCodexBinaryPath', () => {
+    it('resolves to the adapter bundled binary by default', () => {
+        const result = resolveCodexBinaryPath({});
+        expect(result).toMatch(/node_modules\/\.bin\/codex$/);
+    });
+    it('returns the env-specified path when set', () => {
+        expect(resolveCodexBinaryPath({
+            __VF_PROJECT_AI_ADAPTER_CODEX_CLI_PATH__: '/usr/local/bin/codex'
+        })).toBe('/usr/local/bin/codex');
+    });
+    it('falls back to bundled binary when env value is empty string', () => {
+        const result = resolveCodexBinaryPath({
+            __VF_PROJECT_AI_ADAPTER_CODEX_CLI_PATH__: ''
+        });
+        expect(result).toMatch(/node_modules\/\.bin\/codex$/);
+    });
+});
+// ─── Integration tests (require real codex binary) ────────────────────────────
+describe.skipIf(!codexAvailable)('codex app-server integration', () => {
+    let tmpDir;
+    let mockHome;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'vibe-codex-test-'));
+        mockHome = join(tmpDir, '.ai', '.mock');
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    function makeCtx(env = {}) {
+        const mockLogger = {
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+            debug: () => { }
+        };
+        const cacheStore = new Map();
+        return {
+            ctxId: 'test-ctx',
+            cwd: tmpDir,
+            env: {
+                ...env
+            },
+            cache: {
+                set: async (key, value) => {
+                    cacheStore.set(key, value);
+                    return { cachePath: join(tmpDir, `${key}.json`) };
+                },
+                get: async (key) => cacheStore.get(key)
+            },
+            logger: mockLogger,
+            configs: [undefined, undefined]
+        };
+    }
+    function getCachedThreadIds(value) {
+        return Object.values((value ?? {}))
+            .filter((item) => typeof item === 'string');
+    }
+    it('completes the initialize handshake and receives a thread id', async () => {
+        const events = [];
+        const ctx = makeCtx();
+        const session = await createCodexSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'test-session-1',
+            onEvent: (e) => events.push(e)
+        });
+        // Give the server a moment to emit turn/completed
+        await new Promise(r => setTimeout(r, 1000));
+        session.kill();
+        // Session should not have thrown; cache should have a thread id
+        const cachedThreads = await ctx.cache.get('adapter.codex.threads');
+        const cachedThreadIds = getCachedThreadIds(cachedThreads);
+        expect(cachedThreadIds.length).toBeGreaterThan(0);
+        expect(typeof cachedThreadIds[0]).toBe('string');
+    }, 15_000);
+    it('sends a turn and receives agent message and stop events', async () => {
+        const events = [];
+        const ctx = makeCtx();
+        const session = await createCodexSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'test-session-2',
+            description: 'Reply with the single word "pong" and nothing else.',
+            onEvent: (e) => events.push(e)
+        });
+        // Wait up to 30 s for the turn to complete
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(), 30_000);
+            const orig = session.kill;
+            session.kill = () => {
+                clearTimeout(timeout);
+                orig();
+            };
+            const check = () => {
+                const stopped = events.some(e => e.type === 'stop');
+                if (stopped) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            };
+            // Poll for stop event
+            const interval = setInterval(() => {
+                check();
+                if (events.some(e => e.type === 'stop'))
+                    clearInterval(interval);
+            }, 200);
+        });
+        session.kill();
+        const messageEvents = events.filter(e => e.type === 'message');
+        const stopEvents = events.filter(e => e.type === 'stop');
+        expect(stopEvents.length).toBeGreaterThan(0);
+        expect(messageEvents.length).toBeGreaterThan(0);
+    }, 35_000);
+    it('resumes an existing thread via thread/resume', async () => {
+        // Create a thread first
+        const eventsA = [];
+        const ctx = makeCtx();
+        const sessionA = await createCodexSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'test-session-resume',
+            description: 'Say "hello".',
+            onEvent: (e) => eventsA.push(e)
+        });
+        // Wait for stop
+        await new Promise((resolve) => {
+            const interval = setInterval(() => {
+                if (eventsA.some(e => e.type === 'stop')) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 200);
+            setTimeout(resolve, 30_000);
+        });
+        sessionA.kill();
+        const threadIdAfterCreate = getCachedThreadIds(await ctx.cache.get('adapter.codex.threads'))[0];
+        expect(threadIdAfterCreate).toBeDefined();
+        // Now resume the same session
+        const eventsB = [];
+        const sessionB = await createCodexSession(ctx, {
+            type: 'resume',
+            runtime: 'server',
+            sessionId: 'test-session-resume',
+            description: 'Say "world".',
+            onEvent: (e) => eventsB.push(e)
+        });
+        await new Promise((resolve) => {
+            const interval = setInterval(() => {
+                if (eventsB.some(e => e.type === 'stop')) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 200);
+            setTimeout(resolve, 30_000);
+        });
+        sessionB.kill();
+        // Thread id should be the same (resumed not created)
+        const threadIdAfterResume = getCachedThreadIds(await ctx.cache.get('adapter.codex.threads'))[0];
+        expect(threadIdAfterResume).toBe(threadIdAfterCreate);
+    }, 70_000);
+});

package/dist/packages/adapters/codex/src/adapter-config.d.ts

@@ -0,0 +1,47 @@
+export {};
+declare module '@vibe-forge/types' {
+    interface AdapterMap {
+        'codex': {
+            /**
+             * Sandbox policy passed to thread/start and turn/start.
+             * Defaults to { type: 'workspaceWrite' }.
+             */
+            sandboxPolicy?: {
+                type: 'readOnly' | 'workspaceWrite' | 'dangerFullAccess' | 'externalSandbox';
+                writableRoots?: string[];
+                networkAccess?: boolean | 'restricted' | 'enabled';
+            };
+            /** Enable Codex experimental API surface. Defaults to false. */
+            experimentalApi?: boolean;
+            /** Client metadata reported to the Codex app-server. */
+            clientInfo?: {
+                name?: string;
+                title?: string;
+                version?: string;
+            };
+            /** Reasoning effort level for supported models. */
+            effort?: 'low' | 'medium' | 'high';
+            /**
+             * Maximum completion tokens allowed for each turn in stream mode.
+             * Useful when upstream Responses-compatible providers apply a low default.
+             */
+            maxOutputTokens?: number;
+            /**
+             * Feature flag overrides applied via `--enable` / `--disable`.
+             * Keys are feature names from `codex features list`:
+             * `undo`, `shell_tool`, `web_search_request`, `web_search_cached`,
+             * `unified_exec`, `shell_snapshot`, `apply_patch_freeform`, `exec_policy`,
+             * `experimental_windows_sandbox`, `elevated_windows_sandbox`,
+             * `remote_compaction`, `remote_models`, `powershell_utf8`, `codex_hooks`,
+             * `enable_request_compression`, `tui2`.
+             * `true` → `--enable <name>`, `false` → `--disable <name>`.
+             */
+            features?: Partial<Record<'undo' | 'shell_tool' | 'web_search_request' | 'web_search_cached' | 'unified_exec' | 'shell_snapshot' | 'apply_patch_freeform' | 'exec_policy' | 'experimental_windows_sandbox' | 'elevated_windows_sandbox' | 'remote_compaction' | 'remote_models' | 'powershell_utf8' | 'codex_hooks' | 'enable_request_compression' | 'tui2' | (string & {}), boolean>>;
+        };
+    }
+}
+declare module '@vibe-forge/types' {
+    interface Cache {
+        'adapter.codex.threads': Record<string, string>;
+    }
+}

package/dist/packages/adapters/codex/src/adapter-config.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/adapters/codex/src/hook-bridge.d.ts

@@ -0,0 +1,47 @@
+import type { HookInput, HookOutput } from '@vibe-forge/hooks';
+type NativeCodexHookEventName = 'PreToolUse' | 'PostToolUse' | 'SessionStart' | 'UserPromptSubmit' | 'Stop';
+interface NativeCodexHookInputBase {
+    cwd: string;
+    hookEventName: NativeCodexHookEventName;
+    model?: string;
+    sessionId: string;
+    transcriptPath?: string | null;
+}
+interface NativeCodexPreToolUseInput extends NativeCodexHookInputBase {
+    hookEventName: 'PreToolUse';
+    toolInput?: unknown;
+    toolName?: string;
+    toolUseId?: string;
+    turnId?: string;
+}
+interface NativeCodexPostToolUseInput extends NativeCodexHookInputBase {
+    hookEventName: 'PostToolUse';
+    toolInput?: unknown;
+    toolName?: string;
+    toolResponse?: unknown;
+    toolUseId?: string;
+    turnId?: string;
+}
+interface NativeCodexSessionStartInput extends NativeCodexHookInputBase {
+    hookEventName: 'SessionStart';
+    source?: 'startup' | 'resume' | 'clear';
+}
+interface NativeCodexUserPromptSubmitInput extends NativeCodexHookInputBase {
+    hookEventName: 'UserPromptSubmit';
+    prompt: string;
+    turnId?: string;
+}
+interface NativeCodexStopInput extends NativeCodexHookInputBase {
+    hookEventName: 'Stop';
+    lastAssistantMessage?: string | null;
+    stopHookActive?: boolean;
+    turnId?: string;
+}
+export type NativeCodexHookInput = NativeCodexPreToolUseInput | NativeCodexPostToolUseInput | NativeCodexSessionStartInput | NativeCodexUserPromptSubmitInput | NativeCodexStopInput;
+export declare const isCodexNativeHookEnv: () => boolean;
+export declare const mapCodexHookInputToVibeForge: (input: NativeCodexHookInput) => HookInput;
+export declare const mapVibeForgeHookOutputToCodex: (eventName: NativeCodexHookEventName, output: HookOutput) => Record<string, unknown>;
+export declare const runCodexHookBridge: () => Promise<void>;
+export declare const isNativeHookEnv: () => boolean;
+export declare const runHookBridge: () => Promise<void>;
+export {};

package/dist/packages/adapters/codex/src/hook-bridge.js

@@ -0,0 +1,163 @@
+import process from 'node:process';
+import { executeHookInput, readHookInput } from '@vibe-forge/hooks';
+const runtime = process.env.__VF_CODEX_HOOK_RUNTIME__;
+const taskSessionId = process.env.__VF_CODEX_TASK_SESSION_ID__?.trim();
+const blockReason = (value, fallback) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : fallback);
+const applyOutputFields = (output, supported) => {
+    const result = {};
+    if (supported.continue && typeof output.continue === 'boolean')
+        result.continue = output.continue;
+    if (supported.stopReason && typeof output.stopReason === 'string')
+        result.stopReason = output.stopReason;
+    if (supported.suppressOutput && typeof output.suppressOutput === 'boolean')
+        result.suppressOutput = output.suppressOutput;
+    if (supported.systemMessage && typeof output.systemMessage === 'string')
+        result.systemMessage = output.systemMessage;
+    return result;
+};
+export const isCodexNativeHookEnv = () => (process.env.__VF_VIBE_FORGE_CODEX_HOOKS_ACTIVE__ === '1');
+export const mapCodexHookInputToVibeForge = (input) => {
+    const base = {
+        cwd: input.cwd,
+        sessionId: taskSessionId || input.sessionId,
+        transcriptPath: input.transcriptPath,
+        adapter: 'codex',
+        runtime,
+        hookSource: 'native',
+        canBlock: true
+    };
+    switch (input.hookEventName) {
+        case 'PreToolUse':
+            return {
+                ...base,
+                hookEventName: 'PreToolUse',
+                turnId: input.turnId,
+                toolCallId: input.toolUseId,
+                toolName: input.toolName ?? 'Bash',
+                toolInput: input.toolInput
+            };
+        case 'PostToolUse':
+            return {
+                ...base,
+                hookEventName: 'PostToolUse',
+                turnId: input.turnId,
+                toolCallId: input.toolUseId,
+                toolName: input.toolName ?? 'Bash',
+                toolInput: input.toolInput,
+                toolResponse: input.toolResponse
+            };
+        case 'SessionStart':
+            return {
+                ...base,
+                hookEventName: 'SessionStart',
+                source: input.source === 'resume' ? 'resume' : input.source === 'startup' ? 'startup' : undefined,
+                model: input.model
+            };
+        case 'UserPromptSubmit':
+            return {
+                ...base,
+                hookEventName: 'UserPromptSubmit',
+                turnId: input.turnId,
+                prompt: input.prompt
+            };
+        case 'Stop':
+            return {
+                ...base,
+                hookEventName: 'Stop',
+                turnId: input.turnId,
+                stopHookActive: input.stopHookActive,
+                lastAssistantMessage: input.lastAssistantMessage ?? undefined
+            };
+    }
+};
+export const mapVibeForgeHookOutputToCodex = (eventName, output) => {
+    switch (eventName) {
+        case 'PreToolUse': {
+            const result = applyOutputFields(output, { systemMessage: true });
+            const hookSpecificOutput = output.hookSpecificOutput;
+            if (hookSpecificOutput?.hookEventName === 'PreToolUse') {
+                result.hookSpecificOutput = hookSpecificOutput;
+                if (hookSpecificOutput.permissionDecision === 'deny') {
+                    result.decision = 'block';
+                    result.reason = hookSpecificOutput.permissionDecisionReason;
+                }
+            }
+            else if (output.continue === false) {
+                const reason = blockReason(output.stopReason, 'blocked by Vibe Forge PreToolUse hook');
+                result.decision = 'block';
+                result.reason = reason;
+                result.hookSpecificOutput = {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: reason
+                };
+            }
+            return result;
+        }
+        case 'PostToolUse': {
+            const result = applyOutputFields(output, {
+                continue: true,
+                stopReason: true,
+                systemMessage: true
+            });
+            const hookSpecificOutput = output.hookSpecificOutput;
+            if (hookSpecificOutput?.hookEventName === 'PostToolUse') {
+                result.hookSpecificOutput = hookSpecificOutput;
+            }
+            return result;
+        }
+        case 'SessionStart': {
+            const result = applyOutputFields(output, {
+                continue: true,
+                stopReason: true,
+                suppressOutput: true,
+                systemMessage: true
+            });
+            const hookSpecificOutput = output.hookSpecificOutput;
+            if (hookSpecificOutput?.hookEventName === 'SessionStart') {
+                result.hookSpecificOutput = hookSpecificOutput;
+            }
+            return result;
+        }
+        case 'UserPromptSubmit': {
+            const result = applyOutputFields(output, {
+                suppressOutput: true,
+                systemMessage: true
+            });
+            const hookSpecificOutput = output.hookSpecificOutput;
+            if (hookSpecificOutput?.hookEventName === 'UserPromptSubmit') {
+                result.hookSpecificOutput = hookSpecificOutput;
+            }
+            if (output.continue === false) {
+                result.decision = 'block';
+                result.reason = blockReason(output.stopReason, 'blocked by Vibe Forge UserPromptSubmit hook');
+            }
+            return result;
+        }
+        case 'Stop': {
+            const result = applyOutputFields(output, {
+                continue: true,
+                stopReason: true,
+                suppressOutput: true,
+                systemMessage: true
+            });
+            return result;
+        }
+    }
+};
+export const runCodexHookBridge = async () => {
+    try {
+        const input = await readHookInput();
+        const hookInput = mapCodexHookInputToVibeForge(input);
+        const result = await executeHookInput(hookInput);
+        process.stdout.write(`${JSON.stringify(mapVibeForgeHookOutputToCodex(input.hookEventName, result))}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            continue: true,
+            systemMessage: `vibe-forge codex hook bridge error: ${String(error)}`
+        })}\n`);
+    }
+};
+export const isNativeHookEnv = isCodexNativeHookEnv;
+export const runHookBridge = runCodexHookBridge;

package/dist/packages/adapters/codex/src/icon.d.ts

@@ -0,0 +1,2 @@
+export declare const adapterIcon: string;
+export declare const adapterDisplayName = "Codex";

package/dist/packages/adapters/codex/src/icon.js

@@ -0,0 +1,15 @@
+const CODEX_ICON_SVG = `
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg">
+<path d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z" fill="#fff"></path>
+<path d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z" fill="url(#lobe-icons-codex-fill)"></path>
+<defs>
+  <linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-codex-fill" x1="12" x2="12" y1="3" y2="21">
+    <stop stop-color="#B1A7FF"></stop>
+    <stop offset=".5" stop-color="#7A9DFF"></stop>
+    <stop offset="1" stop-color="#3941FF"></stop>
+  </linearGradient>
+</defs>
+</svg>`
+    .trim();
+export const adapterIcon = `data:image/svg+xml;utf8,${encodeURIComponent(CODEX_ICON_SVG)}`;
+export const adapterDisplayName = 'Codex';

package/dist/packages/adapters/codex/src/index.d.ts

@@ -0,0 +1,3 @@
+import './adapter-config';
+declare const _default: import("@vibe-forge/types").Adapter;
+export default _default;

package/dist/packages/adapters/codex/src/index.js

@@ -0,0 +1,8 @@
+import './adapter-config';
+import { defineAdapter } from '@vibe-forge/types';
+import { initCodexAdapter } from './runtime/init';
+import { createCodexSession } from './runtime/session';
+export default defineAdapter({
+    init: initCodexAdapter,
+    query: createCodexSession
+});

package/dist/packages/adapters/codex/src/models.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterBuiltinModel } from '@vibe-forge/types';
+/**
+ * Codex native model options.
+ * These models are supported directly by the `codex` CLI binary
+ * and do not require model-service routing.
+ *
+ * Recommended models (top-tier):
+ *   gpt-5.4, gpt-5.3-codex, gpt-5.3-codex-spark
+ *
+ * Alternative models:
+ *   gpt-5.2-codex, gpt-5.2, gpt-5.1-codex-max, gpt-5.1, gpt-5.1-codex,
+ *   gpt-5-codex, gpt-5-codex-mini, gpt-5
+ */
+export declare const builtinModels: AdapterBuiltinModel[];

package/dist/packages/adapters/codex/src/models.js

@@ -0,0 +1,71 @@
+/**
+ * Codex native model options.
+ * These models are supported directly by the `codex` CLI binary
+ * and do not require model-service routing.
+ *
+ * Recommended models (top-tier):
+ *   gpt-5.4, gpt-5.3-codex, gpt-5.3-codex-spark
+ *
+ * Alternative models:
+ *   gpt-5.2-codex, gpt-5.2, gpt-5.1-codex-max, gpt-5.1, gpt-5.1-codex,
+ *   gpt-5-codex, gpt-5-codex-mini, gpt-5
+ */
+export const builtinModels = [
+    // ── Recommended ───────────────────────────────────────────────
+    {
+        value: 'gpt-5.4',
+        title: 'GPT-5.4',
+        description: 'Flagship frontier model for professional work with industry-leading coding capabilities'
+    },
+    {
+        value: 'gpt-5.3-codex',
+        title: 'GPT-5.3-Codex',
+        description: 'Industry-leading coding model for complex software engineering'
+    },
+    {
+        value: 'gpt-5.3-codex-spark',
+        title: 'GPT-5.3-Codex-Spark',
+        description: 'Text-only research preview model optimized for near-instant, real-time coding iteration'
+    },
+    // ── Alternative ───────────────────────────────────────────────
+    {
+        value: 'gpt-5.2-codex',
+        title: 'GPT-5.2-Codex',
+        description: 'Advanced coding model for real-world engineering'
+    },
+    {
+        value: 'gpt-5.2',
+        title: 'GPT-5.2',
+        description: 'Previous general-purpose model for coding and agentic tasks'
+    },
+    {
+        value: 'gpt-5.1-codex-max',
+        title: 'GPT-5.1-Codex-Max',
+        description: 'Optimized for long-horizon, agentic coding tasks in Codex'
+    },
+    {
+        value: 'gpt-5.1',
+        title: 'GPT-5.1',
+        description: 'Great for coding and agentic tasks across domains'
+    },
+    {
+        value: 'gpt-5.1-codex',
+        title: 'GPT-5.1-Codex',
+        description: 'Optimized for long-running, agentic coding tasks in Codex'
+    },
+    {
+        value: 'gpt-5-codex',
+        title: 'GPT-5-Codex',
+        description: 'Version of GPT-5 tuned for long-running, agentic coding tasks'
+    },
+    {
+        value: 'gpt-5-codex-mini',
+        title: 'GPT-5-Codex-Mini',
+        description: 'Smaller, more cost-effective version of GPT-5-Codex'
+    },
+    {
+        value: 'gpt-5',
+        title: 'GPT-5',
+        description: 'Reasoning model for coding and agentic tasks across domains'
+    }
+];

package/dist/packages/adapters/codex/src/paths.d.ts

@@ -0,0 +1,9 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+/**
+ * Returns the path to the codex binary.
+ *
+ * Resolution order:
+ *   1. `__VF_PROJECT_AI_ADAPTER_CODEX_CLI_PATH__` env override
+ *   2. `<adapterPackageDir>/node_modules/.bin/codex`  (bundled via @openai/codex dependency)
+ */
+export declare const resolveCodexBinaryPath: (env: AdapterCtx["env"]) => string;

package/dist/packages/adapters/codex/src/paths.js

@@ -0,0 +1,17 @@
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+const require = createRequire(import.meta.url ?? __filename);
+const adapterPackageDir = dirname(require.resolve('@vibe-forge/adapter-codex/package.json'));
+/**
+ * Returns the path to the codex binary.
+ *
+ * Resolution order:
+ *   1. `__VF_PROJECT_AI_ADAPTER_CODEX_CLI_PATH__` env override
+ *   2. `<adapterPackageDir>/node_modules/.bin/codex`  (bundled via @openai/codex dependency)
+ */
+export const resolveCodexBinaryPath = (env) => {
+    const envPath = env.__VF_PROJECT_AI_ADAPTER_CODEX_CLI_PATH__;
+    return typeof envPath === 'string' && envPath !== ''
+        ? envPath
+        : resolve(adapterPackageDir, 'node_modules/.bin/codex');
+};

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

@@ -0,0 +1,41 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+import type { CodexRpcClient } from './rpc';
+/**
+ * Prefix a tool name with the adapter namespace so the core framework can
+ * route tool-use / tool-result events to the correct adapter.
+ */
+export declare const prefixToolName: (name: string) => string;
+/**
+ * Accumulator for in-flight agent messages while the turn is active.
+ * We buffer text deltas and flush on `item/completed`.
+ */
+export declare class AgentMessageAccumulator {
+    private textBuffer;
+    append(itemId: string, delta: string): void;
+    get(itemId: string): string;
+    delete(itemId: string): void;
+    clear(): void;
+}
+/**
+ * Accumulator for in-flight command output deltas.
+ */
+export declare class CommandOutputAccumulator {
+    private outputBuffer;
+    append(itemId: string, delta: string): void;
+    get(itemId: string): string;
+    delete(itemId: string): void;
+    clear(): void;
+}
+/**
+ * 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 declare const handleIncomingNotification: (method: string, params: Record<string, unknown>, rpc: CodexRpcClient, onEvent: AdapterQueryOptions["onEvent"], msgAcc: AgentMessageAccumulator, cmdAcc: CommandOutputAccumulator, approvalPolicy?: string) => void;