mu-agent-bridge 1.0.34 → 1.0.39

package/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/dist/src-ts/plugins/desktop-launch.js

@@ -7,10 +7,19 @@ exports.waitFor = waitFor;
 const promises_1 = require("node:fs/promises");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const versionDirectory = /^(?:app[-_ ]?)?v?\d+(?:[.-]\d+)+$/i;
 /** 在 Windows 常见安装目录中查找桌面程序，避免依赖单一盘符。 */
 async function findWindowsExecutable(fileName, configured) {
     if (configured?.trim()) {
         const configuredPath = (0, node_path_1.resolve)(configured);
+        if (fileName.toLowerCase() === "doubao.exe") {
+            let root = (0, node_path_1.dirname)(configuredPath);
+            while (/^app$/i.test((0, node_path_1.basename)(root)) || versionDirectory.test((0, node_path_1.basename)(root)))
+                root = (0, node_path_1.dirname)(root);
+            const latest = await findExecutableInTree(root, fileName, /^/, 3);
+            if (latest)
+                return latest;
+        }
         // 千问升级会保留或删除旧版本目录，从同一安装位置重新定位新版。
         if (fileName.toLowerCase() === "qwenworkcn.exe" && /^v?\d+(?:[.-]\d+)+$/i.test((0, node_path_1.basename)((0, node_path_1.dirname)(configuredPath)))) {
             const latest = await findExecutableInTree((0, node_path_1.dirname)((0, node_path_1.dirname)(configuredPath)), fileName, /^/, 1);
@@ -42,6 +51,16 @@ async function findExecutableInTree(directory, fileName, pattern, depth) {
 async function search(directory, fileName, pattern, depth, insideProduct) {
     try {
         const entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        // 豆包上层文件是启动器，优先查找新版目录或 app 中的实际程序。
+        if (insideProduct && depth > 0 && fileName.toLowerCase() === "doubao.exe") {
+            const versions = entries.filter(entry => entry.isDirectory() && (versionDirectory.test(entry.name) || /^app$/i.test(entry.name)));
+            versions.sort((left, right) => right.name.replace(/^\D+/, "").localeCompare(left.name.replace(/^\D+/, ""), "en", { numeric: true }));
+            for (const entry of versions) {
+                const found = await search((0, node_path_1.join)(directory, entry.name), fileName, pattern, depth - 1, true);
+                if (found)
+                    return found;
+            }
+        }
         for (const entry of entries)
             if (entry.isFile() && insideProduct && entry.name.toLowerCase() === fileName.toLowerCase())
                 return (0, node_path_1.join)(directory, entry.name);

package/dist/src-ts/plugins/doubao/attachments.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupUploadScript = exports.uploadStateScript = void 0;
+exports.buildUploadInjection = buildUploadInjection;
+// 原生上传状态保存在附件区的 React 属性中，避免复刻平台私有上传签名。
+exports.uploadStateScript = `() => {
+  const area = document.querySelector('[data-testid=attachment_area]');
+  let fiber = area?.[Object.keys(area).find(key => key.startsWith('__reactFiber'))];
+  while (fiber) {
+    if (Array.isArray(fiber.memoizedProps?.attachmentStates)) return fiber.memoizedProps.attachmentStates;
+    fiber = fiber.return;
+  }
+  return [];
+}`;
+function buildUploadInjection(items) {
+    return `(() => {
+    const editor = document.querySelector('[contenteditable=true]');
+    if (!editor) return '未找到豆包输入区';
+    if (editor.textContent.trim() || document.querySelector('[data-testid=attachment_area]')) return '豆包存在未发送草稿，请先处理草稿';
+    const input = document.querySelector('input[type=file][data-testid=upload-file-input]');
+    if (!input) return '未找到豆包原生附件上传入口';
+    const transfer = new DataTransfer();
+    for (const item of ${JSON.stringify(items)}) {
+      const bytes = Uint8Array.from(atob(item.base64), char => char.charCodeAt(0));
+      transfer.items.add(new File([bytes], item.uploadName, { type: item.type }));
+    }
+    Object.defineProperty(input, 'files', { value: transfer.files, configurable: true });
+    try { input.dispatchEvent(new Event('change', { bubbles: true })); }
+    finally { delete input.files; }
+    return 'started';
+  })()`;
+}
+// 唯一文件名前缀限定清理范围，用户上传的新附件不会被删除。
+exports.cleanupUploadScript = `(names) => {
+  const states = (${exports.uploadStateScript})();
+  const area = document.querySelector('[data-testid=attachment_area]');
+  const buttons = area?.querySelectorAll('[data-testid=attachment-delete-btn], [data-testid=message_nested_content_file_delete]') || [];
+  for (let index = states.length - 1; index >= 0; index--) {
+    if (names.includes(states[index].fileName)) buttons[index]?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+  }
+  return 'cleaned';
+}`;