@straiffi/archon 1.10.12 → 1.11.0

package/dist/server/lib/codexAppServer.js

@@ -0,0 +1,678 @@
+const DEFAULT_MAX_FRAME_BYTES = 32 * 1024 * 1024;
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+const INTERRUPT_REQUEST_TIMEOUT_MS = 1_000;
+export class CodexAppServerError extends Error {
+    code;
+    constructor(message, code = null) {
+        super(message);
+        this.name = 'CodexAppServerError';
+        this.code = code;
+    }
+}
+const isObject = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value));
+const asString = (value) => typeof value === 'string' && value.trim() ? value : null;
+const asText = (value) => typeof value === 'string' && value.length > 0 ? value : null;
+const asNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : null;
+const asMessagePhase = (value) => value === 'commentary' || value === 'final_answer' ? value : null;
+const asHttpUrl = (value) => {
+    const text = asString(value);
+    if (!text) {
+        return null;
+    }
+    try {
+        const url = new URL(text);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const redactCodexDiagnostic = (value) => value
+    .replace(/(\bauthorization\b\s*[:=]\s*["']?)(?:bearer|basic|token|apikey)\s+[^\s,"'};]+/gi, '$1[REDACTED]')
+    .replace(/(\b(?:bearer|basic|token|apikey)\s+)[A-Za-z0-9._~+/=-]+/gi, '$1[REDACTED]')
+    .replace(/(["']?\b(?:[a-z][a-z0-9]*_)*(?:api[_-]?key|client[_-]?secret|secret[_-]?access[_-]?key|authorization|auth[_-]?token|access[_-]?token|refresh[_-]?token|id[_-]?token)["']?\s*[:=]\s*)(["'])[^"']*\2/gi, '$1$2[REDACTED]$2')
+    .replace(/(["']?\b(?:[a-z][a-z0-9]*_)*(?:api[_-]?key|client[_-]?secret|secret[_-]?access[_-]?key|authorization|auth[_-]?token|access[_-]?token|refresh[_-]?token|id[_-]?token)["']?\s*[:=]\s*)[^\s,;}]+/gi, '$1[REDACTED]')
+    .replace(/\b(?:sk|sess|pat|key)-[A-Za-z0-9_-]{8,}\b/gi, '[REDACTED]')
+    .replace(/\b(?:github_pat_[A-Za-z0-9_]{20,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|npm_[A-Za-z0-9]{20,}|AIza[A-Za-z0-9_-]{20,}|(?:AKIA|ASIA)[A-Z0-9]{16})\b/g, '[REDACTED]')
+    .replace(/\b(?:[sr]k_(?:live|test)_[A-Za-z0-9]{12,}|SG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,})\b/g, '[REDACTED]')
+    .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, '[REDACTED]')
+    .replace(/\bsynthetic-[A-Za-z0-9_-]*?(?:secret|token|key)[A-Za-z0-9_-]*-canary\b/gi, '[REDACTED]');
+const getObject = (value, key) => {
+    if (!isObject(value)) {
+        return null;
+    }
+    const nested = value[key];
+    return isObject(nested) ? nested : null;
+};
+const getTurnError = (turn) => {
+    const error = getObject(turn, 'error');
+    return asString(error?.message) ?? asString(error?.additionalDetails);
+};
+const summarizeTool = (item) => {
+    const itemType = asString(item.type) ?? 'tool';
+    if (itemType === 'commandExecution') {
+        return { name: 'command', input: { command: asString(item.command) ?? '', cwd: asString(item.cwd) ?? '' } };
+    }
+    if (itemType === 'fileChange') {
+        return { name: 'fileChange', input: { changes: Array.isArray(item.changes) ? item.changes : [] } };
+    }
+    if (itemType === 'webSearch') {
+        const action = isObject(item.action) ? item.action : null;
+        const actionType = asString(action?.type);
+        const operation = actionType === 'openPage' || actionType === 'open_page'
+            ? 'open_page'
+            : actionType === 'findInPage' || actionType === 'find_in_page'
+                ? 'find_in_page'
+                : actionType === 'search' ? 'search' : null;
+        const actionQueries = Array.isArray(action?.queries)
+            ? action.queries.flatMap(query => asString(query) ?? [])
+            : [];
+        const actionQuery = asString(action?.query);
+        const itemQuery = asString(item.query);
+        const queries = [...new Set([
+                ...actionQueries,
+                ...(actionQuery ? [actionQuery] : []),
+                ...(itemQuery ? [itemQuery] : []),
+            ])];
+        const results = Array.isArray(item.results) ? item.results.flatMap(result => {
+            if (!isObject(result)) {
+                return [];
+            }
+            const url = asHttpUrl(result.url);
+            if (!url) {
+                return [];
+            }
+            const refId = asString(result.ref_id) ?? asString(result.refId);
+            return [{ url, ...(refId ? { refId } : {}) }];
+        }) : [];
+        const url = asHttpUrl(action?.url);
+        return {
+            name: 'webSearch',
+            input: {
+                ...(operation ? { operation } : {}),
+                ...(queries.length === 1 ? { query: queries[0] } : {}),
+                ...(queries.length > 1 ? { queries } : {}),
+                ...(url ? { url } : {}),
+                ...(asString(action?.pattern) ? { pattern: asString(action?.pattern) } : {}),
+                ...(results.length > 0 ? { results } : {}),
+            },
+        };
+    }
+    if (itemType === 'mcpToolCall' || itemType === 'dynamicToolCall') {
+        return {
+            name: asString(item.tool) ?? itemType,
+            input: isObject(item.arguments) ? item.arguments : {},
+        };
+    }
+    return { name: itemType, input: {} };
+};
+const summarizeToolOutput = (item) => {
+    return asString(item.aggregatedOutput)
+        ?? asString(item.error)
+        ?? (item.result === undefined ? '' : JSON.stringify(item.result));
+};
+const getSubagentStatus = (value) => {
+    if (value === 'completed') {
+        return 'done';
+    }
+    if (value === 'failed') {
+        return 'error';
+    }
+    if (value === 'interrupted') {
+        return 'stopped';
+    }
+    return 'running';
+};
+export class CodexAppServer {
+    child;
+    input;
+    output;
+    maxFrameBytes;
+    requestTimeoutMs;
+    onEvent;
+    pending = new Map();
+    nextId = 1;
+    frameChunks = [];
+    frameBytes = 0;
+    closed = false;
+    initialized = false;
+    threadId = null;
+    turnId = null;
+    messageItems = new Map();
+    planItems = new Map();
+    pendingTurnCompletion = null;
+    terminal = null;
+    resolveOutcome = null;
+    outcomePromise;
+    constructor(child, options = {}) {
+        if (!child.stdin || !child.stdout) {
+            throw new CodexAppServerError('Codex app-server requires piped stdin and stdout.');
+        }
+        this.child = child;
+        this.input = child.stdin;
+        this.output = child.stdout;
+        this.maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.onEvent = options.onEvent ?? (() => { });
+        this.outcomePromise = new Promise(resolve => {
+            this.resolveOutcome = resolve;
+        });
+        this.output.on('data', this.handleData);
+        this.input.on('error', this.handleInputError);
+        child.once('close', this.handleClose);
+        child.once('error', this.handleProcessError);
+    }
+    handleData = (chunk) => {
+        if (this.closed) {
+            return;
+        }
+        const data = Buffer.from(chunk);
+        let offset = 0;
+        while (offset < data.length) {
+            const newline = data.indexOf(0x0a, offset);
+            const end = newline === -1 ? data.length : newline;
+            const segment = data.subarray(offset, end);
+            if (this.frameBytes + segment.length > this.maxFrameBytes) {
+                this.failTransport(this.createFrameLimitError());
+                return;
+            }
+            if (segment.length > 0) {
+                this.frameChunks.push(segment);
+                this.frameBytes += segment.length;
+            }
+            if (newline === -1) {
+                return;
+            }
+            const frame = this.frameChunks.length === 1
+                ? this.frameChunks[0]
+                : Buffer.concat(this.frameChunks, this.frameBytes);
+            this.frameChunks = [];
+            this.frameBytes = 0;
+            offset = newline + 1;
+            if (frame.length > 0) {
+                this.handleFrame(frame.toString('utf8'));
+                if (this.closed) {
+                    return;
+                }
+            }
+        }
+    };
+    createFrameLimitError() {
+        const methods = [...new Set([...this.pending.values()].map(request => request.method))];
+        const operation = methods.length === 1 ? ` while awaiting \"${methods[0]}\"` : '';
+        return new CodexAppServerError(`Codex app-server frame exceeded ${this.maxFrameBytes} bytes${operation}.`);
+    }
+    handleFrame(frame) {
+        let message;
+        try {
+            message = JSON.parse(frame);
+        }
+        catch {
+            this.failTransport(new CodexAppServerError('Codex app-server returned malformed JSON.'));
+            return;
+        }
+        if (!isObject(message)) {
+            this.failTransport(new CodexAppServerError('Codex app-server returned a non-object frame.'));
+            return;
+        }
+        if ((typeof message.id === 'string' || typeof message.id === 'number') && !asString(message.method)) {
+            this.handleResponse(message.id, message);
+            return;
+        }
+        const method = asString(message.method);
+        if (!method) {
+            return;
+        }
+        if (typeof message.id === 'string' || typeof message.id === 'number') {
+            this.handleServerRequest(message.id, method, isObject(message.params) ? message.params : {});
+            return;
+        }
+        this.handleNotification(method, isObject(message.params) ? message.params : {});
+    }
+    handleResponse(id, message) {
+        const request = this.pending.get(id);
+        if (!request) {
+            return;
+        }
+        this.pending.delete(id);
+        clearTimeout(request.timer);
+        const error = getObject(message, 'error');
+        if (error) {
+            request.reject(new CodexAppServerError(redactCodexDiagnostic(asString(error.message) ?? 'Codex app-server request failed.'), asNumber(error.code)));
+            return;
+        }
+        if (request.method === 'thread/start' || request.method === 'thread/resume') {
+            const threadId = asString(getObject(message.result, 'thread')?.id);
+            if (threadId) {
+                this.threadId = threadId;
+            }
+        }
+        else if (request.method === 'turn/start') {
+            const turnId = asString(getObject(message.result, 'turn')?.id);
+            if (turnId) {
+                this.turnId = turnId;
+            }
+        }
+        request.resolve(message.result);
+        if (request.method === 'turn/start' && this.pendingTurnCompletion) {
+            const pendingTurnCompletion = this.pendingTurnCompletion;
+            this.pendingTurnCompletion = null;
+            this.handleNotification('turn/completed', pendingTurnCompletion);
+        }
+    }
+    handleServerRequest(id, method, params) {
+        if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval') {
+            this.send({ id, result: { decision: 'decline' } });
+            return;
+        }
+        if (method === 'mcpServer/elicitation/request') {
+            this.send({ id, result: { action: 'decline', content: null, _meta: null } });
+            return;
+        }
+        if (method === 'item/tool/requestUserInput') {
+            const questions = Array.isArray(params.questions)
+                ? params.questions.flatMap(question => {
+                    if (!isObject(question)) {
+                        return [];
+                    }
+                    const questionId = asString(question.id);
+                    const questionText = asString(question.question);
+                    if (!questionId || !questionText) {
+                        return [];
+                    }
+                    const options = Array.isArray(question.options)
+                        ? question.options.flatMap(option => isObject(option) && asString(option.label) ? [asString(option.label)] : [])
+                        : [];
+                    return [{ id: questionId, question: questionText, suggestions: options }];
+                })
+                : [];
+            if (questions.length > 0) {
+                this.onEvent({ type: 'clarification', questions });
+            }
+            this.send({ id, result: { answers: {} } });
+            return;
+        }
+        if (method === 'item/permissions/requestApproval' || method === 'account/chatgptAuthTokens/refresh') {
+            this.send({ id, error: { code: -32601, message: 'Archon does not support this Codex request.' } });
+            return;
+        }
+        this.send({ id, error: { code: -32601, message: 'Unsupported Codex app-server request.' } });
+    }
+    handleNotification(method, params) {
+        if (this.terminal) {
+            return;
+        }
+        if (this.threadId && asString(params.threadId) && params.threadId !== this.threadId) {
+            return;
+        }
+        if (this.turnId && asString(params.turnId) && params.turnId !== this.turnId) {
+            return;
+        }
+        if (method === 'item/agentMessage/delta' || method === 'item/plan/delta') {
+            const text = asText(params.delta);
+            if (text) {
+                const itemId = asString(params.itemId);
+                if (method === 'item/plan/delta') {
+                    if (itemId) {
+                        this.planItems.set(itemId, `${this.planItems.get(itemId) ?? ''}${text}`);
+                    }
+                    this.onEvent({ type: 'plan-update', itemId, text });
+                }
+                else {
+                    const item = itemId ? this.messageItems.get(itemId) : null;
+                    if (itemId) {
+                        this.messageItems.set(itemId, { phase: item?.phase ?? null, text: `${item?.text ?? ''}${text}` });
+                    }
+                    this.onEvent({ type: 'agent-message-delta', itemId, text, phase: item?.phase ?? null });
+                }
+            }
+            return;
+        }
+        if (method === 'item/reasoning/summaryTextDelta' || method === 'item/reasoning/textDelta') {
+            const text = asText(params.delta);
+            if (text) {
+                const summaryIndex = method === 'item/reasoning/summaryTextDelta'
+                    ? asNumber(params.summaryIndex)
+                    : null;
+                this.onEvent({
+                    type: 'reasoning-delta',
+                    itemId: asString(params.itemId),
+                    text,
+                    ...(summaryIndex !== null ? { summaryIndex } : {}),
+                });
+            }
+            return;
+        }
+        if (method === 'thread/tokenUsage/updated') {
+            const tokenUsage = getObject(params, 'tokenUsage');
+            const latest = getObject(tokenUsage, 'last');
+            this.onEvent({
+                type: 'usage',
+                latestTotalTokens: asNumber(latest?.totalTokens),
+                latestInputTokens: asNumber(latest?.inputTokens),
+                latestOutputTokens: asNumber(latest?.outputTokens),
+                latestCachedInputTokens: asNumber(latest?.cachedInputTokens),
+                latestReasoningTokens: asNumber(latest?.reasoningOutputTokens),
+                contextWindow: asNumber(tokenUsage?.modelContextWindow),
+            });
+            return;
+        }
+        if (method === 'item/started' || method === 'item/completed') {
+            const item = getObject(params, 'item');
+            const id = asString(item?.id);
+            const itemType = asString(item?.type);
+            if (!item || !id || !itemType) {
+                return;
+            }
+            if (itemType === 'agentMessage' || itemType === 'plan') {
+                if (itemType === 'agentMessage') {
+                    const phase = asMessagePhase(item.phase);
+                    const streamed = this.messageItems.get(id);
+                    if (method === 'item/started') {
+                        this.messageItems.set(id, { phase, text: streamed?.text ?? '' });
+                    }
+                    else if (!streamed?.text) {
+                        const text = asText(item.text);
+                        if (text) {
+                            this.onEvent({ type: 'agent-message-delta', itemId: id, text, phase });
+                        }
+                    }
+                }
+                else if (method === 'item/completed') {
+                    const text = asText(item.text);
+                    const streamedText = this.planItems.get(id) ?? '';
+                    if (text && text !== streamedText) {
+                        this.onEvent({ type: 'plan-update', itemId: id, text, snapshot: streamedText.length > 0 });
+                    }
+                }
+                return;
+            }
+            if (itemType === 'reasoning' || itemType === 'userMessage') {
+                return;
+            }
+            if (itemType === 'collabToolCall' || itemType === 'collabAgentToolCall' || itemType === 'subAgentActivity') {
+                const receiverIds = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [];
+                this.onEvent({
+                    type: 'subagent',
+                    id,
+                    threadId: asString(item.newThreadId) ?? asString(item.receiverThreadId) ?? asString(item.agentThreadId) ?? asString(receiverIds[0]),
+                    label: asString(item.prompt) ?? asString(item.tool) ?? 'Subagent',
+                    status: method === 'item/started' ? 'running' : getSubagentStatus(item.status ?? item.kind),
+                    output: method === 'item/completed' ? summarizeToolOutput(item) || null : null,
+                });
+                return;
+            }
+            const tool = summarizeTool(item);
+            if (method === 'item/started') {
+                this.onEvent({ type: 'tool-started', id, name: tool.name, input: tool.input });
+            }
+            else {
+                this.onEvent({
+                    type: 'tool-completed',
+                    id,
+                    name: tool.name,
+                    input: tool.input,
+                    output: summarizeToolOutput(item),
+                    failed: item.status === 'failed' || item.status === 'declined',
+                });
+            }
+            return;
+        }
+        if (method === 'turn/completed') {
+            const turn = getObject(params, 'turn');
+            const turnId = asString(turn?.id);
+            const status = asString(turn?.status);
+            if (turnId && !this.turnId && [...this.pending.values()].some(request => request.method === 'turn/start')) {
+                this.pendingTurnCompletion = params;
+                return;
+            }
+            if (!turn || !turnId || turnId !== this.turnId || !status) {
+                return;
+            }
+            const outcomeStatus = status === 'completed' || status === 'interrupted' || status === 'failed'
+                ? status
+                : 'failed';
+            this.finish({
+                status: outcomeStatus,
+                threadId: this.threadId ?? '',
+                turnId,
+                error: getTurnError(turn),
+            });
+        }
+    }
+    handleClose = () => {
+        this.closed = true;
+        const error = new CodexAppServerError('Codex app-server disconnected before the active turn completed.');
+        this.rejectPending(error);
+        if (this.threadId && this.turnId && !this.terminal) {
+            this.finish({ status: 'disconnected', threadId: this.threadId, turnId: this.turnId, error: error.message });
+        }
+    };
+    handleProcessError = (error) => {
+        this.failTransport(error);
+    };
+    handleInputError = (error) => {
+        this.failTransport(error);
+    };
+    failTransport(error) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.frameChunks = [];
+        this.frameBytes = 0;
+        this.output.off('data', this.handleData);
+        this.rejectPending(error);
+        if (this.threadId && this.turnId && !this.terminal) {
+            this.finish({ status: 'disconnected', threadId: this.threadId, turnId: this.turnId, error: error.message });
+        }
+        this.input.destroy();
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    finish(outcome) {
+        if (this.terminal) {
+            return;
+        }
+        this.terminal = outcome;
+        this.resolveOutcome?.(outcome);
+    }
+    send(message) {
+        if (this.closed || this.input.destroyed) {
+            throw new CodexAppServerError('Codex app-server is not connected.');
+        }
+        this.input.write(`${JSON.stringify(message)}\n`);
+    }
+    request(method, params = {}, timeoutMs = this.requestTimeoutMs) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new CodexAppServerError(`Codex app-server request "${method}" timed out.`));
+            }, timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { method, resolve, reject, timer });
+            try {
+                this.send({ method, id, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    notify(method, params = {}) {
+        this.send({ method, params });
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        await this.request('initialize', {
+            clientInfo: { name: 'archon', title: 'Archon', version: '1.0.0' },
+        });
+        this.notify('initialized');
+        this.initialized = true;
+    }
+    async readAccount() {
+        const result = await this.request('account/read', { refreshToken: false });
+        const account = getObject(result, 'account');
+        const requiresOpenaiAuth = isObject(result) && result.requiresOpenaiAuth === true;
+        if (!account) {
+            if (requiresOpenaiAuth) {
+                return { status: 'reauthentication-required', type: null, accountId: null };
+            }
+            return { status: 'reauthentication-required', type: null, accountId: null };
+        }
+        const type = asString(account.type);
+        if (type !== 'chatgpt' && type !== 'apiKey' && type !== 'amazonBedrock') {
+            return { status: 'reauthentication-required', type: null, accountId: null };
+        }
+        return {
+            status: 'authenticated',
+            type,
+            accountId: type === 'chatgpt' ? asString(account.email) : null,
+        };
+    }
+    async listModels() {
+        const models = [];
+        let cursor = null;
+        do {
+            const result = await this.request('model/list', {
+                limit: 100,
+                includeHidden: false,
+                ...(cursor ? { cursor } : {}),
+            });
+            const page = isObject(result) ? result : null;
+            for (const entry of Array.isArray(page?.data) ? page.data : []) {
+                if (!isObject(entry)) {
+                    continue;
+                }
+                const id = asString(entry.id) ?? asString(entry.model);
+                if (!id || /[\s/]/.test(id)) {
+                    continue;
+                }
+                const supportedReasoningEfforts = Array.isArray(entry.supportedReasoningEfforts)
+                    ? entry.supportedReasoningEfforts.flatMap(option => {
+                        const effort = isObject(option) ? asString(option.reasoningEffort) : asString(option);
+                        return effort && !/[\s/]/.test(effort) ? [effort] : [];
+                    })
+                    : [];
+                const defaultReasoningEffort = asString(entry.defaultReasoningEffort);
+                const inputModalities = Array.isArray(entry.inputModalities)
+                    ? entry.inputModalities.flatMap(modality => asString(modality) ?? [])
+                    : [];
+                models.push({
+                    id,
+                    displayName: asString(entry.displayName) ?? id,
+                    supportedReasoningEfforts: [...new Set(supportedReasoningEfforts)],
+                    defaultReasoningEffort: defaultReasoningEffort && supportedReasoningEfforts.includes(defaultReasoningEffort)
+                        ? defaultReasoningEffort
+                        : null,
+                    inputModalities: [...new Set(inputModalities)],
+                });
+            }
+            cursor = asString(page?.nextCursor);
+        } while (cursor);
+        return models;
+    }
+    async listSkills(cwd) {
+        const result = await this.request('skills/list', { cwds: [cwd], forceReload: false });
+        const page = isObject(result) ? result : null;
+        const containers = Array.isArray(page?.data) ? page.data : [];
+        const skills = [];
+        for (const container of containers) {
+            const entries = isObject(container) && Array.isArray(container.skills)
+                ? container.skills
+                : isObject(container) ? [container] : [];
+            for (const entry of entries) {
+                if (!isObject(entry) || entry.enabled === false) {
+                    continue;
+                }
+                const name = asString(entry.name);
+                const description = asString(entry.description) ?? asString(entry.shortDescription);
+                const path = asString(entry.path);
+                if (name && description && path) {
+                    skills.push({ name, description, path });
+                }
+            }
+        }
+        return skills;
+    }
+    async startThread(options) {
+        const params = {
+            ...(options.resumeThreadId ? { threadId: options.resumeThreadId } : {}),
+            ...(options.model ? { model: options.model } : {}),
+            cwd: options.cwd,
+            approvalPolicy: 'never',
+            sandbox: options.mode === 'plan' ? 'read-only' : 'workspace-write',
+            serviceName: 'archon',
+        };
+        const result = await this.request(options.resumeThreadId ? 'thread/resume' : 'thread/start', params);
+        const thread = getObject(result, 'thread');
+        const threadId = asString(thread?.id);
+        if (!threadId || (options.resumeThreadId && threadId !== options.resumeThreadId)) {
+            throw new CodexAppServerError('Codex did not establish the requested thread identity.');
+        }
+        this.threadId = threadId;
+        return threadId;
+    }
+    async startTurn(options) {
+        if (!this.threadId) {
+            throw new CodexAppServerError('Codex thread must be established before starting a turn.');
+        }
+        const input = [{ type: 'text', text: options.prompt }];
+        for (const file of options.files ?? []) {
+            input.push({ type: 'localImage', path: file });
+        }
+        for (const skill of options.skills ?? []) {
+            input.push({ type: 'skill', name: skill.name, path: skill.path });
+        }
+        const sandboxPolicy = options.mode === 'plan'
+            ? { type: 'readOnly', access: { type: 'fullAccess' } }
+            : { type: 'workspaceWrite', writableRoots: [options.cwd], networkAccess: true };
+        const reasoningEffort = options.reasoningEffort;
+        if (reasoningEffort && options.supportedReasoningEfforts && !options.supportedReasoningEfforts.includes(reasoningEffort)) {
+            throw new CodexAppServerError(`Reasoning effort "${reasoningEffort}" is not supported by the selected Codex model.`);
+        }
+        const result = await this.request('turn/start', {
+            threadId: this.threadId,
+            input,
+            cwd: options.cwd,
+            approvalPolicy: 'never',
+            sandboxPolicy,
+            ...(options.model ? { model: options.model } : {}),
+            ...(reasoningEffort ? { effort: reasoningEffort } : {}),
+            summary: 'concise',
+        });
+        const turn = getObject(result, 'turn');
+        const turnId = asString(turn?.id);
+        if (!turnId) {
+            throw new CodexAppServerError('Codex did not return a turn identity.');
+        }
+        this.turnId = turnId;
+        return turnId;
+    }
+    waitForTurn() {
+        return this.outcomePromise;
+    }
+    async interruptTurn() {
+        if (!this.threadId || !this.turnId || this.terminal) {
+            return false;
+        }
+        await this.request('turn/interrupt', { threadId: this.threadId, turnId: this.turnId }, INTERRUPT_REQUEST_TIMEOUT_MS);
+        return true;
+    }
+    closeInput() {
+        if (!this.input.destroyed) {
+            this.input.end();
+        }
+    }
+}
+//# sourceMappingURL=codexAppServer.js.map