mu-agent-bridge 1.0.34 → 1.0.39

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

@@ -1,9 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatgptCdpClient = exports.userBubbleSelector = exports.turnSelector = exports.editorSelector = void 0;
+exports.chatgptAttachmentPath = chatgptAttachmentPath;
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const attachments_1 = require("../../attachments");
 const session_store_1 = require("./session-store");
 const cdp_draft_1 = require("../cdp-draft");
+function chatgptAttachmentPath(href, outputDirectory) {
+    let path;
+    try {
+        if (decodeURIComponent(href).split(/[\\/]/).some(part => part === "." || part === ".."))
+            return;
+        if (href.startsWith("file://")) {
+            const url = new URL(href);
+            if (url.hostname || url.search || url.hash || url.username || url.password)
+                return;
+            path = decodeURIComponent(url.pathname);
+        }
+        else if (href.startsWith("sandbox:/"))
+            path = decodeURIComponent(href.slice("sandbox:".length));
+        else if (href.startsWith("/") || /^[a-z]:\//i.test(href))
+            path = decodeURIComponent(href);
+        else
+            return;
+    }
+    catch {
+        return;
+    }
+    if (/[%?#\u0000-\u001f\u007f]/.test(path) || path.startsWith("//") || path.includes("\\"))
+        return;
+    if (path.split("/").some(part => part === "." || part === ".."))
+        return;
+    const normalized = /^\/[a-z]:\//i.test(path) ? path.slice(1) : path;
+    const unixRoot = `/tmp/${outputDirectory}/`;
+    const windowsRoot = normalized.match(/^[a-z]:\/Users\/[^/]+\/AppData\/Local\/Temp\//i)?.[0];
+    const prefix = normalized.startsWith(unixRoot) ? unixRoot : windowsRoot && normalized.startsWith(`${windowsRoot}${outputDirectory}/`) ? `${windowsRoot}${outputDirectory}/` : undefined;
+    if (!prefix || normalized.slice(prefix.length).split("/").some(part => !part || part.startsWith(".")))
+        return;
+    return normalized;
+}
 exports.editorSelector = '[data-codex-composer="true"][contenteditable="true"]';
 exports.turnSelector = '[data-chatgpt-conversation-turn="true"]';
 exports.userBubbleSelector = "[data-user-message-bubble]";
@@ -16,6 +52,7 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const sidebarSelector = "[data-app-action-sidebar-thread-id]";
 const newSessionSelector = 'button,[role="button"]';
 class ChatgptCdpClient {
+    attachmentInput = true;
     socket;
     tunnel;
     sequence = 0;
@@ -58,6 +95,78 @@ class ChatgptCdpClient {
     })()`);
         return (0, session_store_1.validSession)(entry) ? entry : undefined;
     }
+    async historyBusy() {
+        return Boolean(await this.evaluate(`Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)}))`));
+    }
+    async readSessionHistory(session) {
+        if (!this.connected())
+            return { supported: false, reason: "ChatGPT CDP 当前未连接" };
+        const before = await this.activeSession();
+        if (!before || before.id !== session.id || before.host !== session.host)
+            return { supported: false, reason: "当前活动会话身份与请求不一致" };
+        if (await this.historyBusy())
+            return { supported: false, reason: "ChatGPT 正在生成回复，暂不读取历史" };
+        const raw = await this.evaluate(`(() => {
+      const selected = document.querySelector('[data-app-action-sidebar-thread-selected="true"], [data-app-action-sidebar-thread-active="true"]');
+      if (selected?.getAttribute('data-app-action-sidebar-thread-id') !== ${JSON.stringify(session.id)}
+        || selected?.getAttribute('data-app-action-sidebar-thread-host-id') !== ${JSON.stringify(session.host)}) return { supported: false, reason: '读取期间活动会话身份发生变化' };
+      if (document.querySelector(${JSON.stringify(stopButtonSelector)})) return { supported: false, reason: 'ChatGPT 正在生成回复，暂不读取历史' };
+      const turns = [...document.querySelectorAll(${JSON.stringify(exports.turnSelector)})];
+      const output = [];
+      const missingReasons = [];
+      let chars = 0;
+      const collect = (role, text) => {
+        chars += text.length;
+        if (chars > 60000) throw new Error('ChatGPT 会话正文超过 60,000 字符上限');
+        output.push({ role, text });
+      };
+      for (const turn of turns) {
+        const turnId = turn.getAttribute(${JSON.stringify(turnIdAttribute)});
+        if (!turnId) {
+          missingReasons.push('部分消息缺少可验证的 turn 身份');
+          continue;
+        }
+        const users = [...turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)})];
+        for (const item of users) {
+          const body = item.querySelector('[data-markdown-text-tone="user-message"]');
+          if (!body) {
+            missingReasons.push('部分用户消息缺少专用正文标记，已跳过');
+            continue;
+          }
+          const text = body.innerText?.trim();
+          if (text) collect('user', text);
+        }
+        const assistants = [...turn.querySelectorAll(${JSON.stringify(assistantMessageSelector)})];
+        for (const item of assistants) {
+          const marker = item.closest('[data-response-annotation-target][data-response-annotation-conversation]');
+          const excluded = item.closest('[data-message-author-role="tool"], [data-message-author-role="system"], [data-message-channel="analysis"], [data-message-channel="commentary"], [data-reasoning], [data-is-streaming="true"], [data-streaming="true"], [aria-busy="true"]');
+          const text = item.innerText?.trim();
+          if (marker?.getAttribute('data-response-annotation-conversation') === ${JSON.stringify(session.id.replace(/^local:/, ""))}
+            && marker.getAttribute('data-response-annotation-target') && !excluded && text) collect('assistant', text);
+        }
+      }
+      return { supported: true, turns: output, missingReasons };
+    })()`);
+        const after = await this.activeSession();
+        if (!after || after.id !== session.id || after.host !== session.host)
+            return { supported: false, reason: "读取期间活动会话身份发生变化" };
+        if (await this.historyBusy())
+            return { supported: false, reason: "ChatGPT 正在生成回复，暂不读取历史" };
+        const result = raw;
+        if (result?.supported === false && typeof result.reason === "string")
+            return { supported: false, reason: result.reason };
+        if (!result || !Array.isArray(result.turns) || !result.turns.every((turn) => {
+            if (!turn || typeof turn !== "object")
+                return false;
+            const value = turn;
+            return (value.role === "user" || value.role === "assistant") && typeof value.text === "string";
+        })) {
+            return { supported: false, reason: "ChatGPT 会话正文格式无法验证" };
+        }
+        const missingReasons = Array.isArray(result.missingReasons) ? result.missingReasons.filter((item) => typeof item === "string") : [];
+        missingReasons.push("仅包含当前页面已加载的可验证正文，页面虚拟化或未加载历史导致完整性无法确认");
+        return { supported: true, turns: result.turns, complete: false, missingReasons };
+    }
     async switchSession(session) {
         await this.recoverDraft();
         const locate = `[...document.querySelectorAll(${JSON.stringify(sidebarSelector)})].find(item =>
@@ -190,15 +299,55 @@ class ChatgptCdpClient {
         this.tunnel = undefined;
         this.rejectPending(new Error("ChatGPT CDP 已关闭"));
     }
-    async direct(text, timeoutMs = 240_000) {
+    async direct(text, timeoutMs = 240_000, attachments) {
+        (0, attachments_1.validateAttachments)(attachments);
+        const slot = `__agentBridgeChatgpt_${(0, node_crypto_1.randomUUID)().replaceAll("-", "")}`;
+        const outputDirectory = `agent-bridge-chatgpt-${(0, node_crypto_1.randomUUID)()}`;
+        const startedAt = Date.now();
+        const instruction = `附件回传约定：如果本轮需要返回文件、图片或视频，请把要返回的文件副本写入本轮新建的临时目录（Linux/macOS：/tmp/${outputDirectory}；Windows：C:/Users/<当前用户>/AppData/Local/Temp/${outputDirectory}），并在最终回复给出文件链接。仅需文字时无需创建目录。`;
+        let failure;
+        try {
+            return await this.directTurn(`${text} ${instruction}`, timeoutMs, attachments, slot, outputDirectory, startedAt);
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            if (attachments?.length) {
+                try {
+                    await this.evaluate(`(async () => {
+          const state = globalThis[${JSON.stringify(slot)}];
+          if (!state) return;
+          state.observer?.disconnect();
+          for (const button of state.buttons ?? []) if (button.isConnected) button.click();
+          try { await Promise.all(state.paths.map(path => state.services.workspaceFiles.releaseTemporaryFile({ path }))); }
+          finally { delete globalThis[${JSON.stringify(slot)}]; }
+        })()`);
+                }
+                catch (cleanupError) {
+                    if (failure === undefined)
+                        throw cleanupError;
+                    throw new AggregateError([failure, cleanupError], `${failure instanceof Error ? failure.message : String(failure)}；临时附件清理失败`, { cause: failure });
+                }
+            }
+        }
+    }
+    async directTurn(text, timeoutMs, attachments, slot, outputDirectory, startedAt) {
         await this.waitFor(`Boolean(document.querySelector(${JSON.stringify(exports.editorSelector)}))`, "ChatGPT 桌面端输入框未就绪");
         await this.recoverDraft();
         const beforeTurnsJson = await this.evaluate(`JSON.stringify([...document.querySelectorAll(${JSON.stringify(exports.turnSelector)})].map(turn => ({ id: turn.getAttribute(${JSON.stringify(turnIdAttribute)}), users: turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).length })))`);
         const beforeTurns = JSON.parse(String(beforeTurnsJson || "[]"));
         const beforeAssistantCount = Number(await this.evaluate(`document.querySelectorAll(${JSON.stringify(assistantMessageSelector)}).length`));
+        const baseline = await this.evaluate(`JSON.stringify([...document.querySelectorAll(${JSON.stringify(assistantMessageSelector)})].map(node => {
+      const message = node.closest('[data-response-annotation-target][data-response-annotation-conversation]');
+      return message ? [message.getAttribute('data-response-annotation-conversation'), message.getAttribute('data-response-annotation-target')] : null;
+    }).filter(Boolean))`);
+        const beforeMessages = JSON.parse(String(baseline || "[]"));
+        const origin = await this.activeSession();
         const ready = await this.evaluate(`(() => {
       const editor = document.querySelector(${JSON.stringify(exports.editorSelector)});
-      if (!editor || editor.innerText.trim()) return false;
+      if (!editor || editor.innerText.trim() || document.querySelector('button[aria-label^="Remove "]')) return false;
       const findButton = () => {
         for (let parent = editor; parent && parent !== document.body; parent = parent.parentElement) {
           const buttons = [...parent.querySelectorAll(${JSON.stringify(sendButtonSelector)})];
@@ -213,6 +362,8 @@ class ChatgptCdpClient {
     })()`);
         if (!ready)
             throw new Error("ChatGPT 输入框含有未发送内容，或桌面端发送按钮未就绪");
+        if (attachments?.length)
+            await this.injectAttachments(attachments, slot);
         await this.cdp("Input.insertText", { text });
         const inputMatches = await this.evaluate(`document.querySelector(${JSON.stringify(exports.editorSelector)})?.innerText.trim() === ${JSON.stringify(text.trim())}`);
         if (!inputMatches)
@@ -239,22 +390,36 @@ class ChatgptCdpClient {
         while (Date.now() < deadline) {
             await sleep(800);
             const raw = await this.evaluate(`(() => {
+        const previous = new Set(${JSON.stringify(Array.isArray(beforeMessages) ? beforeMessages : [])}.map(item => JSON.stringify(item)));
+        let hasArtifacts = false;
+        const artifacts = [...document.querySelectorAll(${JSON.stringify(assistantMessageSelector)})].flatMap(node => {
+          const message = node.closest('[data-response-annotation-target][data-response-annotation-conversation]');
+          if (!message) return [];
+          const conversationId = message.getAttribute('data-response-annotation-conversation');
+          const messageId = message.getAttribute('data-response-annotation-target');
+          if (!conversationId || !messageId || previous.has(JSON.stringify([conversationId, messageId]))) return [];
+          hasArtifacts ||= Boolean(node.querySelector('a[href], img[src], video[src], source[src], [data-file-reference][data-prompt-link-href]'));
+          return [{ conversationId, messageId }];
+        });
         const before = ${JSON.stringify(beforeTurns)};
         const turns = [...document.querySelectorAll(${JSON.stringify(exports.turnSelector)})];
+        const userText = node => (node?.querySelector('[data-markdown-text-tone="user-message"]') ?? node)?.innerText.trim().replace(/\\s+/g, ' ');
+        const expectedUserText = ${JSON.stringify(text.trim().replace(/\s+/g, " "))};
         const turn = turns.findLast((item, index) => {
           const id = item.getAttribute(${JSON.stringify(turnIdAttribute)});
           const oldIndex = before.findIndex(entry => entry.id === id);
           const old = oldIndex < 0 ? undefined : before[oldIndex];
           const users = item.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)});
           const fresh = oldIndex < 0 || index >= before.length || users.length > (old?.users ?? 0);
-          return fresh && users.item(users.length - 1)?.innerText.trim() === ${JSON.stringify(text.trim())};
+          return fresh && userText(users.item(users.length - 1)) === expectedUserText;
         });
         if (!turn) {
           const assistants = [...document.querySelectorAll(${JSON.stringify(assistantMessageSelector)})];
           const fallback = assistants.length > ${beforeAssistantCount}
             ? assistants.at(-1)?.innerText.trim() ?? ""
             : "";
-          return JSON.stringify({ reply: fallback, active: Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)})) });
+          const submitted = [...document.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)})].some(node => userText(node) === expectedUserText);
+          return JSON.stringify({ reply: fallback, artifacts, hasArtifacts, submitted, active: Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)})) });
         }
         const user = turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).item(turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).length - 1);
         const unit = user?.closest(${JSON.stringify(contentUnitSelector)});
@@ -264,14 +429,20 @@ class ChatgptCdpClient {
         const legacyReplies = [...turn.querySelectorAll('[data-message-author-role="assistant"]')].map(item => item.innerText.trim()).filter(Boolean);
         const reply = replies.at(-1) ?? legacyReplies.at(-1) ?? "";
         const active = Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)}));
-        return JSON.stringify({ reply, active });
+        return JSON.stringify({ reply, active, artifacts, hasArtifacts, submitted: true });
       })()`);
             const state = JSON.parse(String(raw));
             const reply = state.reply.trim();
-            stable = reply && reply === previous ? stable + 1 : 0;
-            previous = reply;
-            if (reply && stable >= 2 && !state.active)
-                return reply;
+            const signature = JSON.stringify([reply, state.artifacts, state.hasArtifacts]);
+            stable = (reply || state.hasArtifacts) && signature === previous ? stable + 1 : 0;
+            previous = signature;
+            if ((reply || state.hasArtifacts) && stable >= 2 && !state.active) {
+                const output = state.hasArtifacts && state.artifacts?.length ? await this.readArtifacts(state.artifacts, origin, outputDirectory, startedAt, state.submitted) : [];
+                if (output.length)
+                    return { text: reply, attachments: output };
+                if (reply)
+                    return reply;
+            }
         }
         throw new Error("ChatGPT UI 回复超时");
     }
@@ -315,6 +486,168 @@ class ChatgptCdpClient {
     recoverDraft() {
         return (0, cdp_draft_1.recoverCdpDraft)(this.evaluate.bind(this), exports.editorSelector, stopButtonSelector, this.dataDir);
     }
+    async injectAttachments(items, slot) {
+        const files = items.map(item => ({ filename: (0, attachments_1.attachmentFilename)(item.filename), contentType: item.contentType, data: Buffer.from(item.data).toString("base64") }));
+        await this.evaluate(String.raw `(async () => {
+      const editor = document.querySelector(${JSON.stringify(exports.editorSelector)});
+      if (!editor || document.querySelector('button[aria-label^="Remove "]')) throw new Error('ChatGPT 输入框已有附件或未就绪，未发送消息');
+      const entry = [...document.scripts].find(script => /\/assets\/index-[^/]+\.js$/.test(script.src));
+      if (!entry) throw new Error('ChatGPT 桌面原生接口入口未找到');
+      const source = await (await fetch(entry.src)).text();
+      const rpc = source.match(/["'](\.\/rpc-[\w-]+\.js)["']/);
+      if (!rpc) throw new Error('ChatGPT 桌面原生附件接口未找到');
+      const { appServices: services } = await import(new URL(rpc[1], entry.src).href);
+      const state = { services, paths: [], buttons: new Set(), observer: null }; globalThis[${JSON.stringify(slot)}] = state;
+      const transfer = new DataTransfer();
+      for (const item of ${JSON.stringify(files)}) {
+        const binary = atob(item.data); const bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+        const result = await services.workspaceFiles.createTemporaryFile({ bytes, fileName: item.filename });
+        if (!result?.path) throw new Error('ChatGPT 临时附件创建失败');
+        state.paths.push(result.path);
+        const file = new File([bytes], item.filename, { type: item.contentType });
+        Object.defineProperty(file, 'path', { value: result.path }); transfer.items.add(file);
+      }
+      const names = ${JSON.stringify(files.map(file => `Remove ${file.filename}`))};
+      const capture = () => {
+        for (const button of document.querySelectorAll('button[aria-label^="Remove "]')) {
+          if (names.includes(button.getAttribute('aria-label'))) state.buttons.add(button);
+        }
+      };
+      state.observer = new MutationObserver(capture);
+      state.observer.observe(document.body, { childList: true, subtree: true });
+      editor.dispatchEvent(new ClipboardEvent('paste', { bubbles: true, cancelable: true, clipboardData: transfer }));
+      capture();
+    })()`);
+        await this.waitFor(`(() => {
+      const names = ${JSON.stringify(files.map(file => `Remove ${file.filename}`))};
+      const current = [...document.querySelectorAll('button[aria-label^="Remove "]')].map(node => node.getAttribute('aria-label'));
+      const ready = current.length === names.length && names.every(name => current.filter(value => value === name).length === names.filter(value => value === name).length);
+      if (ready) globalThis[${JSON.stringify(slot)}]?.observer?.disconnect();
+      return ready;
+    })()`, "ChatGPT 附件上传未确认");
+    }
+    async readArtifacts(messages, origin, outputDirectory, startedAt, submitted = false) {
+        const active = await this.activeSession();
+        if (!origin || !active || active.host !== origin.host)
+            throw new Error("ChatGPT 附件所属会话无法确认");
+        if (active.id !== origin.id)
+            throw new Error("ChatGPT 会话已变化，未读取输出附件");
+        let conversationId = active.id.replace(/^local:/, "");
+        if (conversationId.startsWith("client-new-thread:")) {
+            const ids = [...new Set(messages.map(message => message.conversationId))];
+            if (active.id !== origin.id || !submitted || ids.length !== 1 || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(ids[0]))
+                throw new Error("ChatGPT 新会话身份尚未确认，未读取输出附件");
+            conversationId = ids[0];
+        }
+        const scoped = messages.filter(message => typeof message.conversationId === "string" && typeof message.messageId === "string"
+            && message.conversationId === conversationId);
+        const sessionGuard = `const selected = document.querySelector('[data-app-action-sidebar-thread-selected="true"], [data-app-action-sidebar-thread-active="true"]');
+      if (selected?.getAttribute('data-app-action-sidebar-thread-id') !== ${JSON.stringify(active.id)}
+        || selected?.getAttribute('data-app-action-sidebar-thread-host-id') !== ${JSON.stringify(active.host)}) throw new Error('ChatGPT 会话已变化，未读取输出附件');`;
+        const references = await this.evaluate(`(() => {
+      ${sessionGuard}
+      const messages = ${JSON.stringify(scoped)};
+      const references = [];
+      for (const node of document.querySelectorAll(${JSON.stringify(assistantMessageSelector)})) {
+        const message = node.closest('[data-response-annotation-target][data-response-annotation-conversation]');
+        if (!message || !messages.some(item => item.conversationId === message.getAttribute('data-response-annotation-conversation') && item.messageId === message.getAttribute('data-response-annotation-target'))) continue;
+        for (const link of node.querySelectorAll('a[href], img[src], video[src], source[src], [data-file-reference][data-prompt-link-href]')) {
+          const href = link.getAttribute('href') ?? link.getAttribute('src') ?? link.getAttribute('data-prompt-link-href');
+          if (href) references.push(href);
+        }
+      }
+      return references;
+    })()`);
+        const paths = [...new Set(references.map(href => chatgptAttachmentPath(href, outputDirectory)).filter((path) => Boolean(path)))];
+        if (paths.length > attachments_1.MAX_ATTACHMENTS)
+            throw new Error("单条消息最多包含 8 个附件");
+        const output = [];
+        let total = 0;
+        for (const path of paths) {
+            const fileSlot = `__agentBridgeChatgptOutput_${(0, node_crypto_1.randomUUID)().replaceAll("-", "")}`;
+            let file;
+            let readFailure;
+            try {
+                const metadata = await this.evaluate(`(async () => {
+        ${sessionGuard}
+        globalThis[${JSON.stringify(fileSlot)}] = '';
+        const call = (name, params) => new Promise((resolve, reject) => {
+          const requestId = crypto.randomUUID();
+          const finish = () => { clearTimeout(timer); window.removeEventListener('message', receive); };
+          const receive = event => {
+            const response = event.data;
+            if ((event.source !== window && !(event.source === null && event.origin === '')) || response?.type !== 'fetch-response' || response.requestId !== requestId) return;
+            finish();
+            if (response.responseType !== 'success' || response.status !== 200) { reject(new Error('ChatGPT 输出附件读取失败')); return; }
+            try { resolve(JSON.parse(response.bodyJsonString)); } catch { reject(new Error('ChatGPT 输出附件响应无效')); }
+          };
+          const timer = setTimeout(() => { finish(); reject(new Error('ChatGPT 输出附件读取超时')); }, ${this.timeoutMs});
+          window.addEventListener('message', receive);
+          try { window.electronBridge.sendMessageFromView({ type: 'fetch', requestId, method: 'POST', url: 'vscode://codex/' + name, body: JSON.stringify(params) }); }
+          catch (error) { finish(); reject(error); }
+        });
+        const params = { hostId: ${JSON.stringify(active.host)}, path: ${JSON.stringify(path)} };
+        const metadata = await call('read-file-metadata', params);
+        if (!metadata.isFile || !Number.isSafeInteger(metadata.sizeBytes) || metadata.sizeBytes <= 0) throw new Error('ChatGPT 输出附件元数据无效');
+        if (!Number.isFinite(metadata.createdAtMs) || metadata.createdAtMs < ${startedAt - 5000}) throw new Error('ChatGPT 输出附件不是本轮创建的文件');
+        if (metadata.sizeBytes > ${attachments_1.MAX_ATTACHMENT_BYTES}) throw new Error('单个附件不能超过 32 MiB');
+        if (metadata.sizeBytes > ${attachments_1.MAX_TOTAL_ATTACHMENT_BYTES - total}) throw new Error('单条消息附件总大小不能超过 64 MiB');
+        { ${sessionGuard} }
+        const entry = [...document.scripts].find(script => /\\/assets\\/index-[^/]+\\.js$/.test(script.src));
+        if (!entry) throw new Error('ChatGPT 桌面原生接口入口未找到');
+        const source = await (await fetch(entry.src)).text();
+        const rpc = source.match(/["'](\\.\\/rpc-[\\w-]+\\.js)["']/);
+        if (!rpc) throw new Error('ChatGPT 桌面原生附件接口未找到');
+        const { appServices: services } = await import(new URL(rpc[1], entry.src).href);
+        { ${sessionGuard} }
+        const file = await services.workspaceFiles.read({ ...params, representation: 'blob' });
+        { ${sessionGuard} }
+        if (globalThis[${JSON.stringify(fileSlot)}] !== '') throw new Error('ChatGPT 输出附件读取已取消');
+        if (typeof file.blob !== 'string' || file.blob.length !== Math.ceil(metadata.sizeBytes / 3) * 4) throw new Error('ChatGPT 输出附件内容无效');
+        globalThis[${JSON.stringify(fileSlot)}] = file.blob;
+        return { length: file.blob.length, size: metadata.sizeBytes };
+      })()`);
+                if (!Number.isSafeInteger(metadata.length) || metadata.length <= 0 || metadata.length > Math.ceil(attachments_1.MAX_ATTACHMENT_BYTES / 3) * 4)
+                    throw new Error("ChatGPT 输出附件内容无效");
+                const chunks = [];
+                for (let offset = 0; offset < metadata.length; offset += 256 * 1024) {
+                    const chunk = await this.evaluate(`(() => { ${sessionGuard} return globalThis[${JSON.stringify(fileSlot)}]?.slice(${offset}, ${offset + 256 * 1024}); })()`);
+                    if (typeof chunk !== "string" || chunk.length !== Math.min(256 * 1024, metadata.length - offset))
+                        throw new Error("ChatGPT 输出附件分块读取失败");
+                    chunks.push(chunk);
+                }
+                file = { ...metadata, contentsBase64: chunks.join("") };
+            }
+            catch (error) {
+                readFailure = error;
+                throw error;
+            }
+            finally {
+                try {
+                    await this.evaluate(`delete globalThis[${JSON.stringify(fileSlot)}]`);
+                }
+                catch (cleanupError) {
+                    if (readFailure === undefined)
+                        throw cleanupError;
+                    throw new AggregateError([readFailure, cleanupError], `${readFailure instanceof Error ? readFailure.message : String(readFailure)}；输出附件缓存清理失败`, { cause: readFailure });
+                }
+            }
+            if (typeof file.contentsBase64 !== "string" || file.contentsBase64.length > Math.ceil(attachments_1.MAX_ATTACHMENT_BYTES / 3) * 4)
+                throw new Error("ChatGPT 输出附件内容无效");
+            const data = Buffer.from(file.contentsBase64, "base64");
+            if (data.toString("base64") !== file.contentsBase64 || data.byteLength !== file.size)
+                throw new Error("ChatGPT 输出附件大小或编码不一致");
+            const filename = (0, attachments_1.attachmentFilename)(path);
+            const imageType = (0, attachments_1.detectImageContentType)(data);
+            const types = { txt: "text/plain", md: "text/markdown", pdf: "application/pdf", json: "application/json", zip: "application/zip", mp4: "video/mp4", webm: "video/webm", mov: "video/quicktime", mp3: "audio/mpeg", wav: "audio/wav" };
+            const contentType = imageType ?? file.mimeType ?? types[filename.split(".").at(-1)?.toLowerCase() ?? ""] ?? "application/octet-stream";
+            output.push({ kind: imageType ? "image" : "file", data, filename, contentType });
+            total += data.byteLength;
+            (0, attachments_1.validateAttachments)(output);
+        }
+        return output;
+    }
     async waitFor(expression, message) {
         const deadline = Date.now() + this.timeoutMs;
         while (Date.now() < deadline) {

package/plugins/chatgpt/dist/src-ts/plugins/chatgpt/index.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatgptCdpClient = exports.ChatgptPlugin = exports.chatgptManifest = void 0;
+const node_crypto_1 = require("node:crypto");
 const cdp_client_1 = require("./cdp-client");
 const session_store_1 = require("./session-store");
 exports.chatgptManifest = {
     id: "chatgpt",
-    version: "1.0.6",
+    version: "1.0.9",
     displayName: "ChatGPT（Codex）",
     type: "agent",
     entry: "dist/index.js",
@@ -23,15 +24,32 @@ class ChatgptPlugin {
     options;
     manifest = exports.chatgptManifest;
     sessionOperations = [];
+    get attachmentInput() { return this.client?.attachmentInput === true; }
     client;
     failure;
     remote = false;
     queue = Promise.resolve();
+    queuedOperations = 0;
     store;
     logger;
+    historyScope = "";
+    historyGeneration = 0;
+    historyProvider;
     constructor(options = {}) {
         this.options = options;
     }
+    get sessionHistory() {
+        const client = this.client;
+        const unsupported = !client?.listSessions || !client.activeSession || !client.readSessionHistory;
+        const generation = this.historyGeneration;
+        return this.historyProvider ??= {
+            scope: this.historyScope,
+            mode: unsupported ? "unsupported" : "sidebar",
+            limitation: unsupported ? "当前 ChatGPT 客户端不提供只读历史接口" : "仅列举已加载侧栏；仅读取当前活动会话中已加载且可验证的正文，完整性可能受页面虚拟化影响",
+            listSessions: query => generation === this.historyGeneration ? this.listNativeSessions(query) : Promise.resolve({ supported: false, reason: "ChatGPT 插件实例已变化，请重新列举历史" }),
+            readSession: query => generation === this.historyGeneration ? this.readNativeSession(query) : Promise.resolve({ supported: false, reason: "ChatGPT 插件实例已变化，请重新列举历史" }),
+        };
+    }
     async activate(context) {
         const config = context.config;
         const hasSshHost = config.sshHost !== undefined;
@@ -52,6 +70,11 @@ class ChatgptPlugin {
             localPort: port(config.localCdpPort, 9230),
         } : undefined;
         this.remote = Boolean(ssh);
+        this.historyGeneration++;
+        this.historyProvider = undefined;
+        this.historyScope = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(ssh
+            ? [ssh.host, ssh.user, ssh.port, ssh.remotePort]
+            : ["local", port(config.localCdpPort, 9230)])).digest("hex").slice(0, 24);
         this.logger = context.logger;
         this.store = new session_store_1.ChatgptSessionStore(context.dataDir, JSON.stringify(ssh
             ? [ssh.host, ssh.user, ssh.port, ssh.remotePort]
@@ -92,9 +115,9 @@ class ChatgptPlugin {
             throw new Error("消息内容不能为空");
         if (!this.client || !this.store)
             throw new Error("ChatGPT 插件未启动");
-        const run = this.queue.then(() => this.run(request));
-        this.queue = run.then(() => undefined, () => undefined);
-        return { text: await run, sessionId: request.sessionId };
+        const run = this.enqueue(() => this.run(request));
+        const result = await run;
+        return { ...(typeof result === "string" ? { text: result } : result), sessionId: request.sessionId };
     }
     async controlSession(request) {
         if (request.operation !== "new")
@@ -104,7 +127,7 @@ class ChatgptPlugin {
             throw new Error("ChatGPT 新会话缺少 sessionId");
         if (!this.client?.createSession || !this.client.listSessions || !this.store)
             throw new Error("ChatGPT 当前传输不支持新建会话");
-        const run = this.queue.then(async () => {
+        const run = this.enqueue(async () => {
             const existing = new Set((await this.client.listSessions()).map(item => JSON.stringify([item.host, item.id])));
             const created = await this.client.createSession(request.name);
             if (created) {
@@ -118,9 +141,106 @@ class ChatgptPlugin {
             this.persist();
             return { text: "ChatGPT 已创建新会话", sessionId };
         });
+        return run;
+    }
+    enqueue(work) {
+        this.queuedOperations++;
+        const run = this.queue.then(work).finally(() => { this.queuedOperations--; });
         this.queue = run.then(() => undefined, () => undefined);
         return run;
     }
+    async listNativeSessions(query) {
+        const client = this.client;
+        const reject = (reason) => ({ supported: false, reason });
+        if (!client?.listSessions || !client.activeSession || !client.readSessionHistory)
+            return reject("当前 ChatGPT 客户端不支持只读历史");
+        const listSessions = client.listSessions.bind(client);
+        if (!client.connected())
+            return reject("ChatGPT CDP 当前未连接");
+        if (this.queuedOperations)
+            return reject("ChatGPT 正在处理其他操作，历史读取已拒绝");
+        if (!Number.isInteger(query.limit) || query.limit < 1)
+            throw new Error("ChatGPT 历史页条数无效");
+        if (query.cursor !== undefined && !/^list:[a-f0-9]{64}:\d+$/.test(query.cursor))
+            throw new Error("ChatGPT 历史游标无效");
+        return this.enqueue(async () => {
+            if (!client.connected())
+                return reject("ChatGPT CDP 当前未连接");
+            if (await client.historyBusy?.())
+                return reject("ChatGPT 正在生成回复，暂不读取历史");
+            const entries = await listSessions();
+            const fingerprint = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify([this.historyScope, this.historyGeneration, entries.map(({ host, id, title }) => [host, id, title])])).digest("hex");
+            const offset = query.cursor ? Number(query.cursor.split(":").at(-1)) : 0;
+            if (query.cursor !== undefined && !query.cursor.startsWith(`list:${fingerprint}:`))
+                throw new Error("ChatGPT 侧栏已变化，历史游标失效");
+            if (!Number.isSafeInteger(offset) || (query.cursor !== undefined && offset >= entries.length))
+                throw new Error("ChatGPT 历史游标位置无效");
+            const limit = Math.min(query.limit, 50);
+            const sessions = entries.slice(offset, offset + limit).map(item => ({ id: JSON.stringify([item.host, item.id]), title: item.title, ...(item.updatedAt ? { updatedAt: item.updatedAt } : {}) }));
+            return { supported: true, sessions, ...(offset + limit < entries.length ? { nextCursor: `list:${fingerprint}:${offset + limit}` } : {}), complete: false, missingReasons: ["仅包含 ChatGPT 当前已加载的侧栏项目，不代表全部历史会话"], readAt: new Date().toISOString() };
+        });
+    }
+    async readNativeSession(query) {
+        const client = this.client;
+        const reject = (reason) => ({ supported: false, reason });
+        if (!client?.listSessions || !client.activeSession || !client.readSessionHistory)
+            return reject("当前 ChatGPT 客户端不支持只读历史");
+        const listSessions = client.listSessions.bind(client);
+        const activeSession = client.activeSession.bind(client);
+        const readSessionHistory = client.readSessionHistory.bind(client);
+        if (!client.connected())
+            return reject("ChatGPT CDP 当前未连接");
+        if (this.queuedOperations)
+            return reject("ChatGPT 正在处理其他操作，历史读取已拒绝");
+        if (!Number.isInteger(query.limit) || query.limit < 1)
+            throw new Error("ChatGPT 历史页条数无效");
+        if (query.cursor !== undefined && !/^read:[a-f0-9]{64}:\d+$/.test(query.cursor))
+            throw new Error("ChatGPT 历史游标无效");
+        let requested;
+        try {
+            requested = JSON.parse(query.sessionId);
+        }
+        catch {
+            return reject("ChatGPT 会话 ID 无效");
+        }
+        if (!Array.isArray(requested) || requested.length !== 2 || requested.some(part => typeof part !== "string" || !part))
+            return reject("ChatGPT 会话 ID 无效");
+        return this.enqueue(async () => {
+            if (!client.connected())
+                return reject("ChatGPT CDP 当前未连接");
+            if (await client.historyBusy?.())
+                return reject("ChatGPT 正在生成回复，暂不读取历史");
+            const sessions = await listSessions();
+            const session = sessions.find(item => item.host === requested[0] && item.id === requested[1]);
+            if (!session)
+                return reject("目标会话不在当前 ChatGPT 侧栏中");
+            const active = await activeSession();
+            if (!active || active.host !== session.host || active.id !== session.id)
+                return reject("ChatGPT 只支持读取当前活动会话");
+            if (await client.historyBusy?.())
+                return reject("ChatGPT 正在生成回复，暂不读取历史");
+            const result = await readSessionHistory(session);
+            if (!result.supported)
+                return reject(result.reason);
+            const after = await activeSession();
+            if (!after || after.host !== session.host || after.id !== session.id)
+                return reject("读取期间活动会话身份发生变化");
+            const fingerprint = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify([this.historyScope, this.historyGeneration, session.host, session.id, result.turns])).digest("hex");
+            const offset = query.cursor ? Number(query.cursor.split(":").at(-1)) : 0;
+            if (query.cursor !== undefined && !query.cursor.startsWith(`read:${fingerprint}:`))
+                throw new Error("ChatGPT 会话内容已变化，历史游标失效");
+            if (!Number.isSafeInteger(offset) || (query.cursor !== undefined && offset >= result.turns.length))
+                throw new Error("ChatGPT 历史游标位置无效");
+            const turns = result.turns.map(turn => ({ ...turn }));
+            const chars = turns.reduce((total, turn) => total + turn.text.length, 0);
+            if (chars > 60_000)
+                throw new Error("ChatGPT 会话正文超过 60,000 字符上限");
+            const limit = Math.min(query.limit, 100);
+            const pageTurns = turns.slice(offset, offset + limit);
+            const reasons = [...result.missingReasons, "仅包含当前页面已加载的可验证正文，页面虚拟化或未加载历史导致完整性无法确认"];
+            return { supported: true, session: { id: query.sessionId, title: session.title, ...(session.updatedAt ? { updatedAt: session.updatedAt } : {}) }, turns: pageTurns, ...(offset + limit < turns.length ? { nextCursor: `read:${fingerprint}:${offset + limit}` } : {}), complete: false, missingReasons: reasons, readAt: new Date().toISOString() };
+        });
+    }
     persist() {
         void this.store.save().catch(error => this.logger?.warn("ChatGPT 会话缓存保存失败", { error: String(error) }));
     }
@@ -204,7 +324,7 @@ class ChatgptPlugin {
             await this.client.connect();
         selected ??= await this.client.activeSession?.();
         const message = explicit?.[2]?.trim() || request.task;
-        const reply = await this.client.direct(message, request.timeoutMs);
+        const reply = await this.client.direct(message, request.timeoutMs, request.attachments);
         const baseline = request.sessionId ? store.pendingBindings[request.sessionId] : undefined;
         if (baseline) {
             try {
@@ -226,7 +346,7 @@ class ChatgptPlugin {
         if (selected) {
             const current = await this.client.activeSession?.().catch(() => undefined);
             const entry = current?.id === selected.id && current.host === selected.host ? current : selected;
-            store.remember(entry, message, reply);
+            store.remember(entry, message, typeof reply === "string" ? reply : reply.text);
             if (request.sessionId)
                 store.bindings[request.sessionId] = entry;
             this.persist();

package/plugins/chatgpt/package.json

@@ -1 +1 @@
-{"name":"agent-bridge-chatgpt","version":"1.0.6","description":"agent-bridge 的 ChatGPT Codex CDP 插件。","keywords":["mu-agent-bridge-plugin","mu-agent-bridge-agent"],"main":"dist/src-ts/plugins/chatgpt/index.js","files":["dist/","plugin.json","config.schema.json","README.md"],"agentBridge":{"plugin":"./plugin.json","type":"agent"},"engines":{"node":">=22"}}
+{"name":"agent-bridge-chatgpt","version":"1.0.9","description":"agent-bridge 的 ChatGPT Codex CDP 插件。","keywords":["mu-agent-bridge-plugin","mu-agent-bridge-agent"],"main":"dist/src-ts/plugins/chatgpt/index.js","files":["dist/","plugin.json","config.schema.json","README.md"],"agentBridge":{"plugin":"./plugin.json","type":"agent"},"engines":{"node":">=22"}}