@jungjaehoon/mama-os 0.22.1 → 0.24.0

package/dist/agent/codex-app-server-process.js

@@ -0,0 +1,1382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAppServerProcess = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_readline_1 = require("node:readline");
+const codex_home_js_1 = require("./codex-home.js");
+const codex_thread_registry_js_1 = require("./codex-thread-registry.js");
+const DEFAULT_TIMEOUT = 300_000;
+const STOP_GRACE_MS = 200;
+const STDERR_LIMIT = 4_000;
+const CLIENT_INFO = { name: 'mama-codex-app-server', version: '1.0.0' };
+const TURN_STATUSES = new Set(['completed', 'interrupted', 'failed', 'inProgress']);
+const TURN_ITEM_VIEWS = new Set(['notLoaded', 'summary', 'full']);
+const APPROVAL_REVIEWERS = new Set(['user', 'auto_review', 'guardian_subagent']);
+const OVERLOADED_ERROR_CODE = -32001;
+const OVERLOAD_RETRY_LIMIT = 4;
+const OVERLOAD_RETRY_BASE_MS = 25;
+const TURN_START_RECONCILE_GRACE_MS = 250;
+class CodexAppServerRpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'CodexAppServerRpcError';
+        this.code = code;
+    }
+}
+function object(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(stableJson);
+    }
+    const record = object(value);
+    if (!record) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .map((key) => [key, stableJson(record[key])]));
+}
+function deepFreeze(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            deepFreeze(item);
+        }
+        Object.freeze(value);
+        return;
+    }
+    const record = object(value);
+    if (record) {
+        for (const item of Object.values(record)) {
+            deepFreeze(item);
+        }
+        Object.freeze(record);
+    }
+}
+function snapshotHostToolBridge(bridge) {
+    if (!bridge) {
+        return undefined;
+    }
+    const tools = bridge.tools
+        .map((tool) => stableJson(tool))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    deepFreeze(tools);
+    const execute = bridge.execute.bind(bridge);
+    return Object.freeze({ tools, execute });
+}
+function errorMessage(value, fallback) {
+    const record = object(value);
+    return typeof record?.message === 'string' && record.message ? record.message : fallback;
+}
+function stringField(record, name, context) {
+    const value = record[name];
+    if (typeof value !== 'string') {
+        throw new Error(`Codex app-server returned malformed ${context}.${name}`);
+    }
+    return value;
+}
+function nullableStringField(record, name, context) {
+    const value = record[name];
+    if (value !== null && typeof value !== 'string') {
+        throw new Error(`Codex app-server returned malformed ${context}.${name}`);
+    }
+}
+function nullableNumberField(record, name, context) {
+    const value = record[name];
+    if (value !== null && (typeof value !== 'number' || !Number.isFinite(value))) {
+        throw new Error(`Codex app-server returned malformed ${context}.${name}`);
+    }
+}
+function validateTurn(value, context) {
+    const turn = object(value);
+    if (!turn) {
+        throw new Error(`Codex app-server returned malformed ${context}`);
+    }
+    stringField(turn, 'id', context);
+    if (!Array.isArray(turn.items) || !TURN_ITEM_VIEWS.has(String(turn.itemsView))) {
+        throw new Error(`Codex app-server returned malformed ${context} items`);
+    }
+    if (!TURN_STATUSES.has(String(turn.status))) {
+        throw new Error(`Codex app-server returned malformed ${context}.status`);
+    }
+    if (turn.error !== null) {
+        const error = object(turn.error);
+        if (!error ||
+            typeof error.message !== 'string' ||
+            error.codexErrorInfo === undefined ||
+            (error.additionalDetails !== null && typeof error.additionalDetails !== 'string')) {
+            throw new Error(`Codex app-server returned malformed ${context}.error`);
+        }
+    }
+    nullableNumberField(turn, 'startedAt', context);
+    nullableNumberField(turn, 'completedAt', context);
+    nullableNumberField(turn, 'durationMs', context);
+    return turn;
+}
+function validateThread(value) {
+    const thread = object(value);
+    if (!thread) {
+        throw new Error('Codex app-server returned malformed thread');
+    }
+    for (const field of ['id', 'sessionId', 'preview', 'modelProvider', 'cwd', 'cliVersion']) {
+        stringField(thread, field, 'thread');
+    }
+    for (const field of [
+        'forkedFromId',
+        'parentThreadId',
+        'path',
+        'threadSource',
+        'agentNickname',
+        'agentRole',
+        'name',
+    ]) {
+        nullableStringField(thread, field, 'thread');
+    }
+    if (typeof thread.ephemeral !== 'boolean') {
+        throw new Error('Codex app-server returned malformed thread.ephemeral');
+    }
+    for (const field of ['createdAt', 'updatedAt']) {
+        if (typeof thread[field] !== 'number' || !Number.isFinite(thread[field])) {
+            throw new Error(`Codex app-server returned malformed thread.${field}`);
+        }
+    }
+    nullableNumberField(thread, 'recencyAt', 'thread');
+    const status = object(thread.status);
+    if (!status ||
+        !['notLoaded', 'idle', 'systemError', 'active'].includes(String(status.type)) ||
+        (status.type === 'active' && !Array.isArray(status.activeFlags))) {
+        throw new Error('Codex app-server returned malformed thread.status');
+    }
+    const sourceValid = typeof thread.source === 'string' || object(thread.source) !== undefined;
+    if (!sourceValid ||
+        (thread.gitInfo !== null && !object(thread.gitInfo)) ||
+        !Array.isArray(thread.turns)) {
+        throw new Error('Codex app-server returned malformed thread metadata');
+    }
+    for (const turn of thread.turns) {
+        validateTurn(turn, 'thread.turns[]');
+    }
+    return thread;
+}
+function shaFile(path) {
+    return (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(path)).digest('hex');
+}
+function managedFileSignature(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return undefined;
+    }
+    const stat = (0, node_fs_1.statSync)(path);
+    return `${stat.dev}:${stat.ino}:${stat.mode}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}
+function ensurePrivateDirectory(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true, mode: 0o700 });
+    (0, node_fs_1.chmodSync)(path, 0o700);
+}
+function atomicPrivateWrite(path, value) {
+    ensurePrivateDirectory((0, node_path_1.dirname)(path));
+    const temporary = `${path}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    (0, node_fs_1.writeFileSync)(temporary, value, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    (0, node_fs_1.chmodSync)(temporary, 0o600);
+    (0, node_fs_1.renameSync)(temporary, path);
+    (0, node_fs_1.chmodSync)(path, 0o600);
+}
+function copyAuthAtomically(source, destination) {
+    if (!(0, node_fs_1.existsSync)(source) ||
+        (0, node_fs_1.statSync)(source).size === 0 ||
+        (0, node_path_1.resolve)(source) === (0, node_path_1.resolve)(destination)) {
+        return;
+    }
+    ensurePrivateDirectory((0, node_path_1.dirname)(destination));
+    const temporary = `${destination}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    (0, node_fs_1.copyFileSync)(source, temporary);
+    (0, node_fs_1.chmodSync)(temporary, 0o600);
+    (0, node_fs_1.renameSync)(temporary, destination);
+    (0, node_fs_1.chmodSync)(destination, 0o600);
+}
+function configuredSecretValues(launch) {
+    const names = new Set();
+    const addJsonString = (source) => {
+        try {
+            const name = JSON.parse(source);
+            if (typeof name === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+                names.add(name);
+            }
+        }
+        catch (error) {
+            throw new Error('Codex app-server launch config contained malformed environment quoting', {
+                cause: error,
+            });
+        }
+    };
+    for (const argument of launch.args) {
+        for (const match of argument.matchAll(/env_vars\s*=\s*\[([^\]]*)\]/g)) {
+            for (const quoted of match[1].matchAll(/"(?:\\.|[^"\\])*"/g)) {
+                addJsonString(quoted[0]);
+            }
+        }
+        for (const match of argument.matchAll(/bearer_token_env_var\s*=\s*("(?:\\.|[^"\\])*")/g)) {
+            addJsonString(match[1]);
+        }
+        for (const match of argument.matchAll(/env_http_headers\s*=\s*\{([^}]*)\}/g)) {
+            for (const binding of match[1].matchAll(/=\s*("(?:\\.|[^"\\])*")/g)) {
+                addJsonString(binding[1]);
+            }
+        }
+    }
+    const values = new Set();
+    for (const name of names) {
+        const value = launch.env[name];
+        if (typeof value === 'string' && value.length > 0) {
+            values.add(value);
+        }
+    }
+    return values;
+}
+class CodexAppServerProcess {
+    options;
+    registry;
+    child;
+    stdout;
+    stderr;
+    nextId = 0;
+    pending = new Map();
+    lateTurnStarts = new Map();
+    turnStartReconciliations = new Map();
+    turns = new Map();
+    sessions = new Map();
+    sessionQueues = new Map();
+    connectionQueue = Promise.resolve();
+    startPromise;
+    shutdownPromise;
+    stopped = false;
+    stderrTail = '';
+    secrets = new Set();
+    authFingerprint;
+    authFingerprintInitialized = false;
+    authSourceSignature;
+    managedConfigFingerprint;
+    managedConfigSignature;
+    secretLaunchFingerprint;
+    secretLaunchFingerprintInitialized = false;
+    killTimer;
+    finalKillTimer;
+    constructor(options) {
+        const mamaRoot = (0, node_path_1.join)((0, node_os_1.homedir)(), '.mama');
+        this.options = {
+            ...options,
+            command: options.command ?? 'codex',
+            requestTimeout: options.requestTimeout ?? DEFAULT_TIMEOUT,
+            codexHome: (0, node_path_1.resolve)(options.codexHome ?? (0, node_path_1.join)(mamaRoot, '.codex')),
+            isolatedHome: (0, node_path_1.resolve)(options.isolatedHome ?? (0, node_path_1.join)(mamaRoot, 'codex-runtime', 'home')),
+            registryRoot: (0, node_path_1.resolve)(options.registryRoot ?? (0, node_path_1.join)(mamaRoot, 'codex-runtime', 'threads')),
+            cwd: (0, node_path_1.resolve)(options.cwd),
+        };
+        ensurePrivateDirectory((0, node_path_1.dirname)(this.options.registryRoot));
+        this.registry = new codex_thread_registry_js_1.CodexThreadRegistry({ rootDir: this.options.registryRoot });
+    }
+    async prompt(text, callbacks, overrides = {}) {
+        if (this.stopped) {
+            throw new Error('Codex app-server process is stopped');
+        }
+        const session = this.resolveSessionPolicy(overrides);
+        return this.enqueueSession(session.sessionKey, async () => {
+            try {
+                if (this.stopped) {
+                    throw new Error('Codex app-server process is stopped');
+                }
+                const launch = (0, codex_home_js_1.buildCodexAppServerLaunchConfig)(this.options.mcpConfigPath, process.env);
+                if (overrides.resumeSession === false) {
+                    this.registry.remove(session.sessionKey);
+                    this.sessions.delete(session.sessionKey);
+                }
+                this.assertRegistryPolicy(session, launch);
+                await this.prepareConnection(launch, session.requestTimeout);
+                let state = this.sessions.get(session.sessionKey);
+                if (!state?.threadId) {
+                    try {
+                        state = await this.openThread(session, launch);
+                    }
+                    catch (error) {
+                        if (this.child && !this.shutdownPromise) {
+                            await this.shutdown(this.toError(error));
+                        }
+                        throw error;
+                    }
+                    this.sessions.set(session.sessionKey, state);
+                }
+                const reconciliation = this.turnStartReconciliations.get(state.threadId);
+                if (reconciliation) {
+                    await reconciliation.promise;
+                    await this.prepareConnection(launch, session.requestTimeout);
+                    state = this.sessions.get(session.sessionKey);
+                    if (!state?.threadId) {
+                        state = await this.openThread(session, launch);
+                        this.sessions.set(session.sessionKey, state);
+                    }
+                }
+                const turnText = state.bootstrapPending && session.systemPrompt
+                    ? `<system-reminder>\nFresh MAMA runtime context after resuming this durable thread:\n${session.systemPrompt.replace(/<\/system-reminder>/gi, '')}\n</system-reminder>\n\n${text}`
+                    : text;
+                const result = await this.startTurn(state.threadId, turnText, callbacks, session.requestTimeout, session.hostToolBridge);
+                state.bootstrapPending = false;
+                return result;
+            }
+            catch (error) {
+                if (error instanceof CodexAppServerRpcError &&
+                    error.code !== OVERLOADED_ERROR_CODE &&
+                    this.child &&
+                    !this.shutdownPromise) {
+                    await this.shutdown(error);
+                }
+                if (this.shutdownPromise) {
+                    await this.shutdownPromise;
+                }
+                throw error;
+            }
+        });
+    }
+    async reset(sessionKey = this.options.sessionKey) {
+        await this.enqueueSession(sessionKey, async () => {
+            this.registry.remove(sessionKey);
+            this.sessions.delete(sessionKey);
+        });
+    }
+    async stop() {
+        this.stopped = true;
+        await this.shutdown(new Error('Codex app-server process stopped'));
+    }
+    getThreadId(sessionKey = this.options.sessionKey) {
+        return this.sessions.get(sessionKey)?.threadId || undefined;
+    }
+    getStatus() {
+        return {
+            running: this.child !== undefined,
+            childPid: this.child?.pid,
+            pendingRequestCount: this.pending.size,
+            hasActiveTurn: this.turns.size > 0,
+            stdoutListenerCount: this.stdout?.listenerCount('line') ?? 0,
+            stderrListenerCount: this.stderr?.listenerCount('line') ?? 0,
+            shutdownTimerActive: this.killTimer !== undefined || this.finalKillTimer !== undefined,
+        };
+    }
+    resolveSessionPolicy(overrides) {
+        const hostToolBridge = snapshotHostToolBridge(overrides.hostToolBridge);
+        return {
+            sessionKey: overrides.sessionKey ?? this.options.sessionKey,
+            model: overrides.model ?? this.options.model,
+            systemPrompt: overrides.systemPrompt ?? this.options.systemPrompt,
+            cwd: (0, node_path_1.resolve)(overrides.cwd ?? this.options.cwd),
+            sandbox: overrides.sandbox ?? this.options.sandbox,
+            requestTimeout: overrides.requestTimeout ?? this.options.requestTimeout,
+            policyFingerprint: overrides.policyFingerprint ?? this.options.policyFingerprint,
+            hostToolBridge,
+        };
+    }
+    enqueueSession(sessionKey, operation) {
+        const previous = this.sessionQueues.get(sessionKey) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(operation);
+        const tail = result.then(() => undefined, () => undefined);
+        this.sessionQueues.set(sessionKey, tail);
+        void tail.finally(() => {
+            if (this.sessionQueues.get(sessionKey) === tail) {
+                this.sessionQueues.delete(sessionKey);
+            }
+        });
+        return result;
+    }
+    async prepareConnection(launch, requestTimeout) {
+        const operation = this.connectionQueue.then(async () => {
+            if (this.stopped) {
+                throw new Error('Codex app-server process is stopped');
+            }
+            if (this.shutdownPromise) {
+                await this.shutdownPromise;
+            }
+            if (this.stopped) {
+                throw new Error('Codex app-server process is stopped');
+            }
+            const refreshed = this.prepareManagedFiles(launch);
+            if (refreshed && this.child) {
+                await this.restart();
+            }
+            try {
+                await this.ensureStarted(launch, requestTimeout);
+            }
+            catch (error) {
+                if (this.child && !this.shutdownPromise) {
+                    await this.shutdown(this.toError(error));
+                }
+                throw error;
+            }
+        });
+        this.connectionQueue = operation.catch(() => undefined);
+        await operation;
+    }
+    assertRegistryPolicy(session, launch) {
+        const record = this.registry.load(session.sessionKey);
+        if (!record) {
+            return;
+        }
+        const matches = record.model === session.model &&
+            record.cwd === session.cwd &&
+            record.systemPromptFingerprint === this.policyFingerprint(session) &&
+            record.mcpConfigFingerprint === launch.fingerprint;
+        if (!matches) {
+            throw new Error('Codex app-server thread policy mismatch; reset the session explicitly');
+        }
+    }
+    prepareManagedFiles(launch) {
+        ensurePrivateDirectory(this.options.codexHome);
+        ensurePrivateDirectory(this.options.isolatedHome);
+        const configPath = (0, node_path_1.join)(this.options.codexHome, 'config.toml');
+        const config = (0, codex_home_js_1.buildMAMACodexAppServerConfig)();
+        const configFingerprint = (0, codex_thread_registry_js_1.fingerprintText)(config);
+        const configSignature = managedFileSignature(configPath);
+        if (this.managedConfigFingerprint !== configFingerprint ||
+            this.managedConfigSignature !== configSignature) {
+            if (configSignature === undefined || shaFile(configPath) !== configFingerprint) {
+                atomicPrivateWrite(configPath, config);
+            }
+            this.managedConfigFingerprint = configFingerprint;
+            this.managedConfigSignature = managedFileSignature(configPath);
+        }
+        const sourceAuth = (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex', 'auth.json');
+        const destinationAuth = (0, node_path_1.join)(this.options.codexHome, 'auth.json');
+        const sourceStat = (0, node_fs_1.existsSync)(sourceAuth) ? (0, node_fs_1.statSync)(sourceAuth) : undefined;
+        const sourceSignature = sourceStat && sourceStat.size > 0
+            ? `${(0, node_fs_1.realpathSync)(sourceAuth)}:${sourceStat.size}:${sourceStat.mtimeMs}:${sourceStat.ctimeMs}`
+            : undefined;
+        let sourceFingerprint = this.authFingerprint;
+        if (!this.authFingerprintInitialized ||
+            this.authSourceSignature !== sourceSignature ||
+            (sourceSignature !== undefined && !(0, node_fs_1.existsSync)(destinationAuth))) {
+            sourceFingerprint = sourceSignature ? shaFile(sourceAuth) : undefined;
+            if (sourceFingerprint &&
+                (!(0, node_fs_1.existsSync)(destinationAuth) || shaFile(destinationAuth) !== sourceFingerprint)) {
+                copyAuthAtomically(sourceAuth, destinationAuth);
+            }
+        }
+        const changed = this.authFingerprintInitialized && this.authFingerprint !== sourceFingerprint;
+        this.authFingerprint = sourceFingerprint;
+        this.authFingerprintInitialized = true;
+        this.authSourceSignature = sourceSignature;
+        const secretChanged = this.secretLaunchFingerprintInitialized &&
+            this.secretLaunchFingerprint !== launch.secretFingerprint;
+        if (!this.secretLaunchFingerprintInitialized ||
+            this.secretLaunchFingerprint !== launch.secretFingerprint) {
+            this.secrets = configuredSecretValues(launch);
+            this.secretLaunchFingerprint = launch.secretFingerprint;
+            this.secretLaunchFingerprintInitialized = true;
+        }
+        return changed || secretChanged;
+    }
+    async ensureStarted(launch, requestTimeout) {
+        if (this.child) {
+            return;
+        }
+        if (!this.startPromise) {
+            this.startPromise = this.start(launch, requestTimeout);
+        }
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
+    }
+    async start(launch, requestTimeout) {
+        const child = (0, node_child_process_1.spawn)(this.options.command, ['app-server', '--strict-config', '--stdio', ...launch.args], {
+            cwd: this.options.cwd,
+            env: { ...launch.env, HOME: this.options.isolatedHome, CODEX_HOME: this.options.codexHome },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.stdout = (0, node_readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        this.stderr = (0, node_readline_1.createInterface)({ input: child.stderr, crlfDelay: Infinity });
+        this.stdout.on('line', (line) => this.handleLine(child, line));
+        this.stderr.on('line', (line) => this.handleStderr(line));
+        child.once('error', (error) => this.failProcess(child, error));
+        child.once('exit', (code, signal) => this.failProcess(child, new Error(`Codex app-server exited (${code ?? signal ?? 'unknown'})`)));
+        const initialized = await this.request('initialize', {
+            clientInfo: CLIENT_INFO,
+            capabilities: { experimentalApi: true },
+        }, requestTimeout);
+        const initializeResponse = object(initialized);
+        if (!initializeResponse ||
+            typeof initializeResponse.userAgent !== 'string' ||
+            typeof initializeResponse.codexHome !== 'string' ||
+            typeof initializeResponse.platformFamily !== 'string' ||
+            typeof initializeResponse.platformOs !== 'string') {
+            throw new Error('Codex app-server initialize returned a malformed response');
+        }
+        if ((0, node_fs_1.realpathSync)(initializeResponse.codexHome) !== (0, node_fs_1.realpathSync)(this.options.codexHome)) {
+            throw new Error('Codex app-server initialize returned an unexpected CODEX_HOME');
+        }
+        this.notify('initialized');
+    }
+    async openThread(session, launch) {
+        const record = this.registry.load(session.sessionKey);
+        if (record) {
+            const result = object(await this.request('thread/resume', {
+                threadId: record.threadId,
+                model: session.model,
+                cwd: session.cwd,
+                approvalPolicy: 'never',
+                sandbox: session.sandbox,
+            }, session.requestTimeout));
+            this.validateResponsePolicy(result, session);
+            this.validateInstructionMetadata(result, session);
+            const resumed = validateThread(result?.thread);
+            if (typeof resumed?.id !== 'string' || resumed.id !== record.threadId) {
+                throw new Error('Codex app-server resumed an unexpected thread');
+            }
+            return { threadId: record.threadId, bootstrapPending: true };
+        }
+        const threadStartParams = {
+            model: session.model,
+            cwd: session.cwd,
+            approvalPolicy: 'never',
+            sandbox: session.sandbox,
+            baseInstructions: session.systemPrompt,
+            config: {},
+        };
+        if (session.hostToolBridge) {
+            threadStartParams.dynamicTools = session.hostToolBridge.tools;
+        }
+        const result = object(await this.request('thread/start', threadStartParams, session.requestTimeout));
+        this.validateResponsePolicy(result, session);
+        this.validateInstructionMetadata(result, session);
+        const thread = validateThread(result?.thread);
+        if (typeof thread?.id !== 'string' || !thread.id) {
+            throw new Error('Codex app-server thread/start returned no thread id');
+        }
+        this.registry.save({
+            sessionKey: session.sessionKey,
+            threadId: thread.id,
+            model: session.model,
+            cwd: session.cwd,
+            systemPromptFingerprint: this.policyFingerprint(session),
+            mcpConfigFingerprint: launch.fingerprint,
+        });
+        return { threadId: thread.id, bootstrapPending: false };
+    }
+    policyFingerprint(session) {
+        const base = session.policyFingerprint ?? (0, codex_thread_registry_js_1.fingerprintText)(session.systemPrompt);
+        const tools = session.hostToolBridge?.tools;
+        if (!tools?.length) {
+            return base;
+        }
+        return (0, codex_thread_registry_js_1.fingerprintText)(`${base}\n${JSON.stringify(tools)}`);
+    }
+    validateInstructionMetadata(result, session) {
+        const sources = result?.instructionSources;
+        if (!Array.isArray(sources)) {
+            throw new Error('Codex app-server returned malformed instruction sources');
+        }
+        const managedRoots = [session.cwd, this.options.codexHome].map((root) => (0, node_fs_1.realpathSync)(root));
+        for (const source of sources) {
+            if (typeof source !== 'string') {
+                throw new Error('Codex app-server returned malformed instruction source');
+            }
+            let path;
+            try {
+                path = (0, node_fs_1.realpathSync)((0, node_path_1.resolve)(session.cwd, source));
+            }
+            catch (error) {
+                throw new Error('Codex app-server loaded an instruction source outside managed roots', {
+                    cause: error,
+                });
+            }
+            const allowed = managedRoots.some((root) => {
+                const childPath = (0, node_path_1.relative)(root, path);
+                return (childPath === '' ||
+                    (childPath !== '..' && !childPath.startsWith(`..${node_path_1.sep}`) && !(0, node_path_1.isAbsolute)(childPath)));
+            });
+            if (!allowed) {
+                throw new Error('Codex app-server loaded an instruction source outside managed roots');
+            }
+        }
+    }
+    validateResponsePolicy(result, session) {
+        if (!result) {
+            throw new Error('Codex app-server returned a malformed thread response');
+        }
+        if (typeof result.modelProvider !== 'string' ||
+            (result.serviceTier !== null && typeof result.serviceTier !== 'string') ||
+            !APPROVAL_REVIEWERS.has(String(result.approvalsReviewer)) ||
+            (result.reasoningEffort !== null && typeof result.reasoningEffort !== 'string')) {
+            throw new Error('Codex app-server returned malformed thread response metadata');
+        }
+        if (typeof result.model !== 'string' || result.model !== session.model) {
+            throw new Error('Codex app-server response model did not match the requested policy');
+        }
+        if (typeof result.cwd !== 'string' || (0, node_path_1.resolve)(result.cwd) !== session.cwd) {
+            throw new Error('Codex app-server response cwd did not match the requested policy');
+        }
+        if (result.approvalPolicy !== 'never') {
+            throw new Error('Codex app-server response approval policy was not never');
+        }
+        const sandbox = object(result.sandbox);
+        const expectedSandboxType = {
+            'read-only': 'readOnly',
+            'workspace-write': 'workspaceWrite',
+            'danger-full-access': 'dangerFullAccess',
+        }[session.sandbox];
+        if (typeof sandbox?.type !== 'string' || sandbox.type !== expectedSandboxType) {
+            throw new Error('Codex app-server response sandbox did not match the requested policy');
+        }
+        if (sandbox.type === 'readOnly' && typeof sandbox.networkAccess !== 'boolean') {
+            throw new Error('Codex app-server returned a malformed read-only sandbox policy');
+        }
+        if (sandbox.type === 'workspaceWrite' &&
+            (!Array.isArray(sandbox.writableRoots) ||
+                typeof sandbox.networkAccess !== 'boolean' ||
+                typeof sandbox.excludeTmpdirEnvVar !== 'boolean' ||
+                typeof sandbox.excludeSlashTmp !== 'boolean')) {
+            throw new Error('Codex app-server returned a malformed workspace-write sandbox policy');
+        }
+    }
+    startTurn(threadId, text, callbacks, requestTimeout, hostToolBridge) {
+        return new Promise((resolveTurn, rejectTurn) => {
+            const abortController = new AbortController();
+            const timer = setTimeout(() => {
+                const error = new Error(`Codex app-server turn timed out after ${requestTimeout}ms`);
+                this.timeoutTurn(threadId, error, requestTimeout);
+            }, requestTimeout);
+            timer.unref();
+            const pendingTurn = {
+                threadId,
+                chunks: [],
+                usage: { input_tokens: 0, output_tokens: 0 },
+                timer,
+                queuedNotifications: [],
+                queuedToolRequests: [],
+                toolCallQueue: Promise.resolve(),
+                toolCallResults: new Map(),
+                stoppingCallIds: new Set(),
+                hostToolBridge,
+                abortController,
+                intentionalStop: false,
+                onDelta: callbacks?.onDelta,
+                resolve: resolveTurn,
+                reject: rejectTurn,
+            };
+            this.turns.set(threadId, pendingTurn);
+            this.request('turn/start', {
+                threadId,
+                input: [{ type: 'text', text, text_elements: [] }],
+            }, requestTimeout)
+                .then((value) => {
+                const turn = validateTurn(object(value)?.turn, 'turn/start turn');
+                if (typeof turn?.id !== 'string' || !turn.id) {
+                    this.failTurn(threadId, new Error('Codex app-server turn/start returned no turn id'));
+                    return;
+                }
+                const activeTurn = this.turns.get(threadId);
+                if (activeTurn === pendingTurn) {
+                    activeTurn.turnId = turn.id;
+                    const queued = activeTurn.queuedNotifications.splice(0);
+                    for (const notification of queued) {
+                        this.handleNotification(notification.method, notification.params);
+                    }
+                    const queuedToolRequests = activeTurn.queuedToolRequests.splice(0);
+                    for (const request of queuedToolRequests) {
+                        this.handleDynamicToolRequest(request, activeTurn);
+                    }
+                }
+                else if (this.turnStartReconciliations.has(threadId)) {
+                    void this.reconcileAcknowledgedTurn(threadId, turn.id, requestTimeout);
+                }
+            })
+                .catch((error) => {
+                if (this.turns.get(threadId) === pendingTurn) {
+                    this.failTurn(threadId, this.toError(error));
+                    return;
+                }
+                const reconciliation = this.turnStartReconciliations.get(threadId);
+                if (!reconciliation) {
+                    return;
+                }
+                if (error instanceof CodexAppServerRpcError) {
+                    this.completeTurnStartReconciliation(threadId, reconciliation);
+                }
+                else if (!reconciliation.recoveryTimer) {
+                    void this.shutdown(this.toError(error)).finally(() => {
+                        this.completeTurnStartReconciliation(threadId, reconciliation);
+                    });
+                }
+            });
+        });
+    }
+    async request(method, params, requestTimeout = this.options.requestTimeout) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.requestOnce(method, params, requestTimeout);
+            }
+            catch (error) {
+                if (!(error instanceof CodexAppServerRpcError) ||
+                    error.code !== OVERLOADED_ERROR_CODE ||
+                    attempt >= OVERLOAD_RETRY_LIMIT - 1) {
+                    throw error;
+                }
+                const delay = OVERLOAD_RETRY_BASE_MS * 2 ** attempt + Math.floor(Math.random() * 10);
+                await new Promise((resolveDelay) => {
+                    const timer = setTimeout(resolveDelay, delay);
+                    timer.unref();
+                });
+            }
+        }
+    }
+    requestOnce(method, params, requestTimeout) {
+        const child = this.child;
+        if (!child?.stdin.writable) {
+            return Promise.reject(new Error('Codex app-server stdin is not writable'));
+        }
+        const id = ++this.nextId;
+        return new Promise((resolveRequest, rejectRequest) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                const error = new Error(`Codex app-server ${method} timed out after ${requestTimeout}ms`);
+                const threadId = method === 'turn/start' ? object(params)?.threadId : undefined;
+                if (typeof threadId === 'string' && threadId) {
+                    const reconciliation = this.getOrCreateTurnStartReconciliation(threadId);
+                    reconciliation.recoveryTimer = setTimeout(() => {
+                        this.lateTurnStarts.delete(id);
+                        void this.shutdown(error).finally(() => {
+                            this.completeTurnStartReconciliation(threadId, reconciliation);
+                        });
+                    }, Math.max(requestTimeout, TURN_START_RECONCILE_GRACE_MS));
+                    reconciliation.recoveryTimer.unref();
+                    this.lateTurnStarts.set(id, { threadId, requestTimeout, reconciliation });
+                    rejectRequest(error);
+                    return;
+                }
+                rejectRequest(error);
+                void this.shutdown(error);
+            }, requestTimeout);
+            timer.unref();
+            this.pending.set(id, { method, timer, resolve: resolveRequest, reject: rejectRequest });
+            child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        });
+    }
+    notify(method, params) {
+        if (!this.child?.stdin.writable) {
+            throw new Error('Codex app-server stdin is not writable');
+        }
+        const message = params === undefined ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', method, params };
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    handleLine(child, line) {
+        if (child !== this.child || !line.trim()) {
+            return;
+        }
+        let message;
+        try {
+            const parsed = JSON.parse(line);
+            const record = object(parsed);
+            if (!record) {
+                throw new Error('not an object');
+            }
+            message = record;
+        }
+        catch {
+            const error = new Error('Codex app-server emitted malformed JSON');
+            this.failAll(error);
+            void this.shutdown(error);
+            return;
+        }
+        // Codex 0.144 accepts JSON-RPC 2.0 requests but omits the `jsonrpc`
+        // member from its responses and notifications on the stdio wire.
+        if (message.jsonrpc !== undefined && message.jsonrpc !== '2.0') {
+            const error = new Error('Codex app-server emitted a malformed protocol message');
+            this.failAll(error);
+            void this.shutdown(error);
+            return;
+        }
+        const hasMethod = typeof message.method === 'string';
+        const hasResult = Object.hasOwn(message, 'result');
+        const hasError = Object.hasOwn(message, 'error');
+        const hasRequestId = typeof message.id === 'number' || typeof message.id === 'string';
+        const serverRequest = hasMethod && hasRequestId && !hasResult && !hasError;
+        const notification = hasMethod && !hasRequestId && !hasResult && !hasError;
+        const response = !hasMethod && typeof message.id === 'number' && hasResult !== hasError;
+        if ([serverRequest, notification, response].filter(Boolean).length !== 1) {
+            const error = new Error('Codex app-server emitted a malformed protocol message');
+            this.failAll(error);
+            void this.shutdown(error);
+            return;
+        }
+        if (typeof message.method === 'string' &&
+            (typeof message.id === 'number' || typeof message.id === 'string')) {
+            this.handleServerRequest(child, message.id, message.method, message.params);
+            return;
+        }
+        if (typeof message.id === 'number') {
+            const lateTurnStart = this.lateTurnStarts.get(message.id);
+            if (lateTurnStart) {
+                this.handleLateTurnStartResponse(message.id, lateTurnStart, message);
+                return;
+            }
+            const pending = this.pending.get(message.id);
+            if (!pending) {
+                const error = new Error('Codex app-server response id did not match a pending request');
+                this.failAll(error);
+                void this.shutdown(error);
+                return;
+            }
+            clearTimeout(pending.timer);
+            this.pending.delete(message.id);
+            if (message.error !== undefined) {
+                const rpcError = object(message.error);
+                const code = typeof rpcError?.code === 'number' ? rpcError.code : 0;
+                pending.reject(new CodexAppServerRpcError(code, this.redact(errorMessage(message.error, `${pending.method} failed`))));
+            }
+            else if (!Object.hasOwn(message, 'result')) {
+                pending.reject(new Error(`Codex app-server ${pending.method} returned a malformed response`));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (typeof message.method === 'string') {
+            this.handleNotification(message.method, message.params);
+        }
+    }
+    handleNotification(method, params) {
+        const data = object(params);
+        if (!data || typeof data.threadId !== 'string') {
+            return;
+        }
+        const turn = this.turns.get(data.threadId);
+        if (!turn) {
+            return;
+        }
+        const completedTurn = method === 'turn/completed' ? object(data.turn) : undefined;
+        const eventTurnId = typeof data.turnId === 'string'
+            ? data.turnId
+            : typeof completedTurn?.id === 'string'
+                ? completedTurn.id
+                : undefined;
+        if (eventTurnId && !turn.turnId) {
+            turn.queuedNotifications.push({ method, params });
+            return;
+        }
+        if (eventTurnId && eventTurnId !== turn.turnId) {
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            if (typeof data.turnId !== 'string' || data.turnId !== turn.turnId) {
+                return;
+            }
+            if (typeof data.delta === 'string') {
+                turn.chunks.push(data.delta);
+                try {
+                    turn.onDelta?.(data.delta);
+                }
+                catch (error) {
+                    this.failTurn(turn.threadId, this.toError(error));
+                }
+            }
+            return;
+        }
+        if (method === 'thread/tokenUsage/updated') {
+            if (typeof data.turnId !== 'string' || data.turnId !== turn.turnId) {
+                return;
+            }
+            const last = object(object(data.tokenUsage)?.last);
+            turn.usage = {
+                input_tokens: typeof last?.inputTokens === 'number' ? last.inputTokens : 0,
+                output_tokens: typeof last?.outputTokens === 'number' ? last.outputTokens : 0,
+                cache_read_input_tokens: typeof last?.cachedInputTokens === 'number' ? last.cachedInputTokens : undefined,
+            };
+            return;
+        }
+        if (method !== 'turn/completed') {
+            return;
+        }
+        const completed = completedTurn;
+        if (!completed ||
+            typeof completed.id !== 'string' ||
+            (turn.turnId && completed.id !== turn.turnId))
+            return;
+        const status = completed.status;
+        if (status === 'inProgress') {
+            return;
+        }
+        try {
+            validateTurn(completed, 'turn/completed turn');
+        }
+        catch (error) {
+            this.failTurn(turn.threadId, this.toError(error));
+            return;
+        }
+        if (turn.abortError) {
+            this.failTurn(turn.threadId, turn.abortError);
+            return;
+        }
+        if (status === 'failed') {
+            this.failTurn(turn.threadId, new Error(this.redact(errorMessage(completed.error, 'Codex app-server turn failed'))));
+            return;
+        }
+        if (status === 'interrupted') {
+            if (turn.abortError) {
+                this.failTurn(turn.threadId, turn.abortError);
+            }
+            else if (turn.intentionalStop) {
+                this.resolveTurn(turn);
+            }
+            else {
+                this.failTurn(turn.threadId, new Error('Codex app-server turn was interrupted'));
+            }
+            return;
+        }
+        if (status !== 'completed') {
+            this.failTurn(turn.threadId, new Error(`Codex app-server returned unknown turn status: ${String(status)}`));
+            return;
+        }
+        this.resolveTurn(turn);
+    }
+    resolveTurn(turn) {
+        if (this.turns.get(turn.threadId) !== turn) {
+            return;
+        }
+        this.turns.delete(turn.threadId);
+        clearTimeout(turn.timer);
+        this.clearTurnCallbacks(turn);
+        turn.resolve({
+            response: turn.chunks.join(''),
+            usage: turn.usage,
+            session_id: turn.threadId,
+            toolUseBlocks: undefined,
+            hasToolUse: false,
+        });
+    }
+    handleServerRequest(child, id, method, params) {
+        if (method === 'item/tool/call') {
+            this.handleDynamicToolRequest({ child, id, params });
+            return;
+        }
+        const bodies = {
+            'item/tool/requestUserInput': { answers: {} },
+            'mcpServer/elicitation/request': { action: 'decline', content: null, _meta: null },
+            'item/commandExecution/requestApproval': { decision: 'decline' },
+            'item/fileChange/requestApproval': { decision: 'decline' },
+            'item/permissions/requestApproval': {
+                permissions: {},
+                scope: 'turn',
+                strictAutoReview: true,
+            },
+            applyPatchApproval: { decision: 'denied' },
+            execCommandApproval: { decision: 'denied' },
+        };
+        if (Object.hasOwn(bodies, method)) {
+            this.reply(child, { jsonrpc: '2.0', id, result: bodies[method] });
+        }
+        else {
+            this.reply(child, {
+                jsonrpc: '2.0',
+                id,
+                error: { code: -32601, message: `Unsupported app-server request: ${method}` },
+            });
+        }
+    }
+    handleDynamicToolRequest(request, expectedTurn) {
+        const data = object(request.params);
+        const threadId = typeof data?.threadId === 'string' ? data.threadId : undefined;
+        const turn = threadId ? this.turns.get(threadId) : undefined;
+        if (!data || !turn || !turn.hostToolBridge || (expectedTurn && turn !== expectedTurn)) {
+            this.replyDisabledTool(request);
+            return;
+        }
+        try {
+            const turnId = this.requiredToolString(data, 'turnId');
+            const callId = this.requiredToolString(data, 'callId');
+            const tool = this.requiredToolString(data, 'tool');
+            if (data.namespace !== null && typeof data.namespace !== 'string') {
+                throw new Error('Codex app-server tool call namespace must be null or a string');
+            }
+            const input = object(data.arguments);
+            if (!input) {
+                throw new Error('Codex app-server tool call arguments must be an object');
+            }
+            if (!turn.hostToolBridge.tools.some((definition) => definition.name === tool)) {
+                throw new Error(`Codex app-server tool call ${tool} was not advertised`);
+            }
+            if (!turn.turnId) {
+                turn.queuedToolRequests.push(request);
+                return;
+            }
+            if (turnId !== turn.turnId) {
+                this.failToolProtocol(request, turn, new Error('Codex app-server tool call did not match the active turn'));
+                return;
+            }
+            this.dispatchDynamicToolCall(request, turn, callId, tool, data.namespace, input);
+        }
+        catch (error) {
+            this.failToolProtocol(request, turn, this.toError(error));
+        }
+    }
+    failToolProtocol(request, turn, error) {
+        const failure = this.toError(error);
+        this.replyToolError(request, failure.message);
+        this.failTurn(turn.threadId, failure);
+        if (this.child === request.child && !this.shutdownPromise) {
+            void this.shutdown(failure);
+        }
+    }
+    requiredToolString(data, field) {
+        const value = data[field];
+        if (typeof value !== 'string' || !value) {
+            throw new Error(`Codex app-server tool call ${field} must be a string`);
+        }
+        return value;
+    }
+    dispatchDynamicToolCall(request, turn, callId, tool, namespace, input) {
+        const identity = JSON.stringify(stableJson({
+            threadId: turn.threadId,
+            turnId: turn.turnId,
+            tool,
+            namespace,
+            arguments: input,
+        }));
+        const existing = turn.toolCallResults.get(callId);
+        if (existing && existing.identity !== identity) {
+            throw new Error(`Codex app-server callId ${callId} had a conflicting request`);
+        }
+        let execution = existing?.execution;
+        if (!execution) {
+            const bridge = turn.hostToolBridge;
+            if (!bridge) {
+                this.replyDisabledTool(request);
+                return;
+            }
+            execution = turn.toolCallQueue
+                .then(async () => {
+                if (!this.isToolTurnActive(request, turn)) {
+                    return {
+                        result: this.toolResult(false, 'Codex app-server tool call is no longer active'),
+                        stop: false,
+                        abortError: undefined,
+                    };
+                }
+                let result;
+                try {
+                    result = await bridge.execute({
+                        callId,
+                        name: tool,
+                        input,
+                        signal: turn.abortController.signal,
+                    });
+                }
+                catch (error) {
+                    result = { content: this.toError(error).message, isError: true };
+                }
+                const resultData = object(result);
+                if (!resultData ||
+                    typeof resultData.content !== 'string' ||
+                    typeof resultData.isError !== 'boolean') {
+                    return {
+                        result: this.toolResult(false, 'Host tool returned a malformed result'),
+                        stop: false,
+                        abortError: undefined,
+                    };
+                }
+                const abortError = resultData.abort === true && resultData.isError
+                    ? new Error(resultData.content)
+                    : undefined;
+                return {
+                    result: this.toolResult(!resultData.isError, resultData.content),
+                    stop: resultData.stop === true && !resultData.isError,
+                    abortError,
+                };
+            })
+                .catch((error) => ({
+                result: this.toolResult(false, this.toError(error).message),
+                stop: false,
+                abortError: undefined,
+            }));
+            turn.toolCallResults.set(callId, { identity, execution });
+            turn.toolCallQueue = execution.then(() => undefined, () => undefined);
+        }
+        void execution.then(({ result, stop, abortError }) => {
+            if (!this.isToolTurnActive(request, turn)) {
+                if (this.child === request.child) {
+                    this.replyToolError(request, 'Codex app-server tool call is no longer active');
+                }
+                return;
+            }
+            this.reply(request.child, { jsonrpc: '2.0', id: request.id, result });
+            if (abortError && !turn.stoppingCallIds.has(callId)) {
+                turn.stoppingCallIds.add(callId);
+                turn.abortError = abortError;
+                void this.request('turn/interrupt', { threadId: turn.threadId, turnId: turn.turnId }).catch((error) => this.failTurn(turn.threadId, this.toError(error)));
+            }
+            else if (stop && !turn.stoppingCallIds.has(callId)) {
+                turn.stoppingCallIds.add(callId);
+                turn.intentionalStop = true;
+                void this.request('turn/interrupt', { threadId: turn.threadId, turnId: turn.turnId }).catch((error) => this.failTurn(turn.threadId, this.toError(error)));
+            }
+        });
+    }
+    isToolTurnActive(request, turn) {
+        return (this.child === request.child &&
+            this.turns.get(turn.threadId) === turn &&
+            !turn.intentionalStop &&
+            !turn.abortError &&
+            !turn.abortController.signal.aborted);
+    }
+    toolResult(success, content) {
+        return { success, contentItems: [{ type: 'inputText', text: content }] };
+    }
+    replyDisabledTool(request) {
+        this.reply(request.child, {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: this.toolResult(false, 'Native app-server tools are disabled by MAMA'),
+        });
+    }
+    replyToolError(request, message) {
+        this.reply(request.child, {
+            jsonrpc: '2.0',
+            id: request.id,
+            error: { code: -32602, message },
+        });
+    }
+    reply(child, message) {
+        if (child.stdin.writable) {
+            child.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+    }
+    handleStderr(line) {
+        this.stderrTail = `${this.stderrTail}${this.redact(line)}\n`.slice(-STDERR_LIMIT);
+    }
+    redact(value) {
+        let result = value;
+        for (const secret of this.secrets) {
+            result = result.split(secret).join('[REDACTED]');
+        }
+        return result;
+    }
+    toError(error) {
+        return error instanceof Error
+            ? new Error(this.redact(error.message))
+            : new Error(this.redact(String(error)));
+    }
+    failTurn(threadId, error) {
+        const turn = this.turns.get(threadId);
+        if (!turn) {
+            return;
+        }
+        this.turns.delete(threadId);
+        clearTimeout(turn.timer);
+        turn.abortController.abort(error);
+        turn.queuedNotifications.length = 0;
+        turn.queuedToolRequests.length = 0;
+        const safe = this.toError(error);
+        // A gateway mutation that cannot be interrupted must settle before the
+        // caller sees failure. This prevents retries from racing a late mutation.
+        void turn.toolCallQueue.finally(() => {
+            this.clearTurnCallbacks(turn);
+            turn.reject(safe);
+        });
+    }
+    timeoutTurn(threadId, error, requestTimeout) {
+        const turn = this.turns.get(threadId);
+        if (!turn) {
+            return;
+        }
+        const turnId = turn.turnId;
+        if (!turnId) {
+            this.getOrCreateTurnStartReconciliation(threadId);
+        }
+        this.failTurn(threadId, error);
+        if (!turnId) {
+            return;
+        }
+        void this.request('turn/interrupt', { threadId, turnId }, requestTimeout).catch((interruptError) => {
+            if (this.child && !this.shutdownPromise) {
+                void this.shutdown(this.toError(interruptError));
+            }
+        });
+    }
+    getOrCreateTurnStartReconciliation(threadId) {
+        const existing = this.turnStartReconciliations.get(threadId);
+        if (existing) {
+            return existing;
+        }
+        let resolveReconciliation;
+        const promise = new Promise((resolvePromise) => {
+            resolveReconciliation = resolvePromise;
+        });
+        const reconciliation = {
+            promise,
+            resolve: () => resolveReconciliation?.(),
+        };
+        this.turnStartReconciliations.set(threadId, reconciliation);
+        return reconciliation;
+    }
+    completeTurnStartReconciliation(threadId, reconciliation) {
+        if (this.turnStartReconciliations.get(threadId) !== reconciliation) {
+            return;
+        }
+        if (reconciliation.recoveryTimer) {
+            clearTimeout(reconciliation.recoveryTimer);
+            reconciliation.recoveryTimer = undefined;
+        }
+        this.turnStartReconciliations.delete(threadId);
+        reconciliation.resolve();
+    }
+    async reconcileAcknowledgedTurn(threadId, turnId, requestTimeout) {
+        const reconciliation = this.turnStartReconciliations.get(threadId);
+        if (!reconciliation) {
+            return;
+        }
+        try {
+            await this.request('turn/interrupt', { threadId, turnId }, requestTimeout);
+            this.completeTurnStartReconciliation(threadId, reconciliation);
+        }
+        catch (error) {
+            await this.shutdown(this.toError(error));
+            this.completeTurnStartReconciliation(threadId, reconciliation);
+        }
+    }
+    handleLateTurnStartResponse(id, late, message) {
+        this.lateTurnStarts.delete(id);
+        if (late.reconciliation.recoveryTimer) {
+            clearTimeout(late.reconciliation.recoveryTimer);
+            late.reconciliation.recoveryTimer = undefined;
+        }
+        if (message.error !== undefined) {
+            this.completeTurnStartReconciliation(late.threadId, late.reconciliation);
+            return;
+        }
+        try {
+            const turn = validateTurn(object(message.result)?.turn, 'late turn/start turn');
+            if (typeof turn?.id !== 'string' || !turn.id) {
+                throw new Error('Codex app-server late turn/start returned no turn id');
+            }
+            void this.reconcileAcknowledgedTurn(late.threadId, turn.id, late.requestTimeout);
+        }
+        catch (error) {
+            void this.shutdown(this.toError(error)).finally(() => {
+                this.completeTurnStartReconciliation(late.threadId, late.reconciliation);
+            });
+        }
+    }
+    clearTurnCallbacks(turn) {
+        turn.queuedNotifications.length = 0;
+        turn.queuedToolRequests.length = 0;
+        turn.toolCallResults.clear();
+        turn.stoppingCallIds.clear();
+        turn.hostToolBridge = undefined;
+        turn.onDelta = undefined;
+    }
+    failAll(error) {
+        const safe = this.toError(error);
+        for (const threadId of [...this.turns.keys()]) {
+            this.failTurn(threadId, safe);
+        }
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            this.pending.delete(id);
+            pending.reject(safe);
+        }
+    }
+    failProcess(child, error) {
+        if (child !== this.child) {
+            return;
+        }
+        const suffix = this.stderrTail ? `: ${this.stderrTail}` : '';
+        this.failAll(new Error(this.redact(`${error.message}${suffix}`)));
+        this.detach(child);
+    }
+    async restart() {
+        await this.shutdown(new Error('Codex app-server restarting after auth refresh'));
+        this.sessions.clear();
+    }
+    async shutdown(reason) {
+        if (this.shutdownPromise) {
+            return this.shutdownPromise;
+        }
+        const operation = this.performShutdown(reason);
+        this.shutdownPromise = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (this.shutdownPromise === operation) {
+                this.shutdownPromise = undefined;
+            }
+        }
+    }
+    async performShutdown(reason) {
+        const child = this.child;
+        if (!child) {
+            return;
+        }
+        this.failAll(reason);
+        await new Promise((resolveStop) => {
+            let settled = false;
+            const finish = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (this.killTimer) {
+                    clearTimeout(this.killTimer);
+                    this.killTimer = undefined;
+                }
+                if (this.finalKillTimer) {
+                    clearTimeout(this.finalKillTimer);
+                    this.finalKillTimer = undefined;
+                }
+                this.detach(child);
+                resolveStop();
+            };
+            child.once('exit', finish);
+            child.kill('SIGTERM');
+            this.killTimer = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill('SIGKILL');
+                }
+                this.killTimer = undefined;
+                this.finalKillTimer = setTimeout(finish, STOP_GRACE_MS);
+                this.finalKillTimer.unref();
+            }, STOP_GRACE_MS);
+            this.killTimer.unref();
+            if (child.exitCode !== null || child.signalCode !== null) {
+                finish();
+            }
+        });
+    }
+    detach(child) {
+        if (this.child !== child) {
+            return;
+        }
+        this.stdout?.close();
+        this.stderr?.close();
+        child.removeAllListeners();
+        child.stdin.removeAllListeners();
+        child.stdout.removeAllListeners();
+        child.stderr.removeAllListeners();
+        this.stdout = undefined;
+        this.stderr = undefined;
+        this.child = undefined;
+        this.sessions.clear();
+        this.lateTurnStarts.clear();
+        for (const [threadId, reconciliation] of this.turnStartReconciliations) {
+            this.completeTurnStartReconciliation(threadId, reconciliation);
+        }
+    }
+}
+exports.CodexAppServerProcess = CodexAppServerProcess;
+//# sourceMappingURL=codex-app-server-process.js.map