mu-agent-bridge 1.0.16 → 1.0.18

package/README.md

@@ -1,7 +1,7 @@
 # mu-agent-bridge 动态插件平台
 
 运行时使用 TypeScript/Node.js，实现一个可动态发现、启动、停止、重载和安装插件的 daemon。
-当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`，以及插件化管理后台
+当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`、远程 ChatGPT/Codex CDP 插件 `chatgpt`，以及插件化管理后台
 `abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
 
 ## 快速开始
@@ -14,7 +14,7 @@ npm run start
 
 默认监听 `http://127.0.0.1:26107`，管理页面为 `http://127.0.0.1:26107/abweb/`，管理 API 为 `/api/health`、`/api/plugins`，千问办公的
 OpenAI 兼容 API 为 `/v1/models` 和 `/v1/chat/completions`。管理页面位于 `/abweb`。
-千问办公插件使用 CDP `9226`；没有运行千问办公时，daemon 仍会启动，qwenwork 会显示为失败状态，
+千问办公插件使用 CDP `9228`；没有运行千问办公时，daemon 仍会启动，qwenwork 会显示为失败状态，
 可以通过管理 API 重载。
 
 安装后使用 `mab start` 启动。旧桥仍可使用 `17893`，不会与管理页面冲突。局域网访问时设置
@@ -40,14 +40,14 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 
 ## npm 插件
 
-默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书和 WorkBuddy 七个插件，直接安装即可使用：
+默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy 和 ChatGPT/Codex 八个插件，直接安装即可使用：
 
 ```powershell
 npm install -g mu-agent-bridge@latest
 mab start
 ```
 
-七个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
+八个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
 [`docs/npm-publishing.md`](docs/npm-publishing.md)。
 
 `mab start` 启动时会查询核心包和托管插件的 npm 最新版本，检查状态保存于 mab 状态目录的
@@ -72,7 +72,7 @@ abweb 插件目录从 npm 搜索带 `mu-agent-bridge-plugin` 关键词的包，
 插件仍在 daemon 的同一个 Node.js 进程内运行。修改插件入口依赖后应重启 daemon，避免模块缓存
 影响新代码。
 
-npm 尚未发布时，核心包内置的七个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
+npm 尚未发布时，核心包内置的八个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
 可填写 **Windows 主机上**包含 `plugin.json` 的目录路径，例如编译后的
 `C:\path\to\agent_bridge\packages\dsh`；安装后可在下拉框中启动。已内置的千问办公无需再次安装。
 “安装 npm 插件”只适用于包已经公开发布的情况。npm 发布令牌仅供发布脚本向 npm 官网认证，
@@ -108,7 +108,7 @@ $env:CODEBUDDY_NPM_DIR = 'C:\path\to\node_modules\@tencent-ai\codebuddy-code'
 
 千问工作区默认使用 `%APPDATA%\QwenWorkCN\workspace`，可用 `$env:QWEN_WORKSPACE`
 覆盖；AUN 数据默认使用 `$env:EVOLCORE_HOME` 或用户目录下的 `.evolcore`。
-千问 CDP 端口默认为 `9226`，也可用 `$env:QWEN_CDP_PORT` 覆盖。
+千问 CDP 端口默认为 `9228`，也可用 `$env:QWEN_CDP_PORT` 或 `$env:AGENT_BRIDGE_QWEN_CDP_PORT` 覆盖。守护进程注入端口优先级最高，用来覆盖插件配置中的冲突端口；之后依次读取插件配置、环境变量和默认值。守护进程监听端口被占用时，会按 `AGENT_BRIDGE_FALLBACK_PORTS` 或系统临时端口回退，并在启动日志中报告实际端口。豆包和 WorkBuddy 分别使用 `DOUBAO_CDP_PORT`、`WORKBUDDY_CDP_PORT`，也支持对应的 `AGENT_BRIDGE_*_CDP_PORT`。
 
 ## 自检与运行
 

package/dist/src-ts/cli.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = require("node:path");
 const node_http_1 = require("node:http");
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
@@ -70,8 +71,17 @@ async function selfTest(task) {
         console.error(`session=${response.sessionId}`);
     return 0;
 }
+async function daemonPort() {
+    try {
+        const address = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(stateDirectory(), "daemon-address.json"), "utf8"));
+        if (Number.isInteger(address.port) && address.port > 0)
+            return address.port;
+    }
+    catch { /* 后台未写入地址时使用配置端口 */ }
+    return Number(process.env.AGENT_BRIDGE_PORT ?? "26107");
+}
 async function pair() {
-    const port = Number(process.env.AGENT_BRIDGE_PORT ?? "26107");
+    const port = await daemonPort();
     const result = await new Promise((resolve, reject) => {
         const req = (0, node_http_1.request)({ host: "127.0.0.1", port, path: "/api/pair-code", method: "GET" }, (res) => {
             let body = "";
@@ -110,7 +120,7 @@ async function update() {
     return 0;
 }
 async function status() {
-    const port = Number(process.env.AGENT_BRIDGE_PORT ?? "26107");
+    const port = await daemonPort();
     const get = (path) => new Promise((resolve, reject) => {
         const req = (0, node_http_1.request)({ host: "127.0.0.1", port, path, method: "GET" }, (res) => {
             let body = "";
@@ -169,8 +179,14 @@ async function serve() {
     if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1" && !process.env.AGENT_BRIDGE_TOKEN) {
         throw new Error("局域网监听必须设置 AGENT_BRIDGE_TOKEN");
     }
-    const server = new control_server_1.ControlServer({ manager, host, port, token: process.env.AGENT_BRIDGE_TOKEN });
+    const fallbackPorts = (process.env.AGENT_BRIDGE_FALLBACK_PORTS ?? "").split(",").map((value) => Number(value.trim())).filter((value) => Number.isInteger(value) && value >= 0);
+    if (port > 0 && !fallbackPorts.length)
+        fallbackPorts.push(0);
+    const server = new control_server_1.ControlServer({ manager, host, port, fallbackPorts, token: process.env.AGENT_BRIDGE_TOKEN });
     const address = await server.start();
+    const addressFile = (0, node_path_1.resolve)(stateDirectory(), "daemon-address.json");
+    await (0, promises_1.mkdir)(stateDirectory(), { recursive: true });
+    await (0, promises_1.writeFile)(addressFile, JSON.stringify({ host: address.host, port: address.port, pid: process.pid }));
     logger.info(`daemon listening on http://${address.host}:${address.port}`);
     const order = ["abweb", ...manager.list().map((plugin) => plugin.id).filter((id) => id !== "abweb")];
     for (const id of order) {
@@ -199,6 +215,12 @@ async function serve() {
             }
         }
         await server.stop();
+        try {
+            const address = JSON.parse(await (0, promises_1.readFile)(addressFile, "utf8"));
+            if (address.pid === process.pid)
+                await (0, promises_1.rm)(addressFile, { force: true });
+        }
+        catch { /* 地址文件可能已被清理 */ }
         clearInterval(updateTimer);
     };
     process.once("SIGINT", () => void shutdown().finally(() => process.exit(0)));

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

@@ -22,8 +22,36 @@ class ControlServer {
         this.options = options;
         this.server = (0, node_http_1.createServer)((req, res) => { void this.handle(req, res); });
     }
-    async start() { return new Promise((resolve, reject) => { const host = this.options.host ?? "127.0.0.1"; this.server.once("error", reject); this.server.listen(this.options.port ?? 0, host, () => { this.server.removeListener("error", reject); const info = this.server.address(); if (!info || typeof info === "string")
-        return reject(new Error("failed to bind control server")); this.address = { host, port: info.port }; resolve(this.address); }); }); }
+    async start() {
+        const host = this.options.host ?? "127.0.0.1";
+        const candidates = [this.options.port ?? 0, ...(this.options.fallbackPorts ?? [])];
+        for (const port of candidates) {
+            try {
+                const address = await new Promise((resolve, reject) => {
+                    const onError = (error) => { this.server.removeListener("listening", onListening); reject(error); };
+                    const onListening = () => {
+                        this.server.removeListener("error", onError);
+                        const info = this.server.address();
+                        if (!info || typeof info === "string") {
+                            reject(new Error("后台监听地址无效"));
+                            return;
+                        }
+                        resolve({ host, port: info.port });
+                    };
+                    this.server.once("error", onError);
+                    this.server.once("listening", onListening);
+                    this.server.listen(port, host);
+                });
+                this.address = address;
+                return address;
+            }
+            catch (error) {
+                if (error.code !== "EADDRINUSE" || port === candidates.at(-1))
+                    throw error;
+            }
+        }
+        throw new Error("后台监听失败");
+    }
     async stop() { if (!this.server.listening)
         return; await new Promise((resolve, reject) => this.server.close((error) => error ? reject(error) : resolve())); }
     async handle(req, res) {
@@ -82,9 +110,27 @@ class ControlServer {
             if (method === "POST" && url.pathname === "/api/update") {
                 this.options.manager.log("info", "已请求后台升级，准备重启 daemon", undefined, "后台升级");
                 if (process.platform === "win32") {
-                    const script = "$ErrorActionPreference='Continue'; Start-Sleep -Seconds 2; schtasks.exe /End /TN mab | Out-Null; npm.cmd install -g mu-agent-bridge@latest --no-fund --no-audit; schtasks.exe /Run /TN mab | Out-Null";
-                    const child = (0, node_child_process_1.spawn)("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], { detached: true, stdio: "ignore", windowsHide: true });
-                    child.unref();
+                    const logFile = `${process.env.APPDATA ?? process.cwd()}\\agent-bridge\\state\\core-update.log`;
+                    const script = [
+                        "$ErrorActionPreference='Continue'",
+                        `$log = '${logFile.replace(/'/g, "''")}'`,
+                        "$dir = Split-Path -Parent $log",
+                        "New-Item -ItemType Directory -Force $dir | Out-Null",
+                        "function Write-UpdateLog($text) { \"$(Get-Date -Format o) $text\" | Out-File -FilePath $log -Append -Encoding utf8 }",
+                        "Start-Sleep -Seconds 3",
+                        "Write-UpdateLog '停止旧 daemon'",
+                        "schtasks.exe /End /TN mab 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
+                        "Start-Sleep -Seconds 2",
+                        "Write-UpdateLog '开始安装 mu-agent-bridge@latest'",
+                        "npm.cmd install -g mu-agent-bridge@latest --no-fund --no-audit 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
+                        "Write-UpdateLog '重新启动 mab 计划任务'",
+                        "schtasks.exe /Run /TN mab 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
+                        "Write-UpdateLog '后台升级脚本结束'",
+                    ].join('; ');
+                    setTimeout(() => {
+                        const child = (0, node_child_process_1.spawn)("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], { detached: true, stdio: "ignore", windowsHide: true });
+                        child.unref();
+                    }, 1500).unref();
                 }
                 else {
                     return this.json(res, 501, { error: "当前平台未配置后台升级器" });

package/dist/src-ts/llprobe-qwen-bridge.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const node_http_1 = require("node:http");
 const node_crypto_1 = require("node:crypto");
-const PORT = Number(process.env.QWEN_CDP_PORT ?? '9226');
+const PORT = Number(process.env.QWEN_CDP_PORT ?? '9228');
 const SUBCHAT = process.env.QWEN_SUBCHAT ?? 'muj55ep9426gudjw';
 const CHAT = process.env.QWEN_CHAT ?? 'muj55ep9u6wbv0eo';
 const CWD = process.env.QWEN_WORKSPACE ?? `${process.env.APPDATA ?? ''}\\QwenWorkCN\\workspace`;

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

@@ -138,8 +138,11 @@ class PluginManager {
         this.log("info", `开始升级插件：${id}`, { packageName, version }, "插件升级");
         await (0, promises_1.mkdir)(staging, { recursive: true });
         try {
-            if (!cached)
-                await this.downloadPackage(packageName, version).then((downloaded) => (0, promises_1.rename)(downloaded, staging));
+            if (!cached) {
+                const downloaded = await this.downloadPackage(packageName, version);
+                await (0, promises_1.cp)(downloaded, staging, { recursive: true, force: true });
+                await (0, promises_1.rm)(downloaded, { recursive: true, force: true });
+            }
             const candidate = (0, node_path_1.join)(staging, "node_modules", packageName);
             const meta = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(candidate, "package.json"), "utf8"));
             if (meta.name !== packageName || !meta.version || (version && meta.version !== version))
@@ -307,6 +310,11 @@ class PluginManager {
                         }
                     },
                 },
+                runtime: { ports: {
+                        qwenwork: Number(process.env.AGENT_BRIDGE_QWEN_CDP_PORT ?? process.env.QWEN_CDP_PORT ?? "9228"),
+                        doubao: Number(process.env.AGENT_BRIDGE_DOUBAO_CDP_PORT ?? process.env.DOUBAO_CDP_PORT ?? "9227"),
+                        workbuddy: Number(process.env.AGENT_BRIDGE_WORKBUDDY_CDP_PORT ?? process.env.WORKBUDDY_CDP_PORT ?? "9229"),
+                    } },
             });
             loaded.instance = instance;
             loaded.record.status = "ready";

package/dist/src-ts/plugin.js

@@ -1,2 +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,304 @@
+"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");
+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));
+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 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,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatgptCdpClient = exports.ChatgptPlugin = exports.chatgptManifest = void 0;
+const cdp_client_1 = require("./cdp-client");
+exports.chatgptManifest = {
+    id: "chatgpt",
+    version: "1.0.0",
+    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();
+    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.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);
+            throw error;
+        }
+    }
+    async deactivate() {
+        await this.queue;
+        this.client?.close();
+        this.client = undefined;
+        this.remote = false;
+    }
+    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 } };
+    }
+    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));
+        this.queue = run.then(() => undefined, () => undefined);
+        return { text: await run, sessionId: request.sessionId };
+    }
+}
+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/doubao/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoubaoPlugin = exports.doubaoManifest = void 0;
 const cdp_client_1 = require("./cdp-client");
+const plugin_1 = require("../../plugin");
 exports.doubaoManifest = {
     id: "doubao",
     version: "1.0.4",
@@ -24,7 +25,7 @@ class DoubaoPlugin {
     disposer;
     async activate(context) {
         this.client = this.injectedClient ?? new cdp_client_1.DoubaoCdpClient({
-            port: typeof context.config.cdpPort === "number" ? context.config.cdpPort : undefined,
+            port: (0, plugin_1.resolveRuntimePort)(context.config, context.runtime, "doubao", "DOUBAO_CDP_PORT", 9227),
             conversationId: typeof context.config.conversationId === "string" ? context.config.conversationId : undefined,
             botId: typeof context.config.botId === "string" ? context.config.botId : undefined,
             pluginList: Array.isArray(context.config.pluginList) ? context.config.pluginList.filter((value) => typeof value === "string") : undefined,

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

@@ -27,7 +27,7 @@ class QwenCdpClient {
     options;
     constructor(options = {}) {
         this.options = {
-            port: options.port ?? Number(process.env.QWEN_CDP_PORT ?? "9226"),
+            port: options.port ?? Number(process.env.QWEN_CDP_PORT ?? "9228"),
             subChatId: options.subChatId ?? process.env.QWEN_SUBCHAT ?? "muj55ep9426gudjw",
             chatId: options.chatId ?? process.env.QWEN_CHAT ?? "muj55ep9u6wbv0eo",
             workspace: options.workspace ?? `${process.env.APPDATA ?? ""}\\QwenWorkCN\\workspace`,