chatccc 0.2.286 → 0.2.288

package/dist/src/adapters/codex-adapter.js

@@ -1,22 +1,25 @@
 // =============================================================================
-// codex-adapter.ts — OpenAI Codex CLI 适配器
+// codex-adapter.ts — OpenAI Codex CLI 适配器（app-server 模式）
 // =============================================================================
-// 通过 codex exec --json 与 Codex CLI 交互。
-// - createSession: 生成 UUID sessionId，记录 cwd，不创建 Codex 线程（延迟到首次 prompt）
-// - prompt: 首次调用用 codex exec 创建线程，后续用 codex exec resume 恢复
+// 通过 codex app-server（WebSocket JSON-RPC）与 Codex CLI 交互。
+// - createSession: 生成 UUID sessionId，记录 cwd，不创建线程（延迟到首次 prompt）
+// - prompt: 首次 thread/start 创建持久化线程，后续 thread/resume 恢复；
+//   运行中通过 turn/steer 在 item 边界注入新消息（协作式让位，对齐 ccc）
 // - getSessionInfo: 从持久化映射读取 cwd / threadId
+//
+// 权限语义与旧 exec 模式 `--dangerously-bypass-approvals-and-sandbox` 等价：
+//   approvalPolicy: "never" + sandbox: "danger-full-access"（demo 已实测零审批）。
+// /plan、/ask 命令退化为只读沙箱（对应旧 exec 的 --sandbox read-only）。
 // =============================================================================
-import { spawn } from "node:child_process";
 import { createTurnCompletion } from "./turn-completion.js";
-import { cliProcessOptions, ensureCliSessionReleased, ownCliProcess } from "./managed-cli-process.js";
+import { ensureCliSessionReleased } from "./managed-cli-process.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseUserCommand } from "./adapter-interface.js";
 import { defaultCodexSessionMetaStore, } from "./codex-session-meta-store.js";
-import { config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
-import { createRawStreamLog, } from "./raw-stream-log.js";
-import { readJsonLinesWithBadJsonIdleWatchdog } from "./jsonl-stream.js";
+import { config, PROJECT_ROOT } from "../config.js";
+import { AsyncQueue, CodexAppServerManager, JsonRpcClient, } from "./codex-app-server.js";
 // ---------------------------------------------------------------------------
 // 特殊注入提示
 // ---------------------------------------------------------------------------
@@ -51,160 +54,88 @@ function buildCodexPromptText(userText) {
 function detectCodexCommand() {
     return config.codex.path || "codex";
 }
-/** exec 模式共用参数：JSONL 输出、绕过沙盒和确认、跳过 git 仓库检查 */
-const CODEX_BASE_ARGS = [
-    "exec",
-    "--json",
-    "--dangerously-bypass-approvals-and-sandbox",
-    "--skip-git-repo-check",
-];
-/** codex 模型；留空（""）表示不传 --model，由 codex config.toml 决定 */
+/** codex 模型；留空（""）表示不传，由 codex config.toml 决定 */
 function resolveCodexModel() {
     const m = config.codex.model;
     return m.trim() !== "" ? m : null;
 }
-/** codex 努力程度（映射为 -c model_reasoning_effort=<value>）；留空表示不传 */
+/** codex 努力程度；留空表示不传 */
 function resolveCodexEffort() {
     const e = config.codex.effort;
     return e.trim() !== "" ? e : null;
 }
-// ---------------------------------------------------------------------------
-// normalizeCodexMessage — Codex 事件 → UnifiedStreamMessage | null
-// ---------------------------------------------------------------------------
-export function normalizeCodexMessage(msg) {
-    if (msg.type === "error") {
-        throw new Error(`Codex turn failed: ${msg.message?.trim() || "未提供错误详情"}`);
-    }
-    if (msg.type === "turn.failed") {
-        const detail = typeof msg.error === "string" ? msg.error : msg.error?.message;
-        throw new Error(`Codex turn failed: ${detail?.trim() || "unknown Codex error"}`);
+function itemOf(params) {
+    return params.item;
+}
+export function normalizeCodexNotification(method, params) {
+    // error 通知：willRetry=false 是致命错误；willRetry=true 会自动重试，忽略
+    if (method === "error") {
+        const willRetry = params.willRetry;
+        const message = params.error?.message;
+        if (willRetry === false) {
+            throw new Error(`Codex turn failed: ${message?.trim() || "unknown Codex error"}`);
+        }
+        return null;
     }
-    // agent_message 只是 Codex 的一条阶段性文本 item。即使内容看起来像完整答复，
-    // 后面仍可能继续发出工具调用，因此不能用它关闭 response-stall watchdog。
-    if (msg.type === "item.completed" &&
-        msg.item?.type === "agent_message" &&
-        msg.item.text) {
+    // agentMessage 是 Codex 的一条阶段性文本 item（整段）。即使内容像完整答复，
+    // 后面仍可能继续工具调用，因此不能用它关闭 response-stall watchdog。
+    if (method === "item/completed" &&
+        itemOf(params)?.type === "agentMessage" &&
+        itemOf(params)?.text) {
         return {
             type: "assistant",
-            blocks: [{ type: "text", text: msg.item.text }],
+            blocks: [{ type: "text", text: itemOf(params).text }],
         };
     }
-    // turn.completed 是 Codex 对整轮完成的权威确认。正文已经由之前的
-    // agent_message 累计，这里只发送空终态信号，避免重复追加最终文本。
-    if (msg.type === "turn.completed") {
+    // turn/completed 是 Codex 对整轮完成的权威确认。正文已由 agentMessage 累计。
+    if (method === "turn/completed") {
+        const turn = params.turn;
+        if (turn?.status === "failed") {
+            throw new Error(`Codex turn failed: ${turn.error?.message?.trim() || "unknown Codex error"}`);
+        }
         return {
             type: "assistant",
             blocks: [],
             isFinalResponse: true,
         };
     }
-    // command_execution 工具调用开始
-    if (msg.type === "item.started" &&
-        msg.item?.type === "command_execution" &&
-        msg.item.command) {
+    // commandExecution 工具调用开始
+    if (method === "item/started" &&
+        itemOf(params)?.type === "commandExecution" &&
+        itemOf(params)?.command) {
+        const item = itemOf(params);
         return {
             type: "assistant",
             blocks: [
                 {
                     type: "tool_use",
-                    id: msg.item.id,
+                    id: item.id,
                     name: "Bash",
-                    input: { command: msg.item.command },
+                    input: { command: item.command },
                 },
             ],
         };
     }
-    // command_execution 工具调用完成
-    if (msg.type === "item.completed" &&
-        msg.item?.type === "command_execution") {
-        const exitCode = msg.item.exit_code;
+    // commandExecution 工具调用完成
+    if (method === "item/completed" && itemOf(params)?.type === "commandExecution") {
+        const item = itemOf(params);
+        const exitCode = item.exitCode;
         return {
             type: "assistant",
             blocks: [
                 {
                     type: "tool_result",
-                    tool_use_id: msg.item.id ?? "",
-                    content: msg.item.aggregated_output ?? "",
+                    tool_use_id: item.id ?? "",
+                    content: item.aggregatedOutput ?? "",
                     is_error: exitCode != null && exitCode !== 0 ? true : undefined,
                 },
             ],
         };
     }
-    // thread.started / turn.started → 不映射为用户可见消息
+    // thread/started、turn/started、item/agentMessage/delta 等 → 不映射为用户可见消息
     return null;
 }
 // ---------------------------------------------------------------------------
-// 子进程辅助函数
-// ---------------------------------------------------------------------------
-export function buildCodexInvocationArgs(args, modelOverride, effortOverride, fastModeOverride) {
-    const allArgs = [...args];
-    const model = modelOverride ?? resolveCodexModel();
-    if (model) {
-        // 把 -m 插在 exec 后面、其他参数前面
-        const execIdx = allArgs.indexOf("exec");
-        allArgs.splice(execIdx + 1, 0, "-m", model);
-    }
-    const effort = effortOverride ?? resolveCodexEffort();
-    if (effort) {
-        allArgs.push("-c", `model_reasoning_effort="${effort}"`);
-    }
-    const fastMode = fastModeOverride ?? config.codex.fastMode;
-    allArgs.push("-c", `service_tier="${fastMode ? "fast" : "default"}"`);
-    return allArgs;
-}
-function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastModeOverride) {
-    const allArgs = buildCodexInvocationArgs(args, modelOverride, effortOverride, fastModeOverride);
-    const proc = spawn(detectCodexCommand(), allArgs, {
-        cwd,
-        stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
-        windowsHide: true,
-        shell: true,
-        ...cliProcessOptions(),
-    });
-    let stderr = "";
-    let exitCode = null;
-    let signal = null;
-    let settleClose = () => { };
-    const closed = new Promise(resolve => { settleClose = resolve; });
-    proc.once("error", (error) => { stderr += `\n${error.message}`; settleClose(); });
-    proc.stderr.on("data", (chunk) => {
-        stderr += chunk.toString();
-    });
-    proc.on("close", (code, exitSignal) => {
-        exitCode = code;
-        signal = exitSignal;
-        settleClose();
-        if (code !== 0 && stderr.trim()) {
-            console.error(`[Codex stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`);
-        }
-    });
-    if (stdinText !== undefined) {
-        proc.stdin.write(stdinText);
-        proc.stdin.end();
-    }
-    return { proc, async failureDetail() {
-            let timer;
-            try {
-                await Promise.race([closed, new Promise(resolve => { timer = setTimeout(resolve, 2_000); })]);
-                return `exit=${exitCode ?? "unknown"}; signal=${signal ?? "none"}; ${stderr.trim() || "无 stderr 详情"}`;
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-        } };
-}
-async function* readJsonLines(proc, signal, rawLog) {
-    yield* readJsonLinesWithBadJsonIdleWatchdog({
-        input: proc.stdout,
-        tool: "codex",
-        tag: "codex",
-        signal,
-        rawLog,
-        parse: (line) => JSON.parse(line),
-    });
-}
-// ---------------------------------------------------------------------------
 // 适配器实现
 // ---------------------------------------------------------------------------
 class CodexAdapter {
@@ -220,7 +151,7 @@ class CodexAdapter {
         this.effortOverride = effortOverride;
         this.fastModeOverride = fastModeOverride;
     }
-    // createSession: 生成 sessionId，记录 cwd，不创建 Codex 线程（延迟到首次 prompt）
+    // createSession: 生成 sessionId，记录 cwd，不创建线程（延迟到首次 prompt）
     async createSession(cwd) {
         const sessionId = randomUUID();
         await this.metaStore.set(sessionId, { cwd });
@@ -230,61 +161,143 @@ class CodexAdapter {
         if (signal?.aborted)
             return;
         await ensureCliSessionReleased(sessionId);
-        let meta = await this.metaStore.get(sessionId);
+        const meta = await this.metaStore.get(sessionId);
         const threadId = meta?.threadId;
         const isFirstPrompt = !threadId;
-        // 首次 prompt: codex exec 创建新线程
-        // 后续 prompt: codex exec resume 恢复已有线程（resume 不接受 -C，cwd 继承自原线程）
         const cmd = parseUserCommand(userText);
-        const baseArgs = cmd.mode
-            ? ["exec", "--json", "--sandbox", "read-only", "--skip-git-repo-check"]
-            : CODEX_BASE_ARGS;
-        const args = isFirstPrompt
-            ? [...baseArgs, "-C", cwd, "-"]
-            : [...baseArgs, "resume", threadId, "-"];
-        const handle = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
-        const proc = handle.proc;
-        const ownership = ownCliProcess(sessionId, proc.pid);
-        if (proc.pid !== undefined)
-            options?.onProcessStart?.({ pid: proc.pid });
-        const rawLogConfig = config.rawStreamLogs.codex;
-        let rawLog = null;
-        try {
-            rawLog = await createRawStreamLog({
-                enabled: rawLogConfig.enabled,
-                rootDir: RAW_STREAM_LOGS_DIR,
-                tool: "codex",
-                sessionId,
-                label: "prompt",
-                maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
-                retentionDays: rawLogConfig.retentionDays,
-            });
-        }
-        catch (err) {
-            console.error(`[Codex raw stream log] create failed: ${err.message}`);
-        }
-        // 关键：spawn 用了 shell:true，proc.pid 指向的是壳进程（cmd.exe / sh）。
-        // 真正干活的是壳的孙子 codex.exe。普通 proc.kill() 在 Windows 上只杀第一层，
-        // 会留下幽灵 node + codex.exe 继续烧 token、stream-state 永远停在 running。
-        // 因此 abort 与 finally 都必须用 killProcessTree 整棵进程树一起收尸。
-        const onAbort = () => { void ownership.stop().catch(() => { }); };
+        const readOnly = cmd.mode !== null;
+        // thread/start 用字符串枚举；turn/start 用对象策略
+        const threadSandbox = readOnly ? "read-only" : "danger-full-access";
+        const turnSandboxPolicy = readOnly
+            ? { type: "readOnly", networkAccess: true }
+            : { type: "dangerFullAccess" };
+        const model = this.modelOverride ?? resolveCodexModel();
+        const effort = this.effortOverride ?? resolveCodexEffort();
+        const fastMode = this.fastModeOverride ?? config.codex.fastMode;
+        // 确保常驻 app-server 已启动，并建立本次 prompt 的 WebSocket 连接
+        const port = await CodexAppServerManager.get().ensureStarted(detectCodexCommand());
+        const client = await JsonRpcClient.connect(`ws://127.0.0.1:${port}`);
+        let threadIdResolved = threadId ?? null;
+        let currentTurnId = null;
+        const interruptAndClose = async () => {
+            if (threadIdResolved && currentTurnId) {
+                try {
+                    await client.request("turn/interrupt", { threadId: threadIdResolved, turnId: currentTurnId }, 3000);
+                }
+                catch {
+                    /* turn 可能已结束 */
+                }
+            }
+            client.close();
+        };
+        // 上层 stop-stuck-loop 强制关闭：打断当前 turn + 断开连接（不杀共享进程）
+        options?.onSessionCreated?.(() => {
+            void interruptAndClose().catch(() => { });
+        });
+        const onAbort = () => {
+            void interruptAndClose().catch(() => { });
+        };
         signal?.addEventListener("abort", onAbort, { once: true });
         let completed = false;
         const completion = createTurnCompletion("Codex");
         try {
-            for await (const raw of readJsonLines(proc, signal, rawLog)) {
+            // 1. 握手
+            await client.request("initialize", {
+                clientInfo: { name: "chatccc-codex", title: null, version: "0.0.0" },
+                capabilities: null,
+            }, 60000);
+            // 2. 线程：首次 thread/start 创建持久化线程，后续 thread/resume 恢复
+            const threadParams = {
+                cwd,
+                approvalPolicy: "never",
+                sandbox: threadSandbox,
+                ...(model ? { model } : {}),
+            };
+            if (isFirstPrompt) {
+                const r = await client.request("thread/start", threadParams, 60000);
+                threadIdResolved = r.thread?.id;
+                if (threadIdResolved) {
+                    void this.metaStore.setThreadId(sessionId, threadIdResolved).catch(() => { });
+                }
+            }
+            else {
+                try {
+                    await client.request("thread/resume", { threadId: threadId, excludeTurns: true, ...threadParams }, 60000);
+                }
+                catch (err) {
+                    // 存量 threadId 在磁盘上不可恢复（被清理/损坏）→ 回退到新建线程
+                    console.warn(`[Codex] thread/resume 失败，回退到新线程: ${err.message}`);
+                    const r = await client.request("thread/start", threadParams, 60000);
+                    threadIdResolved = r.thread?.id;
+                    if (threadIdResolved) {
+                        void this.metaStore.setThreadId(sessionId, threadIdResolved).catch(() => { });
+                    }
+                }
+            }
+            // 3. 启动 turn
+            const turnResp = await client.request("turn/start", {
+                threadId: threadIdResolved,
+                input: [
+                    { type: "text", text: buildCodexPromptText(userText), text_elements: [] },
+                ],
+                approvalPolicy: "never",
+                sandboxPolicy: turnSandboxPolicy,
+                ...(model ? { model } : {}),
+                ...(effort ? { effort } : {}),
+                serviceTier: fastMode ? "fast" : "default",
+            }, 120000);
+            currentTurnId = turnResp.turn?.id;
+            // 4. 事件循环：WebSocket 通知 → async iterable
+            const queue = new AsyncQueue();
+            client.onNotification = (method, params) => {
+                queue.push({ method, params });
+                // turn/completed 与致命 error 都终止本轮事件流
+                if (method === "turn/completed" || (method === "error" && params.willRetry === false)) {
+                    queue.end();
+                }
+            };
+            // approvalPolicy=never 下不应收到审批请求；fail-closed 暴露配置失效
+            client.onServerRequest = (method, _params, id) => {
+                console.error(`[Codex] 意外收到服务端请求（审批策略未生效？）: ${method}`);
+                client.respondError(id, -32000, `unexpected server request: ${method}`);
+            };
+            client.onClose = () => {
+                queue.end();
+            };
+            // 5. 消费事件流，item 边界执行协作式注入
+            for await (const { method, params } of queue) {
                 if (signal?.aborted)
                     break;
-                if (isFirstPrompt &&
-                    raw.type === "thread.started" &&
-                    raw.thread_id) {
-                    void this.metaStore
-                        .setThreadId(sessionId, raw.thread_id)
-                        .catch(() => { });
+                // 工具步骤边界 → 检查并吸收运行期注入（turn/steer）
+                if (method === "item/completed") {
+                    const injected = options?.drainInput?.();
+                    if (injected && threadIdResolved && currentTurnId) {
+                        try {
+                            const steerResp = await client.request("turn/steer", {
+                                threadId: threadIdResolved,
+                                input: [{ type: "text", text: injected, text_elements: [] }],
+                                expectedTurnId: currentTurnId,
+                            }, 30000);
+                            currentTurnId = steerResp.turnId;
+                            yield { type: "assistant", blocks: [{ type: "input_injected", text: injected }] };
+                        }
+                        catch (err) {
+                            // steer 失败（turn 恰好已结束，expectedTurnId 前置条件不满足）
+                            // → 退回注入队列，交由上层在整轮结束后作为新消息消费，避免丢消息。
+                            console.error(`[Codex] turn/steer 失败，注入消息退回队列: ${err.message}`);
+                            options?.onInjectionRejected?.();
+                        }
+                    }
                 }
-                const normalized = normalizeCodexMessage(raw);
+                // turn/started 确认当前活跃 turn id（turn/steer 后可能变化）
+                if (method === "turn/started") {
+                    const turnId = params.turn?.id;
+                    if (turnId)
+                        currentTurnId = turnId;
+                }
+                const normalized = normalizeCodexNotification(method, params);
                 completion.observe(normalized);
-                if (raw.type === "turn.completed") {
+                if (method === "turn/completed") {
                     completion.complete();
                     completed = true;
                 }
@@ -293,21 +306,13 @@ class CodexAdapter {
                 if (completed)
                     break;
             }
-            if (!signal?.aborted && !completed)
-                completion.assertComplete(await handle.failureDetail());
+            if (!signal?.aborted && !completed) {
+                completion.assertComplete("app-server 连接在 turn 完成前关闭");
+            }
         }
         finally {
             signal?.removeEventListener("abort", onAbort);
-            let released = false;
-            try {
-                await ownership.stop();
-                released = true;
-            }
-            finally {
-                await rawLog?.close({ keep: !released || rawLogConfig.keepCompleted || signal?.aborted === true || !completed });
-                if (released && proc.pid !== undefined)
-                    options?.onProcessExit?.({ pid: proc.pid });
-            }
+            client.close();
         }
     }
     async getSessionInfo(sessionId) {
@@ -317,7 +322,7 @@ class CodexAdapter {
         return { sessionId, cwd: meta.cwd };
     }
     async closeSession(_sessionId) {
-        // no-op：子进程由 prompt 的 finally 自动 kill
+        // no-op：WebSocket 连接由 prompt 的 finally 关闭；app-server 进程常驻复用
     }
 }
 export function createCodexAdapter(options = {}) {