@varveai/adit-cli 0.3.0 → 0.3.2

package/dist/commands/cli-agent/codex-cli-provider.js

@@ -0,0 +1,974 @@
+import { EventEmitter } from "node:events";
+import { spawn } from "node:child_process";
+import { CodexAppServerClient, } from "./codex-app-server-client.js";
+const RECLAIM_COMMAND = "/local";
+const TERMINAL_RECLAIM_RESET = [
+    "\x1b[?1004l", // Focus in/out reporting.
+    "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l", // Mouse modes.
+    "\x1b[?2004l", // Bracketed paste.
+    "\x1b[?1l", // Application cursor keys.
+    "\x1b[=0u\x1b[<u\x1b[<u\x1b[<u", // Kitty/CSI-u keyboard protocol.
+    "\x1b[>4;0m", // xterm modifyOtherKeys.
+    "\x1b[?25h", // Cursor visible.
+].join("");
+const CODEX_PLAN_MODE_INSTRUCTION = [
+    "ADIT Plan mode is active.",
+    "Do not modify files, create files, apply patches, install packages, start services, commit changes, or otherwise change the working tree.",
+    "Use read-only inspection only. If implementation is needed, return a concrete plan with files, steps, risks, and questions instead of editing.",
+    "Do not announce that you are about to edit files; stop at the plan.",
+].join("\n");
+export class CodexCliProvider extends EventEmitter {
+    opts;
+    provider = "codex";
+    local = null;
+    appServer = null;
+    ownerValue = "stopped";
+    busyValue = false;
+    thinkingValue = false;
+    activeSessionId = null;
+    resumeSessionId = null;
+    sdkSessionId = null;
+    activeModelId = null;
+    promptQueue = [];
+    promptActive = false;
+    activeTurnId = null;
+    loadedThreadIds = new Set();
+    boundPendingSessionIds = new Set();
+    pendingPermissions = new Map();
+    pendingQuestions = new Map();
+    lastAssistantMessageBySession = new Map();
+    reclaimAttached = false;
+    reclaimBuffer = "";
+    suppressNextLocalExit = false;
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.startLocal();
+    }
+    get state() {
+        return {
+            owner: this.ownerValue,
+            busy: this.busyValue,
+            thinking: this.thinkingValue,
+            activeSessionId: this.activeSessionId,
+            resumeSessionId: this.resumeSessionId,
+            sdkSessionId: this.sdkSessionId,
+            activeModelId: this.activeModelId,
+        };
+    }
+    get permissions() {
+        return [...this.pendingPermissions.values()].map((item) => item.request);
+    }
+    noteModel(modelId) {
+        if (!modelId || modelId === this.activeModelId)
+            return;
+        this.activeModelId = modelId;
+        this.emitState();
+    }
+    noteLocalSession(id) {
+        if (!id)
+            return;
+        const changed = this.activeSessionId !== id || this.resumeSessionId !== id;
+        this.activeSessionId = id;
+        this.resumeSessionId = id;
+        this.sdkSessionId = id;
+        if (!changed)
+            return;
+        this.emitState();
+    }
+    markLocalBusy() {
+        this.setBusy(true);
+        this.setThinking(true);
+    }
+    markLocalIdle() {
+        this.setThinking(false);
+        this.setBusy(false);
+    }
+    async takeover() {
+        if (this.ownerValue === "web")
+            return;
+        if (this.ownerValue !== "local") {
+            throw Object.assign(new Error("local Codex owner is not available"), {
+                statusCode: 409,
+            });
+        }
+        if (this.busyValue || this.thinkingValue) {
+            throw Object.assign(new Error("local Codex is busy"), {
+                statusCode: 409,
+            });
+        }
+        await this.ensureAppServer();
+        const resumeId = this.activeSessionId ?? this.resumeSessionId;
+        if (resumeId) {
+            await this.resumeThread(resumeId);
+        }
+        this.suppressNextLocalExit = true;
+        const oldLocal = this.local;
+        this.local = null;
+        try {
+            oldLocal?.kill("SIGTERM");
+        }
+        catch { }
+        this.ownerValue = "web";
+        this.emitState();
+        restoreTerminalForCodexReclaim();
+        process.stderr.write(`\n[adit cloud codex] Web has taken over Codex CLI. Type ${RECLAIM_COMMAND} here to reclaim local control.\n`);
+        this.attachReclaimInput();
+    }
+    async releaseToLocal() {
+        if (this.ownerValue !== "web")
+            return;
+        this.detachReclaimInput();
+        process.stderr.write("\n[adit cloud codex] releasing Web control back to local Codex CLI...\n");
+        this.finishWebPrompts(new Error("Web control released to local CLI"));
+        this.rejectPendingRequests(new Error("Web control released to local CLI"));
+        this.appServer?.stop();
+        this.appServer = null;
+        this.loadedThreadIds = new Set();
+        const resumeId = this.resumeSessionId ?? this.activeSessionId;
+        this.startLocal(resumeId ? ["resume", resumeId] : []);
+    }
+    async switchSession(sessionId) {
+        if (!sessionId.trim()) {
+            throw Object.assign(new Error("Codex session not found for this project"), {
+                statusCode: 404,
+            });
+        }
+        if (this.ownerValue === "local") {
+            this.suppressNextLocalExit = true;
+            const oldLocal = this.local;
+            this.local = null;
+            try {
+                oldLocal?.kill("SIGTERM");
+            }
+            catch { }
+            this.activeSessionId = sessionId;
+            this.resumeSessionId = sessionId;
+            this.sdkSessionId = sessionId;
+            this.emitState();
+            this.startLocal(["resume", sessionId]);
+            return;
+        }
+        if (this.ownerValue === "web") {
+            await this.ensureAppServer();
+            await this.resumeThread(sessionId);
+            this.finishWebPrompts(new Error("Codex session switched"));
+            this.setBusy(false);
+            this.setThinking(false);
+            return;
+        }
+    }
+    async sendPrompt(prompt, opts = {}) {
+        if (this.ownerValue !== "web") {
+            throw Object.assign(new Error("Web has not taken over this Codex session"), {
+                statusCode: 409,
+            });
+        }
+        const trimmed = prompt.trim();
+        if (!trimmed)
+            return;
+        await new Promise((resolve, reject) => {
+            this.promptQueue.push({
+                message: trimmed,
+                mode: opts.mode === "plan" ? "plan" : "build",
+                pendingSessionId: opts.pendingSessionId ?? null,
+                resolve,
+                reject,
+            });
+            void this.drainPromptQueue();
+        });
+    }
+    async answerPermission(id, approved, _reason) {
+        const pending = this.pendingPermissions.get(id);
+        if (!pending) {
+            throw Object.assign(new Error("permission request not found"), {
+                statusCode: 404,
+            });
+        }
+        this.pendingPermissions.delete(id);
+        this.pushEvent("permission-resolved", { id, approved });
+        pending.resolve(buildApprovalResponse(pending.method, pending.params, approved));
+    }
+    async answerQuestion(response) {
+        const pending = this.pendingQuestions.get(response.id);
+        if (!pending) {
+            throw Object.assign(new Error("question request not found"), {
+                statusCode: 404,
+            });
+        }
+        this.pendingQuestions.delete(response.id);
+        if (response.rejected) {
+            this.pushEvent("question.rejected", {
+                id: response.id,
+                requestID: response.id,
+            });
+            pending.resolve(buildQuestionResponse(pending.method, pending.params, []));
+            return;
+        }
+        this.pushEvent("question.replied", {
+            id: response.id,
+            requestID: response.id,
+        });
+        pending.resolve(buildQuestionResponse(pending.method, pending.params, response.answers));
+    }
+    async abort() {
+        if (this.ownerValue !== "web")
+            return;
+        const threadId = this.activeSessionId ?? this.resumeSessionId;
+        const turnId = this.activeTurnId;
+        this.finishWebPrompts(new Error("Codex run aborted"));
+        if (threadId && turnId) {
+            try {
+                await this.appServer?.request("turn/interrupt", { threadId, turnId });
+            }
+            catch { }
+        }
+        this.activeTurnId = null;
+        this.setThinking(false);
+        this.setBusy(false);
+        this.pushEvent("error", { message: "Codex run aborted." });
+    }
+    stop() {
+        this.finishWebPrompts(new Error("Codex provider stopped"));
+        this.rejectPendingRequests(new Error("Codex provider stopped"));
+        this.detachReclaimInput();
+        this.appServer?.stop();
+        this.appServer = null;
+        try {
+            this.local?.kill("SIGTERM");
+        }
+        catch { }
+        this.local = null;
+        this.ownerValue = "stopped";
+        this.setThinking(false);
+        this.setBusy(false);
+        this.emitState();
+    }
+    startLocal(extraArgs = []) {
+        this.detachReclaimInput();
+        this.finishWebPrompts(new Error("local mode active"));
+        this.appServer?.stop();
+        this.appServer = null;
+        const child = spawn(this.opts.bin, [...extraArgs, ...this.opts.args], {
+            cwd: this.opts.cwd,
+            env: this.buildEnv(),
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        this.local = child;
+        this.ownerValue = "local";
+        this.emitState();
+        child.on("error", (error) => {
+            this.pushEvent("error", { message: error.message });
+            process.stderr.write(`\n[adit cloud codex] failed to start Codex CLI: ${error.message}\n`);
+        });
+        child.on("exit", (code, signal) => {
+            this.setThinking(false);
+            this.setBusy(false);
+            if (this.suppressNextLocalExit) {
+                this.suppressNextLocalExit = false;
+                return;
+            }
+            if (this.local === child) {
+                this.local = null;
+                this.ownerValue = "stopped";
+                this.emitState();
+                this.emit("exit", { code, signal });
+            }
+        });
+    }
+    async drainPromptQueue() {
+        if (this.promptActive || this.busyValue || this.ownerValue !== "web")
+            return;
+        const item = this.promptQueue.shift();
+        if (!item)
+            return;
+        this.promptActive = true;
+        try {
+            await this.ensureAppServer();
+            const threadId = await this.ensureThreadForPrompt(item.pendingSessionId, item.mode);
+            this.pushEvent("message", {
+                role: "user",
+                sessionId: threadId,
+                text: item.message,
+                createdAt: Date.now(),
+            });
+            const result = asRecord(await this.appServer?.request("turn/start", {
+                threadId,
+                input: [
+                    {
+                        type: "text",
+                        text: promptInputForCodexMode(item.message, item.mode),
+                        text_elements: [],
+                    },
+                ],
+                cwd: this.opts.cwd,
+                ...codexTurnModeOverrides(item.mode, this.opts.cwd),
+            }));
+            const turn = asRecord(result?.turn);
+            this.activeTurnId = readString(turn?.id) ?? this.activeTurnId;
+            this.setBusy(true);
+            this.setThinking(true);
+            item.resolve();
+        }
+        catch (error) {
+            item.reject(error instanceof Error ? error : new Error(String(error)));
+            this.pushEvent("error", {
+                message: error instanceof Error ? error.message : String(error),
+                createdAt: Date.now(),
+            });
+        }
+        finally {
+            this.promptActive = false;
+        }
+    }
+    async ensureThreadForPrompt(pendingSessionId, mode) {
+        if (pendingSessionId) {
+            const threadId = await this.startThread(mode);
+            this.bindPendingSession(pendingSessionId, threadId);
+            return threadId;
+        }
+        const existing = this.activeSessionId ?? this.resumeSessionId;
+        if (existing) {
+            if (!this.loadedThreadIds.has(existing)) {
+                await this.resumeThread(existing, mode);
+            }
+            return existing;
+        }
+        return this.startThread(mode);
+    }
+    async ensureAppServer() {
+        if (this.appServer?.isRunning)
+            return;
+        const client = new CodexAppServerClient({
+            bin: this.opts.bin,
+            cwd: this.opts.cwd,
+            env: this.buildEnv(),
+            onNotification: (message) => this.handleAppNotification(message),
+            onServerRequest: (message) => this.handleAppServerRequest(message),
+            onError: (error) => {
+                this.pushEvent("error", { message: error.message, createdAt: Date.now() });
+            },
+        });
+        this.appServer = client;
+        await client.start();
+    }
+    async startThread(mode) {
+        await this.ensureAppServer();
+        const result = asRecord(await this.appServer?.request("thread/start", {
+            cwd: this.opts.cwd,
+            ...codexThreadModeOverrides(mode),
+            experimentalRawEvents: false,
+            persistExtendedHistory: true,
+        }));
+        const thread = asRecord(result?.thread);
+        const threadId = readString(thread?.id);
+        if (!threadId)
+            throw new Error("Codex app-server did not return a thread id");
+        this.noteThread(thread, result);
+        return threadId;
+    }
+    async resumeThread(threadId, mode = "build") {
+        await this.ensureAppServer();
+        const result = asRecord(await this.appServer?.request("thread/resume", {
+            threadId,
+            cwd: this.opts.cwd,
+            ...codexThreadModeOverrides(mode),
+            persistExtendedHistory: true,
+        }));
+        const thread = asRecord(result?.thread);
+        const resumedId = readString(thread?.id) ?? threadId;
+        this.noteThread({ ...(thread ?? {}), id: resumedId }, result);
+    }
+    handleAppNotification(message) {
+        const method = message.method;
+        const params = asRecord(message.params) ?? {};
+        if (method === "error") {
+            this.pushEvent("error", {
+                message: readString(params.message) ?? "Codex app-server error",
+                createdAt: Date.now(),
+            });
+            return;
+        }
+        if (method === "thread/started") {
+            this.noteThread(asRecord(params.thread), null);
+            return;
+        }
+        if (method === "thread/status/changed") {
+            const status = asRecord(params.status);
+            const active = status?.type === "active";
+            this.setBusy(active);
+            this.setThinking(active);
+            return;
+        }
+        if (method === "turn/started") {
+            this.activeTurnId = readString(asRecord(params.turn)?.id) ?? this.activeTurnId;
+            this.setBusy(true);
+            this.setThinking(true);
+            return;
+        }
+        if (method === "turn/completed") {
+            const turn = asRecord(params.turn);
+            const status = readString(turn?.status);
+            if (status === "failed") {
+                const error = asRecord(turn?.error);
+                this.pushEvent("error", {
+                    message: readString(error?.message) ?? "Codex turn failed",
+                    createdAt: Date.now(),
+                });
+            }
+            this.activeTurnId = null;
+            this.setThinking(false);
+            this.setBusy(false);
+            void this.drainPromptQueue();
+            return;
+        }
+        if (method === "item/started") {
+            this.emitThreadItem(asRecord(params.item), {
+                threadId: readString(params.threadId),
+                running: true,
+            });
+            return;
+        }
+        if (method === "item/completed") {
+            this.emitThreadItem(asRecord(params.item), {
+                threadId: readString(params.threadId),
+                running: false,
+            });
+            return;
+        }
+        if (method === "item/agentMessage/delta" || method === "item/plan/delta") {
+            const text = readString(params.delta);
+            const sessionId = readString(params.threadId);
+            const messageId = readString(params.itemId);
+            if (text && sessionId && messageId) {
+                this.lastAssistantMessageBySession.set(sessionId, messageId);
+                this.pushEvent("assistant-delta", {
+                    sessionId,
+                    messageId,
+                    text,
+                    modelId: this.activeModelId ?? undefined,
+                    createdAt: Date.now(),
+                });
+            }
+            return;
+        }
+        if (method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta") {
+            const text = readString(params.delta);
+            const sessionId = readString(params.threadId);
+            const messageId = readString(params.itemId);
+            if (text && sessionId && messageId) {
+                this.pushEvent("reasoning", {
+                    sessionId,
+                    messageId,
+                    text,
+                    createdAt: Date.now(),
+                });
+            }
+            return;
+        }
+        if (method === "thread/tokenUsage/updated") {
+            const sessionId = readString(params.threadId);
+            const usage = normalizeCodexUsage(asRecord(asRecord(params.tokenUsage)?.last));
+            if (sessionId && usage) {
+                this.pushEvent("usage", {
+                    sessionId,
+                    messageId: this.lastAssistantMessageBySession.get(sessionId),
+                    usage,
+                    createdAt: Date.now(),
+                });
+            }
+        }
+    }
+    handleAppServerRequest(message) {
+        if (message.id === undefined || !message.method) {
+            return Promise.resolve(null);
+        }
+        const id = String(message.id);
+        const params = asRecord(message.params) ?? {};
+        const sessionId = readString(params.threadId) ?? this.activeSessionId ?? this.resumeSessionId;
+        if (message.method === "item/tool/requestUserInput" ||
+            message.method === "mcpServer/elicitation/request") {
+            return new Promise((resolve, reject) => {
+                this.pendingQuestions.set(id, {
+                    id,
+                    method: message.method ?? "",
+                    params,
+                    resolve,
+                    reject,
+                });
+                this.pushEvent("question.asked", {
+                    id,
+                    sessionId,
+                    questions: normalizeCodexQuestions(message.method ?? "", params),
+                    createdAt: Date.now(),
+                });
+                this.emitState();
+            });
+        }
+        if (message.method === "item/commandExecution/requestApproval" ||
+            message.method === "item/fileChange/requestApproval" ||
+            message.method === "item/permissions/requestApproval" ||
+            message.method === "applyPatchApproval" ||
+            message.method === "execCommandApproval") {
+            return new Promise((resolve, reject) => {
+                const toolName = approvalToolName(message.method ?? "", params);
+                const request = {
+                    id,
+                    toolName,
+                    input: params,
+                    createdAt: Date.now(),
+                };
+                this.pendingPermissions.set(id, {
+                    request,
+                    method: message.method ?? "",
+                    params,
+                    resolve,
+                    reject,
+                });
+                this.pushEvent("permission", {
+                    id,
+                    toolName,
+                    input: params,
+                    createdAt: request.createdAt,
+                    sessionId,
+                });
+                this.emitState();
+            });
+        }
+        return Promise.reject(new Error(`Unsupported Codex app-server request: ${message.method}`));
+    }
+    noteThread(thread, result) {
+        const threadId = readString(thread?.id);
+        if (!threadId)
+            return;
+        this.activeSessionId = threadId;
+        this.resumeSessionId = threadId;
+        this.sdkSessionId = threadId;
+        this.loadedThreadIds.add(threadId);
+        const modelId = readString(result?.model);
+        if (modelId)
+            this.activeModelId = modelId;
+        this.emitState();
+    }
+    emitThreadItem(item, opts) {
+        if (!item)
+            return;
+        const type = readString(item.type);
+        const sessionId = opts.threadId ?? this.activeSessionId ?? this.resumeSessionId;
+        const id = readString(item.id);
+        if (!type || !sessionId || !id)
+            return;
+        const createdAt = Date.now();
+        if ((type === "agentMessage" || type === "plan") && !opts.running) {
+            const text = readString(item.text);
+            if (!text)
+                return;
+            this.lastAssistantMessageBySession.set(sessionId, id);
+            this.pushEvent("message", {
+                role: "assistant",
+                sessionId,
+                messageId: id,
+                modelId: this.activeModelId ?? undefined,
+                text,
+                createdAt,
+            });
+            return;
+        }
+        if (type === "reasoning" && !opts.running) {
+            const content = [
+                ...readStringArray(item.summary),
+                ...readStringArray(item.content),
+            ].join("\n");
+            if (!content)
+                return;
+            this.pushEvent("reasoning", {
+                sessionId,
+                messageId: id,
+                text: content,
+                createdAt,
+            });
+            return;
+        }
+        if (type === "commandExecution") {
+            const command = readString(item.command) ?? "command";
+            const status = readString(item.status);
+            this.pushEvent("tool", {
+                sessionId,
+                messageId: this.lastAssistantMessageBySession.get(sessionId) ?? `codex-tools-${sessionId}`,
+                toolUseId: id,
+                toolName: "Bash",
+                input: {
+                    command,
+                    cwd: readString(item.cwd),
+                    source: item.source,
+                    commandActions: item.commandActions,
+                },
+                output: readString(item.aggregatedOutput) ?? undefined,
+                error: status === "failed" ? readString(item.aggregatedOutput) ?? "Command failed" : undefined,
+                status: opts.running || status === "inProgress"
+                    ? "running"
+                    : status === "completed"
+                        ? "completed"
+                        : "error",
+                createdAt,
+            });
+            return;
+        }
+        if (type === "fileChange") {
+            const status = readString(item.status);
+            this.pushEvent("tool", {
+                sessionId,
+                messageId: this.lastAssistantMessageBySession.get(sessionId) ?? `codex-tools-${sessionId}`,
+                toolUseId: id,
+                toolName: "apply_patch",
+                input: { changes: item.changes },
+                output: status === "completed" ? safeJson(item.changes) : undefined,
+                error: status === "failed" || status === "declined" ? `File change ${status}` : undefined,
+                status: opts.running || status === "inProgress"
+                    ? "running"
+                    : status === "completed"
+                        ? "completed"
+                        : "error",
+                createdAt,
+            });
+            return;
+        }
+        if (type === "mcpToolCall" || type === "dynamicToolCall" || type === "webSearch") {
+            const toolName = readString(item.tool) ?? readString(item.server) ?? type;
+            const status = readString(item.status);
+            this.pushEvent("tool", {
+                sessionId,
+                messageId: this.lastAssistantMessageBySession.get(sessionId) ?? `codex-tools-${sessionId}`,
+                toolUseId: id,
+                toolName,
+                input: asRecord(item.arguments) ?? { query: item.query },
+                output: item.result !== undefined ? safeJson(item.result) : undefined,
+                error: item.error !== undefined ? safeJson(item.error) : undefined,
+                status: opts.running || status === "inProgress" || status === "running"
+                    ? "running"
+                    : item.error ? "error" : "completed",
+                createdAt,
+            });
+        }
+    }
+    bindPendingSession(pendingSessionId, sessionId) {
+        if (!pendingSessionId || !sessionId)
+            return;
+        this.activeSessionId = sessionId;
+        this.resumeSessionId = sessionId;
+        this.sdkSessionId = sessionId;
+        if (!this.boundPendingSessionIds.has(pendingSessionId)) {
+            this.boundPendingSessionIds.add(pendingSessionId);
+            this.pushEvent("session-bound", {
+                pendingSessionId,
+                sessionId,
+                createdAt: Date.now(),
+            });
+        }
+        this.emitState();
+    }
+    finishWebPrompts(error) {
+        for (const item of this.promptQueue.splice(0)) {
+            item.reject(error);
+        }
+        this.promptActive = false;
+    }
+    rejectPendingRequests(error) {
+        for (const pending of this.pendingPermissions.values()) {
+            pending.reject(error);
+        }
+        this.pendingPermissions.clear();
+        for (const pending of this.pendingQuestions.values()) {
+            pending.reject(error);
+        }
+        this.pendingQuestions.clear();
+        this.pushEvent("permission-resolved", { id: "all", approved: false });
+        this.pushEvent("question.rejected", { id: "all" });
+    }
+    setBusy(value) {
+        if (this.busyValue === value)
+            return;
+        this.busyValue = value;
+        this.emitState();
+    }
+    setThinking(value) {
+        if (this.thinkingValue === value)
+            return;
+        this.thinkingValue = value;
+        this.emitState();
+    }
+    emitState() {
+        this.emit("state", this.state);
+        this.pushEvent("state", {
+            owner: this.ownerValue,
+            busy: this.busyValue,
+            thinking: this.thinkingValue,
+            activeSessionId: this.activeSessionId,
+            resumeSessionId: this.resumeSessionId,
+            sdkSessionId: this.sdkSessionId,
+            activeModelId: this.activeModelId,
+            createdAt: Date.now(),
+        });
+    }
+    pushEvent(type, payload) {
+        this.opts.onEvent?.({ type, payload });
+    }
+    buildEnv() {
+        return {
+            ...process.env,
+            TERM: process.env.TERM || "xterm-256color",
+            COLORTERM: process.env.COLORTERM || "truecolor",
+            FORCE_COLOR: process.env.FORCE_COLOR || "3",
+            DISABLE_AUTOUPDATER: "1",
+        };
+    }
+    attachReclaimInput() {
+        if (this.reclaimAttached || !process.stdin.isTTY)
+            return;
+        this.reclaimAttached = true;
+        this.reclaimBuffer = "";
+        try {
+            restoreTerminalForCodexReclaim();
+            process.stdin.setEncoding("utf8");
+            process.stdin.resume();
+            process.stdin.on("data", this.onReclaimInput);
+        }
+        catch {
+            this.reclaimAttached = false;
+        }
+    }
+    detachReclaimInput() {
+        if (!this.reclaimAttached)
+            return;
+        this.reclaimAttached = false;
+        process.stdin.off("data", this.onReclaimInput);
+        this.reclaimBuffer = "";
+        try {
+            process.stdin.pause();
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+                process.stdin.setRawMode(false);
+            }
+        }
+        catch { }
+    }
+    onReclaimInput = (chunk) => {
+        const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (text.includes("\u0003")) {
+            this.stop();
+            return;
+        }
+        this.reclaimBuffer = applyReclaimText(this.reclaimBuffer, normalizeCodexReclaimInput(text));
+        if (this.reclaimBuffer.length > 200) {
+            this.reclaimBuffer = this.reclaimBuffer.slice(-200);
+        }
+        if (this.reclaimBuffer.includes(RECLAIM_COMMAND)) {
+            this.reclaimBuffer = "";
+            void this.releaseToLocal();
+            return;
+        }
+        if (text.includes("\n") || text.includes("\r")) {
+            process.stderr.write(`[adit cloud codex] Web owns this session. Type ${RECLAIM_COMMAND} to reclaim.\n`);
+        }
+    };
+}
+function restoreTerminalForCodexReclaim() {
+    try {
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(false);
+        }
+    }
+    catch { }
+    try {
+        if (process.stderr.isTTY) {
+            process.stderr.write(TERMINAL_RECLAIM_RESET);
+        }
+    }
+    catch { }
+}
+export function normalizeCodexReclaimInput(text) {
+    return text
+        .replace(/\x1b\[(\d+)(?:;[0-9:]+)?u/g, (_match, rawCode) => decodeCsiUCode(Number(rawCode)))
+        .replace(/\x1b\[(?:I|O)/g, "")
+        .replace(/\x1b\[[?=>]?[0-9;:]*[A-Za-z~]/g, "");
+}
+function decodeCsiUCode(code) {
+    if (code === 13)
+        return "\n";
+    if (code === 9)
+        return "\t";
+    if (code === 8 || code === 127)
+        return "\b";
+    if (code < 32 || !Number.isFinite(code))
+        return "";
+    try {
+        return String.fromCodePoint(code);
+    }
+    catch {
+        return "";
+    }
+}
+function applyReclaimText(buffer, text) {
+    let next = buffer;
+    for (const char of text) {
+        if (char === "\b" || char === "\x7f") {
+            next = next.slice(0, -1);
+        }
+        else {
+            next += char;
+        }
+    }
+    return next;
+}
+export function promptInputForCodexMode(prompt, mode) {
+    if (mode !== "plan")
+        return prompt;
+    return `${CODEX_PLAN_MODE_INSTRUCTION}\n\nUser request:\n${prompt}`;
+}
+export function codexThreadModeOverrides(mode) {
+    return {
+        approvalPolicy: mode === "plan" ? "never" : "on-request",
+        approvalsReviewer: "user",
+        sandbox: mode === "plan" ? "read-only" : "workspace-write",
+    };
+}
+export function codexTurnModeOverrides(mode, cwd) {
+    if (mode === "plan") {
+        return {
+            approvalPolicy: "never",
+            approvalsReviewer: "user",
+            sandboxPolicy: {
+                type: "readOnly",
+                networkAccess: false,
+            },
+        };
+    }
+    return {
+        approvalPolicy: "on-request",
+        approvalsReviewer: "user",
+        sandboxPolicy: {
+            type: "workspaceWrite",
+            writableRoots: [cwd],
+            networkAccess: false,
+            excludeTmpdirEnvVar: false,
+            excludeSlashTmp: false,
+        },
+    };
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+}
+function safeJson(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value ?? {}, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function normalizeCodexUsage(value) {
+    if (!value)
+        return undefined;
+    const usage = {
+        input_tokens: readNumber(value.inputTokens) ?? 0,
+        output_tokens: readNumber(value.outputTokens) ?? 0,
+        reasoning_tokens: readNumber(value.reasoningOutputTokens) ?? 0,
+        cache_read_input_tokens: readNumber(value.cachedInputTokens) ?? 0,
+    };
+    return Object.values(usage).some((item) => item > 0) ? usage : undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function approvalToolName(method, params) {
+    if (method === "item/commandExecution/requestApproval" || method === "execCommandApproval") {
+        return "Bash";
+    }
+    if (method === "item/fileChange/requestApproval" || method === "applyPatchApproval") {
+        return "apply_patch";
+    }
+    if (method === "item/permissions/requestApproval") {
+        return "CodexPermissions";
+    }
+    return readString(params.toolName) ?? "Codex";
+}
+function buildApprovalResponse(method, params, approved) {
+    if (method === "item/commandExecution/requestApproval") {
+        return { decision: approved ? "accept" : "decline" };
+    }
+    if (method === "item/fileChange/requestApproval") {
+        return { decision: approved ? "accept" : "decline" };
+    }
+    if (method === "item/permissions/requestApproval") {
+        return {
+            permissions: approved ? asRecord(params.permissions) ?? {} : {},
+            scope: "turn",
+        };
+    }
+    if (method === "applyPatchApproval" || method === "execCommandApproval") {
+        return { decision: approved ? "approved" : "denied" };
+    }
+    return { decision: approved ? "accept" : "decline" };
+}
+function normalizeCodexQuestions(method, params) {
+    if (method === "mcpServer/elicitation/request") {
+        return [{
+                question: readString(params.message) ?? readString(params.title) ?? "Codex needs input.",
+                header: readString(params.title) ?? "Question",
+                options: [],
+                multiple: false,
+                custom: true,
+            }];
+    }
+    const rawQuestions = Array.isArray(params.questions) ? params.questions : [];
+    return rawQuestions.map((item) => {
+        const question = asRecord(item) ?? {};
+        const options = Array.isArray(question.options)
+            ? question.options.map((option) => {
+                const record = asRecord(option) ?? {};
+                const label = readString(record.label) ?? readString(record.value) ?? "";
+                return {
+                    label,
+                    description: readString(record.description) ?? "",
+                };
+            }).filter((option) => option.label)
+            : [];
+        return {
+            question: readString(question.question) ?? "Codex needs input.",
+            header: readString(question.header) ?? "Question",
+            options,
+            multiple: false,
+            custom: question.isOther !== false,
+        };
+    });
+}
+function buildQuestionResponse(method, params, answers) {
+    if (method === "mcpServer/elicitation/request") {
+        return {
+            action: answers.length > 0 ? "accept" : "decline",
+            content: answers.length > 0 ? { answer: answers.flat().join("\n") } : null,
+            _meta: null,
+        };
+    }
+    const rawQuestions = Array.isArray(params.questions) ? params.questions : [];
+    const mapped = {};
+    rawQuestions.forEach((item, index) => {
+        const question = asRecord(item) ?? {};
+        const id = readString(question.id) ?? `question-${index}`;
+        mapped[id] = { answers: answers[index] ?? [] };
+    });
+    return { answers: mapped };
+}
+//# sourceMappingURL=codex-cli-provider.js.map