funolio-agent 1.0.52 → 1.0.75

package/dist/codex-app-server-manager.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__codexAppServerTestUtils = exports.CodexAppServerManager = void 0;
+exports.getCodexAppServerManager = getCodexAppServerManager;
+exports.runCodexAppServerTurnForTest = runCodexAppServerTurnForTest;
+const child_process_1 = require("child_process");
+const runtime_context_1 = require("./runtime-context");
+const sync_cli_config_1 = require("./mcp/sync-cli-config");
+const LOCAL_ONLY_ERROR = 'Codex app-server manager is local_desktop only';
+const DEFAULT_CODEX_SETTINGS = {
+    reasoningEffort: 'none',
+    reasoningSummary: 'detailed',
+    personality: 'friendly',
+    serviceTier: 'fast',
+    sandboxPolicy: 'danger-full-access',
+    approvalPolicy: 'never',
+};
+let _manager = null;
+let _prepareCodexCliConfigChain = Promise.resolve();
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildAbortError() {
+    const err = new Error('Codex app-server turn aborted');
+    err.name = 'AbortError';
+    return err;
+}
+function throwIfNotLocalDesktop(runtimeMode) {
+    if (runtimeMode && !(0, runtime_context_1.isLocalDesktopRuntime)(runtimeMode)) {
+        throw new Error(LOCAL_ONLY_ERROR);
+    }
+}
+function sessionKey(conversationId, botId) {
+    return `${conversationId}::${botId}`;
+}
+function createEventLog() {
+    return {
+        schema: 'funolio.codex-app-server.event-log@1',
+        events: [],
+    };
+}
+function appendEvent(eventLog, direction, kind, payload) {
+    if (!eventLog)
+        return;
+    eventLog.events.push({
+        ts: new Date().toISOString(),
+        direction,
+        kind,
+        payload,
+    });
+}
+function serializeEventLog(eventLog) {
+    return JSON.stringify(eventLog);
+}
+function normalizeDetail(text) {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function scrubCodexAppServerEnv(baseEnv, extraEnv) {
+    const env = {};
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (value == null)
+            continue;
+        if (key === 'CODEX_THREAD_ID')
+            continue;
+        env[key] = value;
+    }
+    for (const [key, value] of Object.entries(extraEnv)) {
+        if (!value)
+            continue;
+        env[key] = value;
+    }
+    return env;
+}
+function computeEnvFingerprint(env) {
+    return JSON.stringify(Object.entries(env)
+        .filter(([, value]) => typeof value === 'string')
+        .sort(([a], [b]) => a.localeCompare(b)));
+}
+function buildCodexAppServerToolEnv(input) {
+    const env = {};
+    const actorId = input.botName?.trim() || input.botId.trim();
+    if (actorId)
+        env.FUNOLIO_TOOL_ACTOR_ID = actorId;
+    if (input.projectId !== undefined && input.projectId !== null)
+        env.FUNOLIO_TOOL_PROJECT_ID = String(input.projectId);
+    if (input.todoTaskId !== undefined && input.todoTaskId !== null)
+        env.FUNOLIO_TOOL_TODO_ID = String(input.todoTaskId);
+    return env;
+}
+function extractLatestUserText(messages) {
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+    if (lastMessage?.role === 'user') {
+        return lastMessage.content || '';
+    }
+    if (messages.length === 0)
+        return '';
+    const rendered = messages.map((message) => {
+        const label = message.role === 'user' ? 'USER'
+            : message.role === 'assistant' ? 'ASSISTANT'
+                : message.role === 'tool' ? `TOOL (${message.toolName || 'tool'})`
+                    : String(message.role || 'MESSAGE').toUpperCase();
+        return `${label}:\n${message.content || ''}`;
+    });
+    return rendered.join('\n\n');
+}
+function buildCodexAppServerInput(messages) {
+    return [
+        {
+            type: 'text',
+            text: extractLatestUserText(messages),
+        },
+    ];
+}
+function buildTurnUsage(tokenUsage) {
+    const last = tokenUsage?.last;
+    if (!last || typeof last !== 'object')
+        return undefined;
+    const inputTokens = Number(last.inputTokens || 0) + Number(last.cachedInputTokens || 0);
+    const outputTokens = Number(last.outputTokens || 0) + Number(last.reasoningOutputTokens || 0);
+    if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens))
+        return undefined;
+    return { inputTokens, outputTokens };
+}
+function extractThreadId(payload) {
+    const id = payload?.thread?.id ?? payload?.threadId ?? null;
+    return typeof id === 'string' && id.trim() ? id.trim() : null;
+}
+function extractTurnId(payload) {
+    const id = payload?.turn?.id ?? payload?.turnId ?? null;
+    return typeof id === 'string' && id.trim() ? id.trim() : null;
+}
+function extractTurnStatus(payload) {
+    const status = payload?.turn?.status ?? null;
+    return typeof status === 'string' ? status : null;
+}
+function extractTurnFailureMessage(payload) {
+    const message = payload?.turn?.error?.message ?? payload?.error?.message ?? null;
+    return typeof message === 'string' && message.trim() ? message.trim() : null;
+}
+function isResponseMessage(value) {
+    return !!value && typeof value === 'object' && value.id !== undefined && ('result' in value || 'error' in value);
+}
+function isServerRequestMessage(value) {
+    return !!value && typeof value === 'object' && value.id !== undefined && typeof value.method === 'string';
+}
+function isNotificationMessage(value) {
+    return !!value && typeof value === 'object' && value.id === undefined && typeof value.method === 'string';
+}
+function isTurnMatch(activeTurn, params) {
+    if (!activeTurn)
+        return false;
+    if (activeTurn.threadId && params?.threadId && activeTurn.threadId !== params.threadId)
+        return false;
+    if (activeTurn.turnId && params?.turnId && activeTurn.turnId !== params.turnId)
+        return false;
+    return true;
+}
+function safeJsonParse(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function describeStartupStatus(params) {
+    const name = typeof params?.name === 'string' ? params.name : 'MCP server';
+    const status = typeof params?.status === 'string' ? params.status : 'unknown';
+    const error = typeof params?.error === 'string' && params.error.trim() ? ` (${params.error.trim()})` : '';
+    return `${name}: ${status}${error}`;
+}
+function describeItemProgress(method, params) {
+    if (!params?.item || typeof params.item !== 'object')
+        return null;
+    const itemType = typeof params.item.type === 'string' ? params.item.type : 'item';
+    const label = typeof params.item.name === 'string' ? params.item.name
+        : typeof params.item.title === 'string' ? params.item.title
+            : typeof params.item.serverName === 'string' ? params.item.serverName
+                : typeof params.item.toolName === 'string' ? params.item.toolName
+                    : '';
+    const status = typeof params.item.status === 'string' ? ` (${params.item.status})`
+        : '';
+    const prefix = method === 'item/started' ? 'Started' : 'Completed';
+    return `${prefix} ${itemType}${label ? `: ${label}` : ''}${status}`;
+}
+function normalizeCodexSettings(settings) {
+    return {
+        reasoningEffort: String(settings?.reasoningEffort || DEFAULT_CODEX_SETTINGS.reasoningEffort),
+        reasoningSummary: String(settings?.reasoningSummary || DEFAULT_CODEX_SETTINGS.reasoningSummary),
+        personality: String(settings?.personality || DEFAULT_CODEX_SETTINGS.personality),
+        serviceTier: String(settings?.serviceTier || DEFAULT_CODEX_SETTINGS.serviceTier),
+        sandboxPolicy: String(settings?.sandboxPolicy || DEFAULT_CODEX_SETTINGS.sandboxPolicy),
+        approvalPolicy: String(settings?.approvalPolicy || DEFAULT_CODEX_SETTINGS.approvalPolicy),
+    };
+}
+function buildThreadSandbox(sandboxPolicy) {
+    switch (sandboxPolicy) {
+        case 'read-only':
+            return 'read-only';
+        case 'workspace-write':
+            return 'workspace-write';
+        default:
+            return 'danger-full-access';
+    }
+}
+function buildTurnSandboxPolicy(sandboxPolicy) {
+    switch (sandboxPolicy) {
+        case 'read-only':
+            return { type: 'readOnly' };
+        case 'workspace-write':
+            return { type: 'workspaceWrite' };
+        default:
+            return { type: 'dangerFullAccess' };
+    }
+}
+function buildApprovalResponse(method, params) {
+    switch (method) {
+        case 'item/commandExecution/requestApproval':
+            return { decision: 'accept' };
+        case 'item/fileChange/requestApproval':
+            return { decision: 'accept' };
+        case 'item/permissions/requestApproval':
+            return { permissions: params?.permissions || {}, scope: 'session' };
+        case 'applyPatchApproval':
+            return { decision: 'approved' };
+        case 'execCommandApproval':
+            return { decision: 'approved' };
+        case 'item/tool/requestUserInput':
+            return { answers: {} };
+        case 'mcpServer/elicitation/request':
+            return { action: 'decline' };
+        default:
+            return null;
+    }
+}
+async function defaultPrepareCliConfig() {
+    _prepareCodexCliConfigChain = _prepareCodexCliConfigChain.then(async () => {
+        await (0, sync_cli_config_1.syncMcpToCliConfig)('codex-cli');
+    });
+    return _prepareCodexCliConfigChain;
+}
+class CodexAppServerManager {
+    sessions = new Map();
+    now;
+    spawnProcess;
+    prepareCliConfig;
+    logInfo;
+    logWarn;
+    clientInfo;
+    constructor(deps = {}) {
+        this.now = deps.now || (() => Date.now());
+        this.spawnProcess = deps.spawnProcess || ((command, args, options) => (0, child_process_1.spawn)(command, args, options));
+        this.prepareCliConfig = deps.prepareCliConfig || defaultPrepareCliConfig;
+        this.logInfo = deps.logInfo || ((message) => console.log(message));
+        this.logWarn = deps.logWarn || ((message) => console.warn(message));
+        this.clientInfo = deps.clientInfo || { name: 'funolio-agent', version: '1.0.74' };
+    }
+    async runTurn(opts) {
+        throwIfNotLocalDesktop(opts.runtimeMode);
+        const key = sessionKey(opts.conversationId, opts.botId);
+        const requestedEnv = scrubCodexAppServerEnv(process.env, buildCodexAppServerToolEnv({
+            botId: opts.botId,
+            botName: opts.botName,
+            projectId: opts.projectId,
+            todoTaskId: opts.currentTodoTaskId,
+        }));
+        const requestedEnvFingerprint = computeEnvFingerprint(requestedEnv);
+        let session = this.sessions.get(key);
+        const expectedThreadId = opts.forceFreshSession ? null : (opts.resumeSessionId || null);
+        if (session
+            && (opts.forceFreshSession
+                || session.cwd !== opts.cwd
+                || session.closed
+                || session.envFingerprint !== requestedEnvFingerprint
+                || (expectedThreadId && session.threadId && session.threadId !== expectedThreadId))) {
+            this.closeSession(key);
+            session = undefined;
+        }
+        if (!session) {
+            session = await this.createSession(key, opts.cwd, requestedEnv);
+            this.sessions.set(key, session);
+        }
+        const run = async () => this.runTurnInternal(session, opts);
+        const queued = session.chain.then(run, run);
+        session.chain = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    closeSessionByConversation(conversationId, botId) {
+        this.closeSession(sessionKey(conversationId, botId));
+    }
+    closeAll() {
+        for (const key of [...this.sessions.keys()]) {
+            this.closeSession(key);
+        }
+    }
+    closeSession(key) {
+        const session = this.sessions.get(key);
+        if (!session)
+            return;
+        session.closed = true;
+        try {
+            session.child.kill();
+        }
+        catch {
+            // best effort
+        }
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(new Error('Codex app-server session closed'));
+        }
+        session.pendingRequests.clear();
+        if (session.activeTurn) {
+            session.activeTurn.rejectCompletion(new Error('Codex app-server session closed during active turn'));
+            session.activeTurn = null;
+        }
+        this.sessions.delete(key);
+    }
+    async createSession(key, cwd, env) {
+        await this.prepareCliConfig();
+        const child = this.spawnProcess(process.platform === 'win32' ? 'codex' : 'codex', ['app-server'], {
+            stdio: 'pipe',
+            shell: process.platform === 'win32',
+            windowsHide: true,
+            cwd,
+            env,
+        });
+        const session = {
+            key,
+            cwd,
+            env,
+            envFingerprint: computeEnvFingerprint(env),
+            child,
+            stdoutCarry: '',
+            createdAtMs: this.now(),
+            lastUsedAtMs: this.now(),
+            nextRequestId: 1,
+            pendingRequests: new Map(),
+            activeTurn: null,
+            threadId: null,
+            readyPromise: Promise.resolve(),
+            readyResolved: false,
+            closed: false,
+            chain: Promise.resolve(),
+        };
+        child.stdout.on('data', (chunk) => {
+            this.handleStdout(session, chunk.toString());
+        });
+        child.stderr.on('data', (chunk) => {
+            this.handleStderr(session, chunk.toString());
+        });
+        child.on('error', (err) => {
+            this.handleProcessError(session, err);
+        });
+        child.on('close', (code, signal) => {
+            this.handleProcessClose(session, code, signal);
+        });
+        session.readyPromise = this.initializeSession(session);
+        return session;
+    }
+    async initializeSession(session) {
+        await this.sendRequest(session, 'initialize', {
+            clientInfo: this.clientInfo,
+        });
+        this.sendNotification(session, 'initialized');
+        session.readyResolved = true;
+    }
+    async runTurnInternal(session, opts) {
+        await session.readyPromise;
+        session.lastUsedAtMs = this.now();
+        const codexSettings = normalizeCodexSettings(opts.codexSettings);
+        const eventLog = createEventLog();
+        const completionPromise = new Promise((resolve, reject) => {
+            const activeTurn = {
+                threadId: session.threadId,
+                turnId: null,
+                finalContent: '',
+                thinkingText: '',
+                done: false,
+                aborted: false,
+                callbackChain: Promise.resolve(),
+                detailFingerprints: new Set(),
+                eventLog,
+                onChunk: opts.onChunk,
+                onThinkingChunk: opts.onThinkingChunk,
+                onDetail: opts.onDetail,
+                resolveCompletion: resolve,
+                rejectCompletion: reject,
+            };
+            session.activeTurn = activeTurn;
+        });
+        const activeTurn = session.activeTurn;
+        const abortHandler = async () => {
+            activeTurn.aborted = true;
+            if (activeTurn.turnId) {
+                try {
+                    await this.sendRequest(session, 'turn/interrupt', { turnId: activeTurn.turnId });
+                }
+                catch {
+                    // best effort; close handler will reject if needed
+                }
+            }
+            activeTurn.rejectCompletion(buildAbortError());
+            session.activeTurn = null;
+        };
+        opts.abortSignal?.addEventListener('abort', abortHandler, { once: true });
+        try {
+            const requestedThreadId = opts.forceFreshSession ? null : (opts.resumeSessionId || null);
+            if (opts.forceFreshSession) {
+                session.threadId = null;
+            }
+            if (!session.threadId) {
+                if (requestedThreadId) {
+                    const response = await this.sendRequest(session, 'thread/resume', {
+                        threadId: requestedThreadId,
+                        cwd: opts.cwd,
+                        developerInstructions: opts.systemPrompt || null,
+                        approvalPolicy: codexSettings.approvalPolicy,
+                        sandbox: buildThreadSandbox(codexSettings.sandboxPolicy),
+                        model: opts.model || null,
+                        personality: codexSettings.personality,
+                        modelProvider: 'openai',
+                    });
+                    session.threadId = extractThreadId(response);
+                }
+                else {
+                    const response = await this.sendRequest(session, 'thread/start', {
+                        cwd: opts.cwd,
+                        developerInstructions: opts.systemPrompt || null,
+                        approvalPolicy: codexSettings.approvalPolicy,
+                        sandbox: buildThreadSandbox(codexSettings.sandboxPolicy),
+                        model: opts.model || null,
+                        personality: codexSettings.personality,
+                        modelProvider: 'openai',
+                        ephemeral: false,
+                    });
+                    session.threadId = extractThreadId(response);
+                }
+            }
+            const threadId = session.threadId;
+            if (!threadId) {
+                throw new Error('Codex app-server did not return a thread id');
+            }
+            activeTurn.threadId = threadId;
+            const turnStartResponse = await this.sendRequest(session, 'turn/start', {
+                threadId,
+                cwd: opts.cwd,
+                approvalPolicy: codexSettings.approvalPolicy,
+                effort: codexSettings.reasoningEffort,
+                sandboxPolicy: buildTurnSandboxPolicy(codexSettings.sandboxPolicy),
+                personality: codexSettings.personality,
+                input: buildCodexAppServerInput(opts.messages),
+                model: opts.model || null,
+                serviceTier: codexSettings.serviceTier,
+                summary: codexSettings.reasoningSummary,
+            });
+            activeTurn.turnId = extractTurnId(turnStartResponse);
+            return await completionPromise;
+        }
+        finally {
+            opts.abortSignal?.removeEventListener('abort', abortHandler);
+        }
+    }
+    sendNotification(session, method, params) {
+        const payload = params === undefined
+            ? { jsonrpc: '2.0', method }
+            : { jsonrpc: '2.0', method, params };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'notification', payload);
+        session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    sendResponse(session, id, result, error) {
+        const payload = error
+            ? { jsonrpc: '2.0', id, error }
+            : { jsonrpc: '2.0', id, result };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'response', payload);
+        session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    sendRequest(session, method, params) {
+        if (session.closed) {
+            return Promise.reject(new Error('Codex app-server session is closed'));
+        }
+        const id = session.nextRequestId++;
+        const payload = params === undefined
+            ? { jsonrpc: '2.0', id, method }
+            : { jsonrpc: '2.0', id, method, params };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'request', payload);
+        return new Promise((resolve, reject) => {
+            session.pendingRequests.set(id, { method, resolve, reject });
+            session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+        });
+    }
+    handleStdout(session, chunk) {
+        session.stdoutCarry += chunk;
+        const lines = session.stdoutCarry.split(/\r?\n/);
+        session.stdoutCarry = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parsed = safeJsonParse(trimmed);
+            if (!parsed) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'parse_error', trimmed);
+                this.logWarn(`[codex-app-server] Non-JSON stdout line: ${trimmed}`);
+                continue;
+            }
+            if (isResponseMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'response', parsed);
+                this.handleResponse(session, parsed);
+                continue;
+            }
+            if (isServerRequestMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'server_request', parsed);
+                void this.handleServerRequest(session, parsed);
+                continue;
+            }
+            if (isNotificationMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'notification', parsed);
+                void this.handleNotification(session, parsed);
+                continue;
+            }
+            appendEvent(session.activeTurn?.eventLog, 'in', 'parse_error', parsed);
+            this.logWarn('[codex-app-server] Unrecognized stdout payload');
+        }
+    }
+    handleResponse(session, message) {
+        const pending = session.pendingRequests.get(message.id);
+        if (!pending)
+            return;
+        session.pendingRequests.delete(message.id);
+        if (message.error) {
+            pending.reject(new Error(`${pending.method} failed: ${message.error.message || 'Unknown error'}`));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    async handleServerRequest(session, message) {
+        const approvalResponse = buildApprovalResponse(message.method, message.params);
+        if (approvalResponse !== null) {
+            await this.emitDetail(session.activeTurn, `Auto-handled ${message.method}`);
+            this.sendResponse(session, message.id, approvalResponse);
+            return;
+        }
+        this.sendResponse(session, message.id, undefined, {
+            code: -32601,
+            message: `Unsupported server request: ${message.method}`,
+        });
+    }
+    async handleNotification(session, message) {
+        const params = message.params || {};
+        if (message.method === 'thread/started') {
+            const threadId = extractThreadId(params);
+            if (threadId) {
+                session.threadId = threadId;
+                if (session.activeTurn)
+                    session.activeTurn.threadId = threadId;
+            }
+            return;
+        }
+        if (message.method === 'turn/started') {
+            const turnId = extractTurnId(params);
+            if (session.activeTurn && turnId) {
+                session.activeTurn.turnId = turnId;
+            }
+            return;
+        }
+        if (message.method === 'thread/tokenUsage/updated' && isTurnMatch(session.activeTurn, params)) {
+            const usage = buildTurnUsage(params.tokenUsage);
+            if (usage && session.activeTurn) {
+                session.activeTurn.usage = usage;
+            }
+            return;
+        }
+        if (message.method === 'item/agentMessage/delta' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                session.activeTurn.finalContent += delta;
+                await this.emitChunk(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/reasoning/summaryTextDelta' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                session.activeTurn.thinkingText += delta;
+                await this.emitThinkingChunk(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/commandExecution/outputDelta' && isTurnMatch(session.activeTurn, params)) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                await this.emitDetail(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/fileChange/outputDelta' && isTurnMatch(session.activeTurn, params)) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                await this.emitDetail(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/mcpToolCall/progress' && isTurnMatch(session.activeTurn, params)) {
+            if (typeof params.message === 'string') {
+                await this.emitDetail(session.activeTurn, params.message);
+            }
+            return;
+        }
+        if (message.method === 'mcpServer/startupStatus/updated') {
+            const detail = describeStartupStatus(params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'item/started' && isTurnMatch(session.activeTurn, params)) {
+            const detail = describeItemProgress(message.method, params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'item/completed' && isTurnMatch(session.activeTurn, params)) {
+            const detail = describeItemProgress(message.method, params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'turn/completed' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            activeTurn.done = true;
+            try {
+                await activeTurn.callbackChain;
+            }
+            catch {
+                // Callback failures are already logged by the emit helpers.
+            }
+            const status = extractTurnStatus(params);
+            if (status === 'failed') {
+                const messageText = extractTurnFailureMessage(params) || 'Codex app-server turn failed';
+                session.activeTurn = null;
+                activeTurn.rejectCompletion(new Error(messageText));
+                return;
+            }
+            if (status === 'interrupted' && activeTurn.aborted) {
+                session.activeTurn = null;
+                activeTurn.rejectCompletion(buildAbortError());
+                return;
+            }
+            const result = {
+                content: activeTurn.finalContent.trim(),
+                sessionId: session.threadId,
+                usage: activeTurn.usage,
+                rawOutput: serializeEventLog(activeTurn.eventLog),
+                eventLog: activeTurn.eventLog,
+                thinking: activeTurn.thinkingText || undefined,
+            };
+            session.activeTurn = null;
+            activeTurn.resolveCompletion(result);
+        }
+    }
+    handleStderr(session, chunk) {
+        appendEvent(session.activeTurn?.eventLog, 'stderr', 'stderr', chunk);
+        void this.emitDetail(session.activeTurn, chunk);
+    }
+    handleProcessError(session, err) {
+        this.logWarn(`[codex-app-server] Process error for ${session.key}: ${err.message}`);
+        if (session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            session.activeTurn = null;
+            activeTurn.rejectCompletion(err);
+        }
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(err);
+        }
+        session.pendingRequests.clear();
+        session.closed = true;
+        this.sessions.delete(session.key);
+    }
+    handleProcessClose(session, code, signal) {
+        if (session.stdoutCarry.trim()) {
+            const parsed = safeJsonParse(session.stdoutCarry.trim());
+            if (parsed) {
+                if (isResponseMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'response', parsed);
+                    this.handleResponse(session, parsed);
+                }
+                else if (isServerRequestMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'server_request', parsed);
+                    void this.handleServerRequest(session, parsed);
+                }
+                else if (isNotificationMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'notification', parsed);
+                    void this.handleNotification(session, parsed);
+                }
+            }
+        }
+        session.closed = true;
+        this.sessions.delete(session.key);
+        const closeError = new Error(`Codex app-server exited${code !== null ? ` with code ${code}` : ''}${signal ? ` (${signal})` : ''}`);
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(closeError);
+        }
+        session.pendingRequests.clear();
+        if (session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            session.activeTurn = null;
+            if (!activeTurn.done) {
+                activeTurn.rejectCompletion(closeError);
+            }
+        }
+    }
+    async emitChunk(activeTurn, chunk) {
+        if (!activeTurn?.onChunk || !chunk)
+            return;
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onChunk?.(chunk);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onChunk callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+    async emitThinkingChunk(activeTurn, chunk) {
+        if (!activeTurn?.onThinkingChunk || !chunk)
+            return;
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onThinkingChunk?.(chunk);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onThinkingChunk callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+    async emitDetail(activeTurn, detail) {
+        if (!activeTurn?.onDetail)
+            return;
+        const normalized = normalizeDetail(detail);
+        if (!normalized)
+            return;
+        if (activeTurn.detailFingerprints.has(normalized))
+            return;
+        activeTurn.detailFingerprints.add(normalized);
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onDetail?.(normalized);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onDetail callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+}
+exports.CodexAppServerManager = CodexAppServerManager;
+function getCodexAppServerManager() {
+    if (!_manager) {
+        _manager = new CodexAppServerManager();
+    }
+    return _manager;
+}
+async function runCodexAppServerTurnForTest(manager, opts) {
+    return manager.runTurn(opts);
+}
+exports.__codexAppServerTestUtils = {
+    LOCAL_ONLY_ERROR,
+    buildCodexAppServerInput,
+    buildCodexAppServerToolEnv,
+    scrubCodexAppServerEnv,
+    buildApprovalResponse,
+    buildTurnUsage,
+    createEventLog,
+    serializeEventLog,
+    sessionKey,
+    delay,
+};
+//# sourceMappingURL=codex-app-server-manager.js.map