@xiaohhhh1/canvas-agent 0.2.2 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Infinite Canvas Agent
 
-本地 Canvas Agent 用来连接画布网页和用户电脑上的 Codex / Claude Code。本地开发时优先连接 `http://localhost:3000`，不需要先使用线上站点。
+本地 Canvas Agent 用来连接网站和用户自己电脑上的 Codex。它还负责持久化 Flow C 脚本队列、分段调用本机 Codex、自动回传草案，以及在网页关闭后继续把完成视频校验并保存到用户选择的磁盘目录。
 
 ## 启动
 
@@ -8,6 +8,14 @@
 npx -y @xiaohhhh1/canvas-agent
 ```
 
+需要排查连接、线程、Codex app-server 或工具调用问题时，可开启 Debug 模式：
+
+```bash
+npx -y @xiaohhhh1/canvas-agent --debug
+```
+
+Debug 日志会以 `[DEBUG][HH:mm:ss]` 等传统格式输出到终端，并按启动日期保存到 `~/.infinite-canvas/logs/canvas-agent-YYYY-MM-DD.log`。终端日志带级别颜色，文件日志为纯文本；日志包含 HTTP、SSE、线程、turn、Codex app-server 和工具调用事件，token 与图片 Data URL 会自动隐藏。
+
 本仓库开发时也可以直接运行：
 
 ```bash
@@ -66,13 +74,22 @@ codex plugin marketplace add "$(pwd)"
 codex plugin add infinite-canvas@infinite-canvas-local
 ```
 
-插件默认通过 npm 启动 MCP；这个命令只提供 MCP 工具，不会把 MCP 写入全局配置，也不会在退出时自动卸载：
+插件默认通过 npm 启动 MCP。MCP 启动时会自动检查并拉起常驻本机 HTTP/中继服务，因此客户安装插件后不需要另开终端：
 
 ```bash
 npx -y @xiaohhhh1/canvas-agent mcp
 ```
 
-使用时可以直接在 Codex 里说“打开 Infinite Canvas”，插件会启动本地 Agent，读取 Local URL 和 Connect token，然后在右侧打开 `https://canvas.best/` 并自动新建、连接画布；只有明确要求使用本地项目时才会启动本地前端。
+使用时可以直接打开 `https://canvas.xiaohhhh1.com/workflow-batches`。网站通过已认证的 Agent Relay 与本机助手通信，不把本机目录、Codex 登录信息或短期任务令牌显示给客户。
+
+## Flow C 本机后台工作流
+
+1. 客户在网站添加一个或多个产品，按顺序上传每个产品 1–5 张图片并填写数量。
+2. 点击“交给本机 Codex 写全部脚本”。本机助手每次只处理 10 条并持久化进度，断网或重启后可继续；脚本完成会自动回传网站，不创建付费任务。
+3. 客户审阅脚本并确认费用后，中心 `workflow-runner` 才执行故事板和视频生成。
+4. 客户只需首次选择一个本机目录。Agent 每 10 秒检查交付，先写 `.part`，校验大小与 SHA-256 后原子改名；清单已记录的批次序号不会重复下载，网页关闭后仍会继续。
+
+本机持久状态默认保存在 `~/.infinite-canvas/workflow-state.json`，权限设为仅当前用户可读写。这里包含短期能力令牌和本机路径，不应上传、提交到 Git 或发到聊天中。
 
 Canvas Agent 启动后，给 Codex 添加 MCP：
 
@@ -126,7 +143,7 @@ default_tools_approval_mode = "approve"
 
 本地面板会把提示词发送给 Canvas Agent。Canvas Agent 使用官方 `@openai/codex` CLI 的 `codex app-server --stdio` 启动并复用同一个 Codex thread，启动时会注入 `infinite-canvas` MCP 配置并自动放行 MCP 审批，真正执行画布修改前仍由网页侧边栏二次确认。
 
-侧边栏会展示 Codex 返回的 `thread.started`、`turn.started`、`item.*`、`turn.completed` 等结构化事件；收到 app-server 的 `item/agentMessage/delta` 时，Canvas Agent 会转成 `item.updated`，网页会用同一条消息做真实流式更新，并把工具细节收进运行日志。
+侧边栏会展示 Codex 返回的 `thread.started`、`turn.started`、`item.*`、`turn.completed` 等结构化事件；Canvas Agent 会合并短时间内的回复、思考摘要和命令输出增量，网页使用同一条消息持续更新，并把任务进度、计划、搜索、文件修改与工具操作整理为中文过程时间线。
 
 侧边栏上传或粘贴的图片会先发到本机 Canvas Agent，再由 Canvas Agent 临时写入本机文件并作为 app-server `localImage` 输入传给 Codex；前端会提示附件体积，单次请求体限制为 30MB。
 

package/agent-instructions.md

@@ -0,0 +1,26 @@
+# Infinite Canvas Agent
+
+你正在帮助用户操作 Infinite Canvas 网站。
+
+- 用户要求操作画布时，默认目标就是网页当前已经打开的画布。需要了解内容时先使用 `canvas_get_state`；读取成功后直接在该画布执行任务，不要调用 `canvas_list_projects`，也不要用 `site_navigate` 重复进入画布。
+- 只有用户明确要求查看、选择或切换其他画布，或者 `canvas_get_state` 明确提示当前没有已连接画布时，才使用 `canvas_list_projects` 和 `site_navigate`。`site_navigate` 可跳转 `/`、`/canvas`、`/canvas/:id`、`/image`、`/video`、`/prompts`、`/assets`、`/config`。
+- 修改当前画布时根据任务使用已配置的 infinite-canvas MCP 工具；复杂批量改动使用 `canvas_apply_ops`。
+- 用户要求把上传附件放入画布或作为生成参考图时，必须先用 `canvas_create_attachment_nodes` 创建真实图片节点，再把节点 ID 传给生成流程，不要创建空图片占位节点。
+- 生图与视频工作台分别使用 `workbench_image_*`、`workbench_video_*` 工具；提示词和素材分别使用 `prompts_search`、`assets_*` 工具。
+- 用户要求生成图片、视频、音频或文本时，默认调用对应的 `canvas_generate_image`、`canvas_generate_video`、`canvas_generate_audio`、`canvas_generate_text`，通过当前画布的生成节点完成任务。
+- 只有用户明确要求使用“Codex 内置生图”“ImageGen 技能”或意思明确相同的能力时，才使用 Codex 自带的 `imagegen`；不要因为用户只说“生成图片”就自行改用内置生图。内置生图完成后，其结果会由 Canvas Agent 自动展示到对话并插入当前画布，无需再创建空节点或重复生成。
+- 只有用户明确说要在生图/视频工作台生成时，才使用 `workbench_image_*`、`workbench_video_*`。生成任务提交后应说明已经在画布或工作台开始生成，不要在实际没有结果时声称“已生成”。
+- 需要生成内容时直接调用对应生成工具，不要绑定特定业务场景，不要模拟鼠标点击，不要要求用户手动复制 JSON。
+
+## 流程 C：脚本分镜到视频
+
+- 用户要求打开带货任务时，调用 `open_flow_c_website`，不要输出或询问 Local URL、连接令牌。
+- 网站把脚本任务交给本机 Codex 后，使用 `flow_c_get_script_task` 读取完整、服务器持久化的任务，再用 `flow_c_submit_script_chunk` 每次回传 1–25 条。不要要求用户复制 JSON、选择交接文件或把短期令牌发到聊天中。
+- 大批量脚本按本机助手指定的序号分段创作；批量大小不能成为降低质量、缩短脚本或套用模板的理由。每条都必须独立构思、符合目标市场自然语言习惯、保持紧凑但清晰可说完的 10 秒节奏。
+- 写脚本和回传草案不创建付费任务。只有客户在网站审阅并确认费用后，中心服务才可开始故事板和视频生成。
+
+- 用户明确选择流程 C 时，必须新建独立画布、清单和归档目录，不得混用流程 A 或 B 的资产。
+- 先使用原始同 SKU 商品图和完整脚本生成 9:16、10 秒导演分镜板；每镜必须包含时长、画面/镜头、对应配音、音效/BGM 节奏和情绪，并附专业技术规格栏。
+- 原始商品图是唯一商品标准：每一格都必须保持颜色、外形、文字或 Logo、比例、部件和数量一致。分镜通过逐格检查前，严禁提交视频任务。
+- 视频阶段必须同时提供已通过的分镜板和原始商品图。技术失败、超时、明显商品不一致或明显分镜错误时自动重做；提示词、参考图或平台合规问题才暂停等待用户修改。
+- 未配置流程 C 的第三方视频接口时，只能完成分镜准备和验收，明确说明“待管理员配置视频接口”，不得假装已提交或产生扣费。

package/dist/agent/claude.d.ts

@@ -0,0 +1,3 @@
+import type { AgentEmit } from "./types.js";
+/** 使用 Claude CLI 执行一次带 Canvas Agent 工具的任务。 */
+export declare function runClaudeTurn(prompt: string, emit: AgentEmit): void;

package/dist/agent/claude.js

@@ -0,0 +1,46 @@
+import { spawn } from "node:child_process";
+import { AGENT_PROMPT } from "../config.js";
+import { errorMessage } from "../utils/value.js";
+/** 使用 Claude CLI 执行一次带 Canvas Agent 工具的任务。 */
+export function runClaudeTurn(prompt, emit) {
+    const fullPrompt = withAgentPrompt(prompt);
+    if (!fullPrompt)
+        return;
+    const child = spawnAgent("claude", ["-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--allowedTools", "mcp__infinite-canvas__*", fullPrompt], emit);
+    if (child)
+        pipeJsonLines(child, emit, "claude");
+}
+/** 为 Claude CLI 请求拼接 Canvas Agent 指令。 */
+function withAgentPrompt(prompt) {
+    return prompt.trim() ? `${AGENT_PROMPT}\n\n用户请求：${prompt}` : "";
+}
+/** 将 Claude CLI 的 JSON Lines 输出转换为 Agent 事件。 */
+function pipeJsonLines(child, emit, agent) {
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+        out += chunk.toString();
+        const lines = out.split(/\r?\n/);
+        out = lines.pop() || "";
+        lines.filter(Boolean).forEach((line) => {
+            try {
+                emit("agent_event", { agent, ...JSON.parse(line) });
+            }
+            catch {
+                emit("agent_event", { agent, type: "raw", text: line });
+            }
+        });
+    });
+    child.stderr?.on("data", (chunk) => emit("agent_log", { text: chunk.toString() }));
+    child.on("error", (error) => emit("agent_error", { message: error.message }));
+    child.on("close", (code) => emit("agent_done", { agent, code }));
+}
+/** 启动外部 Agent CLI，并将同步启动异常转换为事件。 */
+function spawnAgent(name, args, emit) {
+    try {
+        return spawn(name, args, { stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32", windowsHide: true });
+    }
+    catch (error) {
+        emit("agent_error", { message: errorMessage(error) });
+        return null;
+    }
+}

package/dist/agent/codex-client.d.ts

@@ -0,0 +1,73 @@
+import type { CodexPlanUpdate, CodexRequestParams } from "./codex-protocol.js";
+import type { AgentEmit, AgentPermissionMode } from "./types.js";
+/** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
+export declare class CodexAppClient {
+    private child;
+    private emit;
+    private nextId;
+    private buffer;
+    private currentThreadId;
+    private currentTurnId;
+    private textByItem;
+    private lastUsage;
+    private pending;
+    private activeTurns;
+    private completedTurns;
+    private pendingDeltas;
+    private plansByTurn;
+    private approvalRequests;
+    /** 保存 app-server 子进程和事件出口。 */
+    private constructor();
+    /** 启动并初始化 Codex app-server。 */
+    static start(emit: AgentEmit, onExit: () => void): Promise<CodexAppClient>;
+    /** 创建新的 Codex 线程。 */
+    startThread(cwd?: string, permissionMode?: AgentPermissionMode): Promise<import("./codex-protocol.js").CodexThread>;
+    /** 恢复已有 Codex 线程。 */
+    resumeThread(threadId: string, cwd?: string, permissionMode?: AgentPermissionMode): Promise<import("./codex-protocol.js").CodexThread>;
+    /** 查询 Codex 线程列表。 */
+    listThreads(params: CodexRequestParams<"thread/list">): Promise<{
+        data: import("./codex-protocol.js").CodexThread[];
+        nextCursor: string | null;
+        backwardsCursor: string | null;
+    }>;
+    /** 读取指定 Codex 线程。 */
+    readThread(threadId: string, includeTurns?: boolean): Promise<{
+        thread: import("./codex-protocol.js").CodexThread;
+    }>;
+    /** 归档指定 Codex 线程。 */
+    archiveThread(threadId: string): Promise<Record<string, never>>;
+    /** 返回指定线程在当前进程中收到的最新任务计划。 */
+    planUpdates(threadId: string): CodexPlanUpdate[];
+    /** 清理已归档线程的任务计划缓存。 */
+    clearPlanUpdates(threadId: string): void;
+    /** 启动一个 Codex turn 并等待完成通知。 */
+    startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void): Promise<void>;
+    /** 中断当前正在运行的 Codex turn。 */
+    interruptCurrentTurn(): Promise<boolean>;
+    /** 回复网页端已经确认的 Codex 权限请求。 */
+    resolveApproval(requestId: string, decision: string): boolean;
+    /** 发送 JSON-RPC 请求并保存待处理 Promise。 */
+    private request;
+    /** 发送无需响应的 JSON-RPC 通知。 */
+    private notify;
+    /** 将 JSON-RPC 消息写入 app-server 标准输入。 */
+    private write;
+    /** 按行解析 app-server 标准输出。 */
+    private read;
+    /** 分派单条 JSON-RPC 响应、请求或通知。 */
+    private handle;
+    /** 转换并广播 app-server 通知。 */
+    private handleNotification;
+    /** 合并并广播 Agent 文本或执行输出增量。 */
+    private emitDelta;
+    /** 合并短时间内的文本增量，减少 SSE 传输和前端渲染次数。 */
+    private flushDelta;
+    /** 自动回复 app-server 发起的授权或交互请求。 */
+    private answerServerRequest;
+    /** 完成指定 JSON-RPC 请求。 */
+    private resolve;
+    /** 拒绝指定 JSON-RPC 请求。 */
+    private reject;
+    /** 拒绝进程退出时仍未完成的请求与 turn。 */
+    private failAll;
+}

package/dist/agent/codex-client.js

@@ -0,0 +1,438 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { VERSION } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { field } from "../utils/value.js";
+const canvasAgentMcp = canvasAgentMcpCommand();
+const require = createRequire(import.meta.url);
+const STREAM_UPDATE_INTERVAL_MS = 40;
+/** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
+export class CodexAppClient {
+    child;
+    emit;
+    nextId = 1;
+    buffer = "";
+    currentThreadId = "";
+    currentTurnId = "";
+    textByItem = new Map();
+    lastUsage = null;
+    pending = new Map();
+    activeTurns = new Map();
+    completedTurns = new Map();
+    pendingDeltas = new Map();
+    plansByTurn = new Map();
+    approvalRequests = new Map();
+    /** 保存 app-server 子进程和事件出口。 */
+    constructor(child, emit) {
+        this.child = child;
+        this.emit = emit;
+    }
+    /** 启动并初始化 Codex app-server。 */
+    static async start(emit, onExit) {
+        logger.info("Starting Codex app-server", { executable: process.execPath, codex: codexBin() });
+        const child = spawn(process.execPath, [codexBin(), "app-server", "--stdio"], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        const client = new CodexAppClient(child, emit);
+        child.stdout?.on("data", (chunk) => client.read(chunk.toString()));
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            logger.warn("Codex app-server stderr", { text });
+            emit("agent_log", { text });
+        });
+        child.on("error", (error) => {
+            logger.error("Codex app-server process error", error);
+            emit("agent_error", { message: error.message });
+        });
+        child.on("exit", (code) => {
+            logger.warn("Codex app-server exited", { code });
+            client.failAll(`Codex app-server exited: ${code ?? 0}`);
+            onExit();
+            emit("agent_log", { text: `Codex app-server exited: ${code ?? 0}` });
+        });
+        await client.request("initialize", { clientInfo: { name: "canvas-agent", title: "Infinite Canvas Agent", version: VERSION }, capabilities: { experimentalApi: true, requestAttestation: false } });
+        client.notify("initialized");
+        return client;
+    }
+    /** 创建新的 Codex 线程。 */
+    async startThread(cwd, permissionMode = "request") {
+        const { thread } = await this.request("thread/start", { ...threadSettings(permissionMode), ...(cwd ? { cwd } : {}), threadSource: "user" });
+        if (!thread.id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread;
+    }
+    /** 恢复已有 Codex 线程。 */
+    async resumeThread(threadId, cwd, permissionMode = "request") {
+        const { thread } = await this.request("thread/resume", { threadId, ...threadSettings(permissionMode), ...(cwd ? { cwd } : {}) });
+        if (!thread.id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread;
+    }
+    /** 查询 Codex 线程列表。 */
+    listThreads(params) {
+        return this.request("thread/list", params);
+    }
+    /** 读取指定 Codex 线程。 */
+    readThread(threadId, includeTurns = true) {
+        return this.request("thread/read", { threadId, includeTurns });
+    }
+    /** 归档指定 Codex 线程。 */
+    archiveThread(threadId) {
+        return this.request("thread/archive", { threadId });
+    }
+    /** 返回指定线程在当前进程中收到的最新任务计划。 */
+    planUpdates(threadId) {
+        return [...this.plansByTurn.values()].filter((item) => item.threadId === threadId);
+    }
+    /** 清理已归档线程的任务计划缓存。 */
+    clearPlanUpdates(threadId) {
+        this.plansByTurn.forEach((item, turnId) => {
+            if (item.threadId === threadId)
+                this.plansByTurn.delete(turnId);
+        });
+    }
+    /** 启动一个 Codex turn 并等待完成通知。 */
+    async startTurn(threadId, prompt, images, permissionMode, onTurn) {
+        this.currentThreadId = threadId;
+        const { turn } = await this.request("turn/start", { threadId, input: codexInput(prompt, images), ...turnSettings(permissionMode) });
+        const turnId = turn.id;
+        if (!turnId)
+            throw new Error("Codex app-server 没有返回 turn id");
+        this.currentTurnId = turnId;
+        onTurn?.(turnId);
+        const completed = this.completedTurns.get(turnId);
+        if (this.completedTurns.has(turnId)) {
+            this.completedTurns.delete(turnId);
+            this.currentThreadId = "";
+            this.currentTurnId = "";
+            if (completed)
+                throw completed;
+            return;
+        }
+        await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+    }
+    /** 中断当前正在运行的 Codex turn。 */
+    async interruptCurrentTurn() {
+        const threadId = this.currentThreadId;
+        const turnId = this.currentTurnId;
+        if (!threadId || !turnId)
+            return false;
+        try {
+            logger.warn("Interrupting active Codex turn", { threadId, turnId });
+            await this.request("turn/interrupt", { threadId, turnId });
+            return true;
+        }
+        catch (error) {
+            logger.warn("Failed to interrupt Codex turn", { error, threadId, turnId });
+            return false;
+        }
+    }
+    /** 回复网页端已经确认的 Codex 权限请求。 */
+    resolveApproval(requestId, decision) {
+        const request = this.approvalRequests.get(requestId);
+        if (!request)
+            return false;
+        this.approvalRequests.delete(requestId);
+        const permissions = field(request.params, "permissions") || field(request.params, "requestedPermissions");
+        const result = request.method === "item/permissions/requestApproval"
+            ? { permissions: decision === "decline" ? {} : permissions || {}, scope: decision === "acceptForSession" ? "session" : "turn" }
+            : { decision };
+        this.write({ id: request.id, result });
+        return true;
+    }
+    /** 发送 JSON-RPC 请求并保存待处理 Promise。 */
+    request(method, params) {
+        const id = this.nextId++;
+        this.write({ id, method, params });
+        return new Promise((resolve, reject) => this.pending.set(id, { resolve: (result) => resolve(result), reject }));
+    }
+    /** 发送无需响应的 JSON-RPC 通知。 */
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    /** 将 JSON-RPC 消息写入 app-server 标准输入。 */
+    write(value) {
+        const method = String(field(value, "method") || "");
+        const params = field(value, "params");
+        if (method)
+            logger.debug(`Codex ${method}`, { id: field(value, "id"), threadId: field(params, "threadId") });
+        this.child.stdin?.write(`${JSON.stringify(value)}\n`);
+    }
+    /** 按行解析 app-server 标准输出。 */
+    read(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = lines.pop() || "";
+        lines.filter(Boolean).forEach((line) => {
+            try {
+                this.handle(JSON.parse(line));
+            }
+            catch (error) {
+                logger.warn("Invalid Codex app-server output", { error, line });
+                this.emit("agent_log", { text: line });
+            }
+        });
+    }
+    /** 分派单条 JSON-RPC 响应、请求或通知。 */
+    handle(message) {
+        const id = Number(message.id);
+        if (message.error && this.pending.has(id)) {
+            const error = String(field(message.error, "message") || "Codex request failed");
+            if (/not materialized yet.*includeTurns/i.test(error))
+                logger.debug("Codex thread has no messages yet", { id });
+            else
+                logger.warn("Codex request failed", { id, error });
+            return this.reject(id, error);
+        }
+        if (this.pending.has(id))
+            return this.resolve(id, message.result);
+        if (typeof message.method === "string" && "id" in message)
+            return this.answerServerRequest(message);
+        if (typeof message.method === "string")
+            this.handleNotification(message.method, (message.params || {}));
+    }
+    /** 转换并广播 app-server 通知。 */
+    handleNotification(method, params) {
+        if (method === "serverRequest/resolved") {
+            const requestId = String(field(params, "requestId") || "");
+            if (requestId)
+                this.approvalRequests.delete(requestId);
+            this.emit("codex_approval_resolved", { requestId, ...params });
+            return;
+        }
+        if (!field(params, "threadId") && this.currentThreadId && (method === "turn/started" || method === "turn/completed" || method === "turn/plan/updated"))
+            params = { ...params, threadId: this.currentThreadId };
+        if (method === "item/agentMessage/delta") {
+            const value = params;
+            this.textByItem.set(value.itemId, `${this.textByItem.get(value.itemId) || ""}${value.delta}`);
+            return this.emitDelta("agent_message", value);
+        }
+        if (method === "item/plan/delta")
+            return this.emitDelta("plan", params);
+        if (method === "item/reasoning/summaryTextDelta")
+            return this.emitDelta("reasoning", params);
+        if (method === "item/commandExecution/outputDelta")
+            return this.emitDelta("command_execution", params);
+        if (method === "turn/plan/updated") {
+            const value = params;
+            const update = { ...value, threadId: value.threadId || "" };
+            if (update.threadId && update.turnId)
+                this.plansByTurn.set(update.turnId, update);
+            params = update;
+        }
+        if (method === "thread/tokenUsage/updated") {
+            this.lastUsage = normalizeUsage(params);
+            this.emit("agent_event", { agent: "codex", type: "usage.updated", usage: this.lastUsage, ...codexEventScope(params) });
+            return;
+        }
+        const event = normalizeCodexNotification(method, params);
+        if (!event)
+            return;
+        if (event.type === "item.completed") {
+            const item = field(event, "item");
+            const id = String(field(item, "id") || "");
+            this.flushDelta(id);
+            const streamedText = this.textByItem.get(id);
+            if (item?.type === "agent_message" && streamedText && !item.text)
+                item.text = streamedText;
+            if (id)
+                this.textByItem.delete(id);
+        }
+        if (event.type === "turn.completed") {
+            const turn = field(params, "turn");
+            const turnId = String(field(turn, "id") || field(params, "turnId") || "");
+            const plan = this.plansByTurn.get(turnId);
+            if (plan)
+                this.plansByTurn.set(turnId, { ...plan, turnStatus: String(field(turn, "status") || "completed") });
+        }
+        if (event.type === "turn.completed")
+            event.usage = this.lastUsage;
+        this.emit("agent_event", { agent: "codex", ...event });
+        if (event.type === "turn.completed") {
+            const turn = params.turn;
+            const turnId = turn.id;
+            const pending = this.activeTurns.get(turnId);
+            const error = turn.error;
+            if (pending) {
+                this.activeTurns.delete(turnId);
+                error ? pending.reject(new Error(error.message || "Codex turn failed")) : pending.resolve(event);
+            }
+            else if (turnId) {
+                this.completedTurns.set(turnId, error ? new Error(error.message || "Codex turn failed") : null);
+            }
+            if (turnId === this.currentTurnId) {
+                this.currentThreadId = "";
+                this.currentTurnId = "";
+            }
+            this.emit("agent_done", { agent: "codex", usage: event.usage, ...codexEventScope(params) });
+        }
+    }
+    /** 合并并广播 Agent 文本或执行输出增量。 */
+    emitDelta(itemType, params) {
+        const id = params.itemId;
+        const pending = this.pendingDeltas.get(id);
+        if (pending) {
+            pending.delta += params.delta;
+            pending.itemType = itemType;
+            pending.params = params;
+            return;
+        }
+        this.pendingDeltas.set(id, {
+            delta: params.delta,
+            itemType,
+            params,
+            timer: setTimeout(() => this.flushDelta(id), STREAM_UPDATE_INTERVAL_MS),
+        });
+    }
+    /** 合并短时间内的文本增量，减少 SSE 传输和前端渲染次数。 */
+    flushDelta(id) {
+        const pending = this.pendingDeltas.get(id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingDeltas.delete(id);
+        if (pending.delta)
+            this.emit("agent_event", { agent: "codex", type: "item.updated", item: { id, type: pending.itemType, delta: pending.delta }, ...codexEventScope(pending.params) });
+    }
+    /** 自动回复 app-server 发起的授权或交互请求。 */
+    answerServerRequest(message) {
+        const method = String(message.method);
+        const params = field(message, "params") || {};
+        if (["item/commandExecution/requestApproval", "item/fileChange/requestApproval", "item/permissions/requestApproval"].includes(method)) {
+            const requestId = String(message.id);
+            this.approvalRequests.set(requestId, { id: Number(message.id), method, params });
+            this.emit("codex_approval", { requestId, method, ...params });
+            return;
+        }
+        const result = method === "mcpServer/elicitation/request" ? { action: "accept", content: {}, _meta: null } : { decision: "decline" };
+        this.write({ id: message.id, result });
+        this.emit("agent_event", { agent: "codex", type: "server.request", method, params, result });
+    }
+    /** 完成指定 JSON-RPC 请求。 */
+    resolve(id, result) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.resolve(result));
+    }
+    /** 拒绝指定 JSON-RPC 请求。 */
+    reject(id, message) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.reject(new Error(message)));
+    }
+    /** 拒绝进程退出时仍未完成的请求与 turn。 */
+    failAll(message) {
+        [...this.pending.values(), ...this.activeTurns.values()].forEach((item) => item.reject(new Error(message)));
+        this.pendingDeltas.forEach((item) => clearTimeout(item.timer));
+        this.pending.clear();
+        this.activeTurns.clear();
+        this.pendingDeltas.clear();
+        this.textByItem.clear();
+        this.approvalRequests.clear();
+        this.currentThreadId = "";
+        this.currentTurnId = "";
+    }
+}
+/** 生成 Codex 调用 Canvas Agent MCP 的启动命令。 */
+function canvasAgentMcpCommand() {
+    const current = process.argv.find((arg) => /index\.(t|j)s$/.test(arg)) || "";
+    const entry = path.resolve(current || fileURLToPath(new URL("../index.js", import.meta.url)));
+    const tsx = path.join(path.dirname(entry), "..", "node_modules", "tsx", "dist", "cli.mjs");
+    return entry.endsWith(".ts") ? { command: process.execPath, args: [tsx, entry, "mcp"] } : { command: process.execPath, args: [entry, "mcp"] };
+}
+/** 生成 Codex app-server 使用的 MCP 配置。 */
+function codexConfig(permissionMode) {
+    return { model_reasoning_summary: "auto", ...(permissionMode === "automatic" ? { approvals_reviewer: "auto_review" } : {}), mcp_servers: { "infinite-canvas": { command: canvasAgentMcp.command, args: canvasAgentMcp.args, default_tools_approval_mode: "approve", startup_timeout_sec: 20, tool_timeout_sec: 90 } } };
+}
+function threadSettings(permissionMode) {
+    return { approvalPolicy: permissionMode === "full" ? "never" : "on-request", sandbox: permissionMode === "full" ? "danger-full-access" : "workspace-write", config: codexConfig(permissionMode) };
+}
+function turnSettings(permissionMode) {
+    return {
+        approvalPolicy: permissionMode === "full" ? "never" : "on-request",
+        sandboxPolicy: permissionMode === "full" ? { type: "dangerFullAccess" } : { type: "workspaceWrite", networkAccess: false },
+    };
+}
+/** 将文本和本地图片转换为 Codex turn 输入。 */
+function codexInput(prompt, images) {
+    return [{ type: "text", text: prompt, text_elements: [] }, ...images.map((file) => ({ type: "localImage", path: file }))];
+}
+/** 将 app-server 通知转换为前端使用的 Agent 事件。 */
+function normalizeCodexNotification(method, params) {
+    const scope = codexEventScope(params);
+    if (method === "thread/started")
+        return { type: "thread.started", ...scope };
+    if (method === "turn/started")
+        return { type: "turn.started", ...scope };
+    if (method === "turn/completed")
+        return { type: "turn.completed", status: field(field(params, "turn"), "status"), error: field(field(params, "turn"), "error"), usage: null, duration_ms: field(field(params, "turn"), "durationMs"), ...scope };
+    if (method === "turn/plan/updated")
+        return { type: "plan.updated", explanation: field(params, "explanation"), plan: field(params, "plan"), ...scope };
+    if (method === "item/started")
+        return { type: "item.started", item: normalizeItem(field(params, "item")), ...scope };
+    if (method === "item/completed")
+        return { type: "item.completed", item: normalizeItem(field(params, "item")), ...scope };
+    if (method === "error")
+        return { type: "error", message: field(field(params, "error"), "message"), ...scope };
+    return null;
+}
+/** 提取 Codex 事件所属的线程和 turn。 */
+function codexEventScope(params) {
+    const threadId = String(field(params, "threadId") || field(field(params, "thread"), "id") || "");
+    const turnId = String(field(params, "turnId") || field(field(params, "turn"), "id") || "");
+    return { ...(threadId ? { thread_id: threadId } : {}), ...(turnId ? { turn_id: turnId } : {}) };
+}
+/** 统一 app-server item 的类型和参数格式。 */
+function normalizeItem(item) {
+    const value = item && typeof item === "object" ? { ...item } : {};
+    if (value.type === "agentMessage")
+        value.type = "agent_message";
+    if (value.type === "mcpToolCall")
+        value.type = "mcp_tool_call";
+    if (value.type === "commandExecution")
+        value.type = "command_execution";
+    if (value.type === "fileChange")
+        value.type = "file_change";
+    if (value.type === "dynamicToolCall")
+        value.type = "dynamic_tool_call";
+    if (value.type === "collabToolCall")
+        value.type = "collab_tool_call";
+    if (value.type === "webSearch")
+        value.type = "web_search";
+    if (value.type === "imageView")
+        value.type = "image_view";
+    if (value.type === "imageGeneration")
+        value.type = "image_generation";
+    if (value.type === "contextCompaction")
+        value.type = "context_compaction";
+    if (value.type === "agent_message" && typeof value.id === "string")
+        value.text = String(value.text || "");
+    if ("arguments" in value)
+        value.arguments = parseMaybeJson(value.arguments);
+    return value;
+}
+/** 将 Codex token usage 转换为前端字段。 */
+function normalizeUsage(params) {
+    const last = params.tokenUsage.last;
+    return {
+        input_tokens: last.inputTokens,
+        cached_input_tokens: last.cachedInputTokens,
+        output_tokens: last.outputTokens,
+        reasoning_output_tokens: last.reasoningOutputTokens,
+    };
+}
+/** 尝试将字符串解析为 JSON，失败时保留原值。 */
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** 定位当前依赖中 Codex CLI 的执行文件。 */
+function codexBin() {
+    return path.join(path.dirname(require.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}