@yuandc/aica 0.1.0

package/dist/acp/providers/codex-acp/adapter.js

@@ -0,0 +1,947 @@
+import { JsonLineRpcClient } from "../../client/json-rpc.js";
+import { startCodexAppServer } from "../codex/codex-process.js";
+import { codexAcpSessionUpdatesFromNotification } from "../codex/events.js";
+import { isCodexApprovalRequest, resolveCodexApprovalRequest } from "../codex/permissions.js";
+import { buildCodexContinuityInstructions, codexTokenUsageFromNotification, decideCodexContextMaintenance, readCodexContextMaintenancePolicy, rolloutFileSize } from "./context-maintenance.js";
+class CodexAcpAdapter {
+    lineBuffer = "";
+    started = null;
+    rpc = null;
+    // ACP 请求可能在初始化完成前并发到达。用共享 Promise 保证一个 Adapter
+    // 只启动一个 Codex app-server，避免 thread/start 和 turn/start 落到不同进程。
+    codexStartupPromise = null;
+    initialized = false;
+    currentSessionId = null;
+    currentCwd = process.cwd();
+    promptActive = false;
+    currentTurnId = null;
+    nextParentRequestId = 1;
+    pendingParentRequests = new Map();
+    completedTurns = new Map();
+    pendingTurnCompletions = new Map();
+    agentMessagePhases = new Map();
+    config = {};
+    sessionAliases = new Map();
+    currentAffectedFiles = new Set();
+    latestTokenUsage = null;
+    currentRolloutPath = null;
+    threadTurnCount = 0;
+    currentPromptText = "";
+    currentAssistantText = "";
+    previousUserText = "";
+    previousAssistantText = "";
+    previousAffectedFiles = new Set();
+    maintenanceActive = false;
+    pendingCompaction = null;
+    shutdownPromise = null;
+    constructor() {
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => this.handleInput(String(chunk)));
+        const parentDisconnected = () => {
+            void this.shutdown().finally(() => process.exit(0));
+        };
+        process.stdin.once("end", parentDisconnected);
+        process.stdin.once("close", parentDisconnected);
+        process.stdin.once("error", parentDisconnected);
+        process.once("SIGTERM", () => {
+            void this.shutdown().finally(() => process.exit(0));
+        });
+        process.once("SIGINT", () => {
+            void this.shutdown().finally(() => process.exit(130));
+        });
+    }
+    handleInput(chunk) {
+        this.lineBuffer += chunk;
+        const lines = this.lineBuffer.split("\n");
+        this.lineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            void this.handleMessage(message);
+        }
+    }
+    async handleMessage(message) {
+        if ("id" in message && ("result" in message || "error" in message) && typeof message.method !== "string") {
+            this.handleParentResponse(message);
+            return;
+        }
+        const method = typeof message.method === "string" ? message.method : "";
+        const id = message.id;
+        if (!method)
+            return;
+        if (id === undefined) {
+            await this.handleNotification(method, objectOrEmpty(message.params));
+            return;
+        }
+        try {
+            const result = await this.handleRequest(method, objectOrEmpty(message.params));
+            this.write({ jsonrpc: "2.0", id, result });
+        }
+        catch (error) {
+            this.write({
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            });
+        }
+    }
+    async handleNotification(method, params) {
+        if (method === "session/cancel") {
+            await this.cancel(params);
+        }
+    }
+    async handleRequest(method, params) {
+        switch (method) {
+            case "initialize":
+                return this.initializeResponse();
+            case "session/new":
+                return this.newSession(params);
+            case "session/resume":
+            case "session/load":
+                return this.resumeSession(params);
+            case "session/prompt":
+                return this.prompt(params);
+            case "session/compact":
+                return this.manualCompact(params);
+            case "session/cancel":
+                await this.cancel(params);
+                return {};
+            case "session/close":
+                await this.closeSession(params);
+                return {};
+            case "session/set_config_option":
+                return this.setConfigOption(params);
+            case "session/set_mode":
+                return this.setMode(params);
+            case "fs/read_text_file":
+            case "fs/write_text_file":
+            case "terminal/create":
+            case "terminal/output":
+            case "terminal/wait_for_exit":
+            case "terminal/kill":
+            case "terminal/release":
+                return {};
+            default:
+                throw new Error(`Unsupported ACP method: ${method}`);
+        }
+    }
+    initializeResponse() {
+        return {
+            protocolVersion: 1,
+            agentCapabilities: {
+                loadSession: true,
+                sessionCapabilities: {
+                    resume: true,
+                    close: true
+                }
+            }
+        };
+    }
+    async newSession(params) {
+        const cwd = stringField(params, "cwd") || process.cwd();
+        this.applyInitialConfig(params);
+        await this.ensureCodex(cwd);
+        const created = await this.requireRpc().request("thread/start", {
+            cwd,
+            approvalsReviewer: "user",
+            ...this.codexConfig(),
+            ephemeral: false,
+            threadSource: "aca-codex-acp"
+        }, 60_000);
+        const sessionId = threadIdFromResponse(created);
+        if (!sessionId)
+            throw new Error("Codex thread/start did not return thread id");
+        this.currentSessionId = sessionId;
+        this.currentCwd = cwd;
+        this.captureThreadMetadata(created);
+        return this.sessionResponse(sessionId);
+    }
+    async resumeSession(params) {
+        const sessionId = stringField(params, "sessionId");
+        if (!sessionId)
+            throw new Error("sessionId is required");
+        const cwd = stringField(params, "cwd") || this.currentCwd;
+        this.applyInitialConfig(params);
+        await this.ensureCodex(cwd);
+        const resumed = await this.requireRpc().request("thread/resume", {
+            threadId: sessionId,
+            cwd,
+            approvalsReviewer: "user",
+            ...this.codexConfig()
+        }, 60_000);
+        this.currentSessionId = threadIdFromResponse(resumed) || sessionId;
+        this.currentCwd = cwd;
+        this.captureThreadMetadata(resumed);
+        return this.sessionResponse(this.currentSessionId);
+    }
+    async prompt(params) {
+        const requestedSessionId = stringField(params, "sessionId") || this.currentSessionId;
+        let sessionId = this.resolveSessionAlias(requestedSessionId);
+        if (!sessionId)
+            throw new Error("sessionId is required");
+        const prompt = Array.isArray(params.prompt) ? params.prompt : [];
+        const rpc = this.requireRpc();
+        this.currentSessionId = sessionId;
+        this.promptActive = true;
+        this.currentTurnId = null;
+        this.currentPromptText = acpPromptText(prompt);
+        this.currentAssistantText = "";
+        this.currentAffectedFiles.clear();
+        this.agentMessagePhases.clear();
+        let promptResponse;
+        try {
+            promptResponse = await rpc.request("turn/start", {
+                threadId: sessionId,
+                clientUserMessageId: `aca-acp-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                input: acpPromptToCodexInput(prompt),
+                cwd: this.currentCwd,
+                ...turnConfigFromConfig(this.config)
+            }, readPromptTimeoutMs());
+            const turnId = String(promptResponse?.turn?.id ?? "");
+            this.currentTurnId = turnId || null;
+            const turn = turnId ? await this.waitForTurnCompleted(turnId, readPromptTimeoutMs()) : promptResponse?.turn;
+            this.threadTurnCount += 1;
+            this.previousUserText = this.currentPromptText;
+            this.previousAssistantText = this.currentAssistantText;
+            this.previousAffectedFiles.clear();
+            for (const filePath of this.currentAffectedFiles)
+                this.previousAffectedFiles.add(filePath);
+            return {
+                stopReason: "end_turn",
+                sessionId: this.currentSessionId,
+                turn,
+                _meta: {
+                    acaContextUsage: contextUsageFromTokenSnapshot(this.latestTokenUsage)
+                }
+            };
+        }
+        finally {
+            this.promptActive = false;
+            this.currentTurnId = null;
+        }
+    }
+    async cancel(params) {
+        const sessionId = stringField(params, "sessionId") || this.currentSessionId;
+        if (!sessionId || !this.rpc)
+            return;
+        await this.rpc.request("turn/interrupt", { threadId: sessionId }).catch(() => void 0);
+        if (this.currentTurnId) {
+            const pending = this.pendingTurnCompletions.get(this.currentTurnId);
+            if (pending) {
+                this.pendingTurnCompletions.delete(this.currentTurnId);
+                clearTimeout(pending.timer);
+                pending.reject(new Error("Codex prompt cancelled"));
+            }
+        }
+    }
+    async manualCompact(params) {
+        const requestedSessionId = stringField(params, "sessionId") || this.currentSessionId;
+        const sessionId = this.resolveSessionAlias(requestedSessionId);
+        if (!sessionId)
+            throw new Error("sessionId is required");
+        if (this.promptActive || this.maintenanceActive)
+            throw new Error("Codex session is busy");
+        this.currentSessionId = sessionId;
+        const maintenance = await this.maintainContext("manual", {
+            userRequest: this.previousUserText,
+            assistantResponse: this.previousAssistantText,
+            affectedFiles: [...this.previousAffectedFiles]
+        }, {
+            force: true,
+            allowRollover: params.allowRollover === true
+        });
+        return {
+            sessionId: this.currentSessionId,
+            maintenance,
+            contextUsage: contextUsageFromMaintenance(maintenance)
+        };
+    }
+    async closeSession(_params) {
+        await this.shutdown();
+    }
+    async ensureCodex(cwd) {
+        if (this.rpc && this.started && this.started.child.exitCode === null && this.started.child.signalCode === null)
+            return;
+        if (this.codexStartupPromise) {
+            await this.codexStartupPromise;
+            return;
+        }
+        const startup = (async () => {
+            if (this.rpc && this.started && this.started.child.exitCode === null && this.started.child.signalCode === null)
+                return;
+            const started = startCodexAppServer(cwd);
+            const rpc = new JsonLineRpcClient(started.child, {
+                peerName: "Codex app-server",
+                onNotification: (method, params) => this.handleCodexNotification(method, params),
+                onRequest: async (method, params) => this.handleCodexRequest(method, params)
+            });
+            this.started = started;
+            this.rpc = rpc;
+            this.initialized = false;
+            await rpc.request("initialize", {
+                clientInfo: { name: "aca-codex-acp", version: "0.1.0" },
+                capabilities: {
+                    experimentalApi: true,
+                    requestAttestation: false
+                }
+            }, 60_000);
+            this.initialized = true;
+        })();
+        this.codexStartupPromise = startup;
+        try {
+            await startup;
+        }
+        catch (error) {
+            if (this.rpc && this.started && !this.initialized) {
+                await waitForClose(this.started.child, 1_000);
+            }
+            this.rpc = null;
+            this.started = null;
+            throw error;
+        }
+        finally {
+            if (this.codexStartupPromise === startup)
+                this.codexStartupPromise = null;
+        }
+    }
+    handleCodexNotification(method, params) {
+        this.captureContextNotification(method, params);
+        if (this.maintenanceActive)
+            return;
+        if (!this.promptActive && method !== "turn/completed")
+            return;
+        this.rpc?.refreshPendingRequestTimeout("turn/start");
+        this.captureAgentMessagePhase(method, params);
+        if (method === "turn/completed")
+            this.resolveTurnCompleted(params);
+        for (const update of codexAcpSessionUpdatesFromNotification(method, params, { agentMessagePhases: this.agentMessagePhases })) {
+            this.captureUpdateEvidence(update);
+            this.notify("session/update", {
+                sessionId: this.currentSessionId,
+                update
+            });
+        }
+    }
+    async handleCodexRequest(method, params) {
+        if (isCodexApprovalRequest(method)) {
+            return resolveCodexApprovalRequest(method, params, async (request) => {
+                const response = await this.requestParent("session/request_permission", {
+                    sessionId: this.currentSessionId,
+                    request: {
+                        ...request,
+                        params,
+                        method
+                    }
+                });
+                const record = objectOrEmpty(response);
+                const outcome = objectOrEmpty(record.outcome);
+                if (outcome.outcome === "selected" && typeof outcome.optionId === "string") {
+                    return { outcome: { outcome: "selected", optionId: outcome.optionId } };
+                }
+                return { outcome: { outcome: "cancelled" } };
+            });
+        }
+        if (isCodexUserInputRequest(method)) {
+            const response = await this.requestParent("elicitation/create", {
+                sessionId: this.currentSessionId,
+                request: {
+                    ...objectOrEmpty(params),
+                    method
+                }
+            });
+            const record = objectOrEmpty(response);
+            const outcome = objectOrEmpty(record.outcome);
+            if (outcome.outcome === "submitted") {
+                return {
+                    outcome: {
+                        outcome: "submitted",
+                        value: typeof outcome.value === "string" ? outcome.value : ""
+                    }
+                };
+            }
+            return { outcome: { outcome: "cancelled" } };
+        }
+        return {};
+    }
+    captureAgentMessagePhase(method, params) {
+        if (method !== "item/started" && method !== "item/completed")
+            return;
+        const item = objectField(params, "item");
+        if (stringField(item, "type") !== "agentMessage")
+            return;
+        const id = stringField(item, "id");
+        if (!id)
+            return;
+        this.agentMessagePhases.set(id, stringField(item, "phase"));
+    }
+    waitForTurnCompleted(turnId, timeoutMs) {
+        const completed = this.completedTurns.get(turnId);
+        if (completed)
+            return Promise.resolve(completed);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingTurnCompletions.delete(turnId);
+                reject(new Error("Codex app-server request timed out while waiting for turn/completed"));
+            }, timeoutMs);
+            timer.unref();
+            this.pendingTurnCompletions.set(turnId, { resolve, reject, timer });
+        });
+    }
+    resolveTurnCompleted(params) {
+        const turn = objectField(params, "turn");
+        const turnId = stringField(turn, "id");
+        if (!turnId)
+            return;
+        this.completedTurns.set(turnId, turn);
+        const pending = this.pendingTurnCompletions.get(turnId);
+        if (!pending)
+            return;
+        this.pendingTurnCompletions.delete(turnId);
+        clearTimeout(pending.timer);
+        if (stringField(turn, "status") === "failed") {
+            pending.reject(new Error(`Codex turn failed: ${JSON.stringify(turn.error ?? {})}`));
+            return;
+        }
+        pending.resolve(turn);
+    }
+    async shutdown() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.shutdownPromise = this.performShutdown();
+        return this.shutdownPromise;
+    }
+    async performShutdown() {
+        if (this.pendingCompaction) {
+            clearTimeout(this.pendingCompaction.timer);
+            this.pendingCompaction.reject(new Error("Codex ACP adapter closed"));
+            this.pendingCompaction = null;
+        }
+        for (const pending of this.pendingParentRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Codex ACP adapter closed"));
+        }
+        this.pendingParentRequests.clear();
+        for (const pending of this.pendingTurnCompletions.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Codex ACP adapter closed"));
+        }
+        this.pendingTurnCompletions.clear();
+        const child = this.started?.child;
+        if (!child || child.exitCode !== null || child.signalCode !== null)
+            return;
+        child.stdin.end();
+        if (await waitForClose(child, 2_000))
+            return;
+        child.kill("SIGTERM");
+        if (await waitForClose(child, 1_000))
+            return;
+        child.kill("SIGKILL");
+        await waitForClose(child, 1_000);
+    }
+    sessionResponse(sessionId) {
+        return {
+            sessionId,
+            modes: {
+                currentModeId: "workspace-write",
+                availableModes: [
+                    { id: "read-only", name: "Read Only" },
+                    { id: "workspace-write", name: "Workspace Write" },
+                    { id: "danger-full-access", name: "Full Access" }
+                ]
+            },
+            configOptions: [
+                { id: "model", category: "model", type: "string" },
+                { id: "approvalPolicy", category: "approval", type: "string" },
+                { id: "sandbox", category: "mode", type: "string" }
+            ]
+        };
+    }
+    requireRpc() {
+        if (!this.rpc)
+            throw new Error("Codex app-server is not started");
+        return this.rpc;
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: "2.0", method, params });
+    }
+    requestParent(method, params, timeoutMs = 10 * 60 * 1000) {
+        const id = this.nextParentRequestId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingParentRequests.delete(id);
+                reject(new Error(`ACP client request timed out: ${method}`));
+            }, timeoutMs);
+            timer.unref();
+            this.pendingParentRequests.set(id, { resolve, reject, timer });
+            this.write({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    handleParentResponse(message) {
+        const id = Number(message.id);
+        const pending = this.pendingParentRequests.get(id);
+        if (!pending)
+            return;
+        this.pendingParentRequests.delete(id);
+        clearTimeout(pending.timer);
+        if ("error" in message) {
+            const error = objectOrEmpty(message.error);
+            pending.reject(new Error(stringField(error, "message") || "ACP client request failed"));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    setConfigOption(params) {
+        const configId = stringField(params, "configId");
+        const value = params.value;
+        if (!configId)
+            throw new Error("configId is required");
+        if (typeof value !== "string" && typeof value !== "boolean")
+            throw new Error("config value must be string or boolean");
+        this.config[configId] = value;
+        this.notify("session/update", {
+            sessionId: this.currentSessionId,
+            update: {
+                sessionUpdate: "config_option_update",
+                configId,
+                value
+            }
+        });
+        return {};
+    }
+    setMode(params) {
+        const modeId = stringField(params, "modeId");
+        if (!modeId)
+            throw new Error("modeId is required");
+        this.config.sandbox = modeId;
+        this.notify("session/update", {
+            sessionId: this.currentSessionId,
+            update: {
+                sessionUpdate: "current_mode_update",
+                modeId
+            }
+        });
+        return {};
+    }
+    applyInitialConfig(params) {
+        const config = objectField(params, "config");
+        for (const [key, value] of Object.entries(config)) {
+            if (typeof value === "string" || typeof value === "boolean") {
+                this.config[key] = value;
+            }
+        }
+    }
+    codexConfig() {
+        return {
+            ...(typeof this.config.model === "string" && this.config.model ? { model: this.config.model } : {}),
+            approvalPolicy: typeof this.config.approvalPolicy === "string" ? this.config.approvalPolicy : "on-request",
+            sandbox: typeof this.config.sandbox === "string" ? this.config.sandbox : "workspace-write"
+        };
+    }
+    captureContextNotification(method, params) {
+        if (method === "thread/tokenUsage/updated") {
+            this.latestTokenUsage = codexTokenUsageFromNotification(params) ?? this.latestTokenUsage;
+        }
+        if (method === "thread/compacted" && this.pendingCompaction) {
+            const pending = this.pendingCompaction;
+            this.pendingCompaction = null;
+            clearTimeout(pending.timer);
+            pending.resolve();
+        }
+        if (method === "item/completed") {
+            const item = objectField(params, "item");
+            if (stringField(item, "type") === "agentMessage" && stringField(item, "phase") === "final_answer") {
+                this.currentAssistantText = textFromUnknown(item) || this.currentAssistantText;
+            }
+        }
+    }
+    captureUpdateEvidence(update) {
+        if (String(update.sessionUpdate || "") === "agent_message_chunk") {
+            this.currentAssistantText += textFromUnknown(update.content);
+        }
+        collectAffectedPaths(update, this.currentAffectedFiles);
+    }
+    captureThreadMetadata(response) {
+        const thread = objectField(response, "thread");
+        this.currentRolloutPath = stringField(thread, "path") || null;
+        this.threadTurnCount = Array.isArray(thread.turns) ? thread.turns.length : 0;
+        const continuity = continuityFromTurns(thread.turns);
+        if (continuity.userRequest)
+            this.previousUserText = continuity.userRequest;
+        if (continuity.assistantResponse)
+            this.previousAssistantText = continuity.assistantResponse;
+        this.previousAffectedFiles.clear();
+        for (const filePath of continuity.affectedFiles)
+            this.previousAffectedFiles.add(filePath);
+        this.latestTokenUsage = null;
+    }
+    async maintainContext(stage, evidence, options = {}) {
+        const policy = readCodexContextMaintenancePolicy();
+        const beforeState = this.contextState();
+        const initialDecision = decideCodexContextMaintenance(beforeState, policy);
+        if ((!initialDecision.compact && !options.force) || !this.currentSessionId) {
+            return this.maintenanceResult({ stage, action: "none", reasons: initialDecision.reasons, beforeState });
+        }
+        const previousThreadId = this.currentSessionId;
+        this.notifyContextStatus("正在整理会话上下文", contextStatusDetail(beforeState));
+        this.maintenanceActive = true;
+        let compactFailed = false;
+        let compactError = "";
+        let afterState = beforeState;
+        let postCompactDecision = initialDecision;
+        let rotated = false;
+        let rolloverError = "";
+        try {
+            const previousUsageAtMs = beforeState.usage?.observedAtMs ?? 0;
+            await this.compactThread(previousThreadId, policy.compactTimeoutMs);
+            await this.waitForTokenUsageAfter(previousUsageAtMs, 2_000);
+        }
+        catch (error) {
+            compactFailed = true;
+            compactError = error instanceof Error ? error.message : String(error);
+        }
+        try {
+            afterState = this.contextState();
+            postCompactDecision = decideCodexContextMaintenance(afterState, policy, {
+                compactAttempted: true,
+                compactFailed
+            });
+            if (postCompactDecision.rollover && options.allowRollover !== false) {
+                this.notifyContextStatus("正在创建轻量会话", postCompactDecision.reasons.join(", "));
+                try {
+                    await this.rotateThread(previousThreadId, evidence);
+                    rotated = true;
+                }
+                catch (error) {
+                    rolloverError = error instanceof Error ? error.message : String(error);
+                    this.notifyContextStatus("轻量会话创建失败", rolloverError);
+                }
+            }
+            else if (!compactFailed) {
+                this.notifyContextStatus("会话上下文已压缩", contextStatusDetail(afterState));
+            }
+        }
+        finally {
+            this.maintenanceActive = false;
+        }
+        return this.maintenanceResult({
+            action: rotated ? "rollover" : rolloverError ? "rollover_failed" : compactFailed ? "compact_failed" : "compact",
+            stage,
+            reasons: postCompactDecision.reasons,
+            beforeState,
+            afterState,
+            compactError: [compactError, rolloverError].filter(Boolean).join("; "),
+            previousThreadId,
+            rolloverRecommended: postCompactDecision.rollover && options.allowRollover === false
+        });
+    }
+    compactThread(threadId, timeoutMs) {
+        if (this.pendingCompaction)
+            return Promise.reject(new Error("Codex context compaction is already running"));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pendingCompaction?.timer === timer)
+                    this.pendingCompaction = null;
+                reject(new Error("Codex thread compaction timed out"));
+            }, timeoutMs);
+            timer.unref();
+            this.pendingCompaction = { resolve, reject, timer };
+            void this.requireRpc().request("thread/compact/start", { threadId }, timeoutMs).catch((error) => {
+                if (this.pendingCompaction?.timer !== timer)
+                    return;
+                this.pendingCompaction = null;
+                clearTimeout(timer);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
+    async rotateThread(previousThreadId, evidence) {
+        const continuityInstructions = buildCodexContinuityInstructions({
+            previousThreadId,
+            cwd: this.currentCwd,
+            userRequest: evidence.userRequest,
+            assistantResponse: evidence.assistantResponse,
+            affectedFiles: evidence.affectedFiles
+        });
+        const created = await this.requireRpc().request("thread/start", {
+            cwd: this.currentCwd,
+            approvalsReviewer: "user",
+            ...this.codexConfig(),
+            developerInstructions: continuityInstructions,
+            ephemeral: false,
+            threadSource: "aca-codex-acp-rollover"
+        }, 60_000);
+        const nextThreadId = threadIdFromResponse(created);
+        if (!nextThreadId)
+            throw new Error("Codex rollover thread/start did not return thread id");
+        this.sessionAliases.set(previousThreadId, nextThreadId);
+        this.currentSessionId = nextThreadId;
+        this.captureThreadMetadata(created);
+    }
+    async waitForTokenUsageAfter(observedAtMs, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if ((this.latestTokenUsage?.observedAtMs ?? 0) > observedAtMs)
+                return;
+            await delay(50);
+        }
+    }
+    resolveSessionAlias(sessionId) {
+        if (!sessionId)
+            return null;
+        let current = sessionId;
+        const visited = new Set();
+        while (this.sessionAliases.has(current) && !visited.has(current)) {
+            visited.add(current);
+            current = this.sessionAliases.get(current) ?? current;
+        }
+        return current;
+    }
+    contextState() {
+        return {
+            usage: this.latestTokenUsage,
+            rolloutBytes: rolloutFileSize(this.currentRolloutPath),
+            turnCount: this.threadTurnCount
+        };
+    }
+    maintenanceResult(input) {
+        return {
+            stage: input.stage,
+            action: input.action,
+            reasons: input.reasons,
+            previousThreadId: input.previousThreadId ?? null,
+            sessionId: this.currentSessionId,
+            before: input.beforeState,
+            after: input.afterState ?? null,
+            compactError: input.compactError || null,
+            rolloverRecommended: input.rolloverRecommended === true
+        };
+    }
+    notifyContextStatus(label, detail) {
+        this.notify("session/update", {
+            sessionId: this.currentSessionId,
+            update: {
+                sessionUpdate: "aca_context_maintenance",
+                label,
+                detail
+            }
+        });
+    }
+    write(message) {
+        process.stdout.write(`${JSON.stringify(message)}\n`);
+    }
+}
+function acpPromptToCodexInput(prompt) {
+    return prompt.map((block) => {
+        const record = objectOrEmpty(block);
+        if (record.type === "image") {
+            const uri = stringField(record, "uri");
+            if (uri)
+                return { type: "localImage", path: uri };
+            const data = stringField(record, "data");
+            const mimeType = stringField(record, "mimeType") || "image/png";
+            return { type: "image", url: `data:${mimeType};base64,${data}` };
+        }
+        return { type: "text", text: stringField(record, "text"), text_elements: [] };
+    });
+}
+function acpPromptText(prompt) {
+    return prompt.map((block) => stringField(objectOrEmpty(block), "text")).filter(Boolean).join("\n\n");
+}
+function turnConfigFromConfig(config) {
+    const result = {};
+    if (typeof config.model === "string" && config.model)
+        result.model = config.model;
+    if (typeof config.approvalPolicy === "string" && config.approvalPolicy)
+        result.approvalPolicy = config.approvalPolicy;
+    if (typeof config.sandbox === "string" && config.sandbox)
+        result.sandbox = config.sandbox;
+    const effort = config.reasoningEffort ?? config.model_reasoning_effort ?? config.effort;
+    if (typeof effort === "string" && effort)
+        result.effort = effort;
+    return result;
+}
+function threadIdFromResponse(value) {
+    const thread = objectField(value, "thread");
+    return stringField(thread, "id") || null;
+}
+function objectField(value, key) {
+    const record = objectOrEmpty(value);
+    return objectOrEmpty(record[key]);
+}
+function objectOrEmpty(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function textFromUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(textFromUnknown).filter(Boolean).join("");
+    if (!value || typeof value !== "object")
+        return "";
+    const record = objectOrEmpty(value);
+    for (const key of ["text", "message", "content", "output_text"]) {
+        const text = textFromUnknown(record[key]);
+        if (text)
+            return text;
+    }
+    return "";
+}
+function collectAffectedPaths(value, sink) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectAffectedPaths(item, sink);
+        return;
+    }
+    const record = objectOrEmpty(value);
+    const type = stringField(record, "type").toLowerCase();
+    const path = stringField(record, "path");
+    if (path && ["diff", "resource_link", "content"].includes(type))
+        sink.add(path);
+    if (Array.isArray(record.locations)) {
+        for (const location of record.locations) {
+            const locationPath = stringField(objectOrEmpty(location), "path");
+            if (locationPath)
+                sink.add(locationPath);
+        }
+    }
+    for (const nested of [record.content, record.update, record.rawInput, record.rawOutput]) {
+        if (nested && nested !== value)
+            collectAffectedPaths(nested, sink);
+    }
+}
+function continuityFromTurns(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return { userRequest: "", assistantResponse: "", affectedFiles: [] };
+    const latestTurn = value.at(-1);
+    const affectedFiles = new Set();
+    collectAffectedPaths(latestTurn, affectedFiles);
+    let userRequest = "";
+    let assistantResponse = "";
+    const visit = (item) => {
+        if (Array.isArray(item)) {
+            for (const child of item)
+                visit(child);
+            return;
+        }
+        if (!item || typeof item !== "object")
+            return;
+        const record = objectOrEmpty(item);
+        const type = stringField(record, "type").toLowerCase();
+        if (type === "usermessage")
+            userRequest = textFromUnknown(record) || userRequest;
+        if (type === "agentmessage")
+            assistantResponse = textFromUnknown(record) || assistantResponse;
+        for (const key of ["items", "content", "input"]) {
+            if (record[key])
+                visit(record[key]);
+        }
+    };
+    visit(latestTurn);
+    return { userRequest, assistantResponse, affectedFiles: [...affectedFiles] };
+}
+function contextUsageFromMaintenance(maintenance) {
+    const action = String(maintenance.action || "none");
+    const after = objectOrEmpty(maintenance.after);
+    const before = objectOrEmpty(maintenance.before);
+    const afterUsage = objectOrEmpty(after.usage);
+    const beforeUsage = objectOrEmpty(before.usage);
+    const usage = Object.keys(afterUsage).length > 0 ? afterUsage : beforeUsage;
+    const contextWindow = numberField(usage, "contextWindow");
+    if (action === "rollover") {
+        return {
+            usedTokens: 0,
+            inputTokens: 0,
+            contextWindow,
+            ratio: 0,
+            observedAtMs: Date.now(),
+            state: "new_thread",
+            maintenanceAction: action
+        };
+    }
+    if (Object.keys(usage).length === 0)
+        return null;
+    const totalTokens = numberField(usage, "totalTokens");
+    const inputTokens = numberField(usage, "inputTokens");
+    return {
+        usedTokens: totalTokens || inputTokens,
+        inputTokens,
+        contextWindow,
+        ratio: contextWindow > 0 ? (totalTokens || inputTokens) / contextWindow : 0,
+        observedAtMs: numberField(usage, "observedAtMs") || Date.now(),
+        state: action === "compact" ? "compacted" : "active",
+        maintenanceAction: action
+    };
+}
+function contextUsageFromTokenSnapshot(usage) {
+    if (!usage)
+        return null;
+    return {
+        usedTokens: usage.totalTokens || usage.inputTokens,
+        inputTokens: usage.inputTokens,
+        contextWindow: usage.contextWindow,
+        ratio: usage.contextWindow > 0 ? (usage.totalTokens || usage.inputTokens) / usage.contextWindow : 0,
+        observedAtMs: usage.observedAtMs,
+        state: "active",
+        maintenanceAction: null
+    };
+}
+function contextStatusDetail(state) {
+    const tokens = state.usage ? `${state.usage.inputTokens} tokens` : "token unknown";
+    const rollout = state.rolloutBytes > 0 ? `${Math.round(state.rolloutBytes / 1024 / 1024)}MB rollout` : "rollout unknown";
+    return `${tokens}, ${rollout}, ${state.turnCount} turns`;
+}
+function numberField(value, key) {
+    const item = objectOrEmpty(value)[key];
+    return typeof item === "number" && Number.isFinite(item) ? item : 0;
+}
+function stringField(value, key) {
+    const record = objectOrEmpty(value);
+    const item = record[key];
+    return typeof item === "string" ? item : "";
+}
+function isCodexUserInputRequest(method) {
+    const normalized = method.toLowerCase();
+    return normalized.includes("elicitation")
+        || normalized.includes("requestuserinput")
+        || normalized.includes("request_user_input")
+        || normalized.includes("input/request");
+}
+function readPromptTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ACA_ACP_PROMPT_TIMEOUT_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 30_000 ? parsed : 6 * 60 * 60 * 1000;
+}
+function waitForClose(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), timeoutMs);
+        timer.unref();
+        child.once("close", () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function runCodexAcpAdapter() {
+    new CodexAcpAdapter();
+}
+const entry = process.argv[1] || "";
+// 单文件 Worker 由 worker-single-cli 显式调用；这里仅保留直接运行 adapter.js/ts
+// 时的入口，避免同一个 SEA 进程创建两个 Adapter 实例。
+if (/(?:^|[\\/])adapter\.(?:js|ts)$/.test(entry)) {
+    runCodexAcpAdapter();
+}