@xiaohhhh1/canvas-agent 0.2.2 → 0.3.0

package/README.md

@@ -8,6 +8,14 @@
 npx -y @xiaohhhh1/canvas-agent
 ```
 
+需要排查连接、线程、Codex app-server 或工具调用问题时，可开启 Debug 模式：
+
+```bash
+npx -y @basketikun/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
@@ -126,7 +134,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,21 @@
+# 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：脚本分镜到视频
+
+- 用户明确选择流程 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");
+}

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

@@ -0,0 +1,25 @@
+import type { CodexPlanUpdate } from "./codex-protocol.js";
+type AgentHistoryMessage = {
+    id: string;
+    role: "user" | "assistant" | "tool" | "error";
+    title?: string;
+    text: string;
+    detail?: unknown;
+    streamId?: string;
+};
+/** 将 Codex 线程转换为列表展示所需的摘要。 */
+export declare function summarizeCodexThread(thread: unknown): {
+    id: string;
+    sessionId: string;
+    preview: string;
+    name: string | null;
+    cwd: string;
+    status: string;
+    source: unknown;
+    threadSource: unknown;
+    createdAt: number;
+    updatedAt: number;
+};
+/** 将 Codex turn items 转换为网页聊天历史。 */
+export declare function threadMessages(thread: unknown, planUpdates?: CodexPlanUpdate[]): AgentHistoryMessage[];
+export {};