qq-codex-bridge 0.1.0

package/dist/packages/adapters/codex-desktop/src/composer-heuristics.js

@@ -0,0 +1,11 @@
+export function isLikelyComposerSubmitButton(candidate) {
+    const explicitSendLabel = /send|发送|submit|开始构建|构建|继续|resume|run/i;
+    const primaryComposerButtonClass = /\bsize-token-button-composer\b/i;
+    const filledPrimaryButtonClass = /\bbg-token-foreground\b/i;
+    const label = `${candidate.text} ${candidate.aria ?? ""} ${candidate.title ?? ""}`.trim();
+    if (explicitSendLabel.test(label)) {
+        return true;
+    }
+    return (primaryComposerButtonClass.test(candidate.className) &&
+        filledPrimaryButtonClass.test(candidate.className));
+}

package/dist/packages/adapters/codex-desktop/src/health.js

@@ -0,0 +1,7 @@
+import fs from "node:fs";
+import path from "node:path";
+export function ensureArtifactDir(baseDir) {
+    const artifactDir = path.join(baseDir, "artifacts", "desktop-driver");
+    fs.mkdirSync(artifactDir, { recursive: true });
+    return artifactDir;
+}

package/dist/packages/adapters/codex-desktop/src/reply-parser.js

@@ -0,0 +1,10 @@
+export function parseAssistantReply(snapshotText) {
+    const lines = snapshotText
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const assistantLines = lines
+        .filter((line) => line.startsWith("Assistant:"))
+        .map((line) => line.replace(/^Assistant:\s*/, ""));
+    return assistantLines.at(-1) ?? "";
+}

package/dist/packages/adapters/qq/src/qq-api-client.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { MediaArtifactKind } from "../../../domain/src/message.js";
+export class QqApiClient {
+    appId;
+    clientSecret;
+    authBaseUrl;
+    apiBaseUrl;
+    fetchFn;
+    now;
+    markdownSupport;
+    cachedToken = null;
+    msgSeqByReplyId = new Map();
+    constructor(appId, clientSecret, options = {}) {
+        this.appId = appId;
+        this.clientSecret = clientSecret;
+        this.authBaseUrl = options.authBaseUrl ?? "https://bots.qq.com";
+        this.apiBaseUrl = options.apiBaseUrl ?? "https://api.sgroup.qq.com";
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.now = options.now ?? Date.now;
+        this.markdownSupport = options.markdownSupport ?? false;
+    }
+    async getAccessToken() {
+        if (this.cachedToken && this.cachedToken.expiresAt > this.now()) {
+            return this.cachedToken.value;
+        }
+        const response = await this.fetchFn(`${this.authBaseUrl}/app/getAppAccessToken`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                appId: this.appId,
+                clientSecret: this.clientSecret
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`QQ auth failed: ${response.status}`);
+        }
+        const payload = (await response.json());
+        const expiresIn = typeof payload.expires_in === "number"
+            ? payload.expires_in
+            : typeof payload.expires_in === "string"
+                ? Number(payload.expires_in)
+                : Number.NaN;
+        if (!payload.access_token || !Number.isFinite(expiresIn) || expiresIn <= 0) {
+            throw new Error("QQ auth response missing access token");
+        }
+        this.cachedToken = {
+            value: payload.access_token,
+            expiresAt: this.now() + Math.max(expiresIn - 60, 1) * 1000
+        };
+        return payload.access_token;
+    }
+    invalidateAccessToken() {
+        this.cachedToken = null;
+    }
+    async getGatewayUrl() {
+        const accessToken = await this.getAccessToken();
+        const response = await this.fetchFn(`${this.apiBaseUrl}/gateway`, {
+            method: "GET",
+            headers: {
+                authorization: `QQBot ${accessToken}`,
+                "content-type": "application/json"
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`QQ gateway discovery failed: ${response.status}`);
+        }
+        const payload = (await response.json());
+        if (!payload.url) {
+            throw new Error("QQ gateway response missing websocket url");
+        }
+        return payload.url;
+    }
+    async sendC2CMessage(userOpenId, content, msgId, options = {}) {
+        return this.sendMessage(`/v2/users/${encodeURIComponent(userOpenId)}/messages`, content, msgId, options);
+    }
+    async sendGroupMessage(groupOpenId, content, msgId, options = {}) {
+        return this.sendMessage(`/v2/groups/${encodeURIComponent(groupOpenId)}/messages`, content, msgId, options);
+    }
+    async sendC2CMediaArtifact(userOpenId, artifact, msgId, content) {
+        return this.sendMediaArtifact(`/v2/users/${encodeURIComponent(userOpenId)}`, artifact, msgId, content);
+    }
+    async sendGroupMediaArtifact(groupOpenId, artifact, msgId, content) {
+        return this.sendMediaArtifact(`/v2/groups/${encodeURIComponent(groupOpenId)}`, artifact, msgId, content);
+    }
+    async sendMessage(path, content, msgId, options = {}) {
+        const accessToken = await this.getAccessToken();
+        const response = await this.fetchFn(`${this.apiBaseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                authorization: `QQBot ${accessToken}`,
+                "content-type": "application/json",
+                "X-Union-Appid": this.appId
+            },
+            body: JSON.stringify(this.buildMessageBody(content, msgId, options))
+        });
+        if (!response.ok) {
+            const responseText = await response.text().catch(() => "");
+            throw new Error(`QQ message send failed: ${response.status}${responseText ? ` ${responseText}` : ""}`);
+        }
+        const payload = (await response.json());
+        return payload.id ?? null;
+    }
+    async sendMediaArtifact(pathPrefix, artifact, msgId, content) {
+        this.assertSupportedMediaFormat(artifact);
+        const accessToken = await this.getAccessToken();
+        const uploadBody = await this.buildMediaUploadBody(artifact);
+        const uploadResponse = await this.fetchFn(`${this.apiBaseUrl}${pathPrefix}/files`, {
+            method: "POST",
+            headers: {
+                authorization: `QQBot ${accessToken}`,
+                "content-type": "application/json",
+                "X-Union-Appid": this.appId
+            },
+            body: JSON.stringify({
+                ...uploadBody,
+                file_type: this.mapMediaFileType(artifact.kind),
+                srv_send_msg: false,
+                ...(artifact.kind === MediaArtifactKind.File ? { file_name: artifact.originalName } : {})
+            })
+        });
+        if (!uploadResponse.ok) {
+            const responseText = await uploadResponse.text().catch(() => "");
+            throw new Error(`QQ media upload failed: ${uploadResponse.status}${responseText ? ` ${responseText}` : ""}`);
+        }
+        const uploadPayload = (await uploadResponse.json());
+        if (!uploadPayload.file_info) {
+            throw new Error("QQ media upload response missing file_info");
+        }
+        const response = await this.fetchFn(`${this.apiBaseUrl}${pathPrefix}/messages`, {
+            method: "POST",
+            headers: {
+                authorization: `QQBot ${accessToken}`,
+                "content-type": "application/json",
+                "X-Union-Appid": this.appId
+            },
+            body: JSON.stringify({
+                msg_type: 7,
+                media: { file_info: uploadPayload.file_info },
+                msg_seq: this.nextMsgSeq(msgId),
+                msg_id: msgId,
+                ...(content ? { content } : {})
+            })
+        });
+        if (!response.ok) {
+            const responseText = await response.text().catch(() => "");
+            throw new Error(`QQ media message send failed: ${response.status}${responseText ? ` ${responseText}` : ""}`);
+        }
+        const payload = (await response.json());
+        return payload.id ?? null;
+    }
+    nextMsgSeq(msgId) {
+        const next = (this.msgSeqByReplyId.get(msgId) ?? 0) + 1;
+        this.msgSeqByReplyId.set(msgId, next);
+        return next;
+    }
+    buildMessageBody(content, msgId, options = {}) {
+        const msgSeq = this.nextMsgSeq(msgId);
+        const useMarkdown = this.markdownSupport || options.preferMarkdown === true;
+        if (useMarkdown) {
+            return {
+                markdown: { content },
+                msg_type: 2,
+                msg_seq: msgSeq,
+                msg_id: msgId
+            };
+        }
+        return {
+            content,
+            msg_type: 0,
+            msg_seq: msgSeq,
+            msg_id: msgId
+        };
+    }
+    async buildMediaUploadBody(artifact) {
+        if (artifact.sourceUrl.startsWith("http://") || artifact.sourceUrl.startsWith("https://")) {
+            return { url: artifact.sourceUrl };
+        }
+        if (existsSync(artifact.localPath)) {
+            const stat = statSync(artifact.localPath);
+            const limitBytes = this.getFileSizeLimitBytes(artifact.kind);
+            if (stat.size > limitBytes) {
+                const limitMb = (limitBytes / 1024 / 1024).toFixed(0);
+                const actualMb = (stat.size / 1024 / 1024).toFixed(1);
+                throw new Error(`QQ media upload size limit exceeded: file is ${actualMb}MB but QQ allows at most ${limitMb}MB for ${artifact.kind} (file: ${artifact.originalName})`);
+            }
+            return { file_data: readFileSync(artifact.localPath).toString("base64") };
+        }
+        throw new Error(`QQ media source not found: ${artifact.localPath}`);
+    }
+    getFileSizeLimitBytes(kind) {
+        switch (kind) {
+            case MediaArtifactKind.Image:
+                return 10 * 1024 * 1024; // 10 MB
+            case MediaArtifactKind.Video:
+                return 16 * 1024 * 1024; // 16 MB
+            case MediaArtifactKind.Audio:
+                return 16 * 1024 * 1024; // 16 MB
+            case MediaArtifactKind.File:
+            default:
+                return 30 * 1024 * 1024; // 30 MB
+        }
+    }
+    assertSupportedMediaFormat(artifact) {
+        const name = artifact.originalName || artifact.localPath || artifact.sourceUrl || "";
+        const ext = name.split(".").pop()?.toLowerCase() ?? "";
+        const SUPPORTED = {
+            [MediaArtifactKind.Image]: ["png", "jpg", "jpeg"],
+            [MediaArtifactKind.Video]: ["mp4"],
+            [MediaArtifactKind.Audio]: ["silk", "wav", "mp3", "flac"],
+            [MediaArtifactKind.File]: []
+        };
+        const allowed = SUPPORTED[artifact.kind];
+        if (allowed.length > 0 && !allowed.includes(ext)) {
+            throw new Error(`QQ media format not supported: .${ext} is not accepted for ${artifact.kind} (QQ only supports: ${allowed.join(", ")}). File: ${name}`);
+        }
+    }
+    mapMediaFileType(kind) {
+        switch (kind) {
+            case MediaArtifactKind.Image:
+                return 1;
+            case MediaArtifactKind.Video:
+                return 2;
+            case MediaArtifactKind.Audio:
+                return 3;
+            case MediaArtifactKind.File:
+            default:
+                return 4;
+        }
+    }
+}

package/dist/packages/adapters/qq/src/qq-channel-adapter.js

@@ -0,0 +1,22 @@
+import { QqGatewayClient } from "./qq-gateway-client.js";
+import { QqMediaDownloader } from "./qq-media-downloader.js";
+import { QqSender } from "./qq-sender.js";
+export function createQqChannelAdapter(config) {
+    return {
+        ingress: new QqGatewayClient({
+            accountKey: config.accountKey,
+            appId: config.appId,
+            apiClient: config.apiClient,
+            sessionStore: config.sessionStore,
+            ...(config.mediaDownloadDir
+                ? {
+                    mediaDownloader: new QqMediaDownloader({
+                        baseDir: config.mediaDownloadDir,
+                        stt: config.stt
+                    })
+                }
+                : {})
+        }),
+        egress: new QqSender(config.apiClient)
+    };
+}

package/dist/packages/adapters/qq/src/qq-gateway-client.js

@@ -0,0 +1,295 @@
+import WebSocket from "ws";
+import { QqGateway } from "./qq-gateway.js";
+const QQ_GATEWAY_INTENTS = (1 << 30) | // PUBLIC_GUILD_MESSAGES
+    (1 << 12) | // DIRECT_MESSAGE
+    (1 << 25) | // GROUP_AND_C2C
+    (1 << 26); // INTERACTION
+const DEFAULT_RECONNECT_DELAYS_MS = [1000, 2000, 5000, 10000, 30000, 60000];
+const RATE_LIMIT_DELAY_MS = 60000;
+export class QqGatewayClient {
+    config;
+    gateway;
+    reconnectDelaysMs;
+    socket = null;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    currentSession;
+    currentAccessToken = null;
+    reconnectAttempt = 0;
+    startingPromise = null;
+    started = false;
+    shouldInvalidateToken = false;
+    nextReconnectDelayMs = null;
+    constructor(config) {
+        this.config = config;
+        this.gateway = new QqGateway({
+            accountKey: config.accountKey,
+            mediaDownloader: config.mediaDownloader
+        });
+        this.reconnectDelaysMs = config.reconnectDelaysMs ?? DEFAULT_RECONNECT_DELAYS_MS;
+        this.currentSession = config.sessionStore.load();
+    }
+    async onMessage(handler) {
+        await this.gateway.onMessage(handler);
+    }
+    async start() {
+        this.started = true;
+        if (!this.startingPromise) {
+            this.startingPromise = this.connect().finally(() => {
+                this.startingPromise = null;
+            });
+        }
+        await this.startingPromise;
+    }
+    async stop() {
+        this.started = false;
+        this.clearHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        const socket = this.socket;
+        this.socket = null;
+        if (!socket) {
+            return;
+        }
+        await new Promise((resolve) => {
+            socket.once("close", () => resolve());
+            socket.close();
+            setTimeout(resolve, 100);
+        });
+    }
+    async connect() {
+        if (!this.started || this.socket) {
+            return;
+        }
+        if (this.shouldInvalidateToken) {
+            this.config.apiClient.invalidateAccessToken?.();
+            this.shouldInvalidateToken = false;
+        }
+        const accessToken = await this.config.apiClient.getAccessToken();
+        this.currentAccessToken = accessToken;
+        const gatewayUrl = await this.config.apiClient.getGatewayUrl();
+        const socket = new WebSocket(gatewayUrl);
+        socket.on("message", (payload) => {
+            void this.handleSocketMessage(socket, payload.toString());
+        });
+        socket.on("close", (code) => {
+            this.onSocketClosed(socket, code);
+        });
+        socket.on("error", (error) => {
+            console.error("[qq-codex-bridge] qq gateway socket error", { error });
+        });
+        await this.waitForSocketOpen(socket);
+        if (!this.started) {
+            socket.close();
+            return;
+        }
+        this.socket = socket;
+        this.reconnectAttempt = 0;
+    }
+    async waitForSocketOpen(socket) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                socket.off("open", handleOpen);
+                socket.off("error", handleError);
+            };
+            const handleOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const handleError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            socket.once("open", handleOpen);
+            socket.once("error", handleError);
+        });
+    }
+    async handleSocketMessage(socket, rawPayload) {
+        let payload;
+        try {
+            payload = JSON.parse(rawPayload);
+        }
+        catch (error) {
+            console.error("[qq-codex-bridge] qq gateway payload parse failed", { error, rawPayload });
+            return;
+        }
+        if (typeof payload.s === "number") {
+            this.updateLastSeq(payload.s);
+        }
+        switch (payload.op) {
+            case 10:
+                await this.handleHello(socket, payload);
+                return;
+            case 0:
+                await this.handleDispatch(payload);
+                return;
+            case 7:
+                this.nextReconnectDelayMs = 0;
+                socket.close();
+                return;
+            case 9:
+                if (payload.d !== true) {
+                    this.clearSession();
+                    this.shouldInvalidateToken = true;
+                }
+                this.nextReconnectDelayMs = 3000;
+                socket.close();
+                return;
+            case 11:
+                return;
+            default:
+                return;
+        }
+    }
+    async handleHello(socket, payload) {
+        const accessToken = this.currentAccessToken;
+        if (!accessToken) {
+            throw new Error("qq gateway access token not initialized");
+        }
+        const heartbeatInterval = this.readHeartbeatInterval(payload.d);
+        if (heartbeatInterval === null) {
+            throw new Error("qq gateway hello payload missing heartbeat interval");
+        }
+        if (this.currentSession) {
+            socket.send(JSON.stringify({
+                op: 6,
+                d: {
+                    token: `QQBot ${accessToken}`,
+                    session_id: this.currentSession.sessionId,
+                    seq: this.currentSession.lastSeq
+                }
+            }));
+        }
+        else {
+            socket.send(JSON.stringify({
+                op: 2,
+                d: {
+                    token: `QQBot ${accessToken}`,
+                    intents: QQ_GATEWAY_INTENTS,
+                    shard: [0, 1]
+                }
+            }));
+        }
+        this.startHeartbeat(heartbeatInterval);
+    }
+    async handleDispatch(payload) {
+        const dispatchData = this.readDispatchData(payload.d);
+        if (payload.t === "READY") {
+            const sessionId = typeof dispatchData?.session_id === "string" ? dispatchData.session_id : null;
+            if (sessionId) {
+                this.currentSession = {
+                    sessionId,
+                    lastSeq: payload.s ?? this.currentSession?.lastSeq ?? 0
+                };
+                this.config.sessionStore.save(this.currentSession);
+            }
+            return;
+        }
+        if (payload.t === "RESUMED") {
+            if (this.currentSession) {
+                this.config.sessionStore.save(this.currentSession);
+            }
+            return;
+        }
+        if (dispatchData
+            && (payload.t === "C2C_MESSAGE_CREATE"
+                || payload.t === "GROUP_AT_MESSAGE_CREATE"
+                || payload.t === "GROUP_MESSAGE_CREATE")) {
+            await this.gateway.dispatchPayload({
+                t: payload.t,
+                d: dispatchData
+            });
+        }
+    }
+    startHeartbeat(intervalMs) {
+        this.clearHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+                return;
+            }
+            this.socket.send(JSON.stringify({
+                op: 1,
+                d: this.currentSession?.lastSeq ?? null
+            }));
+        }, intervalMs);
+    }
+    clearHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    onSocketClosed(socket, code) {
+        if (this.socket !== socket) {
+            return;
+        }
+        this.socket = null;
+        this.clearHeartbeat();
+        if (!this.started) {
+            return;
+        }
+        let delay = this.nextReconnectDelayMs ?? this.reconnectDelaysMs[Math.min(this.reconnectAttempt, this.reconnectDelaysMs.length - 1)];
+        this.nextReconnectDelayMs = null;
+        if (code === 4914 || code === 4915) {
+            console.error("[qq-codex-bridge] qq gateway terminated permanently", { code });
+            this.started = false;
+            return;
+        }
+        if (code === 4004) {
+            this.shouldInvalidateToken = true;
+        }
+        else if (code === 4008) {
+            delay = RATE_LIMIT_DELAY_MS;
+        }
+        else if (code === 4006
+            || code === 4007
+            || code === 4009
+            || (code >= 4900 && code <= 4913)) {
+            this.clearSession();
+            this.shouldInvalidateToken = true;
+        }
+        this.scheduleReconnect(delay);
+    }
+    scheduleReconnect(delayMs) {
+        if (!this.started || this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.reconnectAttempt += 1;
+            void this.connect().catch((error) => {
+                console.error("[qq-codex-bridge] qq gateway reconnect failed", { error });
+                this.scheduleReconnect(this.reconnectDelaysMs[Math.min(this.reconnectAttempt, this.reconnectDelaysMs.length - 1)]);
+            });
+        }, delayMs);
+    }
+    updateLastSeq(lastSeq) {
+        if (!this.currentSession) {
+            return;
+        }
+        this.currentSession = {
+            ...this.currentSession,
+            lastSeq
+        };
+        this.config.sessionStore.save(this.currentSession);
+    }
+    clearSession() {
+        this.currentSession = null;
+        this.config.sessionStore.clear();
+    }
+    readHeartbeatInterval(payload) {
+        if (!payload || typeof payload !== "object") {
+            return null;
+        }
+        const value = payload.heartbeat_interval;
+        return typeof value === "number" ? value : null;
+    }
+    readDispatchData(payload) {
+        if (!payload || typeof payload !== "object") {
+            return null;
+        }
+        return payload;
+    }
+}

package/dist/packages/adapters/qq/src/qq-gateway-session-store.js

@@ -0,0 +1,64 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+export class FileQqGatewaySessionStore {
+    filePath;
+    accountKey;
+    appId;
+    now;
+    maxAgeMs;
+    constructor(filePath, accountKey, appId, options = {}) {
+        this.filePath = filePath;
+        this.accountKey = accountKey;
+        this.appId = appId;
+        this.now = options.now ?? Date.now;
+        this.maxAgeMs = options.maxAgeMs ?? 5 * 60 * 1000;
+    }
+    load() {
+        try {
+            const payload = JSON.parse(readFileSync(this.filePath, "utf8"));
+            const now = this.now();
+            if (payload.accountKey !== this.accountKey || payload.appId !== this.appId) {
+                this.clear();
+                return null;
+            }
+            if (typeof payload.sessionId !== "string"
+                || typeof payload.lastSeq !== "number"
+                || typeof payload.savedAt !== "number") {
+                this.clear();
+                return null;
+            }
+            if (now - payload.savedAt > this.maxAgeMs) {
+                this.clear();
+                return null;
+            }
+            return {
+                sessionId: payload.sessionId,
+                lastSeq: payload.lastSeq
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    save(state) {
+        mkdirSync(dirname(this.filePath), { recursive: true });
+        const now = this.now();
+        const payload = {
+            accountKey: this.accountKey,
+            appId: this.appId,
+            sessionId: state.sessionId,
+            lastSeq: state.lastSeq,
+            lastConnectedAt: now,
+            savedAt: now
+        };
+        writeFileSync(this.filePath, JSON.stringify(payload, null, 2), "utf8");
+    }
+    clear() {
+        try {
+            rmSync(this.filePath, { force: true });
+        }
+        catch {
+            // ignore cleanup failures
+        }
+    }
+}