agent-bridge-chatgpt 1.0.0 → 1.0.1

package/README.md

@@ -29,3 +29,19 @@ Start-Process -FilePath $executable -ArgumentList '--remote-debugging-port=9230'
 ```
 
 插件启动时会建立 SSH 转发，并连接本机 `127.0.0.1:9230`。不配置 SSH 时，可直接连接本机已开启 CDP 的 ChatGPT 页面。
+
+## 最近任务与继续会话
+
+插件会在自己的数据目录保存最多 20 条最近 ChatGPT 会话索引（不保存账号、密码或页面 HTML）。Channel 查询以下内容时优先读取本地缓存，缓存过期后才同步一次远程侧栏：
+
+- `最近任务`
+- `列出最近会话`
+- `有哪些已保存的 ChatGPT 任务`
+
+可以使用 `切换会话：任务标题` 或 `继续处理任务标题` 切换到已有会话。切换成功后，同一 Channel 的后续消息会继续发送到该会话；标题重复时插件会返回候选列表，避免误切换。发送“刷新最近任务”可以强制同步侧栏。
+
+缓存默认有效期为 10 分钟，可跨插件重启恢复，并按远程连接隔离。列表覆盖当前已加载的侧栏项目，不代表全部历史会话，也无法推断远程所有任务的精确更新时间。需要其他项目时，先在桌面侧栏展开后刷新列表。
+
+`切换会话：任务标题` 只切换；`切换会话：任务标题；检查进度` 会切换并发送后半句；`继续处理任务标题` 会切换并向该会话发送这条继续指令。也可用列表中的完整会话 ID 指定目标。当前会话有未发送草稿或正在生成回复时，插件拒绝切换。
+
+索引文件为插件数据目录下的 `chatgpt-sessions.json`，记录最近使用时间和最多 500 字符的最近消息/回复片段。它用于检索会话，不自动生成 Skill；远程暂时不可用时仍可查询已有缓存。

package/dist/src-ts/plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimePort = resolveRuntimePort;
+function resolveRuntimePort(config, runtime, pluginId, envName, fallback) {
+    const injected = runtime?.ports?.[pluginId];
+    if (typeof injected === "number" && Number.isInteger(injected) && injected > 0)
+        return injected;
+    const configured = config.cdpPort;
+    if (typeof configured === "number" && Number.isInteger(configured) && configured > 0)
+        return configured;
+    const environment = Number(process.env[envName] ?? "");
+    return Number.isInteger(environment) && environment > 0 ? environment : fallback;
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatgptCdpClient = exports.userBubbleSelector = exports.turnSelector = exports.editorSelector = void 0;
 const node_child_process_1 = require("node:child_process");
+const session_store_1 = require("./session-store");
 exports.editorSelector = '[data-codex-composer="true"][contenteditable="true"]';
 exports.turnSelector = '[data-chatgpt-conversation-turn="true"]';
 exports.userBubbleSelector = "[data-user-message-bubble]";
@@ -11,6 +12,7 @@ const contentUnitSelector = "[data-content-search-unit-key]";
 const sendButtonSelector = 'button[aria-label="Send"], button[aria-label="发送"]';
 const stopButtonSelector = 'button[aria-label="Stop"], button[aria-label="停止"]';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sidebarSelector = "[data-app-action-sidebar-thread-id]";
 class ChatgptCdpClient {
     socket;
     tunnel;
@@ -29,6 +31,51 @@ class ChatgptCdpClient {
         this.ssh = options.ssh;
     }
     connected() { return Boolean(this.socket); }
+    async listSessions() {
+        const entries = await this.evaluate(`(() => {
+      return [...document.querySelectorAll(${JSON.stringify(sidebarSelector)})].map(item => ({
+        id: item.getAttribute('data-app-action-sidebar-thread-id'),
+        host: item.getAttribute('data-app-action-sidebar-thread-host-id'),
+        title: item.getAttribute('data-app-action-sidebar-thread-title')
+      }));
+    })()`);
+        if (!Array.isArray(entries))
+            throw new Error("ChatGPT 侧栏会话列表格式无效");
+        return entries.filter(session_store_1.validSession);
+    }
+    async activeSession() {
+        const entry = await this.evaluate(`(() => {
+      const item = document.querySelector('[data-app-action-sidebar-thread-selected="true"]');
+      return item ? {
+        id: item.getAttribute('data-app-action-sidebar-thread-id'),
+        host: item.getAttribute('data-app-action-sidebar-thread-host-id'),
+        title: item.getAttribute('data-app-action-sidebar-thread-title')
+      } : null;
+    })()`);
+        return (0, session_store_1.validSession)(entry) ? entry : undefined;
+    }
+    async switchSession(session) {
+        const locate = `[...document.querySelectorAll(${JSON.stringify(sidebarSelector)})].find(item =>
+      item.getAttribute('data-app-action-sidebar-thread-id') === ${JSON.stringify(session.id)}
+      && item.getAttribute('data-app-action-sidebar-thread-host-id') === ${JSON.stringify(session.host)})`;
+        const clicked = await this.evaluate(`(() => {
+      const editor = document.querySelector(${JSON.stringify(exports.editorSelector)});
+      if (editor?.innerText.trim() || document.querySelector(${JSON.stringify(stopButtonSelector)})) {
+        throw new Error('当前会话有未发送内容或正在生成回复，不能切换');
+      }
+      const item = ${locate};
+      if (!item) return false;
+      item.click();
+      return true;
+    })()`);
+        if (!clicked)
+            throw new Error("ChatGPT 侧栏中找不到目标会话");
+        await this.waitFor(`(() => {
+      const item = ${locate};
+      return item?.getAttribute('data-app-action-sidebar-thread-selected') === 'true'
+        && Boolean(document.querySelector(${JSON.stringify(exports.editorSelector)}));
+    })()`, "ChatGPT 会话切换未确认，未发送消息");
+    }
     async connect() {
         if (this.socket)
             return;

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatgptCdpClient = exports.ChatgptPlugin = exports.chatgptManifest = void 0;
 const cdp_client_1 = require("./cdp-client");
+const session_store_1 = require("./session-store");
 exports.chatgptManifest = {
     id: "chatgpt",
-    version: "1.0.0",
+    version: "1.0.1",
     displayName: "ChatGPT（Codex）",
     type: "agent",
     entry: "dist/index.js",
@@ -25,6 +26,8 @@ class ChatgptPlugin {
     failure;
     remote = false;
     queue = Promise.resolve();
+    store;
+    logger;
     constructor(options = {}) {
         this.options = options;
     }
@@ -48,6 +51,11 @@ class ChatgptPlugin {
             localPort: port(config.localCdpPort, 9230),
         } : undefined;
         this.remote = Boolean(ssh);
+        this.logger = context.logger;
+        this.store = new session_store_1.ChatgptSessionStore(context.dataDir, JSON.stringify(ssh
+            ? [ssh.host, ssh.user, ssh.port, ssh.remotePort]
+            : ["local", port(config.localCdpPort, 9230)]));
+        await this.store.load();
         this.failure = undefined;
         this.client = this.options.client ?? new cdp_client_1.ChatgptCdpClient({
             port: port(config.localCdpPort, 9230),
@@ -60,11 +68,13 @@ class ChatgptPlugin {
         catch (error) {
             this.failure = error instanceof Error ? error.message : String(error);
             context.logger.warn(this.failure);
-            throw error;
+            if (!this.store.sessions.length)
+                throw error;
         }
     }
     async deactivate() {
         await this.queue;
+        await this.store?.drain();
         this.client?.close();
         this.client = undefined;
         this.remote = false;
@@ -72,17 +82,111 @@ class ChatgptPlugin {
     async health() {
         return this.client?.connected()
             ? { status: "ready", details: { transport: "cdp", remote: this.remote } }
-            : { status: "failed", message: this.failure ?? "ChatGPT CDP 未连接", details: { transport: "cdp", remote: this.remote } };
+            : { status: this.client && this.store?.sessions.length ? "degraded" : "failed", message: this.failure ?? "ChatGPT CDP 未连接", details: { transport: "cdp", remote: this.remote } };
     }
     async handle(request) {
         if (!request.task.trim())
             throw new Error("消息内容不能为空");
-        if (!this.client?.connected())
-            throw new Error("ChatGPT CDP 未连接");
-        const run = this.queue.then(() => this.client.direct(request.task, request.timeoutMs));
+        if (!this.client || !this.store)
+            throw new Error("ChatGPT 插件未启动");
+        const run = this.queue.then(() => this.run(request));
         this.queue = run.then(() => undefined, () => undefined);
         return { text: await run, sessionId: request.sessionId };
     }
+    persist() {
+        void this.store.save().catch(error => this.logger?.warn("ChatGPT 会话缓存保存失败", { error: String(error) }));
+    }
+    async synchronize() {
+        if (!this.client.connected())
+            await this.client.connect();
+        if (!this.client.listSessions)
+            throw new Error("当前 ChatGPT 客户端不支持会话列表");
+        this.store.synchronize(await this.client.listSessions());
+        this.persist();
+    }
+    async select(session) {
+        if (!this.client.connected())
+            await this.client.connect();
+        if (!this.client.switchSession)
+            throw new Error("当前 ChatGPT 客户端不支持会话切换");
+        const active = await this.client.activeSession?.();
+        if (active?.id === session.id && active.host === session.host)
+            return;
+        try {
+            await this.client.switchSession(session);
+        }
+        catch (error) {
+            // 目标消失时只重新同步一次；不在其他会话中代替发送。
+            if (!String(error).includes("找不到目标会话"))
+                throw error;
+            await this.synchronize();
+            const updated = this.store.sessions.find(item => item.id === session.id && item.host === session.host);
+            if (!updated)
+                throw new Error("ChatGPT 目标会话已删除或不在当前侧栏，请刷新最近任务");
+            await this.client.switchSession(updated);
+        }
+    }
+    async run(request) {
+        const store = this.store;
+        const text = request.task.trim();
+        const refresh = /^(?:刷新最近任务|刷新任务列表|刷新最近会话)$/.test(text);
+        const listing = /^(?:最近任务|列出最近会话|有哪些已保存的 ChatGPT 任务)[？?。]?$/.test(text);
+        if (refresh || listing) {
+            if (refresh || !store.fresh()) {
+                try {
+                    await this.synchronize();
+                }
+                catch (error) {
+                    if (refresh || !store.sessions.length)
+                        throw error;
+                    return `远程暂不可用，以下是本地缓存（同步时间：${store.updatedAt}）：\n${(0, session_store_1.formatSessions)(store.sessions)}`;
+                }
+            }
+            return `最近会话（当前侧栏缓存；同步时间：${store.updatedAt}）：\n${(0, session_store_1.formatSessions)(store.sessions)}`;
+        }
+        const explicit = text.match(/^切换会话\s*[:：]\s*([^；;\n]+)(?:[；;\n]\s*([\s\S]+))?$/);
+        const natural = text.match(/^(?:继续处理|接着处理|继续任务|切换到)\s*(.+?)[。]?$/);
+        const query = explicit?.[1].trim() ?? natural?.[1].trim();
+        let selected;
+        if (query) {
+            if (!store.fresh())
+                await this.synchronize();
+            let matches = store.match(query);
+            if (!matches.length) {
+                await this.synchronize();
+                matches = store.match(query);
+            }
+            if (!matches.length)
+                return `没有找到会话：${query}。请发送“最近任务”查看可用标题。`;
+            if (matches.length > 1)
+                return `找到多个会话，请用完整标题或会话 ID 指定：\n${(0, session_store_1.formatSessions)(matches)}`;
+            selected = matches[0];
+            await this.select(selected);
+            if (request.sessionId)
+                store.bindings[request.sessionId] = selected;
+            this.persist();
+            if ((explicit && !explicit[2]) || text.startsWith("切换到"))
+                return `已切换到：${selected.title}。后续消息将继续此会话。`;
+        }
+        else if (request.sessionId && store.bindings[request.sessionId]) {
+            selected = store.bindings[request.sessionId];
+            await this.select(selected);
+        }
+        if (!this.client.connected())
+            await this.client.connect();
+        selected ??= await this.client.activeSession?.();
+        const message = explicit?.[2]?.trim() || request.task;
+        const reply = await this.client.direct(message, request.timeoutMs);
+        if (selected) {
+            const current = await this.client.activeSession?.().catch(() => undefined);
+            const entry = current?.id === selected.id && current.host === selected.host ? current : selected;
+            store.remember(entry, message, reply);
+            if (request.sessionId)
+                store.bindings[request.sessionId] = entry;
+            this.persist();
+        }
+        return reply;
+    }
 }
 exports.ChatgptPlugin = ChatgptPlugin;
 var cdp_client_2 = require("./cdp-client");

package/dist/src-ts/plugins/chatgpt/session-store.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatgptSessionStore = void 0;
+exports.validSession = validSession;
+exports.formatSessions = formatSessions;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+function validSession(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    return ["id", "host", "title"].every(key => typeof item[key] === "string" && Boolean(item[key]))
+        && ["updatedAt", "lastUserMessage", "lastAssistantReply"].every(key => item[key] === undefined || typeof item[key] === "string");
+}
+class ChatgptSessionStore {
+    directory;
+    endpoint;
+    sessions = [];
+    bindings = {};
+    updatedAt = "";
+    writes = Promise.resolve();
+    constructor(directory, endpoint) {
+        this.directory = directory;
+        this.endpoint = endpoint;
+    }
+    async load() {
+        if (!this.directory)
+            return;
+        try {
+            const value = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.directory, "chatgpt-sessions.json"), "utf8"));
+            if (value.version !== 1 || value.endpoint !== this.endpoint || !Array.isArray(value.sessions)
+                || !value.sessions.every(validSession) || typeof value.updatedAt !== "string"
+                || !value.bindings || typeof value.bindings !== "object" || Array.isArray(value.bindings)
+                || !Object.values(value.bindings).every(validSession))
+                return;
+            this.sessions = value.sessions.slice(0, 20);
+            this.bindings = Object.fromEntries(Object.entries(value.bindings));
+            this.updatedAt = value.updatedAt;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" && !(error instanceof SyntaxError))
+                throw error;
+        }
+    }
+    fresh() { return Date.now() - Date.parse(this.updatedAt) < 10 * 60_000; }
+    synchronize(entries) {
+        const previous = this.sessions;
+        const seen = new Set();
+        this.sessions = entries.filter(validSession).filter(item => {
+            const key = JSON.stringify([item.host, item.id]);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }).map(item => ({ ...previous.find(old => old.id === item.id && old.host === item.host), ...item }))
+            .sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")).slice(0, 20);
+        this.updatedAt = new Date().toISOString();
+    }
+    remember(entry, user, reply) {
+        const next = { ...entry, lastUserMessage: user.slice(0, 500), lastAssistantReply: reply.slice(0, 500), updatedAt: new Date().toISOString() };
+        this.sessions = [next, ...this.sessions.filter(old => old.id !== entry.id || old.host !== entry.host)].slice(0, 20);
+    }
+    match(query) {
+        const text = query.trim().toLocaleLowerCase();
+        if (!text)
+            return [];
+        const exact = this.sessions.filter(item => item.id === query || item.title.toLocaleLowerCase() === text);
+        return exact.length ? exact : this.sessions.filter(item => `${item.title}\n${item.lastUserMessage ?? ""}`.toLocaleLowerCase().includes(text));
+    }
+    save() {
+        const snapshot = { version: 1, endpoint: this.endpoint, updatedAt: this.updatedAt, sessions: this.sessions, bindings: this.bindings };
+        const text = `${JSON.stringify(snapshot, null, 2)}\n`;
+        const write = this.writes.catch(() => { }).then(async () => {
+            if (!this.directory)
+                return;
+            await (0, promises_1.mkdir)(this.directory, { recursive: true });
+            const file = (0, node_path_1.join)(this.directory, "chatgpt-sessions.json");
+            await (0, promises_1.writeFile)(`${file}.tmp`, text, { mode: 0o600 });
+            await (0, promises_1.rename)(`${file}.tmp`, file);
+        });
+        this.writes = write;
+        return write;
+    }
+    async drain() { await this.writes.catch(() => { }); }
+}
+exports.ChatgptSessionStore = ChatgptSessionStore;
+function formatSessions(entries) {
+    if (!entries.length)
+        return "当前侧栏暂无可用会话。";
+    return entries.map((item, index) => `${index + 1}. ${item.title}\n   主机：${item.host}；会话：${item.id}${item.updatedAt ? `；最近使用：${item.updatedAt}` : ""}`).join("\n");
+}

package/package.json

@@ -1 +1 @@
-{"name":"agent-bridge-chatgpt","version":"1.0.0","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.1","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/plugin.json

@@ -1 +1 @@
-{"id":"chatgpt","version":"1.0.0","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.1","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"}