@co0ontty/wand 1.18.12 → 1.21.4

package/dist/structured-session-manager.js

@@ -1,6 +1,18 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { prepareSessionWorktree } from "./git-worktree.js";
+function defaultStructuredRunner(provider) {
+    return provider === "codex" ? "codex-cli-exec" : "claude-cli-print";
+}
+function defaultStructuredState(provider, runner = defaultStructuredRunner(provider)) {
+    return {
+        provider,
+        runner,
+        lastError: null,
+        inFlight: false,
+        activeRequestId: null,
+    };
+}
 const STREAM_EMIT_DEBOUNCE_MS = 16;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 function isRunningAsRoot() {
@@ -84,23 +96,25 @@ function buildIncrementalStructuredPayload(snapshot) {
 export class StructuredSessionManager {
     storage;
     config;
+    logger;
     sessions = new Map();
     pendingChildren = new Map();
     interruptedWith = new Map();
     emitEvent = null;
     archiveTimer = null;
-    constructor(storage, config) {
+    constructor(storage, config, logger = null) {
         this.storage = storage;
         this.config = config;
+        this.logger = logger;
         for (const snapshot of this.storage.loadSessions()) {
             if ((snapshot.sessionKind ?? "pty") !== "structured")
                 continue;
-            const restoredStatus = snapshot.status === "running" ? "stopped" : snapshot.status;
+            const restoredStatus = snapshot.status === "running" ? "idle" : snapshot.status;
             const restored = {
                 ...snapshot,
                 sessionKind: "structured",
-                provider: snapshot.provider ?? "claude",
-                runner: snapshot.runner ?? "claude-cli-print",
+                provider: snapshot.provider ?? snapshot.structuredState?.provider ?? "claude",
+                runner: snapshot.runner ?? snapshot.structuredState?.runner ?? defaultStructuredRunner(snapshot.provider ?? snapshot.structuredState?.provider ?? "claude"),
                 status: restoredStatus,
                 autoApprovePermissions: snapshot.autoApprovePermissions ?? shouldAutoApproveForMode(snapshot.mode),
                 approvalStats: snapshot.approvalStats ?? { tool: 0, command: 0, file: 0, total: 0 },
@@ -109,7 +123,7 @@ export class StructuredSessionManager {
                 permissionBlocked: false,
                 structuredState: {
                     provider: snapshot.structuredState?.provider ?? snapshot.provider ?? "claude",
-                    runner: snapshot.runner ?? "claude-cli-print",
+                    runner: snapshot.runner ?? snapshot.structuredState?.runner ?? defaultStructuredRunner(snapshot.structuredState?.provider ?? snapshot.provider ?? "claude"),
                     model: snapshot.structuredState?.model ?? snapshot.selectedModel ?? undefined,
                     lastError: snapshot.structuredState?.lastError ?? null,
                     inFlight: false,
@@ -171,6 +185,8 @@ export class StructuredSessionManager {
         const id = randomUUID();
         const startedAt = new Date().toISOString();
         const prompt = options.prompt?.trim();
+        const provider = options.provider === "codex" ? "codex" : "claude";
+        const runner = options.runner ?? defaultStructuredRunner(provider);
         const worktreeSetup = options.worktreeEnabled
             ? prepareSessionWorktree({ cwd: options.cwd, sessionId: id })
             : null;
@@ -178,14 +194,14 @@ export class StructuredSessionManager {
         const snapshot = {
             id,
             sessionKind: "structured",
-            provider: "claude",
-            runner: options.runner ?? "claude-cli-print",
-            command: "claude -p --output-format stream-json",
+            provider,
+            runner,
+            command: provider === "codex" ? "codex exec --json" : "claude -p --output-format stream-json",
             cwd: worktreeSetup?.cwd ?? options.cwd,
             mode: options.mode,
             worktreeEnabled: Boolean(worktreeSetup),
             worktree: worktreeSetup?.worktree ?? null,
-            status: "running",
+            status: "idle",
             exitCode: null,
             startedAt,
             endedAt: null,
@@ -196,8 +212,8 @@ export class StructuredSessionManager {
             messages: [],
             queuedMessages: [],
             structuredState: {
-                provider: "claude",
-                runner: options.runner ?? "claude-cli-print",
+                provider,
+                runner,
                 model: selectedModel ?? undefined,
                 inFlight: false,
                 activeRequestId: null,
@@ -211,9 +227,6 @@ export class StructuredSessionManager {
         this.sessions.set(id, snapshot);
         this.storage.saveSession(snapshot);
         this.emit({ type: "started", sessionId: id, data: { sessionKind: "structured" } });
-        if (prompt) {
-            void this.sendMessage(id, prompt);
-        }
         return snapshot;
     }
     async sendMessage(id, input, opts) {
@@ -230,7 +243,7 @@ export class StructuredSessionManager {
                     this.pendingChildren.delete(id);
                 const recovered = {
                     ...session,
-                    status: "stopped",
+                    status: "idle",
                     endedAt: session.endedAt ?? new Date().toISOString(),
                     structuredState: {
                         ...session.structuredState,
@@ -293,7 +306,7 @@ export class StructuredSessionManager {
             endedAt: null,
             messages: [...(session.messages ?? []), userTurn],
             structuredState: {
-                ...(session.structuredState ?? { provider: "claude", runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
+                ...(session.structuredState ?? defaultStructuredState(session.provider ?? "claude", session.runner)),
                 inFlight: true,
                 activeRequestId: requestId,
                 lastError: null,
@@ -313,7 +326,12 @@ export class StructuredSessionManager {
             ? `[对刚才 AskUserQuestion 工具的回答 — 结构化模式不支持工具结果回传，下面是用户从选项中的选择]\n${prompt}`
             : prompt;
         try {
-            await this.runClaudeStreaming(id, updated, claudePrompt);
+            if ((updated.provider ?? "claude") === "codex") {
+                await this.runCodexStreaming(id, updated, prompt);
+            }
+            else {
+                await this.runClaudeStreaming(id, updated, claudePrompt);
+            }
             const finished = this.requireSession(id);
             return finished;
         }
@@ -364,7 +382,7 @@ export class StructuredSessionManager {
             ...session,
             selectedModel: normalized,
             structuredState: {
-                ...(session.structuredState ?? { provider: "claude", runner: "claude-cli-print", inFlight: false, activeRequestId: null, lastError: null }),
+                ...(session.structuredState ?? defaultStructuredState(session.provider ?? "claude", session.runner)),
                 model: normalized ?? undefined,
             },
         };
@@ -428,7 +446,7 @@ export class StructuredSessionManager {
             pendingEscalation: null,
             permissionBlocked: false,
             structuredState: {
-                ...(session.structuredState ?? { provider: "claude", runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
+                ...(session.structuredState ?? defaultStructuredState(session.provider ?? "claude", session.runner)),
                 inFlight: false,
                 activeRequestId: null,
             },
@@ -446,6 +464,7 @@ export class StructuredSessionManager {
         }
         this.sessions.delete(id);
         this.storage.deleteSession(id);
+        this.logger?.deleteSession(id);
     }
     // ---------------------------------------------------------------------------
     // Private helpers
@@ -580,6 +599,285 @@ export class StructuredSessionManager {
         }
         return [];
     }
+    buildCodexArgs(session) {
+        const args = ["exec", "--json", "--color", "never"];
+        const shouldBypass = session.autoApprovePermissions === true || session.mode === "full-access" || session.mode === "managed";
+        if (shouldBypass) {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+        else if (session.mode === "auto-edit" || session.mode === "agent" || session.mode === "agent-max") {
+            args.push("--sandbox", "workspace-write");
+        }
+        else {
+            args.push("--sandbox", "read-only");
+        }
+        args.push("--skip-git-repo-check");
+        const modelChoice = session.selectedModel?.trim();
+        if (modelChoice && modelChoice !== "default") {
+            args.push("--model", modelChoice);
+        }
+        if (session.claudeSessionId) {
+            args.push("resume", session.claudeSessionId, "-");
+        }
+        else {
+            args.push("-");
+        }
+        return args;
+    }
+    // ---------------------------------------------------------------------------
+    // Streaming codex exec --json execution
+    // ---------------------------------------------------------------------------
+    runCodexStreaming(sessionId, session, prompt) {
+        return new Promise((resolve, reject) => {
+            const args = this.buildCodexArgs(session);
+            console.log("[WAND] runCodexStreaming sessionId:", sessionId, "mode:", session.mode, "threadId:", session.claudeSessionId);
+            const spawnedAt = new Date().toISOString();
+            const child = spawn("codex", args, {
+                cwd: session.cwd,
+                env: process.env,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            console.log("[WAND] spawned codex exec pid:", child.pid, "args:", args.join(" "));
+            this.logger?.appendStructuredSpawn(sessionId, {
+                kind: "codex-exec",
+                provider: "codex",
+                pid: child.pid ?? null,
+                cwd: session.cwd,
+                args,
+                prompt: prompt.slice(0, 2048),
+                promptLength: prompt.length,
+                threadId: session.claudeSessionId,
+                spawnedAt,
+            });
+            this.pendingChildren.set(sessionId, child);
+            child.stdin?.end(prompt);
+            const turnState = {
+                blocks: [],
+                result: "",
+                sessionId: session.claudeSessionId,
+                model: session.selectedModel ?? session.structuredState?.model,
+                usage: undefined,
+            };
+            let lineBuf = "";
+            let stderr = "";
+            let emitTimer = null;
+            // codex 把所有错误（包括重试日志和最终失败原因）都通过 stdout 的 NDJSON 事件
+            // 输出，stderr 通常是空的。我们在 processLine 里收集这些，然后在 close 中
+            // 决定真正的报错文本。
+            const codexErrors = [];
+            let codexTurnFailed = null;
+            const flushEmit = () => {
+                if (emitTimer) {
+                    clearTimeout(emitTimer);
+                    emitTimer = null;
+                }
+                const current = this.sessions.get(sessionId);
+                if (!current)
+                    return;
+                this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current) });
+            };
+            const scheduleEmit = () => {
+                if (!emitTimer)
+                    emitTimer = setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS);
+            };
+            const syncSnapshot = () => {
+                const current = this.sessions.get(sessionId);
+                if (!current)
+                    return;
+                const inProgressTurn = {
+                    role: "assistant",
+                    content: this.compactContentBlocks([...turnState.blocks], turnState.result),
+                    usage: turnState.usage,
+                };
+                const msgs = [...(current.messages ?? [])];
+                const lastMsg = msgs[msgs.length - 1];
+                if (lastMsg && lastMsg.role === "assistant") {
+                    msgs[msgs.length - 1] = inProgressTurn;
+                }
+                else {
+                    msgs.push(inProgressTurn);
+                }
+                const patched = {
+                    ...current,
+                    claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                    messages: msgs,
+                    output: turnState.result || current.output,
+                    structuredState: {
+                        ...current.structuredState,
+                        model: turnState.model ?? current.structuredState?.model,
+                    },
+                };
+                this.sessions.set(sessionId, patched);
+                this.storage.saveSession(patched);
+            };
+            const processLine = (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                let parsed;
+                try {
+                    parsed = JSON.parse(trimmed);
+                }
+                catch {
+                    return;
+                }
+                this.logger?.appendStreamEvent(sessionId, parsed);
+                if (parsed?.type === "thread.started" && typeof parsed.thread_id === "string") {
+                    turnState.sessionId = parsed.thread_id;
+                    syncSnapshot();
+                    return;
+                }
+                if (parsed?.type === "item.started" && parsed.item) {
+                    const block = this.extractCodexItemBlock(parsed.item, false);
+                    if (block) {
+                        turnState.blocks.push(block);
+                        syncSnapshot();
+                        scheduleEmit();
+                    }
+                    return;
+                }
+                if (parsed?.type === "item.completed" && parsed.item) {
+                    const block = this.extractCodexItemBlock(parsed.item, true);
+                    if (block) {
+                        if (block.type === "text")
+                            turnState.result = block.text;
+                        this.upsertCodexBlock(turnState.blocks, block);
+                        syncSnapshot();
+                        scheduleEmit();
+                    }
+                    return;
+                }
+                if (parsed?.type === "turn.completed") {
+                    turnState.usage = this.extractCodexUsage(parsed.usage) ?? turnState.usage;
+                    syncSnapshot();
+                    scheduleEmit();
+                    return;
+                }
+                if (parsed?.type === "error") {
+                    const message = typeof parsed.message === "string" ? parsed.message : "";
+                    if (message) {
+                        console.log("[WAND] codex error event:", message.slice(0, 300));
+                        codexErrors.push(message);
+                    }
+                    return;
+                }
+                if (parsed?.type === "turn.failed") {
+                    const errObj = (parsed.error && typeof parsed.error === "object") ? parsed.error : null;
+                    const message = (errObj && typeof errObj.message === "string" && errObj.message)
+                        || (typeof parsed.message === "string" ? parsed.message : "")
+                        || "codex turn failed";
+                    console.log("[WAND] codex turn.failed:", message.slice(0, 300));
+                    codexTurnFailed = message;
+                    return;
+                }
+            };
+            child.stdout?.on("data", (chunk) => {
+                const text = chunk.toString();
+                this.logger?.appendStructuredStdout(sessionId, text);
+                lineBuf += text;
+                const lines = lineBuf.split("\n");
+                lineBuf = lines.pop() ?? "";
+                for (const line of lines)
+                    processLine(line);
+            });
+            child.stderr?.on("data", (chunk) => {
+                const text = chunk.toString();
+                this.logger?.appendStructuredStderr(sessionId, text);
+                stderr += text;
+            });
+            child.on("error", (error) => {
+                console.log("[WAND] codex exec child error:", error.message);
+                this.pendingChildren.delete(sessionId);
+                if (emitTimer)
+                    clearTimeout(emitTimer);
+                this.logger?.appendStructuredSpawn(sessionId, {
+                    kind: "codex-exec-error",
+                    pid: child.pid ?? null,
+                    spawnedAt,
+                    closedAt: new Date().toISOString(),
+                    spawnError: error.message,
+                });
+                reject(error);
+            });
+            child.on("close", (code) => {
+                console.log("[WAND] codex exec child close code:", code, "stderr:", stderr.substring(0, 200), "errors:", codexErrors.length, "turnFailed:", codexTurnFailed?.slice(0, 100));
+                this.pendingChildren.delete(sessionId);
+                if (lineBuf.trim()) {
+                    processLine(lineBuf);
+                    lineBuf = "";
+                }
+                flushEmit();
+                const closedAt = new Date().toISOString();
+                this.logger?.appendStructuredSpawn(sessionId, {
+                    kind: "codex-exec-close",
+                    pid: child.pid ?? null,
+                    spawnedAt,
+                    closedAt,
+                    exitCode: code,
+                    stderrTail: stderr.slice(-2048),
+                    codexErrors,
+                    codexTurnFailed,
+                });
+                const current = this.sessions.get(sessionId);
+                if (!current) {
+                    reject(new Error("Session removed during execution."));
+                    return;
+                }
+                // codex 把模型/网络/沙箱等错误写到 stdout 的 NDJSON 流（type: error / turn.failed），
+                // 而不是 stderr。我们以 turn.failed 的 message 为准，其次是最后一个 error 事件。
+                const codexFailed = codexTurnFailed !== null;
+                if (codexFailed || (code !== 0 && code !== null)) {
+                    const errorText = (codexTurnFailed && codexTurnFailed.trim())
+                        || (codexErrors.length > 0 ? codexErrors[codexErrors.length - 1] : "")
+                        || stderr.trim()
+                        || `codex exec exited with code ${code}`;
+                    const exitForSnapshot = typeof code === "number" ? code : 1;
+                    const failed = this.finishStructuredFailure(current, exitForSnapshot, errorText, turnState);
+                    this.sessions.set(sessionId, failed);
+                    this.storage.saveSession(failed);
+                    this.emitStructuredSnapshot(failed);
+                    this.emitStructuredSnapshot(failed, "ended");
+                    reject(new Error(errorText));
+                    return;
+                }
+                const assistantTurn = {
+                    role: "assistant",
+                    content: this.compactContentBlocks([...turnState.blocks], turnState.result),
+                    usage: turnState.usage,
+                };
+                const msgs = [...(current.messages ?? [])];
+                const lastMsg = msgs[msgs.length - 1];
+                if (lastMsg && lastMsg.role === "assistant")
+                    msgs[msgs.length - 1] = assistantTurn;
+                else
+                    msgs.push(assistantTurn);
+                const finished = {
+                    ...current,
+                    status: "idle",
+                    exitCode: 0,
+                    endedAt: new Date().toISOString(),
+                    output: turnState.result,
+                    claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                    messages: msgs,
+                    pendingEscalation: null,
+                    permissionBlocked: false,
+                    structuredState: {
+                        ...current.structuredState,
+                        model: turnState.model ?? current.structuredState?.model,
+                        inFlight: false,
+                        activeRequestId: null,
+                        lastError: null,
+                    },
+                };
+                this.sessions.set(sessionId, finished);
+                this.storage.saveSession(finished);
+                this.emitStructuredSnapshot(finished);
+                this.emitStructuredSnapshot(finished, "ended");
+                resolve();
+                setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+            });
+        });
+    }
     // ---------------------------------------------------------------------------
     // Streaming claude -p execution
     // ---------------------------------------------------------------------------
@@ -633,12 +931,24 @@ export class StructuredSessionManager {
             // variadic 参数贪婪吞掉（commander 的 <tools...> 会一直吃 positional 直到
             // 下一个 flag）。表现为 claude 报 "Input must be provided either through
             // stdin or as a prompt argument when using --print"。
+            const spawnedAt = new Date().toISOString();
             const child = spawn("claude", args, {
                 cwd: session.cwd,
                 env: process.env,
                 stdio: ["pipe", "pipe", "pipe"],
             });
             console.log("[WAND] spawned claude -p pid:", child.pid, "args:", args.join(" "));
+            this.logger?.appendStructuredSpawn(sessionId, {
+                kind: "claude-print",
+                provider: "claude",
+                pid: child.pid ?? null,
+                cwd: session.cwd,
+                args,
+                prompt: prompt.slice(0, 2048),
+                promptLength: prompt.length,
+                claudeSessionId: session.claudeSessionId,
+                spawnedAt,
+            });
             this.pendingChildren.set(sessionId, child);
             child.stdin?.end(prompt);
             const turnState = {
@@ -720,6 +1030,7 @@ export class StructuredSessionManager {
                 catch {
                     return;
                 }
+                this.logger?.appendStreamEvent(sessionId, parsed);
                 if (parsed && parsed.type === "assistant" && parsed.message) {
                     const extracted = this.extractAssistantMessage(parsed.message);
                     if (extracted.content.length > 0) {
@@ -776,7 +1087,9 @@ export class StructuredSessionManager {
             };
             let stderr = "";
             child.stdout?.on("data", (chunk) => {
-                lineBuf += chunk.toString();
+                const text = chunk.toString();
+                this.logger?.appendStructuredStdout(sessionId, text);
+                lineBuf += text;
                 const lines = lineBuf.split("\n");
                 // Keep the last (possibly incomplete) segment in the buffer.
                 lineBuf = lines.pop() ?? "";
@@ -785,18 +1098,35 @@ export class StructuredSessionManager {
                 }
             });
             child.stderr?.on("data", (chunk) => {
-                stderr += chunk.toString();
+                const text = chunk.toString();
+                this.logger?.appendStructuredStderr(sessionId, text);
+                stderr += text;
             });
             child.on("error", (error) => {
                 console.log("[WAND] claude -p child error:", error.message);
                 this.pendingChildren.delete(sessionId);
                 if (emitTimer)
                     clearTimeout(emitTimer);
+                this.logger?.appendStructuredSpawn(sessionId, {
+                    kind: "claude-print-error",
+                    pid: child.pid ?? null,
+                    spawnedAt,
+                    closedAt: new Date().toISOString(),
+                    spawnError: error.message,
+                });
                 reject(error);
             });
             child.on("close", (code) => {
                 console.log("[WAND] claude -p child close code:", code, "stderr:", stderr.substring(0, 200));
                 this.pendingChildren.delete(sessionId);
+                this.logger?.appendStructuredSpawn(sessionId, {
+                    kind: "claude-print-close",
+                    pid: child.pid ?? null,
+                    spawnedAt,
+                    closedAt: new Date().toISOString(),
+                    exitCode: code,
+                    stderrTail: stderr.slice(-2048),
+                });
                 // Process any remaining data in the line buffer.
                 if (lineBuf.trim()) {
                     processLine(lineBuf);
@@ -871,7 +1201,7 @@ export class StructuredSessionManager {
                 const keepRunning = killedForAskUserQuestion || !!interruptPrompt;
                 const finished = {
                     ...current,
-                    status: keepRunning ? "running" : "stopped",
+                    status: keepRunning ? "running" : "idle",
                     exitCode: keepRunning ? null : 0,
                     endedAt: keepRunning ? null : new Date().toISOString(),
                     output: turnState.result,
@@ -1002,6 +1332,106 @@ export class StructuredSessionManager {
         }
         return typeof content === "undefined" || content === null ? "" : String(content);
     }
+    extractCodexText(value) {
+        if (typeof value === "string")
+            return value;
+        if (!value || typeof value !== "object")
+            return "";
+        if (Array.isArray(value)) {
+            return value.map((item) => this.extractCodexText(item)).filter(Boolean).join("");
+        }
+        const record = value;
+        for (const key of ["text", "output_text", "message", "content", "summary"]) {
+            const extracted = this.extractCodexText(record[key]);
+            if (extracted)
+                return extracted;
+        }
+        return "";
+    }
+    extractCodexItemBlock(item, completed) {
+        const id = typeof item.id === "string" ? item.id : randomUUID();
+        const type = typeof item.type === "string" ? item.type : "unknown";
+        if (type === "agent_message") {
+            const text = this.extractCodexText(item);
+            return text ? { type: "text", text } : null;
+        }
+        if (type === "reasoning") {
+            const text = this.extractCodexText(item);
+            return text ? { type: "thinking", thinking: text } : null;
+        }
+        if (type === "command_execution") {
+            const command = typeof item.command === "string" ? item.command : "";
+            const aggregatedOutput = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
+            const exitCode = typeof item.exit_code === "number" ? item.exit_code : null;
+            const status = typeof item.status === "string" ? item.status : completed ? "completed" : "in_progress";
+            if (!completed) {
+                return {
+                    type: "tool_use",
+                    id,
+                    name: "Bash",
+                    input: { command, status },
+                };
+            }
+            return {
+                type: "tool_result",
+                tool_use_id: id,
+                content: aggregatedOutput || (exitCode === null ? "" : `exit_code: ${exitCode}`),
+                is_error: typeof exitCode === "number" && exitCode !== 0,
+            };
+        }
+        if (completed) {
+            const text = this.extractCodexText(item);
+            if (text)
+                return { type: "text", text };
+        }
+        return null;
+    }
+    upsertCodexBlock(blocks, block) {
+        if (block.type === "tool_result") {
+            const toolUseIndex = blocks.findIndex((existing) => existing.type === "tool_use" && existing.id === block.tool_use_id);
+            if (toolUseIndex >= 0) {
+                const nextIndex = toolUseIndex + 1;
+                if (blocks[nextIndex]?.type === "tool_result" && blocks[nextIndex].tool_use_id === block.tool_use_id) {
+                    blocks[nextIndex] = block;
+                }
+                else {
+                    blocks.splice(nextIndex, 0, block);
+                }
+                return;
+            }
+        }
+        blocks.push(block);
+    }
+    finishStructuredFailure(current, code, errorText, turnState) {
+        const failureTurn = {
+            role: "assistant",
+            content: [{ type: "text", text: `结构化会话执行失败：${errorText}` }],
+        };
+        const msgs = [...(current.messages ?? [])];
+        const lastMsg = msgs[msgs.length - 1];
+        if (lastMsg && lastMsg.role === "assistant")
+            msgs[msgs.length - 1] = failureTurn;
+        else
+            msgs.push(failureTurn);
+        return {
+            ...current,
+            status: "failed",
+            exitCode: code,
+            endedAt: new Date().toISOString(),
+            output: errorText,
+            claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+            messages: msgs,
+            pendingEscalation: null,
+            permissionBlocked: false,
+            structuredState: {
+                ...current.structuredState,
+                model: turnState.model ?? current.structuredState?.model,
+                inFlight: false,
+                activeRequestId: null,
+                lastError: errorText,
+            },
+        };
+    }
     extractModelName(modelUsage) {
         if (!modelUsage)
             return undefined;
@@ -1029,4 +1459,17 @@ export class StructuredSessionManager {
         }
         return value;
     }
+    extractCodexUsage(source) {
+        if (!source || typeof source !== "object")
+            return undefined;
+        const value = {
+            inputTokens: typeof source.input_tokens === "number" ? source.input_tokens : undefined,
+            outputTokens: typeof source.output_tokens === "number" ? source.output_tokens : undefined,
+            cacheReadInputTokens: typeof source.cached_input_tokens === "number" ? source.cached_input_tokens : undefined,
+        };
+        if (value.inputTokens === undefined && value.outputTokens === undefined && value.cacheReadInputTokens === undefined) {
+            return undefined;
+        }
+        return value;
+    }
 }

package/dist/tui/index.d.ts

@@ -0,0 +1,24 @@
+import { ProcessManager } from "../process-manager.js";
+import { StructuredSessionManager } from "../structured-session-manager.js";
+export interface TuiDeps {
+    processManager: ProcessManager;
+    structuredSessions: StructuredSessionManager;
+    version: string;
+    configPath: string;
+    dbPath: string;
+    bindAddr: string;
+    httpsEnabled: boolean;
+    urls: Array<{
+        url: string;
+        scheme: "HTTP" | "HTTPS";
+    }>;
+    orphanRecoveredCount: number;
+    /** 退出 TUI 时调用。返回的 Promise resolve 后 cli 才会 process.exit。 */
+    onExit: (reason: ExitReason) => void | Promise<void>;
+}
+export type ExitReason = "user" | "signal" | "error";
+export interface TuiHandle {
+    isActive: boolean;
+    stop(reason: ExitReason): Promise<void>;
+}
+export declare function startTui(deps: TuiDeps): TuiHandle;