mu-agent-bridge 1.0.73 → 1.0.78

package/plugins/zcode/dist/src-ts/plugins/workbuddy/session-history.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbuddySessionHistoryProvider = void 0;
+const node_crypto_1 = require("node:crypto");
+const unsupported = (reason) => ({ supported: false, reason });
+class WorkbuddySessionHistoryProvider {
+    options;
+    scope;
+    limitation = "仅支持配置实例中当前已选任务的已加载完成正文；不枚举、切换任务，无法证明完整历史。";
+    listedSessionId;
+    snapshot;
+    constructor(options) {
+        this.options = options;
+        this.scope = options.scope;
+    }
+    get mode() { return this.options.supported() ? "current" : "unsupported"; }
+    async listSessions(query) {
+        const invalid = this.validateQuery(query, 50);
+        if (invalid)
+            return unsupported(invalid);
+        if (query.cursor !== undefined)
+            return unsupported("WorkBuddy 当前任务列表没有后续页");
+        return this.options.run(async () => {
+            this.listedSessionId = undefined;
+            this.snapshot = undefined;
+            const client = this.options.client();
+            const state = await client.historyAvailability();
+            if (state.waiting)
+                return unsupported("WorkBuddy 正在等待用户选择，暂不读取历史");
+            const before = state.conversationId;
+            const after = await client.conversationId();
+            if (!before || before !== after)
+                return unsupported("WorkBuddy 当前任务身份不可核验或读取期间已切换");
+            this.listedSessionId = before;
+            return { supported: true, sessions: [{ id: before, title: "WorkBuddy 当前任务" }], complete: false, missingReasons: [this.limitation], readAt: new Date().toISOString() };
+        });
+    }
+    async readSession(query) {
+        const invalid = this.validateQuery(query, 100);
+        if (invalid)
+            return unsupported(invalid);
+        if (!this.listedSessionId || query.sessionId !== this.listedSessionId)
+            return unsupported("WorkBuddy 仅支持读取本实例刚列出的当前任务");
+        return this.options.run(async () => {
+            const client = this.options.client();
+            const before = await client.conversationId();
+            if (!before || before !== query.sessionId) {
+                this.snapshot = undefined;
+                return unsupported("WorkBuddy 当前任务已切换，请重新列出任务");
+            }
+            const current = await client.historyAvailability();
+            if (current.waiting) {
+                this.snapshot = undefined;
+                return unsupported("WorkBuddy 正在等待用户选择，暂不读取历史");
+            }
+            if (current.conversationId !== before) {
+                this.snapshot = undefined;
+                return unsupported("WorkBuddy 读取前后任务身份发生变化");
+            }
+            let state = this.snapshot;
+            if (query.cursor !== undefined) {
+                if (!state || state.sessionId !== before || !state.cursor || query.cursor !== state.cursor)
+                    return unsupported("WorkBuddy 历史游标无效或已过期");
+            }
+            else {
+                this.snapshot = undefined;
+                const raw = await client.readHistorySnapshot();
+                if (raw.unavailableReason)
+                    return unsupported(raw.unavailableReason);
+                if (raw.conversationId !== before)
+                    return unsupported("WorkBuddy 正文与当前任务身份不一致");
+                if (!Array.isArray(raw.messages) || !Array.isArray(raw.missingReasons) || raw.missingReasons.some(reason => typeof reason !== "string"))
+                    return unsupported("WorkBuddy 历史快照格式无效");
+                const turns = [];
+                const missingReasons = [this.limitation, ...raw.missingReasons];
+                const ids = new Set();
+                let characters = 0;
+                for (const message of raw.messages) {
+                    if (!message || typeof message.id !== "string" || !message.id.trim() || typeof message.text !== "string" || (message.role !== "user" && message.role !== "assistant")) {
+                        missingReasons.push("部分消息缺少稳定 ID 或可核验角色，已排除。");
+                        continue;
+                    }
+                    if (message.complete !== true) {
+                        missingReasons.push("当前任务存在未完成消息，已排除未完成正文。");
+                        continue;
+                    }
+                    if (ids.has(message.id))
+                        return unsupported("WorkBuddy 历史出现重复消息 ID，无法核验正文");
+                    ids.add(message.id);
+                    const text = message.text.trim();
+                    if (!text)
+                        continue;
+                    characters += text.length;
+                    if (characters > 60_000)
+                        return unsupported("WorkBuddy 历史正文超过 60000 字符，拒绝读取而不截断");
+                    turns.push({ id: message.id, role: message.role, text });
+                }
+                if (!turns.some(turn => turn.role === "user"))
+                    missingReasons.push("当前 DOM 没有可核验的用户消息，不能证明完整对话。");
+                state = { sessionId: before, turns, missingReasons: [...new Set(missingReasons)], readAt: new Date().toISOString(), offset: 0 };
+            }
+            if (await client.conversationId() !== before) {
+                this.snapshot = undefined;
+                return unsupported("WorkBuddy 读取前后任务身份发生变化");
+            }
+            const turns = state.turns.slice(state.offset, state.offset + query.limit);
+            state.offset += turns.length;
+            state.cursor = state.offset < state.turns.length ? (0, node_crypto_1.randomUUID)() : undefined;
+            this.snapshot = state;
+            return { supported: true, session: { id: before, title: "WorkBuddy 当前任务" }, turns, ...(state.cursor ? { nextCursor: state.cursor } : {}), complete: false, missingReasons: state.missingReasons, readAt: state.readAt };
+        });
+    }
+    validateQuery(query, maximum) {
+        if (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > maximum)
+            return `WorkBuddy 每页数量必须为 1–${maximum}`;
+        if (query.cursor !== undefined && (typeof query.cursor !== "string" || !query.cursor.trim()))
+            return "WorkBuddy 历史游标无效";
+        return undefined;
+    }
+}
+exports.WorkbuddySessionHistoryProvider = WorkbuddySessionHistoryProvider;

package/plugins/zcode/dist/src-ts/plugins/zcode/cdp-client.js

@@ -0,0 +1,500 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZcodeCdpClient = exports.zcodeReplyArtifactsScript = exports.zcodeSnapshotScript = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const agent_1 = require("../../agent");
+const attachments_1 = require("../../attachments");
+const cdp_client_1 = require("../workbuddy/cdp-client");
+const editorSelector = '[data-testid="v4-composer-input"]';
+const paneSelector = '[data-testid="v4-pane-shell-workspace-main"]';
+const sessionSelector = '[data-testid="v4-session-pane-workspace-main"]';
+const sendSelector = '[data-testid="v4-composer-send"]';
+const busySelector = 'button[aria-label="停止生成"],button[aria-label="停止"],button[aria-label="Stop generating"],[data-testid="chat-loading"],[data-query-row-id][data-running="true"]';
+const permissionSelector = 'button[data-permission-option-kind]';
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// shortcut: 依据 ZCode v4 的可测试 DOM 适配，桌面改版时需重新完成真机验收。
+exports.zcodeSnapshotScript = `(() => {
+  const root = document.querySelector(${JSON.stringify(paneSelector)});
+  const editor = root?.querySelector(${JSON.stringify(editorSelector)});
+  const running = root?.closest('[data-testid="side-pane-full-view-host"]')?.getAttribute('data-running');
+  const id = root?.querySelector(${JSON.stringify(sessionSelector)})?.getAttribute('data-session-id');
+  const error = root?.querySelector('[role="alert"],[data-testid="chat-error"],[data-testid="chat-error-banner"],[data-testid="v4-session-quota-banner"]');
+  const list = root?.querySelector(${JSON.stringify(permissionSelector)})?.closest('[role="listbox"]');
+  const interaction = list ? {
+    // React 以权限请求 ID 为 key 重建面板，节点标识可拒绝文案相同的新请求。
+    id: list.__agentBridgePermissionId ??= crypto.randomUUID(),
+    prompt: list.parentElement?.previousElementSibling?.innerText.trim() || 'ZCode 需要权限',
+    options: [...list.querySelectorAll(${JSON.stringify(permissionSelector)})].map(node => node.innerText.replace(/^\\s*\\d+[.、]\\s*/, '').trim()),
+    labels: [...list.querySelectorAll(${JSON.stringify(permissionSelector)})].map(node => node.getAttribute('aria-label') || ''),
+  } : undefined;
+  const rows = [...(root?.querySelectorAll('[data-row-id]') || [])].flatMap(row => {
+    const user = row.querySelector('[data-v4-user-input-collapsible-content]');
+    const assistant = row.classList.contains('group/assistant-row') && row.querySelector('[data-conversation-selectable="true"]');
+    const content = user || assistant;
+    const id = row.getAttribute('data-row-id');
+    let text = content ? content.innerText.trim() : '';
+    if (user && id) {
+      for (let fiber = user[Object.keys(user).find(key => key.startsWith('__reactFiber'))]; fiber; fiber = fiber.return) {
+        if (String(fiber.memoizedProps?.rowId) === id && typeof fiber.memoizedProps?.contentText === 'string') { text = fiber.memoizedProps.contentText.trim(); break; }
+      }
+    }
+    return content && id ? [{ id, role: user ? 'user' : 'assistant', text,
+      ...(assistant ? { finished: Boolean(root.querySelector('[data-testid="v4-feedback-like-' + id + '"]')) } : {}) }] : [];
+  });
+  return {
+    sessionId: id && id !== 'draft' ? id : undefined,
+    editor: editor?.getAttribute('contenteditable') === 'true', draft: editor?.innerText.replace(/[\\uFEFF\\u200B]/g, '').trim() || '',
+    running: running === 'true' || Boolean(root?.querySelector(${JSON.stringify(busySelector)})),
+    send: Boolean(root?.querySelector(${JSON.stringify(sendSelector)})),
+    error: error?.innerText.trim() || '', errorId: error ? (error.__agentBridgeErrorId ??= crypto.randomUUID()) : undefined, rows,
+    completed: running === 'false', interaction,
+  };
+})()`;
+exports.zcodeReplyArtifactsScript = `(expected, rowId) => {
+  const state = ${exports.zcodeSnapshotScript};
+  if (state.error || state.sessionId !== expected.sessionId || JSON.stringify(state.rows.filter(row => row.role === 'user')) !== JSON.stringify(expected.rows.filter(row => row.role === 'user'))) throw new Error('ZCode 任务或回复轮次已变化，未读取附件');
+  // 完成标记出现后正文仍可能重绘，同一轮先等下一次稳定快照。
+  if (state.running || state.interaction || !state.completed || JSON.stringify(state.rows) !== JSON.stringify(expected.rows)) return null;
+  const root = document.querySelector(${JSON.stringify(paneSelector)});
+  const row = [...(root?.querySelectorAll('[data-row-id]') || [])].find(item => item.getAttribute('data-row-id') === rowId);
+  const content = row?.querySelector('[data-conversation-selectable="true"]');
+  const nodes = content?.querySelectorAll('img[data-markdown-image][data-streamdown="image"]') || [];
+  if (nodes.length > ${attachments_1.MAX_ATTACHMENTS}) throw new Error('ZCode 回复图片数量超过 8 个');
+  let total = 0;
+  const images = [...nodes].map(image => {
+    const src = image.getAttribute('src') || '';
+    const size = (src.length - src.indexOf(',') - 1) / 4 * 3 - (src.endsWith('==') ? 2 : src.endsWith('=') ? 1 : 0);
+    if (size > ${attachments_1.MAX_ATTACHMENT_BYTES}) throw new Error('ZCode 单张图片超过 32 MiB');
+    total += size;
+    if (total > ${attachments_1.MAX_TOTAL_ATTACHMENT_BYTES}) throw new Error('ZCode 图片总大小超过 64 MiB');
+    return { src, title: image.closest('[data-image-thumbnail-trigger]')?.getAttribute('title') || undefined };
+  });
+  const files = new Set();
+  for (const node of content?.querySelectorAll('button[title]') || []) {
+    const key = Object.keys(node).find(key => key.startsWith('__reactFiber'));
+    // 只读取正式 Markdown 文件按钮的已解析路径，不扫描回复或工具输出中的任意路径。
+    for (let fiber = node[key]; fiber; fiber = fiber.return) {
+      const link = fiber.memoizedProps?.fileLink;
+      if (!link) continue;
+      if (link.workspaceRemoteSessionId) throw new Error('ZCode 远程工作区文件无法在本机读取');
+      if (typeof link.path !== 'string' || link.path !== node.getAttribute('title')) throw new Error('ZCode 文件链接路径已变化');
+      files.add(link.path);
+      if (files.size > ${attachments_1.MAX_ATTACHMENTS}) throw new Error('单条消息最多包含 8 个附件');
+      break;
+    }
+  }
+  return { images, files: [...files] };
+}`;
+class ZcodeCdpClient {
+    socket;
+    sequence = 0;
+    pending = new Map();
+    port;
+    timeoutMs;
+    fetchImpl;
+    pendingInteraction;
+    constructor(options = {}) {
+        this.port = options.port ?? 9231;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    connected() { return this.socket?.readyState === WebSocket.OPEN; }
+    pendingInteractionSessionId() { return this.pendingInteraction?.turn.sessionId; }
+    async connect() {
+        if (this.connected())
+            return;
+        this.close();
+        const url = `http://127.0.0.1:${this.port}/json`;
+        const signal = AbortSignal.timeout(this.timeoutMs);
+        const response = await this.fetchImpl(url, { signal }).catch(error => {
+            // 重载桌面后连接池可能残留旧连接，仅重试只读发现请求。
+            if (error.cause?.code !== "ECONNRESET")
+                throw error;
+            return this.fetchImpl(url, { signal });
+        });
+        if (!response.ok)
+            throw new Error(`ZCode CDP /json HTTP ${response.status}`);
+        const targets = await response.json();
+        const page = Array.isArray(targets) ? targets.find(target => target.type === "page" && /zcode/i.test(`${target.title} ${target.url}`)) : undefined;
+        if (!page?.webSocketDebuggerUrl)
+            throw new Error(`未找到 ZCode 页面 target（端口 ${this.port}）`);
+        const socket = new WebSocket(page.webSocketDebuggerUrl);
+        this.socket = socket;
+        try {
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error("ZCode CDP WebSocket 连接超时")), this.timeoutMs);
+                const finish = (error) => { clearTimeout(timer); error ? reject(error) : resolve(); };
+                socket.onopen = () => finish();
+                socket.onerror = () => { finish(new Error("ZCode CDP WebSocket 连接失败")); if (this.socket === socket)
+                    this.close(); };
+                socket.onclose = () => { finish(new Error("ZCode CDP 已断开")); if (this.socket === socket)
+                    this.close(); };
+                socket.onmessage = event => {
+                    let message;
+                    try {
+                        message = JSON.parse(String(event.data));
+                    }
+                    catch {
+                        return;
+                    }
+                    if (!message || typeof message !== "object")
+                        return;
+                    const pending = this.pending.get(message.id);
+                    if (!pending)
+                        return;
+                    this.pending.delete(message.id);
+                    clearTimeout(pending.timer);
+                    if (message.error)
+                        pending.reject(new Error(`ZCode CDP 调用失败：${message.error.message ?? message.error.code}`));
+                    else
+                        pending.resolve(message.result);
+                };
+            });
+        }
+        catch (error) {
+            this.close();
+            throw error;
+        }
+    }
+    close() {
+        const socket = this.socket;
+        this.socket = undefined;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("ZCode CDP 已关闭"));
+        }
+        this.pending.clear();
+        socket?.close();
+    }
+    async conversationId() { return (await this.snapshot()).sessionId; }
+    async createTask() {
+        await this.waitFor(async () => (await this.snapshot()).editor, "ZCode 输入框未就绪，请等待任务加载或先登录");
+        if (!await this.clickIdle('[data-testid="task-new-button"]'))
+            throw new Error("ZCode 新建任务入口未找到");
+        await this.waitFor(async () => { const state = await this.snapshot(); return state.editor && !state.sessionId && !state.rows.length && !state.draft && !state.running; }, "ZCode 新任务状态校验失败");
+        this.pendingInteraction = undefined;
+    }
+    async activateConversation(conversationId) {
+        if (!conversationId.trim())
+            throw new Error("ZCode 会话标识不能为空");
+        if ((await this.snapshot()).sessionId === conversationId)
+            return;
+        await this.waitFor(async () => (await this.snapshot()).editor, "ZCode 输入框未就绪，请等待任务加载或先登录");
+        const selector = `[data-testid=${JSON.stringify(`task-item-${conversationId}`)}]`;
+        await this.waitFor(async () => {
+            if (await this.clickIdle(selector))
+                return true;
+            if (!await this.clickIdle('[data-testid="conversation-section"] [data-task-list-show-more="true"]'))
+                throw new Error("ZCode 未找到原任务，请先在桌面任务列表中加载该任务");
+            return false;
+        }, "ZCode 原任务列表展开超时");
+        await this.waitFor(async () => (await this.snapshot()).sessionId === conversationId, "ZCode 原任务切换未完成");
+    }
+    async direct(text, timeoutMs, expert, newTask) {
+        return (await this.complete({ task: text, timeoutMs }, expert, newTask)).text;
+    }
+    async complete(request, expert, newTask = false, expectedConversationId) {
+        let stage = "准备 ZCode 桌面任务";
+        try {
+            if (typeof request.task !== "string" || !request.task.trim())
+                throw new Error("ZCode 消息不能为空");
+            if (request.attachments?.length)
+                throw new Error("ZCode 当前仅支持文本消息");
+            if (expert)
+                throw new Error("ZCode 当前不支持 WorkBuddy 专家选择");
+            request.signal?.throwIfAborted();
+            if (this.pendingInteraction) {
+                stage = "确认 ZCode 权限选择";
+                if (this.pendingInteraction.turn.sessionId !== request.sessionId)
+                    throw new Error("ZCode 正在等待另一个会话的选择");
+                return await this.continueInteraction(request, expectedConversationId);
+            }
+            let before = await this.snapshot();
+            if (!before.editor)
+                await this.waitFor(async () => { before = await this.snapshot(); return before.editor; }, "ZCode 输入框未就绪，请等待任务加载或先登录", request.signal);
+            if (newTask) {
+                await this.createTask();
+                before = await this.snapshot();
+            }
+            this.assertIdle(before);
+            if (expectedConversationId !== undefined && (before.sessionId ?? null) !== expectedConversationId)
+                throw new Error("ZCode 桌面任务已切换，与逻辑会话预期任务不符，未输入消息");
+            const beforeIds = before.rows.map(row => row.id);
+            stage = "填写 ZCode 输入框";
+            await this.evaluate(`document.querySelector(${JSON.stringify(paneSelector)}).querySelector(${JSON.stringify(editorSelector)}).focus()`);
+            await this.cdp("Input.insertText", { text: request.task });
+            const filled = await this.snapshot();
+            if (filled.draft !== request.task.trim() || filled.sessionId !== before.sessionId)
+                throw new Error("ZCode 输入内容或任务校验失败，未发送消息");
+            request.signal?.throwIfAborted();
+            stage = "向 ZCode 提交任务（尚未确认发送，请勿重复提交）";
+            await this.waitFor(async () => Boolean(await this.evaluate(`(() => { const root = document.querySelector(${JSON.stringify(paneSelector)}); const button = root?.querySelector(${JSON.stringify(sendSelector)}); return button && !button.disabled; })()`)), "ZCode 发送按钮未就绪", request.signal);
+            request.signal?.throwIfAborted();
+            const sent = await this.evaluate(`(() => {
+        const root = document.querySelector(${JSON.stringify(paneSelector)});
+        const editor = root?.querySelector(${JSON.stringify(editorSelector)});
+        const button = root?.querySelector(${JSON.stringify(sendSelector)});
+        const id = root?.querySelector(${JSON.stringify(sessionSelector)})?.getAttribute('data-session-id');
+        if (!button || button.disabled || root.closest('[data-testid="side-pane-full-view-host"]')?.getAttribute('data-running') === 'true' || root.querySelector(${JSON.stringify(busySelector)}) || root.querySelector(${JSON.stringify(permissionSelector)}) || editor?.innerText.trim() !== ${JSON.stringify(request.task.trim())} || (id && id !== 'draft' ? id : undefined) !== ${JSON.stringify(before.sessionId)}) return false;
+        button.click(); return true;
+      })()`);
+            if (!sent)
+                throw new Error("ZCode 页面或输入发生变化，未发送消息");
+            stage = "等待 ZCode 回复（任务已提交，桌面未被停止，请勿重复提交）";
+            return await this.waitForReply(request, { beforeIds, task: request.task.trim(), conversationId: before.sessionId, sessionId: request.sessionId,
+                previousError: before.error ? { id: before.errorId, text: before.error } : undefined });
+        }
+        catch (error) {
+            throw new agent_1.AgentOperationError("ZCODE_TASK_FAILED", stage, error);
+        }
+    }
+    async continueInteraction(request, expectedConversationId) {
+        const { interaction, turn } = this.pendingInteraction;
+        const state = await this.snapshot();
+        if (state.sessionId !== turn.conversationId || expectedConversationId !== undefined && (state.sessionId ?? null) !== expectedConversationId)
+            throw new Error("ZCode 桌面任务已切换，未确认权限");
+        if (!state.interaction) {
+            this.pendingInteraction = undefined;
+            return this.waitForReply(request, turn);
+        }
+        if (JSON.stringify(state.interaction) !== JSON.stringify(interaction))
+            throw new Error("ZCode 权限面板已变化，请在桌面核对，未确认权限");
+        const index = (0, cdp_client_1.interactionChoice)(request.task, interaction.options) ?? (0, cdp_client_1.interactionChoice)(request.task, interaction.labels);
+        if (index === undefined)
+            return { text: (0, cdp_client_1.formatInteraction)(interaction) };
+        // 聚焦只改变选中项；下一次 CDP 调用等 React 更新后才确认，避免误触默认选项。
+        const action = (click) => `(() => {
+      const state = ${exports.zcodeSnapshotScript};
+      if (state.error || state.draft || state.sessionId !== ${JSON.stringify(turn.conversationId)} || JSON.stringify(state.interaction) !== ${JSON.stringify(JSON.stringify(interaction))}) throw new Error('ZCode 任务、草稿或权限面板已变化，未确认权限');
+      const user = state.rows.findIndex(row => row.role === 'user' && !${JSON.stringify(turn.beforeIds)}.includes(row.id) && row.text === ${JSON.stringify(turn.task)});
+      if (user < 0 || state.rows.slice(user + 1).some(row => row.role === 'user')) throw new Error('ZCode 出现人工追加的用户消息，未确认权限');
+      const option = document.querySelector(${JSON.stringify(paneSelector)}).querySelectorAll(${JSON.stringify(permissionSelector)})[${index}];
+      if (!option || option.disabled || option.getAttribute('aria-disabled') === 'true') throw new Error('ZCode 权限选项不可用');
+      ${click ? "if (option.getAttribute('aria-selected') !== 'true') throw new Error('ZCode 权限选项尚未选中'); option.click();" : "option.focus();"}
+      return true;
+    })()`;
+        request.signal?.throwIfAborted();
+        await this.evaluate(action(false));
+        request.signal?.throwIfAborted();
+        await this.evaluate(action(true));
+        this.pendingInteraction = undefined;
+        return this.waitForReply(request, turn, interaction.id);
+    }
+    async waitForReply(request, turn, confirmedId) {
+        const beforeIds = new Set(turn.beforeIds);
+        const deadline = Date.now() + (request.timeoutMs ?? 3_600_000);
+        let previous = "";
+        let previousSince = 0;
+        while (Date.now() < deadline) {
+            request.signal?.throwIfAborted();
+            await sleep(200);
+            const current = await this.snapshot();
+            request.signal?.throwIfAborted();
+            if (turn.conversationId && current.sessionId !== turn.conversationId)
+                throw new Error("ZCode 桌面任务已切换，未返回其他任务的消息");
+            turn.conversationId ??= current.sessionId;
+            if (turn.previousError && current.errorId === turn.previousError.id && current.error === turn.previousError.text)
+                continue;
+            turn.previousError = undefined;
+            if (current.error)
+                throw new Error(current.error);
+            const userIndex = current.rows.findIndex(row => row.role === "user" && !beforeIds.has(row.id) && row.text === turn.task);
+            const following = userIndex < 0 ? [] : current.rows.slice(userIndex + 1);
+            if (following.some(row => row.role === "user"))
+                throw new Error("ZCode 桌面追加了新的用户消息，未混入其他轮次回复");
+            const reply = following.filter(row => row.role === "assistant" && !beforeIds.has(row.id)).at(-1);
+            if (current.interaction) {
+                if (current.interaction.id !== confirmedId && userIndex >= 0 && turn.conversationId) {
+                    this.pendingInteraction = { interaction: current.interaction, turn };
+                    return { text: (0, cdp_client_1.formatInteraction)(current.interaction) };
+                }
+                continue;
+            }
+            const completed = current.completed && reply?.finished;
+            if (!current.running && current.send && completed && reply) {
+                const artifacts = await this.evaluate(`(${exports.zcodeReplyArtifactsScript})(${JSON.stringify(current)}, ${JSON.stringify(reply.id)})`);
+                request.signal?.throwIfAborted();
+                if (!artifacts) {
+                    previous = "";
+                    previousSince = 0;
+                    continue;
+                }
+                if (reply.text || artifacts.images.length || artifacts.files.length) {
+                    const signature = JSON.stringify({ text: reply.text, artifacts });
+                    if (signature === previous) {
+                        if (Date.now() - previousSince < 1_000)
+                            continue;
+                        const attachments = await this.replyFileAttachments(artifacts.files, this.replyAttachments(artifacts.images));
+                        const verified = await this.evaluate(`(${exports.zcodeReplyArtifactsScript})(${JSON.stringify(current)}, ${JSON.stringify(reply.id)})`);
+                        if (!verified) {
+                            previous = "";
+                            previousSince = 0;
+                            continue;
+                        }
+                        if (JSON.stringify(verified) !== JSON.stringify(artifacts))
+                            throw new Error("ZCode 回复附件已变化，未回传其他文件");
+                        request.signal?.throwIfAborted();
+                        return { text: reply.text || "附件已生成。", ...(attachments.length ? { attachments } : {}) };
+                    }
+                    previous = signature;
+                    previousSince = Date.now();
+                    continue;
+                }
+            }
+            previous = "";
+            previousSince = 0;
+        }
+        throw new Error("ZCode 回复超时，未确认本轮任务完成；桌面任务未被停止，请勿重复提交");
+    }
+    assertIdle(state) {
+        // 旧轮次的错误横幅不阻止用户重试，本轮错误在提交后回传。
+        if (!state.editor)
+            throw new Error("ZCode 输入框未就绪，请先登录并打开主任务页面");
+        if (state.draft)
+            throw new Error("ZCode 有未发送的用户草稿，请先在桌面处理");
+        if (state.interaction)
+            throw new Error("ZCode 正在等待权限确认，请先处理原任务的选择");
+        if (state.running)
+            throw new Error("ZCode 正在生成回复，请等待当前任务结束");
+    }
+    replyAttachments(images) {
+        if (!images?.length)
+            return [];
+        if (images.length > attachments_1.MAX_ATTACHMENTS)
+            throw new Error("ZCode 回复图片数量超过 8 个");
+        let total = 0;
+        const attachments = images.map((image) => {
+            if (image.src.length > Math.ceil(attachments_1.MAX_ATTACHMENT_BYTES / 3) * 4 + 64)
+                throw new Error("ZCode 单张图片超过 32 MiB");
+            const match = /^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/]+={0,2})$/i.exec(image.src);
+            if (!match)
+                throw new Error("ZCode 图片地址不支持");
+            const contentType = match[1].toLowerCase();
+            const size = match[2].length / 4 * 3 - (match[2].endsWith("==") ? 2 : match[2].endsWith("=") ? 1 : 0);
+            if (size > attachments_1.MAX_ATTACHMENT_BYTES)
+                throw new Error("ZCode 单张图片超过 32 MiB");
+            total += size;
+            if (total > attachments_1.MAX_TOTAL_ATTACHMENT_BYTES)
+                throw new Error("ZCode 图片总大小超过 64 MiB");
+            const data = Buffer.from(match[2], "base64");
+            if (data.toString("base64") !== match[2])
+                throw new Error("ZCode 图片编码无效");
+            const basename = image.title?.split(/[\\/]/).pop() || `zcode-${(0, node_crypto_1.randomUUID)()}.${contentType.slice(6)}`;
+            return { kind: "image", data, filename: (0, attachments_1.attachmentFilename)(basename), contentType };
+        });
+        (0, attachments_1.validateAttachments)(attachments);
+        return attachments;
+    }
+    async replyFileAttachments(paths, attachments) {
+        const mimeTypes = {
+            ".txt": "text/plain", ".md": "text/markdown", ".csv": "text/csv", ".json": "application/json", ".html": "text/html", ".pdf": "application/pdf",
+            ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".zip": "application/zip",
+            ".mp4": "video/mp4", ".webm": "video/webm", ".mov": "video/quicktime",
+        };
+        const digest = (data) => (0, node_crypto_1.createHash)("sha256").update(data).digest("hex");
+        const seen = new Set();
+        for (const path of paths) {
+            if (!(0, node_path_1.isAbsolute)(path) || path.startsWith("\\") || path.startsWith("//") || process.platform === "win32" && path.startsWith("/") || /[\u0000-\u001f\u007f]/.test(path))
+                throw new Error("ZCode 文件链接路径无效");
+            const key = (0, node_path_1.normalize)(path);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const filename = (0, attachments_1.attachmentFilename)(path);
+            let data;
+            try {
+                const before = await (0, promises_1.lstat)(path);
+                if (!before.isFile())
+                    throw new Error("ZCode 附件不是普通文件");
+                const handle = await (0, promises_1.open)(path, node_fs_1.constants.O_RDONLY | (node_fs_1.constants.O_NOFOLLOW ?? 0));
+                try {
+                    const info = await handle.stat();
+                    if (!info.isFile())
+                        throw new Error("ZCode 附件不是普通文件");
+                    if (before.dev !== info.dev || before.ino > 0 && before.ino !== info.ino)
+                        throw new Error("ZCode 附件路径在读取前已变化");
+                    if (info.size < 1 || info.size > attachments_1.MAX_ATTACHMENT_BYTES)
+                        throw new Error("ZCode 附件大小无效，单个附件不能超过 32 MiB");
+                    const buffer = Buffer.alloc(info.size + 1);
+                    let offset = 0;
+                    while (offset < buffer.length) {
+                        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
+                        if (!bytesRead)
+                            break;
+                        offset += bytesRead;
+                    }
+                    const after = await handle.stat();
+                    if (offset !== info.size || after.size !== info.size || after.mtimeMs !== info.mtimeMs)
+                        throw new Error("ZCode 附件在读取时发生变化");
+                    data = buffer.subarray(0, offset);
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            catch (error) {
+                throw new Error(`ZCode 文件读取失败：${filename}（${error instanceof Error ? error.message : String(error)}）`);
+            }
+            const imageType = (0, attachments_1.detectImageContentType)(data);
+            const contentType = imageType ?? mimeTypes[(0, node_path_1.extname)(path).toLowerCase()] ?? "application/octet-stream";
+            if (contentType === "video/mp4" && (data.length < 12 || data.subarray(4, 8).toString() !== "ftyp"))
+                throw new Error("ZCode 视频内容与类型不符");
+            const duplicate = imageType && attachments.find(item => item.kind === "image" && digest(item.data) === digest(data));
+            if (duplicate) {
+                duplicate.filename = filename;
+                continue;
+            }
+            attachments.push({ kind: imageType ? "image" : "file", data, filename, contentType });
+            (0, attachments_1.validateAttachments)(attachments);
+        }
+        return attachments;
+    }
+    async snapshot() { return await this.evaluate(exports.zcodeSnapshotScript); }
+    async clickIdle(selector) {
+        return await this.evaluate(`(() => {
+      const state = ${exports.zcodeSnapshotScript};
+      if (!state.editor || state.draft || state.running || state.interaction) throw new Error('ZCode 有草稿、待确认权限、正在生成或页面未就绪，未切换任务');
+      const item = document.querySelector(${JSON.stringify(selector)});
+      if (!item || item.disabled || item.getAttribute('aria-disabled') === 'true') return false;
+      item.click(); return true;
+    })()`);
+    }
+    async waitFor(check, message, signal) {
+        const deadline = Date.now() + this.timeoutMs;
+        do {
+            signal?.throwIfAborted();
+            if (await check())
+                return;
+            signal?.throwIfAborted();
+            await sleep(100);
+        } while (Date.now() < deadline);
+        throw new Error(message);
+    }
+    async cdp(method, params = {}) {
+        if (!this.connected())
+            throw new Error("ZCode CDP 尚未连接");
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`ZCode CDP ${method} 超时`)); }, this.timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.socket.send(JSON.stringify({ id, method, params }));
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    async evaluate(expression) {
+        const result = await this.cdp("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
+        if (result.exceptionDetails)
+            throw new Error(`ZCode 页面 JS 异常：${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+        return result.result?.value;
+    }
+}
+exports.ZcodeCdpClient = ZcodeCdpClient;