agent-bridge-chatgpt 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# ChatGPT（Codex）插件
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+插件通过 SSH 本地转发和 CDP，向远程 Windows 上已登录的 ChatGPT 桌面端发送消息并读取回复。插件不会保存 ChatGPT 账号或密码。
+
+## 远程桌面准备
+
+在远程 Windows 的已登录桌面会话中，先正常退出 ChatGPT，再打开 PowerShell 执行以下命令：
+
+```powershell
+$package = Get-AppxPackage -Name OpenAI.CodexBeta
+$executable = Join-Path $package.InstallLocation 'app\ChatGPT (Beta).exe'
+Start-Process -FilePath $executable -ArgumentList '--remote-debugging-port=9230'
+```
+
+启动后在桌面端确认账号仍处于登录状态。CDP 端口由 SSH 隧道访问，不需要开放到局域网。
+
+## 插件配置
+
+在 Agent Bridge 的 `chatgpt` 插件配置中填写：
+
+```json
+{
+  "sshHost": "192.168.31.151",
+  "sshUser": "m2lih",
+  "sshKeyPath": "/本机/SSH/私钥路径",
+  "remoteCdpPort": 9230,
+  "localCdpPort": 9230
+}
+```
+
+插件启动时会建立 SSH 转发，并连接本机 `127.0.0.1:9230`。不配置 SSH 时，可直接连接本机已开启 CDP 的 ChatGPT 页面。
+
+## 最近任务与继续会话
+
+插件会在自己的数据目录保存最多 20 条最近 ChatGPT 会话索引（不保存账号、密码或页面 HTML）。Channel 查询以下内容时优先读取本地缓存，缓存过期后才同步一次远程侧栏：
+
+- `最近任务`
+- `列出最近会话`
+- `有哪些已保存的 ChatGPT 任务`
+
+可以使用 `切换会话：任务标题` 或 `继续处理任务标题` 切换到已有会话。切换成功后，同一 Channel 的后续消息会继续发送到该会话；标题重复时插件会返回候选列表，避免误切换。发送“刷新最近任务”可以强制同步侧栏。
+
+缓存默认有效期为 10 分钟，可跨插件重启恢复，并按远程连接隔离。列表覆盖当前已加载的侧栏项目，不代表全部历史会话，也无法推断远程所有任务的精确更新时间。需要其他项目时，先在桌面侧栏展开后刷新列表。
+
+`切换会话：任务标题` 只切换；`切换会话：任务标题；检查进度` 会切换并发送后半句；`继续处理任务标题` 会切换并向该会话发送这条继续指令。也可用列表中的完整会话 ID 指定目标。当前会话有未发送草稿或正在生成回复时，插件拒绝切换。
+
+索引文件为插件数据目录下的 `chatgpt-sessions.json`，记录最近使用时间和最多 500 字符的最近消息/回复片段。它用于检索会话，不自动生成 Skill；远程暂时不可用时仍可查询已有缓存。

package/config.schema.json

@@ -0,0 +1 @@
+{"type":"object","properties":{"sshHost":{"type":"string","description":"Windows 主机地址"},"sshUser":{"type":"string","description":"SSH 用户名"},"sshPort":{"type":"integer","minimum":1,"maximum":65535,"default":22},"sshKeyPath":{"type":"string","description":"SSH 私钥路径"},"remoteCdpPort":{"type":"integer","minimum":1,"maximum":65535,"default":9230},"localCdpPort":{"type":"integer","minimum":1,"maximum":65535,"default":9230},"timeoutMs":{"type":"integer","minimum":1,"default":30000}},"additionalProperties":false}

package/dist/src-ts/agent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentError = void 0;
+class AgentError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AgentError";
+    }
+}
+exports.AgentError = AgentError;

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

@@ -0,0 +1,351 @@
+"use strict";
+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]";
+const assistantMessageSelector = '[data-markdown-text-style="assistant-message"]';
+const turnIdAttribute = "data-chatgpt-conversation-turn-id";
+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;
+    sequence = 0;
+    pending = new Map();
+    port;
+    timeoutMs;
+    fetchImpl;
+    webSocketFactory;
+    ssh;
+    constructor(options = {}) {
+        this.port = options.port ?? options.ssh?.localPort ?? 9230;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.webSocketFactory = options.webSocketFactory ?? ((url) => new WebSocket(url));
+        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;
+        try {
+            if (this.ssh) {
+                await this.startTunnel();
+            }
+            const page = await this.findPage();
+            if (!page.webSocketDebuggerUrl)
+                throw new Error("ChatGPT CDP target 缺少 WebSocket 地址");
+            const socketUrl = new URL(page.webSocketDebuggerUrl);
+            if (this.ssh) {
+                socketUrl.hostname = "127.0.0.1";
+                socketUrl.port = String(this.port);
+            }
+            const socket = this.webSocketFactory(socketUrl);
+            this.socket = socket;
+            let opened = false;
+            let rejectOpening;
+            socket.onmessage = (event) => this.onMessage(String(event.data));
+            socket.onclose = () => {
+                if (this.socket === socket) {
+                    this.socket = undefined;
+                    this.tunnel?.kill();
+                    this.tunnel = undefined;
+                }
+                if (!opened)
+                    rejectOpening?.(new Error("ChatGPT CDP WebSocket 连接已关闭"));
+                this.rejectPending(new Error("ChatGPT CDP 连接已关闭"));
+            };
+            await new Promise((resolve, reject) => {
+                rejectOpening = reject;
+                const timer = setTimeout(() => reject(new Error("ChatGPT CDP WebSocket 连接超时")), this.timeoutMs);
+                socket.onopen = () => {
+                    opened = true;
+                    clearTimeout(timer);
+                    resolve();
+                };
+                socket.onerror = () => {
+                    clearTimeout(timer);
+                    reject(new Error("ChatGPT CDP WebSocket 连接失败"));
+                };
+            });
+        }
+        catch (error) {
+            this.close();
+            throw error;
+        }
+    }
+    async findPage() {
+        const deadline = Date.now() + this.timeoutMs;
+        let last;
+        while (Date.now() < deadline) {
+            try {
+                const response = await this.fetchImpl(`http://127.0.0.1:${this.port}/json`, {
+                    signal: AbortSignal.timeout(Math.min(this.timeoutMs, 3_000)),
+                });
+                if (!response.ok)
+                    throw new Error(`ChatGPT CDP /json HTTP ${response.status}`);
+                const targets = await response.json();
+                const page = targets.find((target) => target.type === "page" && (/chatgpt|codex/i.test(`${target.title} ${target.url}`)
+                    || target.url === "app://-/index.html"));
+                if (page?.webSocketDebuggerUrl)
+                    return page;
+                last = new Error(`未找到 ChatGPT/Codex 页面 target（端口 ${this.port}）`);
+            }
+            catch (error) {
+                last = error;
+            }
+            await sleep(500);
+        }
+        throw new Error(`ChatGPT CDP 连接超时：${last instanceof Error ? last.message : String(last ?? "端口不可达")}`, { cause: last });
+    }
+    close() {
+        this.socket?.close();
+        this.socket = undefined;
+        this.tunnel?.kill();
+        this.tunnel = undefined;
+        this.rejectPending(new Error("ChatGPT CDP 已关闭"));
+    }
+    async direct(text, timeoutMs = 240_000) {
+        await this.waitFor(`Boolean(document.querySelector(${JSON.stringify(exports.editorSelector)}))`, "ChatGPT 桌面端输入框未就绪");
+        const beforeTurnsJson = await this.evaluate(`JSON.stringify([...document.querySelectorAll(${JSON.stringify(exports.turnSelector)})].map(turn => ({ id: turn.getAttribute(${JSON.stringify(turnIdAttribute)}), users: turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).length })))`);
+        const beforeTurns = JSON.parse(String(beforeTurnsJson || "[]"));
+        const beforeAssistantCount = Number(await this.evaluate(`document.querySelectorAll(${JSON.stringify(assistantMessageSelector)}).length`));
+        const ready = await this.evaluate(`(() => {
+      const editor = document.querySelector(${JSON.stringify(exports.editorSelector)});
+      if (!editor || editor.innerText.trim()) return false;
+      const findButton = () => {
+        for (let parent = editor; parent && parent !== document.body; parent = parent.parentElement) {
+          const buttons = [...parent.querySelectorAll(${JSON.stringify(sendButtonSelector)})];
+          if (buttons.length === 1) return buttons[0];
+        }
+        return null;
+      };
+      const button = findButton();
+      if (!button) return false;
+      editor.focus();
+      return document.activeElement === editor;
+    })()`);
+        if (!ready)
+            throw new Error("ChatGPT 输入框含有未发送内容，或桌面端发送按钮未就绪");
+        await this.cdp("Input.insertText", { text });
+        const inputMatches = await this.evaluate(`document.querySelector(${JSON.stringify(exports.editorSelector)})?.innerText.trim() === ${JSON.stringify(text.trim())}`);
+        if (!inputMatches)
+            throw new Error("ChatGPT 输入内容校验失败，未发送消息");
+        const sent = await this.evaluate(`(() => {
+      const editor = document.querySelector(${JSON.stringify(exports.editorSelector)});
+      const findButton = () => {
+        for (let parent = editor; parent && parent !== document.body; parent = parent.parentElement) {
+          const buttons = [...parent.querySelectorAll(${JSON.stringify(sendButtonSelector)})];
+          if (buttons.length === 1) return buttons[0];
+        }
+        return null;
+      };
+      const button = findButton();
+      if (!button || button.disabled) return false;
+      button.click();
+      return true;
+    })()`);
+        if (!sent)
+            throw new Error("ChatGPT 桌面端发送按钮不可用，未确认消息已发送");
+        const deadline = Date.now() + timeoutMs;
+        let previous = "";
+        let stable = 0;
+        while (Date.now() < deadline) {
+            await sleep(800);
+            const raw = await this.evaluate(`(() => {
+        const before = ${JSON.stringify(beforeTurns)};
+        const turns = [...document.querySelectorAll(${JSON.stringify(exports.turnSelector)})];
+        const turn = turns.findLast((item, index) => {
+          const id = item.getAttribute(${JSON.stringify(turnIdAttribute)});
+          const oldIndex = before.findIndex(entry => entry.id === id);
+          const old = oldIndex < 0 ? undefined : before[oldIndex];
+          const users = item.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)});
+          const fresh = oldIndex < 0 || index >= before.length || users.length > (old?.users ?? 0);
+          return fresh && users.item(users.length - 1)?.innerText.trim() === ${JSON.stringify(text.trim())};
+        });
+        if (!turn) {
+          const assistants = [...document.querySelectorAll(${JSON.stringify(assistantMessageSelector)})];
+          const fallback = assistants.length > ${beforeAssistantCount}
+            ? assistants.at(-1)?.innerText.trim() ?? ""
+            : "";
+          return JSON.stringify({ reply: fallback, active: Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)})) });
+        }
+        const user = turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).item(turn.querySelectorAll(${JSON.stringify(exports.userBubbleSelector)}).length - 1);
+        const unit = user?.closest(${JSON.stringify(contentUnitSelector)});
+        const units = [...turn.querySelectorAll(${JSON.stringify(contentUnitSelector)})];
+        const index = unit ? units.indexOf(unit) : -1;
+        const replies = index < 0 ? [] : units.slice(index + 1).map(item => item.innerText.trim()).filter(Boolean);
+        const legacyReplies = [...turn.querySelectorAll('[data-message-author-role="assistant"]')].map(item => item.innerText.trim()).filter(Boolean);
+        const reply = replies.at(-1) ?? legacyReplies.at(-1) ?? "";
+        const active = Boolean(document.querySelector(${JSON.stringify(stopButtonSelector)}));
+        return JSON.stringify({ reply, active });
+      })()`);
+            const state = JSON.parse(String(raw));
+            const reply = state.reply.trim();
+            stable = reply && reply === previous ? stable + 1 : 0;
+            previous = reply;
+            if (reply && stable >= 2 && !state.active)
+                return reply;
+        }
+        throw new Error("ChatGPT UI 回复超时");
+    }
+    async startTunnel() {
+        const ssh = this.ssh;
+        const args = [
+            "-N", "-o", "BatchMode=yes", "-o", "ExitOnForwardFailure=yes", "-o", "ConnectTimeout=10",
+            "-L", `${ssh.localPort}:127.0.0.1:${ssh.remotePort}`, "-p", String(ssh.port ?? 22),
+        ];
+        if (ssh.keyPath)
+            args.push("-i", ssh.keyPath);
+        args.push(`${ssh.user}@${ssh.host}`);
+        this.tunnel = (0, node_child_process_1.spawn)("ssh", args, { stdio: "ignore", windowsHide: true });
+        const tunnel = this.tunnel;
+        await new Promise((resolve, reject) => {
+            let ready = false;
+            const fail = (error) => {
+                if (!ready)
+                    reject(error);
+                else if (this.tunnel === tunnel) {
+                    this.tunnel = undefined;
+                    this.socket?.close();
+                    this.socket = undefined;
+                    this.rejectPending(error);
+                }
+            };
+            const timer = setTimeout(() => {
+                ready = true;
+                resolve();
+            }, 500);
+            tunnel.once("error", (error) => {
+                clearTimeout(timer);
+                fail(error);
+            });
+            tunnel.once("exit", () => {
+                clearTimeout(timer);
+                fail(new Error("SSH CDP 隧道已关闭，请检查远程连接"));
+            });
+        });
+    }
+    async waitFor(expression, message) {
+        const deadline = Date.now() + this.timeoutMs;
+        while (Date.now() < deadline) {
+            if (await this.evaluate(expression))
+                return;
+            await sleep(200);
+        }
+        throw new Error(message);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+    onMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message.id === undefined)
+            return;
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        if (message.error)
+            pending.reject(new Error(message.error.message ?? "CDP 调用失败"));
+        else
+            pending.resolve(message);
+    }
+    async cdp(method, params = {}) {
+        if (!this.socket)
+            throw new Error("ChatGPT CDP 尚未连接");
+        const id = ++this.sequence;
+        const socket = this.socket;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`CDP ${method} 超时`));
+            }, this.timeoutMs);
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timer);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+            });
+            try {
+                socket.send(JSON.stringify({ id, method, params }));
+            }
+            catch (error) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(error);
+            }
+        });
+    }
+    async evaluate(expression) {
+        const response = await this.cdp("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
+        if (response.result?.exceptionDetails) {
+            throw new Error(`ChatGPT 页面 JS 异常：${JSON.stringify(response.result.exceptionDetails).slice(0, 300)}`);
+        }
+        return response.result?.result?.value;
+    }
+}
+exports.ChatgptCdpClient = ChatgptCdpClient;

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

@@ -0,0 +1,194 @@
+"use strict";
+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.1",
+    displayName: "ChatGPT（Codex）",
+    type: "agent",
+    entry: "dist/index.js",
+    apiVersion: "1",
+    process: "in-process",
+    capabilities: ["chat", "health"],
+    configSchema: "config.schema.json",
+};
+function port(value, fallback) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65_535
+        ? value
+        : fallback;
+}
+class ChatgptPlugin {
+    options;
+    manifest = exports.chatgptManifest;
+    client;
+    failure;
+    remote = false;
+    queue = Promise.resolve();
+    store;
+    logger;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async activate(context) {
+        const config = context.config;
+        const hasSshHost = config.sshHost !== undefined;
+        const hasSshUser = config.sshUser !== undefined;
+        if (hasSshHost !== hasSshUser || (hasSshHost && (typeof config.sshHost !== "string" || !config.sshHost.trim()
+            || typeof config.sshUser !== "string" || !config.sshUser.trim()))) {
+            throw new Error("sshHost 和 sshUser 必须同时填写有效值");
+        }
+        if (config.sshKeyPath !== undefined && typeof config.sshKeyPath !== "string") {
+            throw new Error("sshKeyPath 必须是字符串");
+        }
+        const ssh = hasSshHost ? {
+            host: config.sshHost.trim(),
+            user: config.sshUser.trim(),
+            port: port(config.sshPort, 22),
+            keyPath: typeof config.sshKeyPath === "string" ? config.sshKeyPath : undefined,
+            remotePort: port(config.remoteCdpPort, 9230),
+            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),
+            timeoutMs: typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : 30_000,
+            ssh,
+        });
+        try {
+            await this.client.connect();
+        }
+        catch (error) {
+            this.failure = error instanceof Error ? error.message : String(error);
+            context.logger.warn(this.failure);
+            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;
+    }
+    async health() {
+        return this.client?.connected()
+            ? { status: "ready", 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 || !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");
+Object.defineProperty(exports, "ChatgptCdpClient", { enumerable: true, get: function () { return cdp_client_2.ChatgptCdpClient; } });
+exports.default = ChatgptPlugin;

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,6 +1 @@
-{
-  "name": "agent-bridge-chatgpt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{"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

@@ -0,0 +1 @@
+{"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"}