mu-agent-bridge 1.0.35 → 1.0.39

package/dist/tests-ts/workbuddy-history.test.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_vm_1 = require("node:vm");
+const workbuddy_1 = require("../src-ts/plugins/workbuddy");
+const cdp_client_1 = require("../src-ts/plugins/workbuddy/cdp-client");
+const logger = { info() { }, warn() { }, error() { } };
+const snapshot = () => ({ conversationId: "task-a", messages: [
+        { id: "u1", role: "user", text: "问题", complete: true },
+        { id: "a1", role: "assistant", text: "回答", complete: true },
+        { id: "draft", role: "assistant", text: "草稿", complete: false },
+        { id: "tool", role: "tool", text: "工具输出", complete: true },
+        { role: "user", text: "没有稳定 ID", complete: true },
+    ], missingReasons: [] });
+async function fixture(overrides = {}, config = { transport: "cdp" }) {
+    const calls = [];
+    let activeId = "task-a";
+    const client = {
+        connect: async () => undefined, close() { }, connected: () => true,
+        conversationId: async () => activeId,
+        historyAvailability: async () => ({ conversationId: activeId, waiting: false }),
+        readHistorySnapshot: async () => { calls.push("read"); return snapshot(); },
+        direct: async () => { calls.push("direct"); return "普通回复"; },
+        complete: async () => { calls.push("complete"); return { text: "普通回复" }; },
+        createTask: async () => { calls.push("createTask"); },
+        ...overrides,
+    };
+    const plugin = new workbuddy_1.WorkbuddyPlugin({ client });
+    await plugin.activate({ config, logger });
+    const history = plugin.sessionHistory;
+    strict_1.default.ok(history, "WorkBuddy 应公开受限原生历史 provider");
+    return { plugin, history, calls, client, setActiveId: (value) => { activeId = value; } };
+}
+(0, node_test_1.default)("WorkBuddy 原生历史只列出并读取当前任务，拒绝任意 ID 且不调用普通任务接口", async () => {
+    const { history, calls } = await fixture();
+    strict_1.default.equal(history.mode, "current");
+    const listed = await history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, true);
+    if (!listed.supported)
+        return;
+    strict_1.default.deepEqual(listed.sessions.map(item => item.id), ["task-a"]);
+    strict_1.default.equal(listed.complete, false);
+    strict_1.default.equal((await history.readSession({ sessionId: "other", limit: 100 })).supported, false);
+    const read = await history.readSession({ sessionId: "task-a", limit: 100 });
+    strict_1.default.equal(read.supported, true);
+    if (!read.supported)
+        return;
+    strict_1.default.deepEqual(read.turns, [{ id: "u1", role: "user", text: "问题" }, { id: "a1", role: "assistant", text: "回答" }]);
+    strict_1.default.equal(read.complete, false);
+    strict_1.default.ok(read.missingReasons.some(reason => /完整|已加载/.test(reason)));
+    strict_1.default.deepEqual(calls, ["read"]);
+});
+(0, node_test_1.default)("WorkBuddy CLI、旧客户端、断线、等待选择与未列出的任务明确不支持读取", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "wb-history-cli-"));
+    try {
+        const cliPath = (0, node_path_1.join)(root, "codebuddy.cjs");
+        await (0, promises_1.writeFile)(cliPath, "throw Error('不应运行 CLI');");
+        const cli = await fixture({}, { transport: "cli", cliPath });
+        strict_1.default.equal(cli.history.mode, "unsupported");
+        strict_1.default.equal((await cli.history.listSessions({ limit: 50 })).supported, false);
+        strict_1.default.deepEqual(cli.calls, []);
+    }
+    finally {
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+    for (const overrides of [
+        { readHistorySnapshot: undefined },
+        { connected: () => false },
+        { pendingInteractionSessionId: () => "logical-a" },
+        { historyAvailability: async () => ({ conversationId: "task-a", waiting: true }) },
+    ]) {
+        const { history, calls } = await fixture(overrides);
+        strict_1.default.equal((await history.listSessions({ limit: 50 })).supported, false);
+        strict_1.default.deepEqual(calls, []);
+    }
+    const { history, calls } = await fixture({ readHistorySnapshot: async () => ({ ...snapshot(), messages: [{ id: "a1", role: "assistant", text: "回复", complete: true }] }) });
+    const missingUser = await history.listSessions({ limit: 50 });
+    strict_1.default.equal(missingUser.supported, true);
+    if (!missingUser.supported)
+        return;
+    const result = await history.readSession({ sessionId: missingUser.sessions[0].id, limit: 100 });
+    strict_1.default.equal(result.supported, true);
+    if (result.supported) {
+        strict_1.default.equal(result.complete, false);
+        strict_1.default.ok(result.missingReasons.some(reason => /用户消息/.test(reason)));
+    }
+    strict_1.default.deepEqual(calls, []);
+});
+(0, node_test_1.default)("WorkBuddy 任务忙时立即拒绝历史读取，历史读取和 handle 共用队列", async () => {
+    let release;
+    const waiting = new Promise(resolve => { release = resolve; });
+    const { plugin, history } = await fixture({ complete: async () => { await waiting; return { text: "完成" }; } });
+    const request = plugin.handle({ task: "执行任务" });
+    const busy = await history.listSessions({ limit: 50 });
+    strict_1.default.equal(busy.supported, false);
+    if (!busy.supported)
+        strict_1.default.match(busy.reason, /忙/);
+    release();
+    await request;
+    let releaseRead;
+    let entered;
+    const reading = new Promise(resolve => { releaseRead = resolve; });
+    const started = new Promise(resolve => { entered = resolve; });
+    const next = await fixture({ readHistorySnapshot: async () => { entered(); await reading; return snapshot(); } });
+    await next.history.listSessions({ limit: 50 });
+    const read = next.history.readSession({ sessionId: "task-a", limit: 100 });
+    await started;
+    const handle = next.plugin.handle({ task: "普通任务" });
+    strict_1.default.deepEqual(next.calls, []);
+    releaseRead();
+    strict_1.default.equal((await read).supported, true);
+    await handle;
+    strict_1.default.deepEqual(next.calls, ["complete"]);
+});
+(0, node_test_1.default)("WorkBuddy 读取前后身份变化及快照任务不一致时拒绝", async () => {
+    const current = await fixture();
+    await current.history.listSessions({ limit: 50 });
+    current.setActiveId("task-b");
+    strict_1.default.equal((await current.history.readSession({ sessionId: "task-a", limit: 100 })).supported, false);
+    strict_1.default.deepEqual(current.calls, []);
+    let reads = 0;
+    const changed = await fixture({ conversationId: async () => ++reads <= 3 ? "task-a" : "task-b", historyAvailability: async () => ({ conversationId: ++reads <= 3 ? "task-a" : "task-b", waiting: false }) });
+    await changed.history.listSessions({ limit: 50 });
+    strict_1.default.equal((await changed.history.readSession({ sessionId: "task-a", limit: 100 })).supported, false);
+    const mismatch = await fixture({ readHistorySnapshot: async () => ({ ...snapshot(), conversationId: "task-b" }) });
+    await mismatch.history.listSessions({ limit: 50 });
+    strict_1.default.equal((await mismatch.history.readSession({ sessionId: "task-a", limit: 100 })).supported, false);
+});
+(0, node_test_1.default)("WorkBuddy 没有用户证据和被排除的未完成回复时保留明确缺失原因", async () => {
+    const value = await fixture({ readHistorySnapshot: async () => ({ ...snapshot(), messages: snapshot().messages.filter(item => item.role === "assistant" && item.complete), missingReasons: ["未完成助手回复已排除。"] }) });
+    const listed = await value.history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, true);
+    if (!listed.supported)
+        return;
+    const result = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 100 });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, false);
+    strict_1.default.ok(result.missingReasons.some(reason => /用户/.test(reason)));
+    strict_1.default.ok(result.missingReasons.some(reason => /未完成/.test(reason)));
+});
+(0, node_test_1.default)("WorkBuddy 分页上限、不可伪造游标及 60000 字符限制", async () => {
+    const value = await fixture({ readHistorySnapshot: async () => ({ ...snapshot(), messages: Array.from({ length: 3 }, (_, index) => ({ id: `u${index}`, role: "user", text: `问题${index}`, complete: true })) }) });
+    strict_1.default.equal((await value.history.listSessions({ limit: 51 })).supported, false);
+    strict_1.default.equal((await value.history.readSession({ sessionId: "task-a", limit: 101 })).supported, false);
+    strict_1.default.equal((await value.history.readSession({ sessionId: "task-a", limit: 0 })).supported, false);
+    strict_1.default.equal((await value.history.readSession({ sessionId: "task-a", limit: 1, cursor: "task-b" })).supported, false);
+    const listed = await value.history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, true);
+    if (!listed.supported)
+        return;
+    const first = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 1 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported)
+        return;
+    strict_1.default.equal(first.turns.length, 1);
+    strict_1.default.ok(first.nextCursor);
+    strict_1.default.ok(!first.nextCursor.includes("task-a"));
+    const second = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 100, cursor: first.nextCursor });
+    strict_1.default.equal(second.supported, true);
+    if (second.supported)
+        strict_1.default.deepEqual(second.turns.map(turn => turn.id), ["u1", "u2"]);
+    strict_1.default.deepEqual(value.calls, []);
+    const oversized = await fixture({ readHistorySnapshot: async () => ({ ...snapshot(), messages: [{ id: "u1", role: "user", text: "字".repeat(60_001), complete: true }] }) });
+    const oversizedList = await oversized.history.listSessions({ limit: 50 });
+    strict_1.default.equal(oversizedList.supported, true);
+    if (!oversizedList.supported)
+        return;
+    const result = await oversized.history.readSession({ sessionId: oversizedList.sessions[0].id, limit: 100 });
+    strict_1.default.equal(result.supported, false);
+    if (!result.supported)
+        strict_1.default.match(result.reason, /60000/);
+});
+(0, node_test_1.default)("WorkBuddy CDP 历史 DOM 只读排除推理、工具、附件、草稿及未完成正文", async () => {
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const read = client.readHistorySnapshot;
+    strict_1.default.equal(typeof read, "function", "CDP 应提供单独的只读历史快照方法");
+    const removed = [];
+    const body = (text) => ({ cloneNode: () => ({ textContent: text, querySelectorAll: (selector) => { removed.push(selector); return []; } }) });
+    const message = (id, role, text, finished) => ({
+        getAttribute: (name) => name === "data-message-id" ? id : null,
+        matches: (selector) => selector.includes(".cr-agent") && role === "assistant",
+        querySelector: (selector) => selector === '[data-user-content]' ? role === "user" ? body(text) : null : selector === '[data-assistant-content]' ? role === "assistant" ? body(text) : null : selector.includes("conversation-finished-footer") ? finished ? {} : null : null,
+    });
+    const selected = { className: "_selected_", getAttribute: () => "task-a" };
+    const expressions = [];
+    const internal = client;
+    internal.evaluate = async (expression) => {
+        expressions.push(expression);
+        return (0, node_vm_1.runInNewContext)(expression, { document: {
+                querySelectorAll: (selector) => selector === '[data-conversation-id]' ? [selected] : selector.includes("data-message-id") ? [message("u1", "user", "问题", true), message("a1", "assistant", "回答", true), message("draft", "assistant", "草稿", false)] : [],
+                querySelector: () => null,
+            } });
+    };
+    const result = await read.call(client);
+    strict_1.default.deepEqual(JSON.parse(JSON.stringify(result.messages)), [{ id: "u1", role: "user", text: "问题", complete: true }, { id: "a1", role: "assistant", text: "回答", complete: true }]);
+    strict_1.default.ok(removed.some(selector => /cr-reasoning/.test(selector) && /tool/.test(selector) && /artifact/.test(selector)));
+    strict_1.default.ok(expressions.every(expression => !/\.click\(|\.focus\(|fetch\(|Input\.|dispatchEvent|createTask|complete\(/.test(expression)));
+    internal.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, { document: {
+            querySelectorAll: (selector) => selector === '[data-conversation-id]' ? [selected] : [],
+            querySelector: (selector) => selector.includes("pending-sandbox-panel") ? {} : null,
+        } });
+    const waiting = await read.call(client);
+    strict_1.default.match(waiting.unavailableReason ?? "", /等待用户选择/);
+});
+(0, node_test_1.default)("WorkBuddy 当前页面存在未登记的等待选择时拒绝读取", async () => {
+    let waiting = false;
+    const value = await fixture({ historyAvailability: async () => ({ conversationId: "task-a", waiting }) });
+    const client = value.client;
+    const listed = await value.history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, true);
+    if (!listed.supported)
+        return;
+    waiting = true;
+    const result = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 100 });
+    strict_1.default.equal(result.supported, false);
+    if (!result.supported)
+        strict_1.default.match(result.reason, /等待用户选择/);
+});
+(0, node_test_1.default)("WorkBuddy 页面已等待选择时不列出任务", async () => {
+    const value = await fixture({ historyAvailability: async () => ({ conversationId: "task-a", waiting: true }) });
+    const listed = await value.history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, false);
+    if (!listed.supported)
+        strict_1.default.match(listed.reason, /等待用户选择/);
+});
+(0, node_test_1.default)("WorkBuddy 分页期间出现等待选择时拒绝续页并清除缓存", async () => {
+    let waiting = false;
+    const value = await fixture({
+        historyAvailability: async () => ({ conversationId: "task-a", waiting }),
+        readHistorySnapshot: async () => ({ ...snapshot(), messages: Array.from({ length: 2 }, (_, index) => ({ id: `u${index}`, role: "user", text: `问题${index}`, complete: true })) }),
+    });
+    const listed = await value.history.listSessions({ limit: 50 });
+    strict_1.default.equal(listed.supported, true);
+    if (!listed.supported)
+        return;
+    const first = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 1 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported || !first.nextCursor)
+        return;
+    waiting = true;
+    const rejected = await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 1, cursor: first.nextCursor });
+    strict_1.default.equal(rejected.supported, false);
+    if (!rejected.supported)
+        strict_1.default.match(rejected.reason, /等待用户选择/);
+    waiting = false;
+    strict_1.default.equal((await value.history.readSession({ sessionId: listed.sessions[0].id, limit: 1, cursor: first.nextCursor })).supported, false);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mu-agent-bridge",
-  "version": "1.0.35",
+  "version": "1.0.39",
   "description": "将 AUN Agent 连接到本地桌面 AI 客户端的插件平台。",
   "main": "dist/src-ts/cli.js",
   "bin": {

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

@@ -95,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 =>

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.8",
+    version: "1.0.9",
     displayName: "ChatGPT（Codex）",
     type: "agent",
     entry: "dist/index.js",
@@ -28,11 +29,27 @@ class ChatgptPlugin {
     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;
@@ -53,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]
@@ -93,8 +115,7 @@ 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);
+        const run = this.enqueue(() => this.run(request));
         const result = await run;
         return { ...(typeof result === "string" ? { text: result } : result), sessionId: request.sessionId };
     }
@@ -106,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) {
@@ -120,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) }));
     }

package/plugins/chatgpt/package.json

@@ -1 +1 @@
-{"name":"agent-bridge-chatgpt","version":"1.0.8","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"}}

package/plugins/chatgpt/plugin.json

@@ -1 +1,14 @@
-{"id":"chatgpt","version":"1.0.8","type":"agent","displayName":"ChatGPT（Codex）","entry":"dist/src-ts/plugins/chatgpt/index.js","apiVersion":"1","process":"in-process","capabilities":["chat","health"],"configSchema":"config.schema.json"}
+{
+  "id": "chatgpt",
+  "version": "1.0.9",
+  "type": "agent",
+  "displayName": "ChatGPT（Codex）",
+  "entry": "dist/src-ts/plugins/chatgpt/index.js",
+  "apiVersion": "1",
+  "process": "in-process",
+  "capabilities": [
+    "chat",
+    "health"
+  ],
+  "configSchema": "config.schema.json"
+}