qcanvas-local-agent 0.1.0

package/dist/agents.js

@@ -0,0 +1,748 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { AGENT_PROMPT, VERSION } from "./config.js";
+export const LOCAL_AGENTS = [
+    { id: "codex", label: "Codex", threads: true },
+    { id: "claude", label: "Claude", threads: false },
+];
+export function isLocalAgentId(value) {
+    return typeof value === "string" && LOCAL_AGENTS.some((agent) => agent.id === value);
+}
+let codexQueue = Promise.resolve();
+let codexApp = null;
+let codexThreadId = "";
+const canvasAgentMcp = canvasAgentMcpCommand();
+const require = createRequire(import.meta.url);
+export function withAgentPrompt(prompt) {
+    return prompt.trim() ? `${AGENT_PROMPT}\n\n用户请求：${prompt}` : "";
+}
+export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
+    if (!prompt.trim())
+        return;
+    codexQueue = codexQueue.catch(() => undefined).then(() => runCodexTurnNow(prompt, emit, attachments, options));
+    await codexQueue;
+}
+async function runCodexTurnNow(prompt, emit, attachments, options) {
+    let files = [];
+    try {
+        files = await writeAttachmentFiles(attachments);
+        codexApp ||= await CodexAppClient.start(emit);
+        const threadId = await ensureCodexThread(codexApp, options);
+        await codexApp.startTurn(threadId, prompt, files);
+    }
+    catch (error) {
+        emit("agent_error", { agent: "codex", message: errorMessage(error) });
+    }
+    finally {
+        await Promise.all(files.map((file) => fs.unlink(file).catch(() => undefined)));
+    }
+}
+export async function startCodexThread(emit, cwd) {
+    codexApp ||= await CodexAppClient.start(emit);
+    const thread = await codexApp.startThread(cwd);
+    codexThreadId = String(field(thread, "id") || "");
+    return thread;
+}
+export async function resumeCodexThread(emit, threadId, cwd) {
+    const thread = await loadCodexThread(emit, threadId, cwd, true);
+    return { thread, messages: threadMessages(thread) };
+}
+export async function listCodexThreads(emit, options) {
+    codexApp ||= await CodexAppClient.start(emit);
+    const result = await codexApp.listThreads({
+        limit: options.limit || 40,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        sourceKinds: ["cli", "vscode", "appServer", "exec"],
+        cwd: options.cwd,
+        ...(options.searchTerm ? { searchTerm: options.searchTerm } : {}),
+    });
+    const data = Array.isArray(field(result, "data")) ? field(result, "data").map(summarizeCodexThread).filter((thread) => threadInWorkspace(thread, options.cwd)) : [];
+    return { data, nextCursor: field(result, "nextCursor") || null, backwardsCursor: field(result, "backwardsCursor") || null };
+}
+export async function readCodexThread(emit, threadId, cwd) {
+    const thread = await loadCodexThread(emit, threadId, cwd, true);
+    return { thread: summarizeCodexThread(thread), messages: threadMessages(thread) };
+}
+export async function verifyCodexThreadWorkspace(emit, threadId, cwd) {
+    await loadCodexThread(emit, threadId, cwd, false);
+}
+export async function archiveCodexThread(emit, threadId, cwd) {
+    codexApp ||= await CodexAppClient.start(emit);
+    await loadCodexThread(emit, threadId, cwd, false);
+    await codexApp.archiveThread(threadId);
+}
+let claudeQueue = Promise.resolve();
+export async function runClaudeTurn(prompt, emit, attachments = [], options = {}) {
+    if (!prompt.trim())
+        return;
+    claudeQueue = claudeQueue.catch(() => undefined).then(() => runClaudeTurnNow(prompt, emit, attachments, options));
+    await claudeQueue;
+}
+async function runClaudeTurnNow(prompt, emit, attachments, options) {
+    const tempFiles = [];
+    try {
+        const images = await writeAttachmentFiles(attachments);
+        tempFiles.push(...images);
+        const mcpConfigFile = await writeClaudeMcpConfigFile();
+        tempFiles.push(mcpConfigFile);
+        const fullPrompt = images.length
+            ? `${prompt}\n\n参考图片（本地文件路径，可直接查看）：\n${images.map((file) => `- ${file}`).join("\n")}`
+            : prompt;
+        try {
+            await runClaudeProcess(fullPrompt, emit, mcpConfigFile, options);
+        }
+        catch (error) {
+            if (options.allowFreshFallback && options.threadId && isMissingClaudeSessionError(error)) {
+                emit("agent_log", { agent: "claude", text: `保存的 Claude 会话 ${options.threadId} 已失效，改为开启新会话。` });
+                await runClaudeProcess(fullPrompt, emit, mcpConfigFile, { ...options, threadId: undefined });
+                return;
+            }
+            throw error;
+        }
+    }
+    catch (error) {
+        emit("agent_error", { agent: "claude", message: errorMessage(error) });
+    }
+    finally {
+        await Promise.all(tempFiles.map((file) => fs.unlink(file).catch(() => undefined)));
+    }
+}
+async function writeClaudeMcpConfigFile() {
+    const file = path.join(os.tmpdir(), `qcanvas-claude-mcp-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
+    const config = {
+        mcpServers: {
+            qcanvas: { command: canvasAgentMcp.command, args: canvasAgentMcp.args, env: { QCANVAS_AGENT_ID: "claude" } },
+        },
+    };
+    await fs.writeFile(file, JSON.stringify(config));
+    return file;
+}
+function runClaudeProcess(prompt, emit, mcpConfigFile, options) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            "-p",
+            "--output-format", "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+            "--mcp-config", mcpConfigFile,
+            "--strict-mcp-config",
+            "--allowedTools", "mcp__qcanvas",
+            ...(options.threadId ? ["--resume", options.threadId] : []),
+        ];
+        // 显式配置（env/config 的完整路径）优先；否则用随包安装的 claude；再否则回退 PATH 上的 claude。
+        const explicitCommand = options.command && options.command !== "claude" ? options.command : null;
+        const command = explicitCommand || claudeBin() || "claude";
+        let child;
+        try {
+            child = spawnClaudeCli(command, args, options.cwd);
+        }
+        catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const parser = new ClaudeTurnParser(emit, options);
+        let stderrTail = "";
+        let settled = false;
+        const fail = (error) => {
+            if (!settled)
+                (settled = true, reject(error));
+        };
+        child.stdout?.on("data", (chunk) => parser.push(chunk.toString()));
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderrTail = `${stderrTail}${text}`.slice(-4000);
+            emit("agent_log", { agent: "claude", text });
+        });
+        child.on("error", (error) => fail(new Error(`启动 ${command} 失败：${error.message}`)));
+        child.on("close", (code) => {
+            parser.flush();
+            if (parser.sawResult && !settled) {
+                settled = true;
+                resolve();
+                return;
+            }
+            fail(new Error(claudeExitMessage(code, stderrTail, command)));
+        });
+        emit("agent_event", { agent: "claude", type: "turn.started" });
+        child.stdin?.write(prompt);
+        child.stdin?.end();
+    });
+}
+function spawnClaudeCli(command, args, cwd) {
+    // Windows 下 claude 是 .cmd/.ps1 shim，必须经 shell 启动；此时 Node 不会自动为参数加引号。
+    const useShell = process.platform === "win32";
+    return spawn(useShell ? quoteWindowsShellArg(command) : command, useShell ? args.map(quoteWindowsShellArg) : args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: useShell,
+        windowsHide: true,
+        ...(cwd ? { cwd } : {}),
+    });
+}
+function quoteWindowsShellArg(value) {
+    if (!/[\s"^&|<>()]/.test(value))
+        return value;
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function claudeExitMessage(code, stderrTail, command) {
+    const detail = stderrTail.trim().split(/\r?\n/).slice(-6).join("\n").trim();
+    // cmd 找不到命令时 errorlevel 为 9009；中文系统的 stderr 是 GBK 编码，正则难以匹配，优先看退出码。
+    if (code === 9009 || /not recognized|command not found|ENOENT|不是内部或外部命令/i.test(detail)) {
+        return `未找到 ${command} 命令：请安装 Claude Code CLI（npm install -g @anthropic-ai/claude-code），或在 ~/.qcanvas/qcanvas-local-agent.json 的 claudeCommand 字段填写完整路径。`;
+    }
+    return detail || `Claude CLI exited: ${code ?? 0}`;
+}
+function isMissingClaudeSessionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /no conversation found/i.test(message);
+}
+class ClaudeTurnParser {
+    emit;
+    options;
+    sawResult = false;
+    buffer = "";
+    currentMessageId = "";
+    streamTextById = new Map();
+    toolNames = new Map();
+    constructor(emit, options) {
+        this.emit = emit;
+        this.options = options;
+    }
+    push(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = lines.pop() || "";
+        lines.filter(Boolean).forEach((line) => this.handleLine(line));
+    }
+    flush() {
+        const line = this.buffer.trim();
+        this.buffer = "";
+        if (line)
+            this.handleLine(line);
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.emit("agent_log", { agent: "claude", text: line });
+            return;
+        }
+        const type = String(message.type || "");
+        if (type === "system" && message.subtype === "init")
+            return this.handleInit(message);
+        if (type === "stream_event")
+            return this.handleStreamEvent(field(message, "event"));
+        if (type === "assistant")
+            return this.handleAssistant(field(message, "message"));
+        if (type === "user")
+            return this.handleToolResults(field(message, "message"));
+        if (type === "result")
+            return this.handleResult(message);
+    }
+    handleInit(message) {
+        const sessionId = String(message.session_id || "");
+        if (!sessionId)
+            return;
+        this.options.onThread?.(sessionId);
+        this.emit("agent_event", { agent: "claude", type: "thread.started", thread_id: sessionId });
+    }
+    handleStreamEvent(event) {
+        const type = String(field(event, "type") || "");
+        if (type === "message_start") {
+            const id = String(field(field(event, "message"), "id") || "");
+            if (id)
+                this.currentMessageId = id;
+            return;
+        }
+        if (type !== "content_block_delta")
+            return;
+        const delta = field(event, "delta");
+        if (String(field(delta, "type") || "") !== "text_delta")
+            return;
+        const text = String(field(delta, "text") || "");
+        if (!text)
+            return;
+        const id = this.currentMessageId || "claude-stream";
+        const merged = `${this.streamTextById.get(id) || ""}${text}`;
+        this.streamTextById.set(id, merged);
+        this.emit("agent_event", { agent: "claude", type: "item.updated", item: { id, type: "agent_message", text: merged } });
+    }
+    handleAssistant(message) {
+        const messageId = String(field(message, "id") || this.currentMessageId || "");
+        const blocks = arrayField(message, "content");
+        blocks.forEach((block, index) => {
+            const type = String(field(block, "type") || "");
+            if (type === "text") {
+                const text = String(field(block, "text") || "");
+                if (!text)
+                    return;
+                const itemId = messageId || `claude-msg-${index}`;
+                this.streamTextById.set(itemId, text);
+                this.emit("agent_event", { agent: "claude", type: "item.completed", item: { id: itemId, type: "agent_message", text } });
+                return;
+            }
+            if (type === "tool_use") {
+                const toolUseId = String(field(block, "id") || "");
+                const name = String(field(block, "name") || "");
+                if (toolUseId && name)
+                    this.toolNames.set(toolUseId, name);
+                this.emit("agent_event", {
+                    agent: "claude",
+                    type: "item.started",
+                    item: { id: toolUseId, type: "mcp_tool_call", tool: name, status: "running", arguments: field(block, "input") },
+                });
+            }
+        });
+    }
+    handleToolResults(message) {
+        arrayField(message, "content").forEach((block) => {
+            if (String(field(block, "type") || "") !== "tool_result")
+                return;
+            const toolUseId = String(field(block, "tool_use_id") || "");
+            const tool = this.toolNames.get(toolUseId) || "工具调用";
+            const isError = field(block, "is_error") === true;
+            const text = claudeToolResultText(field(block, "content"));
+            this.emit("agent_event", {
+                agent: "claude",
+                type: "item.completed",
+                item: {
+                    id: toolUseId,
+                    type: "mcp_tool_call",
+                    tool,
+                    status: isError ? "failed" : "completed",
+                    ...(isError ? { error: { message: text || "工具执行失败" } } : {}),
+                },
+            });
+        });
+    }
+    handleResult(message) {
+        this.sawResult = true;
+        // resume 在部分 CLI 版本会 fork 出新 session id，以 result 上报的为准。
+        const sessionId = String(message.session_id || "");
+        if (sessionId) {
+            this.options.onThread?.(sessionId);
+            this.emit("agent_event", { agent: "claude", type: "thread.started", thread_id: sessionId });
+        }
+        const usage = normalizeClaudeUsage(field(message, "usage"));
+        if (message.is_error === true || String(message.subtype || "") !== "success") {
+            this.emit("agent_event", { agent: "claude", type: "error", message: String(message.result || message.subtype || "Claude turn failed") });
+        }
+        this.emit("agent_event", { agent: "claude", type: "turn.completed", usage });
+        this.emit("agent_done", { agent: "claude", usage });
+    }
+}
+function arrayField(value, key) {
+    const raw = field(value, key);
+    return Array.isArray(raw) ? raw : [];
+}
+function claudeToolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((item) => (String(field(item, "type") || "") === "text" ? String(field(item, "text") || "") : ""))
+        .filter(Boolean)
+        .join("\n");
+}
+function normalizeClaudeUsage(usage) {
+    if (!usage || typeof usage !== "object")
+        return null;
+    return {
+        input_tokens: field(usage, "input_tokens"),
+        cached_input_tokens: field(usage, "cache_read_input_tokens"),
+        output_tokens: field(usage, "output_tokens"),
+    };
+}
+async function ensureCodexThread(app, options) {
+    if (options.threadId) {
+        // A freshly started thread is already the active in-memory thread and has no
+        // rollout yet — thread/resume would fail with "no rollout found". Only resume
+        // when switching to a different (already persisted) thread from history.
+        if (options.threadId === codexThreadId)
+            return codexThreadId;
+        const thread = await app.resumeThread(options.threadId, options.cwd);
+        assertThreadWorkspace(thread, options.cwd);
+        codexThreadId = String(field(thread, "id") || options.threadId);
+        return codexThreadId;
+    }
+    if (!codexThreadId) {
+        const thread = await app.startThread(options.cwd);
+        codexThreadId = String(field(thread, "id") || "");
+    }
+    return codexThreadId;
+}
+class CodexAppClient {
+    child;
+    emit;
+    nextId = 1;
+    buffer = "";
+    textByItem = new Map();
+    deltaCount = 0;
+    lastUsage = null;
+    pending = new Map();
+    activeTurns = new Map();
+    completedTurns = new Map();
+    constructor(child, emit) {
+        this.child = child;
+        this.emit = emit;
+    }
+    static async start(emit) {
+        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) => emit("agent_log", { agent: "codex", text: chunk.toString() }));
+        child.on("error", (error) => emit("agent_error", { agent: "codex", message: error.message }));
+        child.on("exit", (code) => {
+            client.failAll(`Codex app-server exited: ${code ?? 0}`);
+            codexApp = null;
+            codexThreadId = "";
+            emit("agent_log", { agent: "codex", text: `Codex app-server exited: ${code ?? 0}` });
+        });
+        await client.request("initialize", { clientInfo: { name: "qcanvas-local-agent", title: "QCanvas Local Agent", version: VERSION }, capabilities: { experimentalApi: true, requestAttestation: false } });
+        client.notify("initialized");
+        return client;
+    }
+    async startThread(cwd) {
+        const result = await this.request("thread/start", { approvalPolicy: "never", sandbox: "workspace-write", config: codexConfig(), ...(cwd ? { cwd } : {}), threadSource: "user" });
+        const thread = field(result, "thread");
+        const id = String(field(thread, "id") || "");
+        if (!id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread || {};
+    }
+    async resumeThread(threadId, cwd) {
+        const result = await this.request("thread/resume", { threadId, approvalPolicy: "never", sandbox: "workspace-write", config: codexConfig(), ...(cwd ? { cwd } : {}) });
+        const thread = field(result, "thread");
+        const id = String(field(thread, "id") || "");
+        if (!id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread || {};
+    }
+    listThreads(params) {
+        return this.request("thread/list", params);
+    }
+    readThread(threadId, includeTurns = true) {
+        return this.request("thread/read", { threadId, includeTurns });
+    }
+    archiveThread(threadId) {
+        return this.request("thread/archive", { threadId });
+    }
+    async startTurn(threadId, prompt, images) {
+        const result = await this.request("turn/start", { threadId, input: codexInput(prompt, images), approvalPolicy: "never" });
+        const turnId = String(field(field(result, "turn"), "id") || "");
+        if (!turnId)
+            throw new Error("Codex app-server 没有返回 turn id");
+        const completed = this.completedTurns.get(turnId);
+        if (this.completedTurns.has(turnId)) {
+            this.completedTurns.delete(turnId);
+            if (completed)
+                throw completed;
+            return;
+        }
+        await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        this.write({ id, method, params });
+        return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    }
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    write(value) {
+        this.child.stdin?.write(`${JSON.stringify(value)}\n`);
+    }
+    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 {
+                this.emit("agent_log", { agent: "codex", text: line });
+            }
+        });
+    }
+    handle(message) {
+        const id = Number(message.id);
+        if (message.error && this.pending.has(id))
+            return this.reject(id, String(field(message.error, "message") || "Codex request failed"));
+        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 || {}));
+    }
+    handleNotification(method, params) {
+        if (method === "item/agentMessage/delta")
+            return this.emitDelta(params);
+        if (method === "thread/tokenUsage/updated")
+            this.lastUsage = normalizeUsage(params);
+        const event = normalizeCodexNotification(method, params);
+        if (!event)
+            return;
+        if (event.type === "turn.completed")
+            event.usage = this.lastUsage;
+        this.emit("agent_event", { agent: "codex", ...event });
+        if (event.type === "turn.completed") {
+            const turnId = String(field(params, "turnId") || field(field(params, "turn"), "id") || "");
+            const pending = this.activeTurns.get(turnId);
+            const error = field(field(params, "turn"), "error");
+            if (pending) {
+                this.activeTurns.delete(turnId);
+                error ? pending.reject(new Error(String(field(error, "message") || "Codex turn failed"))) : pending.resolve(event);
+            }
+            else if (turnId) {
+                this.completedTurns.set(turnId, error ? new Error(String(field(error, "message") || "Codex turn failed")) : null);
+            }
+            this.emit("agent_event", { agent: "codex", type: "stream.summary", delta_count: this.deltaCount });
+            this.deltaCount = 0;
+            this.emit("agent_done", { agent: "codex", usage: event.usage });
+        }
+    }
+    emitDelta(params) {
+        const id = String(field(params, "itemId") || "");
+        const text = `${this.textByItem.get(id) || ""}${String(field(params, "delta") || "")}`;
+        this.deltaCount += 1;
+        this.textByItem.set(id, text);
+        this.emit("agent_event", { agent: "codex", type: "item.updated", item: { id, type: "agent_message", text } });
+    }
+    answerServerRequest(message) {
+        const method = String(message.method);
+        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: message.params, result });
+    }
+    resolve(id, result) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.resolve(result));
+    }
+    reject(id, message) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.reject(new Error(message)));
+    }
+    failAll(message) {
+        [...this.pending.values(), ...this.activeTurns.values()].forEach((item) => item.reject(new Error(message)));
+        this.pending.clear();
+        this.activeTurns.clear();
+    }
+}
+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"] };
+}
+function codexConfig() {
+    return { mcp_servers: { qcanvas: { command: canvasAgentMcp.command, args: canvasAgentMcp.args, env: { QCANVAS_AGENT_ID: "codex" }, default_tools_approval_mode: "approve", startup_timeout_sec: 20, tool_timeout_sec: 90 } } };
+}
+function codexInput(prompt, images) {
+    return [{ type: "text", text: prompt, text_elements: [] }, ...images.map((file) => ({ type: "localImage", path: file }))];
+}
+function normalizeCodexNotification(method, params) {
+    if (method === "thread/started")
+        return { type: "thread.started", thread_id: field(field(params, "thread"), "id") };
+    if (method === "turn/started")
+        return { type: "turn.started" };
+    if (method === "turn/completed")
+        return { type: "turn.completed", usage: null };
+    if (method === "item/started")
+        return { type: "item.started", item: normalizeItem(field(params, "item")) };
+    if (method === "item/completed")
+        return { type: "item.completed", item: normalizeItem(field(params, "item")) };
+    if (method === "error")
+        return { type: "error", message: field(field(params, "error"), "message") || field(params, "message") };
+    return null;
+}
+async function loadCodexThread(emit, threadId, cwd, includeTurns) {
+    codexApp ||= await CodexAppClient.start(emit);
+    if (threadId !== codexThreadId) {
+        const resumed = await codexApp.resumeThread(threadId, cwd);
+        assertThreadWorkspace(resumed, cwd);
+        codexThreadId = String(field(resumed, "id") || threadId);
+        if (!includeTurns)
+            return resumed;
+    }
+    const result = await codexApp.readThread(threadId, includeTurns);
+    const thread = field(result, "thread") || {};
+    assertThreadWorkspace(thread, cwd);
+    return thread;
+}
+function assertThreadWorkspace(thread, cwd) {
+    if (!cwd || threadInWorkspace(thread, cwd))
+        return;
+    throw new Error("该 Codex 会话不属于当前画布工作空间");
+}
+function threadInWorkspace(thread, cwd) {
+    const threadCwd = String(field(thread, "cwd") || "");
+    return Boolean(threadCwd && path.resolve(threadCwd) === path.resolve(cwd));
+}
+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 === "agent_message" && typeof value.id === "string")
+        value.text = String(value.text || "");
+    if ("arguments" in value)
+        value.arguments = parseMaybeJson(value.arguments);
+    return value;
+}
+function normalizeUsage(params) {
+    const total = field(field(params, "tokenUsage"), "total");
+    return {
+        input_tokens: field(total, "inputTokens"),
+        cached_input_tokens: field(total, "cachedInputTokens"),
+        output_tokens: field(total, "outputTokens"),
+        reasoning_output_tokens: field(total, "reasoningOutputTokens"),
+    };
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function field(value, key) {
+    return value && typeof value === "object" ? value[key] : undefined;
+}
+export function summarizeCodexThread(thread) {
+    return {
+        id: String(field(thread, "id") || ""),
+        sessionId: String(field(thread, "sessionId") || ""),
+        preview: displayUserText(String(field(thread, "preview") || "")),
+        name: stringOrNull(field(thread, "name")),
+        cwd: String(field(thread, "cwd") || ""),
+        status: String(field(thread, "status") || ""),
+        source: field(thread, "source"),
+        threadSource: field(thread, "threadSource"),
+        createdAt: Number(field(thread, "createdAt") || 0),
+        updatedAt: Number(field(thread, "updatedAt") || 0),
+    };
+}
+function threadMessages(thread) {
+    const turns = arrayValue(field(thread, "turns"));
+    const messages = [];
+    turns.forEach((turn, turnIndex) => {
+        arrayValue(field(turn, "items")).forEach((item, itemIndex) => {
+            const type = String(field(item, "type") || "");
+            const id = String(field(item, "id") || `${turnIndex}-${itemIndex}`);
+            if (type === "userMessage") {
+                const text = displayUserText(userInputText(field(item, "content")));
+                if (text)
+                    messages.push({ id, role: "user", text });
+            }
+            if (type === "agentMessage") {
+                const text = String(field(item, "text") || "").trim();
+                if (text)
+                    messages.push({ id, role: "assistant", title: "Codex", text, streamId: id });
+            }
+            if (type === "mcpToolCall") {
+                const tool = String(field(item, "tool") || "工具调用");
+                const error = field(field(item, "error"), "message");
+                messages.push({ id, role: error ? "error" : "tool", title: toolName(tool), text: error ? String(error) : `${toolName(tool)} ${String(field(item, "status") || "完成")}`, detail: item });
+            }
+            if (type === "commandExecution") {
+                const command = String(field(item, "command") || "").trim();
+                if (command)
+                    messages.push({ id, role: "tool", title: "命令", text: command, detail: { cwd: field(item, "cwd"), status: field(item, "status"), exitCode: field(item, "exitCode") } });
+            }
+            if (type === "fileChange")
+                messages.push({ id, role: "tool", title: "文件变更", text: "Codex 修改了文件", detail: item });
+        });
+    });
+    return messages.filter((item) => item.text).slice(-120);
+}
+function userInputText(content) {
+    return arrayValue(content)
+        .map((item) => {
+        const type = String(field(item, "type") || "");
+        if (type === "text")
+            return String(field(item, "text") || "");
+        if (type === "image" || type === "localImage")
+            return "图片附件";
+        if (type === "mention")
+            return `@${String(field(item, "name") || "文件")}`;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function displayUserText(text) {
+    const value = text.trim();
+    const marker = "用户请求：";
+    const index = value.lastIndexOf(marker);
+    return (index >= 0 ? value.slice(index + marker.length) : value).trim();
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringOrNull(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function toolName(name) {
+    if (name.endsWith("tapcanvas_flow_get"))
+        return "读取画布";
+    if (name.endsWith("tapcanvas_flow_patch"))
+        return "画布操作";
+    return name;
+}
+async function writeAttachmentFiles(attachments) {
+    return await Promise.all(attachments.filter((item) => item.dataUrl?.startsWith("data:image/")).map(writeAttachmentFile));
+}
+async function writeAttachmentFile(item) {
+    const [, meta = "", data = ""] = item.dataUrl?.match(/^data:([^;]+);base64,(.+)$/) || [];
+    if (!data)
+        throw new Error(`图片附件无效：${item.name || "未命名图片"}`);
+    const file = path.join(os.tmpdir(), `qcanvas-${Date.now()}-${Math.random().toString(16).slice(2)}.${imageExt(meta || item.type)}`);
+    await fs.writeFile(file, Buffer.from(data, "base64"));
+    return file;
+}
+function imageExt(type = "") {
+    if (type.includes("png"))
+        return "png";
+    if (type.includes("webp"))
+        return "webp";
+    return "jpg";
+}
+function codexBin() {
+    return path.join(path.dirname(require.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}
+/**
+ * 定位随本包一起安装的 Claude Code 可执行文件（`@anthropic-ai/claude-code`）。
+ * 通过 npx 安装时它会作为依赖存在，从而让 Claude 也开箱即用；未安装则返回 null，
+ * 由调用方回退到 PATH 上的 `claude`。bin 路径读自其 package.json，跨平台稳妥。
+ */
+function claudeBin() {
+    try {
+        const pkgPath = require.resolve("@anthropic-ai/claude-code/package.json");
+        const pkg = require("@anthropic-ai/claude-code/package.json");
+        const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.claude;
+        if (!binRel)
+            return null;
+        return path.join(path.dirname(pkgPath), binRel);
+    }
+    catch {
+        return null;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}