qq-codex-bridge 0.1.0

package/dist/apps/bridge-daemon/src/http-server.js

@@ -0,0 +1,36 @@
+import { createServer } from "node:http";
+export function createQqWebhookServer(deps) {
+    return createServer(async (request, response) => {
+        if (request.url !== deps.webhookPath) {
+            response.statusCode = 404;
+            response.end("not found");
+            return;
+        }
+        if (request.method !== "POST") {
+            response.statusCode = 405;
+            response.end("method not allowed");
+            return;
+        }
+        const chunks = [];
+        for await (const chunk of request) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        let payload;
+        try {
+            payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch (error) {
+            response.statusCode = 400;
+            response.end(error instanceof Error ? error.message : "invalid request");
+            return;
+        }
+        Promise.resolve()
+            .then(() => deps.ingress.dispatchPayload(payload))
+            .catch((error) => {
+            const normalized = error instanceof Error ? error : new Error(typeof error === "string" ? error : "dispatch failed");
+            deps.onDispatchError?.(normalized, payload);
+        });
+        response.statusCode = 202;
+        response.end("accepted");
+    });
+}

package/dist/apps/bridge-daemon/src/main.js

@@ -0,0 +1,57 @@
+import { pathToFileURL } from "node:url";
+import { bootstrap } from "./bootstrap.js";
+import { ThreadCommandHandler } from "./thread-command-handler.js";
+export function createIngressMessageHandler(deps) {
+    return async (message) => {
+        try {
+            const handled = await deps.threadCommandHandler.handleIfCommand(message);
+            if (handled) {
+                return;
+            }
+            await deps.orchestrator.handleInbound(message);
+        }
+        catch (error) {
+            console.error("[qq-codex-bridge] message handling failed", {
+                messageId: message.messageId,
+                sessionKey: message.sessionKey,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            if (error instanceof Error && error.stack) {
+                console.error("  stack:", error.stack);
+            }
+        }
+    };
+}
+export async function runBridgeDaemon() {
+    const app = bootstrap();
+    const threadCommandHandler = new ThreadCommandHandler({
+        sessionStore: app.sessionStore,
+        transcriptStore: app.transcriptStore,
+        desktopDriver: app.adapters.codexDesktop,
+        qqEgress: app.adapters.qq.egress
+    });
+    await app.adapters.qq.ingress.onMessage(createIngressMessageHandler({
+        threadCommandHandler,
+        orchestrator: app.orchestrator
+    }));
+    await app.adapters.qq.ingress.start();
+    console.log("[qq-codex-bridge] ready", {
+        transport: "qq-gateway-websocket",
+        accountKey: "qqbot:default"
+    });
+}
+function handleFatal(error) {
+    const cause = error instanceof Error ? error.cause : undefined;
+    console.error("[qq-codex-bridge] fatal:", error instanceof Error ? error.message : String(error));
+    if (cause !== undefined) {
+        console.error("  caused by:", cause);
+    }
+    if (error instanceof Error && error.stack) {
+        console.error("  stack:", error.stack);
+    }
+    process.exitCode = 1;
+}
+const entrypoint = process.argv[1];
+if (entrypoint && import.meta.url === pathToFileURL(entrypoint).href) {
+    runBridgeDaemon().catch(handleFatal);
+}

package/dist/apps/bridge-daemon/src/thread-command-handler.js

@@ -0,0 +1,197 @@
+import { randomUUID } from "node:crypto";
+import { BridgeSessionStatus } from "../../../packages/domain/src/session.js";
+import { DesktopDriverError } from "../../../packages/domain/src/driver.js";
+export class ThreadCommandHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async handleIfCommand(message) {
+        if (message.chatType !== "c2c") {
+            return false;
+        }
+        const text = message.text.trim();
+        if (!this.isSupportedCommand(text)) {
+            return false;
+        }
+        const alreadySeen = await this.deps.transcriptStore.hasInbound(message.messageId);
+        if (alreadySeen) {
+            return true;
+        }
+        await this.deps.sessionStore.withSessionLock(message.sessionKey, async () => {
+            const seenInsideLock = await this.deps.transcriptStore.hasInbound(message.messageId);
+            if (seenInsideLock) {
+                return;
+            }
+            await this.ensureSessionExists(message);
+            await this.deps.transcriptStore.recordInbound(message);
+            if (text === "/threads" || text === "/t") {
+                const threads = await this.deps.desktopDriver.listRecentThreads(20);
+                await this.deliverControlReply(message, this.formatThreads(threads));
+                return;
+            }
+            if (text === "/thread current" || text === "/tc") {
+                const session = await this.deps.sessionStore.getSession(message.sessionKey);
+                const threads = await this.deps.desktopDriver.listRecentThreads(20);
+                const current = threads.find((thread) => thread.threadRef === session?.codexThreadRef)
+                    ?? threads.find((thread) => thread.isCurrent)
+                    ?? null;
+                const reply = current
+                    ? `当前绑定线程：${current.title}${current.projectName ? `\n项目：${current.projectName}` : ""}${current.relativeTime ? `\n最近活动：${current.relativeTime}` : ""}`
+                    : "当前私聊还没有绑定线程。";
+                await this.deliverControlReply(message, reply);
+                return;
+            }
+            if (text === "/help") {
+                await this.deliverControlReply(message, this.buildHelpText());
+                return;
+            }
+            const useMatch = text.match(/^(?:\/thread\s+use|\/tu)\s+(\d+)$/);
+            if (useMatch) {
+                const index = Number(useMatch[1]);
+                const threads = await this.deps.desktopDriver.listRecentThreads(20);
+                const thread = threads[index - 1];
+                if (!thread) {
+                    await this.deliverControlReply(message, `没有第 ${index} 个线程。请先发送 /threads 查看列表。`);
+                    return;
+                }
+                let binding;
+                try {
+                    binding = await this.deps.desktopDriver.switchToThread(message.sessionKey, thread.threadRef);
+                }
+                catch (error) {
+                    if (error instanceof DesktopDriverError && error.reason === "session_not_found") {
+                        await this.deliverControlReply(message, `切换失败：没有在当前 Codex 侧边栏里找到这个线程。\n请先发送 /t 刷新列表后重试。`);
+                        return;
+                    }
+                    throw error;
+                }
+                await this.deps.sessionStore.updateBinding(message.sessionKey, binding.codexThreadRef);
+                await this.deliverControlReply(message, `已切换到线程：${thread.title}${thread.projectName ? `\n项目：${thread.projectName}` : ""}`);
+                return;
+            }
+            const newMatch = text.match(/^(?:\/thread\s+new|\/tn)\s+(.+)$/);
+            if (newMatch) {
+                const title = newMatch[1].trim();
+                const binding = await this.deps.desktopDriver.createThread(message.sessionKey, this.buildNewThreadSeedPrompt(title));
+                await this.deps.sessionStore.updateBinding(message.sessionKey, binding.codexThreadRef);
+                await this.deliverControlReply(message, `已创建并切换到新线程：${title}`);
+                return;
+            }
+            const forkMatch = text.match(/^(?:\/thread\s+fork|\/tf)\s+(.+)$/);
+            if (forkMatch) {
+                const title = forkMatch[1].trim();
+                const recentConversation = await this.deps.transcriptStore.listRecentConversation(message.sessionKey, 8);
+                const binding = await this.deps.desktopDriver.createThread(message.sessionKey, this.buildForkThreadSeedPrompt(title, recentConversation));
+                await this.deps.sessionStore.updateBinding(message.sessionKey, binding.codexThreadRef);
+                await this.deliverControlReply(message, `已根据最近几轮对话 fork 新线程：${title}`);
+                return;
+            }
+            await this.deliverControlReply(message, this.buildHelpText());
+        });
+        return true;
+    }
+    async ensureSessionExists(message) {
+        const existing = await this.deps.sessionStore.getSession(message.sessionKey);
+        if (existing) {
+            return;
+        }
+        const created = {
+            sessionKey: message.sessionKey,
+            accountKey: message.accountKey,
+            peerKey: message.peerKey,
+            chatType: message.chatType,
+            peerId: message.senderId,
+            codexThreadRef: null,
+            skillContextKey: null,
+            status: BridgeSessionStatus.Active,
+            lastInboundAt: message.receivedAt,
+            lastOutboundAt: null,
+            lastError: null
+        };
+        await this.deps.sessionStore.createSession(created);
+    }
+    isSupportedCommand(text) {
+        return (text === "/threads" ||
+            text === "/t" ||
+            text === "/thread current" ||
+            text === "/tc" ||
+            text === "/help" ||
+            /^\/thread\s+use\s+\d+$/.test(text) ||
+            /^\/tu\s+\d+$/.test(text) ||
+            /^\/thread\s+new\s+.+$/.test(text) ||
+            /^\/tn\s+.+$/.test(text) ||
+            /^\/thread\s+fork\s+.+$/.test(text) ||
+            /^\/tf\s+.+$/.test(text) ||
+            text === "/thread");
+    }
+    formatThreads(threads) {
+        if (threads.length === 0) {
+            return "当前没有可用的 Codex 线程。";
+        }
+        const escapeCell = (value) => (value ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ").trim();
+        return [
+            "最近 20 条最近有消息活动的 Codex 线程：",
+            "",
+            "| 序号 | 项目 | 线程标题 | 最近活动 |",
+            "| --- | --- | --- | --- |",
+            ...threads.map((thread) => {
+                const index = thread.isCurrent ? `→ ${thread.index}` : `${thread.index}`;
+                const project = escapeCell(thread.projectName) || "-";
+                const title = escapeCell(thread.title) || "-";
+                const time = escapeCell(thread.relativeTime) || "-";
+                return `| ${index} | ${project} | ${title} | ${time} |`;
+            })
+        ].join("\n");
+    }
+    async deliverControlReply(message, text) {
+        const draft = {
+            draftId: randomUUID(),
+            sessionKey: message.sessionKey,
+            text,
+            createdAt: new Date().toISOString(),
+            replyToMessageId: message.messageId
+        };
+        await this.deps.transcriptStore.recordOutbound(draft);
+        await this.deps.qqEgress.deliver(draft);
+    }
+    buildHelpText() {
+        return [
+            "线程管理命令：",
+            "",
+            "| 用途 | 完整命令 | 简写 |",
+            "| --- | --- | --- |",
+            "| 查看最近活跃线程 | `/threads` | `/t` |",
+            "| 查看当前绑定线程 | `/thread current` | `/tc` |",
+            "| 切换到指定线程 | `/thread use <序号>` | `/tu <序号>` |",
+            "| 新建线程 | `/thread new <标题>` | `/tn <标题>` |",
+            "| 基于最近对话 fork 线程 | `/thread fork <标题>` | `/tf <标题>` |",
+            "",
+            "建议先发 `/t` 看列表，再用 `/tu 2` 这种方式切换。"
+        ].join("\n");
+    }
+    buildNewThreadSeedPrompt(title) {
+        return [
+            `线程标题：${title}`,
+            "",
+            "这是一个刚创建的新线程。",
+            "请把上面的标题视为本线程主题。",
+            "现在无需展开分析，只需理解上下文并等待我的下一条消息。"
+        ].join("\n");
+    }
+    buildForkThreadSeedPrompt(title, entries) {
+        const summaryLines = entries.map((entry) => {
+            const speaker = entry.direction === "inbound" ? "用户" : "助手";
+            return `- ${speaker}：${entry.text}`;
+        });
+        return [
+            `线程标题：${title}`,
+            "",
+            "这是从另一个 QQ 私聊会话中 fork 出来的新线程。",
+            "以下是最近几轮 QQ 对话摘要，请把它们作为本线程的起始上下文：",
+            ...(summaryLines.length > 0 ? summaryLines : ["- 暂无可用对话摘要"]),
+            "",
+            "请理解上下文，等待我的下一条消息。"
+        ].join("\n");
+    }
+}

package/dist/packages/adapters/codex-desktop/src/cdp-session.js

@@ -0,0 +1,189 @@
+import WebSocket from "ws";
+export class CdpSession {
+    config;
+    fetchFn;
+    connection = null;
+    browserSocket = null;
+    browserSocketPromise = null;
+    nextCommandId = 1;
+    pendingCommands = new Map();
+    attachedSessions = new Map();
+    constructor(config, options = {}) {
+        this.config = config;
+        this.fetchFn = options.fetchFn ?? fetch;
+    }
+    async connect() {
+        if (this.connection) {
+            return this.connection;
+        }
+        const response = await this.fetchFn(`http://127.0.0.1:${this.config.remoteDebuggingPort}/json/version`);
+        if (!response.ok) {
+            throw new Error(`CDP connect failed: ${response.status}`);
+        }
+        const payload = (await response.json());
+        if (!payload.webSocketDebuggerUrl) {
+            throw new Error("CDP version response missing webSocketDebuggerUrl");
+        }
+        this.connection = {
+            appName: this.config.appName,
+            browserVersion: payload.Browser ?? "unknown",
+            browserWebSocketUrl: payload.webSocketDebuggerUrl
+        };
+        return this.connection;
+    }
+    getBrowserWebSocketUrl() {
+        return this.connection?.browserWebSocketUrl ?? null;
+    }
+    async listTargets() {
+        const response = await this.fetchFn(`http://127.0.0.1:${this.config.remoteDebuggingPort}/json/list`);
+        if (!response.ok) {
+            throw new Error(`CDP target listing failed: ${response.status}`);
+        }
+        const payload = (await response.json());
+        return payload.map((target) => ({
+            id: target.id ?? "",
+            title: target.title ?? "",
+            type: target.type ?? "unknown",
+            url: target.url ?? ""
+        }));
+    }
+    async evaluateOnPage(expression, targetId) {
+        const target = await this.resolvePageTarget(targetId);
+        const sessionId = await this.attachToTarget(target.id);
+        const payload = (await this.sendCommand("Runtime.evaluate", {
+            expression,
+            returnByValue: true,
+            awaitPromise: true
+        }, sessionId));
+        if (payload.exceptionDetails) {
+            const detail = payload.exceptionDetails.exception?.description ||
+                payload.exceptionDetails.text ||
+                "unknown runtime exception";
+            throw new Error(`CDP runtime evaluation failed: ${detail}`);
+        }
+        return payload.result?.value;
+    }
+    async insertText(text, targetId) {
+        const target = await this.resolvePageTarget(targetId);
+        const sessionId = await this.attachToTarget(target.id);
+        await this.sendCommand("Input.insertText", {
+            text
+        }, sessionId);
+    }
+    async dispatchKeyEvent(event, targetId) {
+        const target = await this.resolvePageTarget(targetId);
+        const sessionId = await this.attachToTarget(target.id);
+        await this.sendCommand("Input.dispatchKeyEvent", event, sessionId);
+    }
+    async resolvePageTarget(targetId) {
+        const targets = await this.listTargets();
+        if (targetId) {
+            const target = targets.find((candidate) => candidate.id === targetId);
+            if (!target) {
+                throw new Error(`CDP target not found: ${targetId}`);
+            }
+            return target;
+        }
+        const pageTarget = targets.find((candidate) => candidate.type === "page");
+        if (!pageTarget) {
+            throw new Error("CDP target listing did not include a page target");
+        }
+        return pageTarget;
+    }
+    async attachToTarget(targetId) {
+        const cachedSessionId = this.attachedSessions.get(targetId);
+        if (cachedSessionId) {
+            return cachedSessionId;
+        }
+        const payload = (await this.sendCommand("Target.attachToTarget", {
+            targetId,
+            flatten: true
+        }));
+        if (!payload.sessionId) {
+            throw new Error(`CDP attach failed for target ${targetId}`);
+        }
+        this.attachedSessions.set(targetId, payload.sessionId);
+        return payload.sessionId;
+    }
+    async sendCommand(method, params, sessionId) {
+        const socket = await this.getBrowserSocket();
+        const id = this.nextCommandId++;
+        return new Promise((resolve, reject) => {
+            this.pendingCommands.set(id, { resolve, reject });
+            const command = JSON.stringify({
+                id,
+                method,
+                params,
+                ...(sessionId ? { sessionId } : {})
+            });
+            socket.send(command, (error) => {
+                if (!error) {
+                    return;
+                }
+                this.pendingCommands.delete(id);
+                reject(error);
+            });
+        });
+    }
+    async getBrowserSocket() {
+        if (this.browserSocket) {
+            return this.browserSocket;
+        }
+        if (this.browserSocketPromise) {
+            return this.browserSocketPromise;
+        }
+        this.browserSocketPromise = this.connectBrowserSocket();
+        return this.browserSocketPromise;
+    }
+    async connectBrowserSocket() {
+        const connection = await this.connect();
+        return new Promise((resolve, reject) => {
+            const socket = new WebSocket(connection.browserWebSocketUrl);
+            const cleanup = () => {
+                socket.off("open", handleOpen);
+                socket.off("error", handleError);
+            };
+            const handleOpen = () => {
+                cleanup();
+                this.browserSocket = socket;
+                this.browserSocketPromise = null;
+                socket.on("message", (payload) => {
+                    this.handleSocketMessage(payload.toString());
+                });
+                socket.on("close", () => {
+                    this.browserSocket = null;
+                    this.attachedSessions.clear();
+                    const pending = Array.from(this.pendingCommands.values());
+                    this.pendingCommands.clear();
+                    for (const command of pending) {
+                        command.reject(new Error("CDP browser websocket closed"));
+                    }
+                });
+                resolve(socket);
+            };
+            const handleError = (error) => {
+                cleanup();
+                this.browserSocketPromise = null;
+                reject(error);
+            };
+            socket.once("open", handleOpen);
+            socket.once("error", handleError);
+        });
+    }
+    handleSocketMessage(payload) {
+        const message = JSON.parse(payload);
+        if (typeof message.id !== "number") {
+            return;
+        }
+        const pending = this.pendingCommands.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.pendingCommands.delete(message.id);
+        if (message.error) {
+            pending.reject(new Error(message.error.message ?? "CDP command failed"));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+}