agent-bridge-chatgpt 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,31 @@
-# 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 页面。

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/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/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.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"}}

package/plugin.json

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