mu-agent-bridge 1.0.35 → 1.0.39

package/dist/src-ts/plugins/qwenwork/session-history.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QwenworkSessionHistoryProvider = void 0;
+const node_crypto_1 = require("node:crypto");
+const MAX_SESSIONS = 1000;
+const MAX_MESSAGE_PAGES = 20;
+const MESSAGE_PAGE_SIZE = 100;
+const MAX_READ_TURNS = MAX_MESSAGE_PAGES * MESSAGE_PAGE_SIZE;
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function rows(value) {
+    if (!Array.isArray(value))
+        return { rows: [], malformed: true };
+    const valid = value.filter((item) => typeof object(item)?.id === "string");
+    return { rows: valid, malformed: valid.length !== value.length };
+}
+function asTime(value) {
+    const time = value instanceof Date ? value.toISOString() : typeof value === "string" ? value : undefined;
+    return time && Number.isFinite(Date.parse(time)) ? new Date(time).toISOString() : undefined;
+}
+function subChats(value) {
+    const chat = object(value);
+    if (!Array.isArray(chat?.subChats))
+        return { rows: [], malformed: true };
+    const valid = chat.subChats.filter((item) => typeof object(item)?.id === "string");
+    return { rows: valid, malformed: valid.length !== chat.subChats.length };
+}
+function sessionFromChat(chat) {
+    const updatedAt = asTime(chat.updatedAt);
+    return { id: chat.id, title: typeof chat.name === "string" && chat.name.trim() ? chat.name.trim() : "未命名会话", ...(updatedAt ? { updatedAt } : {}) };
+}
+function fingerprint(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(value)).digest("hex");
+}
+/** 千问桌面端内置数据库的只读 tRPC 会话接口。 */
+class QwenworkSessionHistoryProvider {
+    mode = "all";
+    scope;
+    limitation = "读取千问桌面端可列出的任务及其 sub-chat；每个会话最多读取 20 页消息。";
+    unavailableReason;
+    query;
+    cursors = new Map();
+    constructor(options) {
+        this.scope = options.scope;
+        this.unavailableReason = options.unavailableReason;
+        this.query = options.query;
+    }
+    async listSessions(query) {
+        if (!this.available())
+            return { supported: false, reason: this.unavailableReason() };
+        const cursor = this.resolveCursor(query.cursor, "list");
+        if (!cursor)
+            return { supported: false, reason: "千问会话目录游标无效或已过期，请重新列举" };
+        try {
+            const [active, archived, deleted] = await Promise.all([
+                this.query("chats.list", {}), this.query("chats.listArchived", {}), this.query("chats.listDeleted", {}),
+            ]);
+            const parsedLists = [rows(active), rows(archived), rows(deleted)];
+            if (parsedLists.some(result => result.malformed && result.rows.length === 0))
+                return { supported: false, reason: "千问会话目录返回了无法识别的结构" };
+            const combined = new Map();
+            for (const chat of parsedLists.flatMap(result => result.rows))
+                combined.set(chat.id, chat);
+            const all = [...combined.values()].sort((a, b) => (asTime(b.updatedAt) ?? "").localeCompare(asTime(a.updatedAt) ?? ""));
+            const dataFingerprint = fingerprint(all);
+            if (query.cursor && cursor.fingerprint !== dataFingerprint)
+                return { supported: false, reason: "千问会话目录在分页期间发生变化，请重新列举" };
+            const capReached = all.length > MAX_SESSIONS;
+            const limited = all.slice(0, MAX_SESSIONS);
+            const limit = Math.max(1, Math.min(100, Math.floor(query.limit) || 50));
+            const page = limited.slice(cursor.offset, cursor.offset + limit);
+            const nextOffset = cursor.offset + page.length;
+            const nextCursor = nextOffset < limited.length ? this.createCursor({ kind: "list", offset: nextOffset, fingerprint: dataFingerprint }) : undefined;
+            const missingReasons = [];
+            if (parsedLists.some(result => result.malformed))
+                missingReasons.push("千问会话目录含有无法识别的条目");
+            if (capReached)
+                missingReasons.push(`千问会话超过 ${MAX_SESSIONS} 项读取上限`);
+            if (page.some(chat => !asTime(chat.updatedAt)))
+                missingReasons.push("部分会话缺少有效更新时间，无法判断是否属于今天");
+            return {
+                supported: true,
+                sessions: page.map(sessionFromChat),
+                ...(nextCursor ? { nextCursor } : {}),
+                complete: !capReached && missingReasons.length === 0,
+                missingReasons,
+                readAt: new Date().toISOString(),
+            };
+        }
+        catch {
+            return { supported: false, reason: "千问会话目录只读查询失败" };
+        }
+    }
+    async readSession(query) {
+        if (!this.available())
+            return { supported: false, reason: this.unavailableReason() };
+        const since = query.since === undefined ? undefined : asTime(query.since);
+        if (query.since !== undefined && !since)
+            return { supported: false, reason: "千问 since 时间格式无效" };
+        const cursor = this.resolveCursor(query.cursor, "read", query.sessionId, since);
+        if (!cursor)
+            return { supported: false, reason: "千问消息游标无效或已过期，请重新读取会话" };
+        try {
+            const rawChat = await this.query("chats.get", { id: query.sessionId });
+            const chat = object(rawChat);
+            if (!chat || chat.id !== query.sessionId)
+                return { supported: false, reason: "千问会话不存在或已不可读取" };
+            const parsedChildren = subChats(chat);
+            const children = parsedChildren.rows;
+            const missingReasons = [];
+            if (parsedChildren.malformed)
+                missingReasons.push("千问 sub-chat 目录缺失或含有无法识别的条目");
+            const turns = [];
+            const fingerprintMessages = [];
+            for (const child of children) {
+                let beforeSequence;
+                let pageCount = 0;
+                let moreBefore = false;
+                while (pageCount < MAX_MESSAGE_PAGES) {
+                    const input = { subChatId: child.id, limit: MESSAGE_PAGE_SIZE, ...(beforeSequence === undefined ? {} : { beforeSequence }) };
+                    const result = object(await this.query("chats.listBySubChat", input));
+                    const messages = Array.isArray(result?.messages) ? result.messages : undefined;
+                    if (!messages) {
+                        missingReasons.push(`sub-chat ${child.id} 消息列表格式无效`);
+                        fingerprintMessages.push({ subChatId: child.id, malformed: true, response: result });
+                        break;
+                    }
+                    fingerprintMessages.push({ subChatId: child.id, beforeSequence, result });
+                    for (const rawMessage of messages) {
+                        const message = object(rawMessage);
+                        if (!message) {
+                            missingReasons.push(`sub-chat ${child.id} 含有无法识别的消息`);
+                            continue;
+                        }
+                        if (message.role !== "user" && message.role !== "assistant")
+                            continue;
+                        const time = asTime(message.createdAt);
+                        if (!time)
+                            missingReasons.push(`消息 ${String(message.id ?? "未知 ID")} 缺少有效创建时间`);
+                        if (since && time && Date.parse(time) < Date.parse(since))
+                            continue;
+                        if (!Array.isArray(message.parts)) {
+                            missingReasons.push(`消息 ${String(message.id ?? "未知 ID")} 的 parts 格式无效`);
+                            continue;
+                        }
+                        const visibleParts = [];
+                        let malformedParts = false;
+                        for (const rawPart of message.parts) {
+                            const part = object(rawPart);
+                            if (!part || typeof part.type !== "string") {
+                                malformedParts = true;
+                                continue;
+                            }
+                            if (part.type === "text") {
+                                if (typeof part.text !== "string")
+                                    malformedParts = true;
+                                else
+                                    visibleParts.push(part.text);
+                            }
+                            else if (part.type === "data-file") {
+                                visibleParts.push(`[附件：${typeof part.filename === "string" ? part.filename : "附件"}]`);
+                            }
+                            else if (part.type === "artifact") {
+                                visibleParts.push(`[文件产物：${typeof part.fileName === "string" ? part.fileName : typeof part.mediaType === "string" ? part.mediaType : "产物"}]`);
+                            }
+                            else if (part.type.startsWith("tool-") || ["reasoning", "tool-call", "tool-Thinking", "thinking"].includes(part.type)) {
+                                // 思考过程和工具调用属于执行细节，不作为用户可见正文。
+                            }
+                            else {
+                                malformedParts = true;
+                            }
+                        }
+                        if (malformedParts)
+                            missingReasons.push(`消息 ${String(message.id ?? "未知 ID")} 含有无法识别的 parts`);
+                        const text = visibleParts.join("\n").trim();
+                        if (!text)
+                            continue;
+                        turns.push({ role: message.role, text, ...(typeof message.id === "string" ? { id: message.id } : {}), ...(time ? { time } : {}) });
+                    }
+                    pageCount++;
+                    moreBefore = result?.hasMoreBefore === true;
+                    if (!moreBefore)
+                        break;
+                    const oldest = Number(result?.oldestSequence);
+                    if (!Number.isSafeInteger(oldest) || oldest < 0 || beforeSequence === oldest) {
+                        missingReasons.push(`sub-chat ${child.id} 消息分页游标无效`);
+                        break;
+                    }
+                    beforeSequence = oldest;
+                }
+                if (pageCount === MAX_MESSAGE_PAGES && moreBefore)
+                    missingReasons.push(`sub-chat ${child.id} 超过 ${MAX_MESSAGE_PAGES} 页读取上限`);
+            }
+            const unique = new Map();
+            for (const turn of turns)
+                unique.set(turn.id ?? `${turn.role}:${turn.time ?? ""}:${turn.text}`, turn);
+            const allTurns = [...unique.values()].sort((a, b) => (a.time ?? "").localeCompare(b.time ?? "") || (a.id ?? "").localeCompare(b.id ?? ""));
+            if (allTurns.length > MAX_READ_TURNS)
+                missingReasons.push(`千问会话消息超过 ${MAX_READ_TURNS} 条读取上限`);
+            const limitedTurns = allTurns.slice(0, MAX_READ_TURNS);
+            const dataFingerprint = fingerprint({ chat, messages: fingerprintMessages });
+            if (query.cursor && cursor.fingerprint !== dataFingerprint)
+                return { supported: false, reason: "千问会话正文在分页期间发生变化，请重新读取会话" };
+            const limit = Math.max(1, Math.min(200, Math.floor(query.limit) || 100));
+            const pageTurns = limitedTurns.slice(cursor.offset, cursor.offset + limit);
+            const nextOffset = cursor.offset + pageTurns.length;
+            const nextCursor = nextOffset < limitedTurns.length ? this.createCursor({ kind: "read", offset: nextOffset, fingerprint: dataFingerprint, sessionId: query.sessionId, ...(since ? { since } : {}) }) : undefined;
+            return {
+                supported: true,
+                session: sessionFromChat(chat),
+                turns: pageTurns,
+                ...(nextCursor ? { nextCursor } : {}),
+                complete: missingReasons.length === 0,
+                missingReasons: [...new Set(missingReasons)],
+                readAt: new Date().toISOString(),
+            };
+        }
+        catch {
+            return { supported: false, reason: "千问会话正文只读查询失败" };
+        }
+    }
+    resolveCursor(token, kind, sessionId, since) {
+        const now = Date.now();
+        for (const [key, value] of this.cursors)
+            if (value.expires <= now)
+                this.cursors.delete(key);
+        if (token === undefined)
+            return { kind, offset: 0, fingerprint: "", ...(sessionId ? { sessionId } : {}), ...(since ? { since } : {}), expires: now + 5 * 60_000 };
+        const cursor = this.cursors.get(token);
+        if (!cursor || cursor.kind !== kind || cursor.sessionId !== sessionId || cursor.since !== since)
+            return undefined;
+        this.cursors.delete(token);
+        return cursor;
+    }
+    createCursor(cursor) {
+        if (this.cursors.size >= 1000)
+            this.cursors.delete(this.cursors.keys().next().value);
+        const token = `qwen:${(0, node_crypto_1.randomUUID)()}`;
+        this.cursors.set(token, { ...cursor, expires: Date.now() + 5 * 60_000 });
+        return token;
+    }
+    available() { return !this.unavailableReason(); }
+}
+exports.QwenworkSessionHistoryProvider = QwenworkSessionHistoryProvider;

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

@@ -34,6 +34,39 @@ class WorkbuddyCdpClient {
         const value = await this.evaluate(`([...document.querySelectorAll('[data-conversation-id]')].find(item => String(item.className).includes('_selected_')))?.getAttribute('data-conversation-id')`);
         return typeof value === "string" && value.trim() ? value : undefined;
     }
+    async readHistorySnapshot() {
+        return await this.evaluate(`(() => {
+      const selected = [...document.querySelectorAll('[data-conversation-id]')].find(item => String(item.className).includes('_selected_'));
+      const conversationId = selected?.getAttribute('data-conversation-id') || undefined;
+      const messages = [...document.querySelectorAll('.cr-agent[data-message-id]')].flatMap(element => {
+        const id = element.getAttribute('data-message-id');
+        const user = element.querySelector('[data-user-content]');
+        const assistant = element.querySelector('[data-assistant-content]');
+        if (!id || (!user && !assistant)) return [];
+        const content = (user || assistant).cloneNode(true);
+        content.querySelectorAll('.cr-reasoning,[class*="reasoning"],[data-testid*="reasoning"],[class*="tool"],[data-testid*="tool"],[class*="artifact"],[data-testid*="artifact"],[class*="attachment"],[data-testid*="attachment"],[data-slate-placeholder="true"],[data-slate-zero-width]').forEach(node => node.remove());
+        const finished = Boolean(element.querySelector('[data-testid="conversation-finished-footer"]'));
+        const text = content.innerText?.trim() || content.textContent?.trim() || '';
+        if (!user && !finished) return [];
+        return [{ id, role: user ? 'user' : 'assistant', text, complete: true }];
+      });
+      const first = document.querySelector('.cr-agent[data-message-id]');
+      const scroll = first?.parentElement;
+      const missingReasons = [];
+      const waitingChoice = document.querySelector(${JSON.stringify(interactionOptionSelector)});
+      if (waitingChoice) return { conversationId, messages: [], missingReasons, unavailableReason: 'WorkBuddy 正在等待用户选择，暂不读取历史' };
+      if (scroll && scroll.scrollHeight > scroll.clientHeight && scroll.scrollTop > 0) missingReasons.push('消息容器当前不在顶部，较早消息可能未加载。');
+      else if (scroll && scroll.scrollHeight > scroll.clientHeight && scroll.scrollTop === 0) missingReasons.push('消息容器可能采用虚拟列表，无法证实未渲染消息范围。');
+      if (!messages.length) missingReasons.push('当前 DOM 没有带稳定 ID 的用户或助手消息。');
+      return { conversationId, messages, missingReasons };
+    })()`);
+    }
+    async historyAvailability() {
+        return await this.evaluate(`(() => ({
+      conversationId: [...document.querySelectorAll('[data-conversation-id]')].find(item => String(item.className).includes('_selected_'))?.getAttribute('data-conversation-id') || undefined,
+      waiting: Boolean(document.querySelector(${JSON.stringify(interactionOptionSelector)})),
+    }))()`);
+    }
     async connect() {
         if (this.socket)
             return;

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

@@ -12,8 +12,9 @@ const attachments_1 = require("../../attachments");
 const plugin_1 = require("../../plugin");
 const cdp_client_1 = require("./cdp-client");
 const cli_client_1 = require("./cli-client");
+const session_history_1 = require("./session-history");
 exports.workbuddyManifest = {
-    id: "workbuddy", version: "1.1.12", displayName: "WorkBuddy", type: "agent",
+    id: "workbuddy", version: "1.1.13", displayName: "WorkBuddy", type: "agent",
     entry: "dist/index.js", apiVersion: "1", process: "in-process",
     capabilities: ["chat", "health"], configSchema: "config.schema.json",
 };
@@ -50,6 +51,7 @@ class WorkbuddyPlugin {
     expertSession = false;
     activeExpert;
     sessionOperations = [];
+    sessionHistory;
     constructor(options = {}) {
         this.options = options;
     }
@@ -78,6 +80,24 @@ class WorkbuddyPlugin {
             savedBinding = saved.active;
         }
         this.sessionOperations = [];
+        this.sessionHistory = new session_history_1.WorkbuddySessionHistoryProvider({
+            scope: `workbuddy:cdp:${(0, plugin_1.resolveRuntimePort)(config, context.runtime, "workbuddy", "WORKBUDDY_CDP_PORT", this.options.cdpPort ?? 9229)}`,
+            supported: () => this.transport !== "cli" && !(this.transport !== "cdp" && this.cliPath) && Boolean(this.client?.connected() && this.client.conversationId && this.client.readHistorySnapshot && this.client.historyAvailability),
+            client: () => this.client,
+            run: async (work) => {
+                if (this.transport === "cli" || (this.transport !== "cdp" && this.cliPath))
+                    return { supported: false, reason: "WorkBuddy CLI 模式不支持原生历史读取" };
+                if (!this.client?.connected() || !this.client.conversationId || !this.client.readHistorySnapshot || !this.client.historyAvailability)
+                    return { supported: false, reason: "WorkBuddy 当前客户端未连接或不提供只读历史接口" };
+                if (this.pending || this.client?.pendingInteractionSessionId?.())
+                    return { supported: false, reason: "WorkBuddy 当前忙或正在等待交互，暂不读取历史" };
+                return this.enqueue(async () => {
+                    if (this.client?.pendingInteractionSessionId?.())
+                        return { supported: false, reason: "WorkBuddy 正在等待交互，暂不读取历史" };
+                    return work();
+                });
+            },
+        });
         if (this.transport === "cli") {
             if (!this.cliPath)
                 throw new Error("未找到 CodeBuddy CLI，请配置 cliPath");

package/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;