@agent-link/agent 0.1.263 → 0.1.265

package/dist/codex.js

@@ -0,0 +1,1086 @@
+/**
+ * Codex CLI process driver for AgentLink.
+ *
+ * MVP integration:
+ * - Each turn spawns `codex exec --json` (or `codex exec resume --json`)
+ * - Prompt is written to stdin to avoid command-line length limits
+ * - Codex thread_id is used as the AgentLink session id
+ * - JSONL stdout is translated into backend_event messages
+ * - Session history is read from ~/.codex/sessions/YYYY/MM/DD/*.jsonl
+ */
+import { spawn, execFileSync } from 'child_process';
+import { createInterface } from 'readline';
+import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdirSync, unlinkSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { homedir, platform } from 'os';
+import { processUserMessage } from './history-message-transform.js';
+import { codexCapabilities } from './backends/types.js';
+import { CONFIG_DIR } from './config.js';
+import { getCleanEnv } from './sdk.js';
+import { getProvider, resolveProviderCommand } from './providers.js';
+import { FileCache } from './file-cache.js';
+const conversations = new Map();
+const sendFns = new Set();
+const MODEL_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const TURN_HEARTBEAT_INTERVAL_MS = 15_000;
+const CODEX_SESSION_LIST_LIMIT = 150;
+const CODEX_SESSION_DIR = join(homedir(), '.codex', 'sessions');
+const CODEX_TITLES_FILE = join(CONFIG_DIR, 'codex-session-titles.json');
+function generateTurnId() {
+    return `turn_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function sendFn(msg) {
+    for (const fn of sendFns) {
+        try {
+            fn(msg);
+        }
+        catch { /* ignore */ }
+    }
+}
+export function addCodexSendFn(fn) {
+    sendFns.add(fn);
+    return () => { sendFns.delete(fn); };
+}
+function sessionRef(sessionId) {
+    return {
+        backendType: 'codex',
+        backendSessionId: sessionId,
+        backendThreadId: sessionId,
+        providerSessionId: sessionId || null,
+    };
+}
+function startCodexTurn(state) {
+    state.turnActive = true;
+    state.turnId = generateTurnId();
+    state.stateVersion++;
+    state.startedToolIds.clear();
+    sendFn({
+        type: 'turn_started',
+        conversationId: state.conversationId,
+        claudeSessionId: state.codexSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+    });
+    if (!state.heartbeatTimer) {
+        state.heartbeatTimer = setInterval(() => {
+            if (!state.turnActive) {
+                if (state.heartbeatTimer)
+                    clearInterval(state.heartbeatTimer);
+                state.heartbeatTimer = null;
+                return;
+            }
+            sendFn({
+                type: 'turn_heartbeat',
+                conversationId: state.conversationId,
+                claudeSessionId: state.codexSessionId,
+                turnId: state.turnId,
+                stateVersion: state.stateVersion,
+                phase: 'running',
+                lastActivityAt: Date.now(),
+            });
+        }, TURN_HEARTBEAT_INTERVAL_MS);
+    }
+}
+function finishCodexTurn(state) {
+    state.turnActive = false;
+    state.stateVersion++;
+    state.startedToolIds.clear();
+    if (state.heartbeatTimer) {
+        clearInterval(state.heartbeatTimer);
+        state.heartbeatTimer = null;
+    }
+}
+function emitCodexCancelled(conversationId, state) {
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: { type: 'turn_cancelled', session: sessionRef(state?.codexSessionId || '') },
+    });
+    sendFn({
+        type: 'execution_cancelled',
+        conversationId,
+        claudeSessionId: state?.codexSessionId || null,
+        turnId: state?.turnId || null,
+        stateVersion: state?.stateVersion || 0,
+    });
+}
+function buildCodexUsage(state, rawUsage) {
+    return {
+        provider: 'codex',
+        model: state.model || undefined,
+        inputTokens: numberOrUndefined(rawUsage?.input_tokens),
+        outputTokens: numberOrUndefined(rawUsage?.output_tokens),
+        cacheReadInputTokens: numberOrUndefined(rawUsage?.cached_input_tokens),
+    };
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function sendCodexSetupError(state, message) {
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: { type: 'error', message },
+    });
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: { type: 'turn_completed', session: sessionRef(state.codexSessionId || '') },
+    });
+    sendFn({
+        type: 'turn_completed',
+        conversationId: state.conversationId,
+        workDir: state.workDir,
+        claudeSessionId: state.codexSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+    });
+}
+let resolvedCodexPath = null;
+function resolveCmdWrapperDirectExecution(cmdPath) {
+    if (platform() !== 'win32')
+        return null;
+    if (!cmdPath.toLowerCase().endsWith('.cmd'))
+        return null;
+    try {
+        const content = readFileSync(cmdPath, 'utf-8');
+        const jsMatch = content.match(/%dp0%\\(.+?\.js)"/i) ||
+            content.match(/%dp0%\\(.+?\.js)/i);
+        if (jsMatch) {
+            const scriptPath = join(dirname(cmdPath), jsMatch[1].replace(/\\/g, '/'));
+            if (existsSync(scriptPath)) {
+                return { command: process.execPath, prefixArgs: [scriptPath] };
+            }
+        }
+        const exeMatch = content.match(/%dp0%\\(.+?\.exe)"/i) ||
+            content.match(/%dp0%\\(.+?\.exe)/i);
+        if (exeMatch) {
+            const exePath = join(dirname(cmdPath), exeMatch[1].replace(/\\/g, '/'));
+            if (existsSync(exePath)) {
+                return { command: exePath, prefixArgs: [] };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function _resetResolvedCodexPathForTests() {
+    resolvedCodexPath = null;
+}
+function resolveCodexPath() {
+    if (resolvedCodexPath)
+        return resolvedCodexPath;
+    const isWin = platform() === 'win32';
+    try {
+        const bin = isWin ? 'where' : 'which';
+        const output = execFileSync(bin, ['codex'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+            env: getCleanEnv(),
+            windowsHide: true,
+        }).toString().trim();
+        const lines = output.split('\n').map(l => l.trim()).filter(Boolean);
+        resolvedCodexPath = (isWin && lines.length > 1)
+            ? (lines.find(l => /\.(cmd|exe)$/i.test(l)) || lines[0])
+            : (lines[0] || null);
+    }
+    catch {
+        if (isWin) {
+            try {
+                const psOutput = execFileSync('powershell.exe', [
+                    '-NoProfile', '-Command',
+                    '(Get-Command codex -ErrorAction SilentlyContinue).Source',
+                ], {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    timeout: 8000,
+                    env: getCleanEnv(),
+                    windowsHide: true,
+                }).toString().trim();
+                if (psOutput && existsSync(psOutput))
+                    resolvedCodexPath = psOutput;
+            }
+            catch { /* ignore */ }
+        }
+    }
+    if (!resolvedCodexPath)
+        resolvedCodexPath = 'codex';
+    console.log(`[Codex] Resolved command: ${resolvedCodexPath}`);
+    return resolvedCodexPath;
+}
+export function getCodexConversation(conversationId) {
+    return conversations.get(conversationId);
+}
+export function getCodexConversations() {
+    return conversations;
+}
+export function rebindCodexConversation(codexSessionId, newConvId) {
+    for (const [oldConvId, state] of conversations) {
+        if ((state.codexSessionId === codexSessionId || state.lastCodexSessionId === codexSessionId)
+            && oldConvId !== newConvId) {
+            conversations.delete(oldConvId);
+            state.conversationId = newConvId;
+            conversations.set(newConvId, state);
+            return true;
+        }
+    }
+    return false;
+}
+export function createCodexPlaceholder(conversationId, opts) {
+    if (conversations.has(conversationId))
+        return;
+    conversations.set(conversationId, {
+        conversationId,
+        child: null,
+        abortController: null,
+        codexSessionId: null,
+        lastCodexSessionId: null,
+        workDir: process.cwd(),
+        turnActive: false,
+        providerId: opts?.providerId || 'codex',
+        model: null,
+        turnId: null,
+        stateVersion: 0,
+        heartbeatTimer: null,
+        sessionNotified: false,
+        startedToolIds: new Set(),
+    });
+}
+export function restartCodexConversation(conversationId, opts) {
+    const state = conversations.get(conversationId);
+    const wasTurnActive = state?.turnActive || false;
+    const codexSessionId = state?.codexSessionId || null;
+    if (state)
+        cleanupCodexConversation(conversationId);
+    conversations.set(conversationId, {
+        conversationId,
+        child: null,
+        abortController: null,
+        codexSessionId: null,
+        lastCodexSessionId: codexSessionId,
+        workDir: state?.workDir || process.cwd(),
+        turnActive: false,
+        providerId: opts?.providerId || state?.providerId || 'codex',
+        model: opts?.model || state?.model || null,
+        turnId: null,
+        stateVersion: (state?.stateVersion || 0) + 1,
+        heartbeatTimer: null,
+        sessionNotified: false,
+        startedToolIds: new Set(),
+    });
+    return { wasTurnActive, codexSessionId };
+}
+function normalizeCodexRunOptions(input) {
+    const options = {};
+    if (!input)
+        return { options };
+    if (input.model != null && input.model !== '') {
+        if (!MODEL_PATTERN.test(input.model)) {
+            return { options, error: `Invalid Codex model name: ${input.model}` };
+        }
+        options.model = input.model;
+    }
+    return { options };
+}
+export function handleCodexChat(conversationId, text, workDir, options, files) {
+    let state = conversations.get(conversationId);
+    if (!state) {
+        state = {
+            conversationId,
+            child: null,
+            abortController: null,
+            codexSessionId: null,
+            lastCodexSessionId: null,
+            workDir,
+            turnActive: false,
+            providerId: 'codex',
+            model: null,
+            turnId: null,
+            stateVersion: 0,
+            heartbeatTimer: null,
+            sessionNotified: false,
+            startedToolIds: new Set(),
+        };
+        conversations.set(conversationId, state);
+    }
+    state.workDir = workDir;
+    if (options?.providerId)
+        state.providerId = options.providerId;
+    const resumeId = options?.resumeSessionId
+        || state.codexSessionId
+        || state.lastCodexSessionId;
+    if (resumeId) {
+        state.codexSessionId = resumeId;
+        state.lastCodexSessionId = resumeId;
+    }
+    const normalized = normalizeCodexRunOptions(options?.codexOptions);
+    if (normalized.error) {
+        sendCodexSetupError(state, normalized.error);
+        return;
+    }
+    if (normalized.options.model)
+        state.model = normalized.options.model;
+    if (files?.length) {
+        sendCodexSetupError(state, 'Codex attachments are not supported yet.');
+        return;
+    }
+    const args = resumeId
+        ? ['exec', 'resume', '--json', '--dangerously-bypass-approvals-and-sandbox']
+        : ['exec', '--json', '--dangerously-bypass-approvals-and-sandbox', '-C', workDir];
+    const model = state.model;
+    if (model)
+        args.push('--model', model);
+    if (resumeId)
+        args.push(resumeId);
+    args.push('-');
+    const controller = new AbortController();
+    state.abortController = controller;
+    startCodexTurn(state);
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: {
+            type: 'turn_started',
+            session: sessionRef(state.codexSessionId || 'pending'),
+        },
+    });
+    const provider = getProvider(state.providerId);
+    const { command, prefixArgs, spawnOpts } = state.providerId === 'codex'
+        ? { command: resolveCodexPath(), prefixArgs: [], spawnOpts: {} }
+        : resolveProviderCommand(provider);
+    const isWin = platform() === 'win32';
+    const direct = resolveCmdWrapperDirectExecution(command);
+    let spawnCmd;
+    let spawnArgs;
+    if (direct) {
+        spawnCmd = direct.command;
+        spawnArgs = [...direct.prefixArgs, ...prefixArgs, ...args];
+    }
+    else if (isWin && command.toLowerCase().endsWith('.cmd')) {
+        spawnCmd = process.env.COMSPEC || 'cmd.exe';
+        spawnArgs = ['/c', command, ...prefixArgs, ...args];
+    }
+    else {
+        spawnCmd = command;
+        spawnArgs = [...prefixArgs, ...args];
+    }
+    const child = spawn(spawnCmd, spawnArgs, {
+        cwd: provider.cwd || workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...getCleanEnv(), ...(provider.env || {}) },
+        signal: controller.signal,
+        ...spawnOpts,
+        windowsHide: true,
+    });
+    state.child = child;
+    child.stdin?.end(text);
+    const rl = createInterface({ input: child.stdout });
+    let stderrBuf = '';
+    child.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString();
+    });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const event = JSON.parse(line);
+            handleCodexEvent(state, event);
+        }
+        catch {
+            stderrBuf += `${line}\n`;
+        }
+    });
+    child.on('close', (code) => {
+        if (state.child !== child)
+            return;
+        state.child = null;
+        state.abortController = null;
+        if (state.turnActive) {
+            finishCodexTurn(state);
+            if (code !== 0 && code !== null) {
+                const errMsg = stderrBuf.trim() || `Codex process exited with code ${code}`;
+                sendFn({
+                    type: 'backend_event',
+                    conversationId,
+                    event: { type: 'error', message: errMsg },
+                });
+            }
+            sendFn({
+                type: 'backend_event',
+                conversationId,
+                event: { type: 'turn_completed', session: sessionRef(state.codexSessionId || '') },
+            });
+            sendFn({
+                type: 'turn_completed',
+                conversationId,
+                workDir: state.workDir,
+                claudeSessionId: state.codexSessionId,
+                turnId: state.turnId,
+                stateVersion: state.stateVersion,
+            });
+        }
+    });
+    child.on('error', (err) => {
+        if (state.child !== child)
+            return;
+        state.child = null;
+        finishCodexTurn(state);
+        if (!resumeId)
+            state.codexSessionId = null;
+        sendFn({
+            type: 'backend_event',
+            conversationId,
+            event: { type: 'error', message: `Failed to start codex: ${err.message}` },
+        });
+        sendFn({
+            type: 'backend_event',
+            conversationId,
+            event: { type: 'turn_completed', session: sessionRef(state.codexSessionId || '') },
+        });
+        sendFn({
+            type: 'turn_completed',
+            conversationId,
+            workDir: state.workDir,
+            claudeSessionId: state.codexSessionId,
+            turnId: state.turnId,
+            stateVersion: state.stateVersion,
+        });
+    });
+}
+function handleCodexEvent(state, event) {
+    const convId = state.conversationId;
+    switch (event.type) {
+        case 'thread.started': {
+            const threadId = event.thread_id;
+            if (threadId) {
+                state.codexSessionId = threadId;
+                state.lastCodexSessionId = threadId;
+                if (!state.sessionNotified) {
+                    state.sessionNotified = true;
+                    sendFn({
+                        type: 'backend_event',
+                        conversationId: convId,
+                        event: { type: 'session_started', session: sessionRef(threadId) },
+                    });
+                }
+            }
+            break;
+        }
+        case 'item.started': {
+            const item = event.item;
+            if (item && isToolItem(item))
+                emitToolStarted(state, item);
+            break;
+        }
+        case 'item.completed': {
+            const item = event.item;
+            if (!item)
+                break;
+            const itemType = String(item.type || '');
+            if (itemType === 'agent_message') {
+                const text = textFromUnknown(item.text);
+                if (text) {
+                    sendFn({
+                        type: 'backend_event',
+                        conversationId: convId,
+                        event: { type: 'text_delta', session: sessionRef(state.codexSessionId || 'pending'), text },
+                    });
+                }
+            }
+            else if (itemType === 'reasoning') {
+                const text = textFromUnknown(item.text);
+                if (text) {
+                    sendFn({
+                        type: 'backend_event',
+                        conversationId: convId,
+                        event: { type: 'reasoning_delta', session: sessionRef(state.codexSessionId || 'pending'), text },
+                    });
+                }
+            }
+            else if (isToolItem(item)) {
+                emitToolCompleted(state, item);
+            }
+            break;
+        }
+        case 'turn.completed': {
+            finishCodexTurn(state);
+            const usage = buildCodexUsage(state, event.usage);
+            sendFn({
+                type: 'backend_event',
+                conversationId: convId,
+                event: {
+                    type: 'turn_completed',
+                    session: sessionRef(state.codexSessionId || ''),
+                    usage,
+                },
+            });
+            sendFn({
+                type: 'turn_completed',
+                conversationId: convId,
+                workDir: state.workDir,
+                claudeSessionId: state.codexSessionId,
+                turnId: state.turnId,
+                stateVersion: state.stateVersion,
+                usage,
+            });
+            break;
+        }
+        case 'turn.failed':
+        case 'error': {
+            const message = textFromUnknown(event.message)
+                || textFromUnknown(event.error?.message)
+                || 'Codex turn failed';
+            sendFn({
+                type: 'backend_event',
+                conversationId: convId,
+                event: { type: 'error', message },
+            });
+            break;
+        }
+    }
+}
+function isToolItem(item) {
+    const type = String(item.type || '');
+    return !!type && !['agent_message', 'reasoning'].includes(type);
+}
+function toolId(item) {
+    return textFromUnknown(item.id) || `codex-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function toolName(item) {
+    return textFromUnknown(item.type) || 'codex_item';
+}
+function emitToolStarted(state, item) {
+    const id = toolId(item);
+    if (state.startedToolIds.has(id))
+        return;
+    state.startedToolIds.add(id);
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'tool_started',
+            session: sessionRef(state.codexSessionId || 'pending'),
+            tool: {
+                id,
+                name: toolName(item),
+                itemKind: toolName(item),
+                input: codexToolInput(item),
+                status: 'in_progress',
+            },
+        },
+    });
+}
+function emitToolCompleted(state, item) {
+    const id = toolId(item);
+    if (!state.startedToolIds.has(id))
+        emitToolStarted(state, item);
+    const status = textFromUnknown(item.status);
+    const exitCode = numberOrUndefined(item.exit_code);
+    const isError = status === 'failed' || (exitCode != null && exitCode !== 0);
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'tool_completed',
+            session: sessionRef(state.codexSessionId || 'pending'),
+            tool: {
+                id,
+                name: toolName(item),
+                output: codexToolOutput(item),
+                isError,
+                status: 'completed',
+            },
+        },
+    });
+}
+function codexToolInput(item) {
+    if (item.command)
+        return { command: item.command };
+    return Object.fromEntries(Object.entries(item).filter(([key]) => !['id', 'type', 'text', 'aggregated_output', 'output', 'status', 'exit_code'].includes(key)));
+}
+function codexToolOutput(item) {
+    return textFromUnknown(item.aggregated_output)
+        || textFromUnknown(item.output)
+        || textFromUnknown(item.text)
+        || JSON.stringify(item, null, 2);
+}
+export function cancelCodexExecution(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state) {
+        emitCodexCancelled(conversationId);
+        return;
+    }
+    if (!state.child) {
+        if (state.turnActive)
+            finishCodexTurn(state);
+        emitCodexCancelled(conversationId, state);
+        return;
+    }
+    finishCodexTurn(state);
+    emitCodexCancelled(conversationId, state);
+    if (platform() === 'win32') {
+        try {
+            spawn('cmd', ['/c', 'taskkill', '/pid', String(state.child.pid), '/f', '/t'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+        }
+        catch { /* ignore */ }
+    }
+    else {
+        state.child.kill('SIGTERM');
+    }
+    state.child = null;
+    state.abortController = null;
+}
+function cleanupCodexConversation(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state)
+        return;
+    if (state.child)
+        cancelCodexExecution(conversationId);
+    if (state.heartbeatTimer) {
+        clearInterval(state.heartbeatTimer);
+        state.heartbeatTimer = null;
+    }
+    if (state.codexSessionId)
+        state.lastCodexSessionId = state.codexSessionId;
+    conversations.delete(conversationId);
+}
+export function cleanupAllCodexConversations() {
+    for (const convId of conversations.keys())
+        cleanupCodexConversation(convId);
+}
+export function evictByCodexSessionId(codexSessionId) {
+    for (const [convId, conv] of conversations) {
+        if (conv.codexSessionId === codexSessionId || conv.lastCodexSessionId === codexSessionId) {
+            if (conv.turnActive)
+                return true;
+            cleanupCodexConversation(convId);
+        }
+    }
+    return false;
+}
+function normalizeCursorPath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function normalizeSessionLimit(limit) {
+    if (limit == null)
+        return CODEX_SESSION_LIST_LIMIT;
+    if (limit === Number.POSITIVE_INFINITY)
+        return Number.POSITIVE_INFINITY;
+    if (!Number.isFinite(limit) || limit <= 0)
+        return CODEX_SESSION_LIST_LIMIT;
+    return Math.min(Math.floor(limit), 500);
+}
+function compareCursorSortKeys(a, b) {
+    const lastModifiedDiff = b.lastModified - a.lastModified;
+    if (lastModifiedDiff !== 0)
+        return lastModifiedDiff;
+    const sessionDiff = a.sessionId.localeCompare(b.sessionId);
+    if (sessionDiff !== 0)
+        return sessionDiff;
+    return a.tieBreaker.localeCompare(b.tieBreaker);
+}
+function encodeCodexCursor(scope, sortKey, workDir) {
+    return Buffer.from(JSON.stringify({
+        v: 1,
+        provider: 'codex',
+        scope,
+        ...(scope === 'workdir' && workDir ? { workDir: normalizeCursorPath(workDir) } : {}),
+        lastModified: sortKey.lastModified,
+        sessionId: sortKey.sessionId,
+        tieBreaker: sortKey.tieBreaker,
+    }), 'utf-8').toString('base64url');
+}
+function decodeCodexCursor(cursor, scope, workDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf-8'));
+    }
+    catch {
+        throw new Error('Invalid codex session list cursor');
+    }
+    if (!parsed || typeof parsed !== 'object')
+        throw new Error('Invalid codex session list cursor');
+    const value = parsed;
+    if (value.v !== 1
+        || value.provider !== 'codex'
+        || value.scope !== scope
+        || typeof value.lastModified !== 'number'
+        || !Number.isFinite(value.lastModified)
+        || typeof value.sessionId !== 'string'
+        || typeof value.tieBreaker !== 'string') {
+        throw new Error('Invalid codex session list cursor');
+    }
+    if (scope === 'workdir' && value.workDir !== normalizeCursorPath(workDir || '')) {
+        throw new Error('Codex session list cursor does not match requested workDir');
+    }
+    return { lastModified: value.lastModified, sessionId: value.sessionId, tieBreaker: value.tieBreaker };
+}
+function listCodexSessionFiles(root = CODEX_SESSION_DIR) {
+    if (!existsSync(root))
+        return [];
+    const result = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                stack.push(full);
+            else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+                result.push(full);
+        }
+    }
+    return result;
+}
+function loadTitleMap() {
+    try {
+        const raw = readFileSync(CODEX_TITLES_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeTitleMap(map) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CODEX_TITLES_FILE, JSON.stringify(map, null, 2) + '\n', 'utf-8');
+}
+function setCustomTitle(sessionId, title) {
+    const map = loadTitleMap();
+    map[sessionId] = title;
+    writeTitleMap(map);
+    codexSessionCache.invalidateAll();
+}
+function removeCustomTitle(sessionId) {
+    const map = loadTitleMap();
+    if (Object.prototype.hasOwnProperty.call(map, sessionId)) {
+        delete map[sessionId];
+        writeTitleMap(map);
+    }
+}
+function textFromUnknown(value) {
+    return typeof value === 'string' ? value : '';
+}
+function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return '';
+        const record = item;
+        return textFromUnknown(record.text)
+            || textFromUnknown(record.content)
+            || textFromUnknown(record.delta?.text);
+    })
+        .filter(Boolean)
+        .join('');
+}
+function cleanCodexUserText(text) {
+    return text
+        .replace(/<environment_context>[\s\S]*?<\/environment_context>/g, '')
+        .trim();
+}
+function sessionIdFromPath(filePath) {
+    const name = filePath.replace(/\\/g, '/').split('/').pop() || '';
+    const match = name.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i);
+    return match?.[0] || name.replace(/\.jsonl$/, '');
+}
+function parseTimestamp(value) {
+    if (typeof value !== 'string')
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+function parseCodexSessionJsonl(filePath, stats) {
+    let sessionId = sessionIdFromPath(filePath);
+    let firstPrompt = '';
+    let lastAssistant = '';
+    let projectPath = '';
+    let lastModified = 0;
+    const content = readFileSync(filePath, 'utf-8');
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            const payload = row.payload;
+            if (!payload)
+                continue;
+            const ts = parseTimestamp(row.timestamp);
+            if (ts > lastModified)
+                lastModified = ts;
+            if (row.type === 'session_meta') {
+                if (typeof payload.id === 'string')
+                    sessionId = payload.id;
+                if (typeof payload.cwd === 'string')
+                    projectPath = payload.cwd;
+                continue;
+            }
+            if (typeof payload.cwd === 'string' && !projectPath)
+                projectPath = payload.cwd;
+            const payloadType = String(payload.type || '');
+            if (row.type === 'event_msg' && payloadType === 'user_message') {
+                const msg = cleanCodexUserText(textFromUnknown(payload.message));
+                if (msg && !firstPrompt)
+                    firstPrompt = msg.substring(0, 100);
+            }
+            else if (row.type === 'event_msg' && payloadType === 'agent_message') {
+                const msg = textFromUnknown(payload.message).trim();
+                if (msg)
+                    lastAssistant = msg.substring(0, 120);
+            }
+            else if (row.type === 'event_msg' && payloadType === 'task_complete') {
+                const msg = textFromUnknown(payload.last_agent_message).trim();
+                if (msg)
+                    lastAssistant = msg.substring(0, 120);
+            }
+            else if (row.type === 'response_item' && payload.type === 'message') {
+                const text = cleanCodexUserText(contentText(payload.content));
+                if (payload.role === 'user' && text && !firstPrompt)
+                    firstPrompt = text.substring(0, 100);
+                if (payload.role === 'assistant' && text)
+                    lastAssistant = text.substring(0, 120);
+            }
+        }
+        catch { /* skip malformed lines */ }
+    }
+    const titleMap = loadTitleMap();
+    const customTitle = titleMap[sessionId];
+    const title = customTitle || firstPrompt || lastAssistant || sessionId.slice(0, 8);
+    if (!projectPath)
+        projectPath = '';
+    return {
+        sessionId,
+        title,
+        ...(customTitle ? { customTitle } : {}),
+        preview: lastAssistant || firstPrompt || title,
+        firstPrompt: firstPrompt || title,
+        lastModified: lastModified || stats.mtimeMs,
+        projectPath,
+        projectFolder: projectPath.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || projectPath,
+        sourcePath: filePath,
+    };
+}
+const codexSessionCache = new FileCache({
+    name: 'codex-session-jsonl',
+    compute: parseCodexSessionJsonl,
+    maxEntries: 10000,
+    ttlMs: 0,
+    debug: false,
+});
+function getCodexSessionEntries(workDir) {
+    const normalizedWorkDir = workDir ? normalizeCursorPath(workDir) : '';
+    const entries = [];
+    for (const filePath of listCodexSessionFiles()) {
+        const parsed = codexSessionCache.get(filePath);
+        if (!parsed)
+            continue;
+        if (normalizedWorkDir && normalizeCursorPath(parsed.projectPath) !== normalizedWorkDir)
+            continue;
+        entries.push({
+            session: parsed,
+            sortKey: {
+                lastModified: parsed.lastModified,
+                sessionId: parsed.sessionId,
+                tieBreaker: normalizeCursorPath(filePath),
+            },
+        });
+    }
+    entries.sort((a, b) => compareCursorSortKeys(a.sortKey, b.sortKey));
+    return entries;
+}
+export function listCodexSessions(workDir) {
+    return listCodexSessionsPage(workDir, { limit: Number.POSITIVE_INFINITY }).sessions;
+}
+export function listCodexSessionsPage(workDir, options = {}) {
+    const entries = getCodexSessionEntries(workDir);
+    const limit = normalizeSessionLimit(options.limit);
+    let startIndex = 0;
+    if (options.cursor) {
+        const cursor = decodeCodexCursor(options.cursor, 'workdir', workDir);
+        startIndex = entries.findIndex(entry => compareCursorSortKeys(entry.sortKey, cursor) > 0);
+        if (startIndex < 0)
+            return { sessions: [], hasMore: false };
+    }
+    const pageEntries = limit === Number.POSITIVE_INFINITY
+        ? entries.slice(startIndex)
+        : entries.slice(startIndex, startIndex + limit);
+    const nextIndex = startIndex + pageEntries.length;
+    const hasMore = nextIndex < entries.length;
+    return {
+        sessions: pageEntries.map(({ session }) => ({
+            sessionId: session.sessionId,
+            title: session.title,
+            customTitle: session.customTitle,
+            preview: session.preview,
+            lastModified: session.lastModified,
+        })),
+        hasMore,
+        ...(hasMore && pageEntries.length > 0 ? { nextCursor: encodeCodexCursor('workdir', pageEntries[pageEntries.length - 1].sortKey, workDir) } : {}),
+    };
+}
+export function listAllCodexSessions(limit = 500) {
+    return listAllCodexSessionsPage({ limit }).sessions;
+}
+export function listAllCodexSessionsPage(options = {}) {
+    const entries = getCodexSessionEntries();
+    const limit = normalizeSessionLimit(options.limit);
+    let startIndex = 0;
+    if (options.cursor) {
+        const cursor = decodeCodexCursor(options.cursor, 'global');
+        startIndex = entries.findIndex(entry => compareCursorSortKeys(entry.sortKey, cursor) > 0);
+        if (startIndex < 0)
+            return { sessions: [], hasMore: false, indexState: 'ready' };
+    }
+    const pageEntries = limit === Number.POSITIVE_INFINITY
+        ? entries.slice(startIndex)
+        : entries.slice(startIndex, startIndex + limit);
+    const nextIndex = startIndex + pageEntries.length;
+    const hasMore = nextIndex < entries.length;
+    return {
+        sessions: pageEntries.map(({ session }) => ({
+            sessionId: session.sessionId,
+            projectPath: session.projectPath,
+            projectFolder: session.projectFolder,
+            stableIdentity: normalizeCursorPath(session.sourcePath),
+            title: session.title,
+            firstPrompt: session.firstPrompt,
+            lastModified: session.lastModified,
+        })),
+        hasMore,
+        ...(hasMore && pageEntries.length > 0 ? { nextCursor: encodeCodexCursor('global', pageEntries[pageEntries.length - 1].sortKey) } : {}),
+        indexState: 'ready',
+    };
+}
+function findCodexSessionFile(sessionId) {
+    for (const filePath of listCodexSessionFiles()) {
+        const parsed = codexSessionCache.get(filePath);
+        if (parsed?.sessionId === sessionId)
+            return filePath;
+    }
+    return null;
+}
+function pushUniqueMessage(messages, seen, msg) {
+    const key = `${msg.role}\n${msg.timestamp || ''}\n${msg.content}\n${msg.toolName || ''}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    messages.push(msg);
+}
+export function readCodexSessionMessages(_workDir, sessionId) {
+    const filePath = findCodexSessionFile(sessionId);
+    if (!filePath)
+        return [];
+    const messages = [];
+    const seen = new Set();
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const row = JSON.parse(line);
+                const payload = row.payload;
+                if (!payload)
+                    continue;
+                const ts = typeof row.timestamp === 'string' ? row.timestamp : undefined;
+                const payloadType = String(payload.type || '');
+                if (row.type === 'event_msg' && payloadType === 'user_message') {
+                    const text = cleanCodexUserText(textFromUnknown(payload.message));
+                    if (!text.trim())
+                        continue;
+                    const processed = processUserMessage(text, ts);
+                    for (const entry of processed.prefixEntries)
+                        pushUniqueMessage(messages, seen, entry);
+                    if (processed.userEntry)
+                        pushUniqueMessage(messages, seen, processed.userEntry);
+                }
+                else if (row.type === 'event_msg' && payloadType === 'agent_message') {
+                    const text = textFromUnknown(payload.message);
+                    if (text.trim())
+                        pushUniqueMessage(messages, seen, { role: 'assistant', content: text, timestamp: ts });
+                }
+                else if (row.type === 'response_item' && payload.type === 'message') {
+                    const text = payload.role === 'user'
+                        ? cleanCodexUserText(contentText(payload.content))
+                        : contentText(payload.content);
+                    if (!text.trim())
+                        continue;
+                    if (payload.role === 'user') {
+                        const processed = processUserMessage(text, ts);
+                        for (const entry of processed.prefixEntries)
+                            pushUniqueMessage(messages, seen, entry);
+                        if (processed.userEntry)
+                            pushUniqueMessage(messages, seen, processed.userEntry);
+                    }
+                    else if (payload.role === 'assistant') {
+                        pushUniqueMessage(messages, seen, { role: 'assistant', content: text, timestamp: ts });
+                    }
+                }
+                else if (row.type === 'response_item' && payload.type && payload.type !== 'message') {
+                    pushUniqueMessage(messages, seen, {
+                        role: 'tool',
+                        content: '',
+                        toolName: String(payload.type),
+                        toolInput: JSON.stringify(payload, null, 2),
+                        toolId: textFromUnknown(payload.id),
+                        timestamp: ts,
+                    });
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+    }
+    catch { /* skip unreadable files */ }
+    return messages;
+}
+export function renameCodexSession(_workDir, sessionId, newTitle) {
+    if (!findCodexSessionFile(sessionId))
+        return false;
+    setCustomTitle(sessionId, newTitle);
+    return true;
+}
+export function deleteCodexSession(_workDir, sessionId) {
+    const filePath = findCodexSessionFile(sessionId);
+    if (!filePath)
+        return false;
+    const resolved = resolve(filePath);
+    if (!resolved.startsWith(resolve(CODEX_SESSION_DIR)))
+        return false;
+    try {
+        unlinkSync(resolved);
+        codexSessionCache.invalidate(resolved);
+        removeCustomTitle(sessionId);
+        return true;
+    }
+    catch {
+        try {
+            rmSync(resolved, { force: true });
+            codexSessionCache.invalidate(resolved);
+            removeCustomTitle(sessionId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export { codexCapabilities };
+//# sourceMappingURL=codex.js.map