mu-agent-bridge 1.0.35 → 1.0.39

package/README.md

@@ -44,6 +44,8 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 `AGENT_BRIDGE_PLUGINS_DIR`、`AGENT_BRIDGE_STATE_DIR`。默认插件目录是仓库的 `plugins/`，状态目录
 是 Windows 的 `%APPDATA%\agent-bridge\state`。
 
+跨会话读取支持按来源授权的 AUN/飞书托管记录，以及另外授权的 ChatGPT、WorkBuddy 受限原生历史，并通过独立无工具端点总结。归档默认关闭，千问办公暂不支持原生历史。配置与 `/sessions` 命令见[跨会话读取说明](docs/cross-session-reading.md)。
+
 ## npm 插件
 
 默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy 和 ChatGPT/Codex 八个插件，直接安装即可使用：

package/dist/src-ts/channel-sessions.js

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelSessions = void 0;
+exports.channelSourceKey = channelSourceKey;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+function channelSourceKey(message) {
+    return JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
+}
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const validSession = (value) => {
+    if (!isRecord(value))
+        return false;
+    return [value.source, value.agentPlugin, value.sessionId, value.updatedAt].every(item => typeof item === "string")
+        && (value.newSession === undefined || typeof value.newSession === "boolean");
+};
 const unsupportedCommands = /^(?:\/(?:s|session|slist|name|rename|del|status|stop|pause|resume|compact|fork|rewind|rw|repair|renew))(?:[ \t]+[^\r\n]*)?$/;
 class ChannelSessions {
     directory;
     sessions = {};
+    active = {};
     loaded;
     writes = Promise.resolve();
     pending = new Map();
@@ -18,25 +30,87 @@ class ChannelSessions {
         this.loaded ??= (async () => {
             try {
                 const data = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.directory, "channel-sessions.json"), "utf8"));
-                if (!data || typeof data !== "object" || Array.isArray(data))
+                if (!isRecord(data))
                     throw new Error("通道会话文件格式无效");
-                for (const [key, value] of Object.entries(data)) {
-                    const entry = value;
-                    if (!entry || typeof entry.sessionId !== "string" || typeof entry.source !== "string" || typeof entry.agentPlugin !== "string" || typeof entry.updatedAt !== "string" || (entry.newSession !== undefined && typeof entry.newSession !== "boolean"))
-                        throw new Error("通道会话记录无效");
-                    this.sessions[key] = entry;
+                const sessions = {};
+                const active = {};
+                if (data.version === 1) {
+                    if (!isRecord(data.sessions) || !isRecord(data.active))
+                        throw new Error("通道会话文件格式无效");
+                    for (const [id, entry] of Object.entries(data.sessions)) {
+                        if (!validSession(entry) || entry.logicalSessionId !== id || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id))
+                            throw new Error("通道会话记录无效");
+                        sessions[id] = entry;
+                    }
+                    for (const [source, id] of Object.entries(data.active)) {
+                        if (typeof id !== "string" || sessions[id]?.source !== source)
+                            throw new Error("通道活动绑定无效");
+                        active[source] = id;
+                    }
+                }
+                else {
+                    for (const [source, entry] of Object.entries(data)) {
+                        if (!validSession(entry) || entry.source !== source)
+                            throw new Error("通道会话记录无效");
+                        const logicalSessionId = (0, node_crypto_1.randomUUID)();
+                        sessions[logicalSessionId] = { ...entry, logicalSessionId };
+                        active[source] = logicalSessionId;
+                    }
+                }
+                if (data.version !== 1)
+                    await this.persist(active, sessions);
+                else {
+                    this.sessions = sessions;
+                    this.active = active;
                 }
             }
             catch (error) {
-                if (error.code !== "ENOENT")
+                if (error.code !== "ENOENT") {
+                    this.loaded = undefined;
                     throw error;
+                }
             }
         })();
         await this.loaded;
     }
-    async list() { await this.load(); return Object.values(this.sessions).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
+    async persist(active, sessions) {
+        await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(this.directory, 0o700);
+        const file = (0, node_path_1.join)(this.directory, "channel-sessions.json");
+        const temporary = `${file}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+        try {
+            await (0, promises_1.writeFile)(temporary, `${JSON.stringify({ version: 1, active, sessions }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+            await (0, promises_1.rename)(temporary, file);
+        }
+        finally {
+            await (0, promises_1.rm)(temporary, { force: true });
+        }
+        this.active = active;
+        this.sessions = sessions;
+    }
+    save(entry) {
+        const save = this.writes.catch(() => { }).then(() => this.persist({ ...this.active, [entry.source]: entry.logicalSessionId }, { ...this.sessions, [entry.logicalSessionId]: entry }));
+        this.writes = save;
+        return save;
+    }
+    async list() { await this.load(); return Object.values(this.sessions).map(entry => ({ ...entry })).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
+    isBusy(source) { return this.pending.has(source); }
+    async current(message, agentPlugin) {
+        await this.load();
+        const source = channelSourceKey(message);
+        const current = this.writes.catch(() => { }).then(async () => {
+            const entry = this.sessions[this.active[source]];
+            if (entry)
+                return { ...entry };
+            const next = { source, logicalSessionId: (0, node_crypto_1.randomUUID)(), agentPlugin, sessionId: (0, node_crypto_1.randomUUID)(), updatedAt: new Date().toISOString(), newSession: true };
+            await this.persist({ ...this.active, [source]: next.logicalSessionId }, { ...this.sessions, [next.logicalSessionId]: next });
+            return { ...next };
+        });
+        this.writes = current.then(() => undefined, () => undefined);
+        return current;
+    }
     async run(message, agentPlugin, call, control) {
-        const source = JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
+        const source = channelSourceKey(message);
         const hasAttachments = Boolean(message.attachments?.length);
         const command = hasAttachments ? undefined : message.text?.trim().match(/^\/new(?:[ \t]+([^\r\n]+))?$/);
         const unsupported = hasAttachments ? undefined : message.text?.trim().match(unsupportedCommands);
@@ -59,25 +133,17 @@ class ChannelSessions {
         const previous = this.pending.get(source) ?? Promise.resolve();
         const turn = previous.catch(() => { }).then(async () => {
             await this.load();
-            const entry = this.sessions[source];
-            const sessionId = !command && entry?.agentPlugin === agentPlugin ? entry.sessionId : (0, node_crypto_1.randomUUID)();
+            const active = this.sessions[this.active[source]];
+            const entry = !command && active?.agentPlugin === agentPlugin ? active : undefined;
+            const sessionId = entry?.sessionId ?? (0, node_crypto_1.randomUUID)();
             const response = command
                 ? await control({ operation: "new", sessionId, ...(command[1]?.trim() ? { name: command[1].trim() } : {}) })
-                : await call(sessionId, !entry || entry.agentPlugin !== agentPlugin || entry.newSession === true);
+                : await call(sessionId, !entry || entry.newSession === true);
             if (command && (typeof response.sessionId !== "string" || !response.sessionId.trim()))
                 throw new Error("插件未返回有效的新会话标识，原会话绑定保持不变");
-            const next = { source, agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
-            const save = this.writes.catch(() => { }).then(async () => {
-                const snapshot = { ...this.sessions, [source]: next };
-                await (0, promises_1.mkdir)(this.directory, { recursive: true });
-                const file = (0, node_path_1.join)(this.directory, "channel-sessions.json");
-                await (0, promises_1.writeFile)(`${file}.tmp`, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 });
-                await (0, promises_1.rename)(`${file}.tmp`, file);
-                this.sessions = snapshot;
-            });
-            this.writes = save;
-            await save;
-            return response;
+            const next = { source, logicalSessionId: entry?.logicalSessionId ?? (0, node_crypto_1.randomUUID)(), agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
+            await this.save(next);
+            return command ? response : { ...response, source, logicalSessionId: next.logicalSessionId, agentPlugin, request: message, response };
         });
         this.pending.set(source, turn);
         try {

package/dist/src-ts/control-server.js

@@ -135,6 +135,36 @@ class ControlServer {
             const authorized = (Boolean(this.options.token) && authorization === `Bearer ${this.options.token}`) || (authorization?.startsWith("Bearer ") && (this.pairedTokens.get((0, node_crypto_1.createHash)("sha256").update(authorization.slice(7)).digest("hex")) ?? 0) > Date.now());
             if (this.options.token && !isLoopback(req.socket.remoteAddress) && !authorized && !(method === "GET" && url.pathname.startsWith("/abweb")))
                 return this.json(res, 401, { error: "unauthorized" });
+            if (parts[0] === "api" && parts[1] === "session-history") {
+                if (!isLoopback(req.socket.remoteAddress) && !authorized)
+                    return this.json(res, 401, { error: "会话归档管理仅允许本机或已认证调用方" });
+                const history = this.options.manager.sessionManagement;
+                const actor = authorized ? "authenticated" : "local";
+                if (method === "GET" && parts.length === 3 && parts[2] === "providers")
+                    return this.json(res, 200, history.providers());
+                if (method === "GET" && parts.length === 3 && parts[2] === "config")
+                    return this.json(res, 200, await history.config());
+                if (method === "PATCH" && parts.length === 3 && parts[2] === "config") {
+                    await history.saveConfig(await this.body(req, 64 * 1024), actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "DELETE" && parts.length === 2) {
+                    await history.clear(actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "DELETE" && parts.length === 4 && parts[2] === "sessions") {
+                    await history.deleteSession(decodeURIComponent(parts[3]), actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "POST" && parts.length === 3 && parts[2] === "delete-source") {
+                    const body = await this.body(req, 64 * 1024);
+                    if (typeof body.source !== "string")
+                        return this.json(res, 400, { error: "需要有效的完整来源键" });
+                    await history.deleteSource(body.source, actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                return this.json(res, 404, { error: "会话归档接口不存在" });
+            }
             if (parts[0] === "api" && parts[1] === "agents" && parts[2] && parts[3] === "v1") {
                 const id = decodeURIComponent(parts[2]);
                 if (req.headers["x-evolcore-session-id"] !== undefined && !authorized && !isLoopback(req.socket.remoteAddress))
@@ -312,14 +342,25 @@ class ControlServer {
         const loaded = this.options.manager.get("aun");
         return loaded?.record.status === "ready" ? loaded.instance?.identity : undefined;
     }
-    async body(req) { let raw = ""; for await (const chunk of req)
-        raw += chunk; if (!raw)
-        return {}; try {
-        return JSON.parse(raw);
+    async body(req, maxBytes = Infinity) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += buffer.length;
+            if (size > maxBytes)
+                throw Object.assign(new Error("请求正文不能超过 64 KiB"), { statusCode: 413 });
+            chunks.push(buffer);
+        }
+        if (!size)
+            return {};
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch {
+            throw new Error("请求正文必须是有效 JSON");
+        }
     }
-    catch {
-        throw new Error("invalid JSON body");
-    } }
     json(res, status, value) { res.statusCode = status; res.setHeader("content-type", "application/json; charset=utf-8"); res.end(JSON.stringify(value)); }
 }
 exports.ControlServer = ControlServer;

package/dist/src-ts/plugin-manager.js

@@ -18,6 +18,7 @@ const version_manager_1 = require("./version-manager");
 const plugin_catalog_1 = require("./plugin-catalog");
 const log_store_1 = require("./log-store");
 const channel_sessions_1 = require("./channel-sessions");
+const session_management_1 = require("./session-management");
 const _2020_1 = __importDefault(require("ajv/dist/2020"));
 const attachments_1 = require("./attachments");
 const logger = { info() { }, warn() { }, error() { } };
@@ -30,6 +31,7 @@ class PluginManager {
     httpRoutes = new Map();
     root;
     messages = [];
+    activeIngress = new Map();
     trustConfig = defaultPluginTrustConfig();
     trustLoaded = false;
     publisherLookups = new Map();
@@ -37,12 +39,14 @@ class PluginManager {
     versions;
     logs;
     sessions;
+    sessionManagement;
     constructor(options) {
         this.options = options;
         this.root = (0, node_path_1.resolve)(options.pluginsDir);
         this.versions = options.versions ?? new version_manager_1.VersionManager({ stateDir: options.stateDir });
         this.logs = new log_store_1.LogStore((0, node_path_1.join)(options.stateDir, "logs"));
         this.sessions = new channel_sessions_1.ChannelSessions(options.stateDir);
+        this.sessionManagement = new session_management_1.SessionManagement(options.stateDir, (operation, fields) => this.log("info", operation, fields, "会话管理"), { list: () => this.sessions.list(), isBusy: source => this.sessions.isBusy(source) || this.activeIngress.has(source) }, () => [...this.plugins.entries()].flatMap(([pluginId, loaded]) => loaded.instance?.sessionHistory ? [{ pluginId, provider: loaded.instance.sessionHistory, identity: loaded.instance, status: loaded.record.status }] : []));
     }
     log(level, message, fields, source = "mab") { this.logs.append({ time: new Date().toISOString(), level, source, message, ...(fields ? { fields } : {}) }); }
     setControlUrl(url) { this.controlUrl = url; }
@@ -375,8 +379,27 @@ class PluginManager {
                 pluginStatus: (targetId) => this.plugins.get(targetId)?.record.status,
                 ingress: {
                     publish: async (message) => {
+                        if (message.channel !== id)
+                            throw new agent_1.AgentError("消息来源与通道插件身份不一致");
+                        const trustedChannel = loaded.record.type === "channel" && (id === "aun" || id === "feishu");
+                        if (trustedChannel && (typeof message.peerId !== "string" || !message.peerId.trim() || [message.peerId, message.recipientId, message.chatId, message.threadId].some(value => value !== undefined && (typeof value !== "string" || value.length > 512 || /[\u0000-\u001f*]/.test(value)))))
+                            throw new agent_1.AgentError("通道来源标识无效");
                         const target = message.agentPlugin || "qwenwork";
+                        if (/^\/sessions(?:\s|$)/.test(message.text.trimStart())) {
+                            if (!trustedChannel)
+                                throw new agent_1.AgentError("当前通道不支持会话管理");
+                            const current = await this.sessions.current(message, target);
+                            const result = await this.sessionManagement.command(message.text, { source: current.source, sessionId: current.logicalSessionId });
+                            await message.reply(result);
+                            return;
+                        }
+                        if (trustedChannel)
+                            await this.sessionManagement.ready();
+                        const archiveToken = trustedChannel ? this.sessionManagement.archiveWriteToken((0, channel_sessions_1.channelSourceKey)(message)) : undefined;
                         this.recordMessage(target, "request", message.text, message.peerId);
+                        const source = (0, channel_sessions_1.channelSourceKey)(message);
+                        if (trustedChannel)
+                            this.activeIngress.set(source, (this.activeIngress.get(source) ?? 0) + 1);
                         try {
                             const instance = this.plugins.get(target)?.instance;
                             const control = instance?.sessionOperations?.includes("new")
@@ -384,11 +407,13 @@ class PluginManager {
                                 : undefined;
                             const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
                             const forwarded = new Set();
+                            const sent = [];
                             const onMessage = async (text) => {
                                 if (!text.trim() || forwarded.has(text))
                                     return;
                                 await message.reply(text);
                                 forwarded.add(text);
+                                sent.push({ text });
                                 this.recordMessage(target, "reply", text, message.peerId);
                             };
                             const response = await this.sessions.run(message, target, (sessionId, newSession) => this.handle(target, { task, sessionId, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}) }), control);
@@ -400,15 +425,37 @@ class PluginManager {
                                     throw new agent_1.AgentError("当前通道不支持附件回传");
                                 }
                                 await message.replyAttachments(attachments, response.text);
+                                sent.push({ text: response.text, attachments });
                                 this.recordMessage(target, "reply", response.text, message.peerId);
                             }
                             else
                                 await onMessage(response.text);
+                            if (trustedChannel && response.source && response.logicalSessionId) {
+                                const identity = { sessionId: response.logicalSessionId, source: response.source, principal: response.source, channel: message.channel, agentPlugin: target, completed: true, time: new Date().toISOString() };
+                                const requestId = message.messageId || (0, node_crypto_1.randomUUID)();
+                                const metadata = (items) => items?.map(item => ({ filename: item.filename, contentType: item.contentType, sizeBytes: item.data.byteLength }));
+                                try {
+                                    await this.sessionManagement.recordIngressTurns(source, archiveToken, [
+                                        { ...identity, role: "user", text: message.text, requestId, messageId: message.messageId ? `${message.messageId}:user` : undefined, attachments: metadata(message.attachments) },
+                                        ...sent.map((item, index) => ({ ...identity, role: "assistant", text: item.text, requestId, messageId: message.messageId ? `${message.messageId}:assistant:${index}` : undefined, attachments: metadata(item.attachments) })),
+                                    ]);
+                                }
+                                catch {
+                                    this.log("warn", "会话归档失败", { sessionId: identity.sessionId, status: "failed" }, "会话管理");
+                                }
+                            }
                         }
                         catch (error) {
                             this.recordMessage(target, "error", error instanceof Error ? error.message : String(error), message.peerId);
                             throw error;
                         }
+                        finally {
+                            const remaining = (this.activeIngress.get(source) ?? 1) - 1;
+                            if (remaining)
+                                this.activeIngress.set(source, remaining);
+                            else
+                                this.activeIngress.delete(source);
+                        }
                     },
                 },
                 runtime: { controlUrl: this.controlUrl, ports: {

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