qq-codex-bridge 0.1.2 → 0.1.4

package/dist/apps/weixin-gateway/src/config.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+const weixinGatewayAccountConfigSchema = z.object({
+    accountId: z.string().min(1),
+    bridgeWebhookPath: z.string().startsWith("/"),
+    baseUrl: z.string().url(),
+    token: z.string().min(1).nullable(),
+    messageStorePath: z.string().min(1)
+});
+export const weixinGatewayConfigSchema = z.object({
+    listenHost: z.string().min(1),
+    listenPort: z.number().int().positive(),
+    bridgeBaseUrl: z.string().url(),
+    bridgeWebhookPath: z.string().startsWith("/"),
+    expectedBearerToken: z.string().min(1).nullable(),
+    messageStorePath: z.string().min(1),
+    recentMessageLimit: z.number().int().positive(),
+    enabled: z.boolean(),
+    accountId: z.string().min(1),
+    baseUrl: z.string().url(),
+    token: z.string().min(1).nullable(),
+    longPollTimeoutMs: z.number().int().positive(),
+    apiTimeoutMs: z.number().int().positive(),
+    stateFilePath: z.string().min(1),
+    loginBaseUrl: z.string().url(),
+    loginBotType: z.string().min(1),
+    qrFetchTimeoutMs: z.number().int().positive(),
+    qrPollTimeoutMs: z.number().int().positive(),
+    qrTotalTimeoutMs: z.number().int().positive(),
+    stateWatchIntervalMs: z.number().int().positive(),
+    accounts: z.array(weixinGatewayAccountConfigSchema).min(1)
+});
+export function loadWeixinGatewayConfigFromEnv(env) {
+    const fallbackAccount = {
+        accountId: env.WEIXIN_ACCOUNT_ID ?? "default",
+        bridgeWebhookPath: env.WEIXIN_GATEWAY_BRIDGE_WEBHOOK_PATH
+            ?? env.WEIXIN_WEBHOOK_PATH
+            ?? "/webhooks/weixin",
+        baseUrl: env.WEIXIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        token: env.WEIXIN_TOKEN ?? null,
+        messageStorePath: env.WEIXIN_GATEWAY_MESSAGE_STORE_PATH
+            ?? "runtime/weixin-gateway-messages.ndjson"
+    };
+    return weixinGatewayConfigSchema.parse({
+        listenHost: env.WEIXIN_GATEWAY_LISTEN_HOST ?? "127.0.0.1",
+        listenPort: Number(env.WEIXIN_GATEWAY_LISTEN_PORT ?? "3200"),
+        bridgeBaseUrl: env.WEIXIN_GATEWAY_BRIDGE_BASE_URL
+            ?? `http://${env.QQ_CODEX_LISTEN_HOST ?? "127.0.0.1"}:${env.QQ_CODEX_LISTEN_PORT ?? "3100"}`,
+        bridgeWebhookPath: env.WEIXIN_GATEWAY_BRIDGE_WEBHOOK_PATH
+            ?? env.WEIXIN_WEBHOOK_PATH
+            ?? "/webhooks/weixin",
+        expectedBearerToken: env.WEIXIN_GATEWAY_EXPECTED_TOKEN ?? env.WEIXIN_EGRESS_TOKEN ?? null,
+        messageStorePath: env.WEIXIN_GATEWAY_MESSAGE_STORE_PATH
+            ?? "runtime/weixin-gateway-messages.ndjson",
+        recentMessageLimit: Number(env.WEIXIN_GATEWAY_RECENT_MESSAGE_LIMIT ?? "100"),
+        enabled: env.WEIXIN_ENABLED !== "false",
+        accountId: env.WEIXIN_ACCOUNT_ID ?? "default",
+        baseUrl: env.WEIXIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        token: env.WEIXIN_TOKEN ?? null,
+        longPollTimeoutMs: Number(env.WEIXIN_LONG_POLL_TIMEOUT_MS ?? "35000"),
+        apiTimeoutMs: Number(env.WEIXIN_API_TIMEOUT_MS ?? "15000"),
+        stateFilePath: env.WEIXIN_GATEWAY_STATE_FILE_PATH ?? "runtime/weixin-gateway-state.json",
+        loginBaseUrl: env.WEIXIN_LOGIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        loginBotType: env.WEIXIN_BOT_TYPE ?? "3",
+        qrFetchTimeoutMs: Number(env.WEIXIN_QR_FETCH_TIMEOUT_MS ?? "10000"),
+        qrPollTimeoutMs: Number(env.WEIXIN_QR_POLL_TIMEOUT_MS ?? "35000"),
+        qrTotalTimeoutMs: Number(env.WEIXIN_QR_TOTAL_TIMEOUT_MS ?? String(8 * 60 * 1000)),
+        stateWatchIntervalMs: Number(env.WEIXIN_GATEWAY_STATE_WATCH_INTERVAL_MS ?? "1000"),
+        accounts: resolveGatewayAccounts(env, fallbackAccount)
+    });
+}
+function resolveGatewayAccounts(env, fallback) {
+    const jsonAccounts = parseJsonArray(env.WEIXIN_GATEWAY_ACCOUNTS_JSON ?? env.WEIXIN_ACCOUNTS_JSON);
+    if (jsonAccounts) {
+        return jsonAccounts.map((item, index) => {
+            const record = asRecord(item);
+            const accountId = stringValue(record.accountId ?? record.id, `account${index + 1}`);
+            return {
+                accountId,
+                bridgeWebhookPath: stringValue(record.bridgeWebhookPath ?? record.webhookPath, `/webhooks/weixin/${accountId}`),
+                baseUrl: stringValue(record.baseUrl, fallback.baseUrl),
+                token: nullableString(record.token ?? record.weixinToken),
+                messageStorePath: stringValue(record.messageStorePath, `runtime/weixin-gateway-messages-${safePathSegment(accountId)}.ndjson`)
+            };
+        });
+    }
+    const accountIds = splitList(env.WEIXIN_GATEWAY_ACCOUNT_IDS ?? env.WEIXIN_ACCOUNT_IDS);
+    if (accountIds.length > 0) {
+        return accountIds.map((accountId, index) => {
+            const suffix = envNameSuffix(accountId);
+            return {
+                accountId,
+                bridgeWebhookPath: env[`WEIXIN_GATEWAY_${suffix}_BRIDGE_WEBHOOK_PATH`]
+                    ?? env[`WEIXIN_${suffix}_WEBHOOK_PATH`]
+                    ?? `/webhooks/weixin/${accountId}`,
+                baseUrl: env[`WEIXIN_${suffix}_BASE_URL`] ?? fallback.baseUrl,
+                token: env[`WEIXIN_${suffix}_TOKEN`] ?? (index === 0 ? fallback.token : null),
+                messageStorePath: env[`WEIXIN_GATEWAY_${suffix}_MESSAGE_STORE_PATH`]
+                    ?? `runtime/weixin-gateway-messages-${safePathSegment(accountId)}.ndjson`
+            };
+        });
+    }
+    return [fallback];
+}
+function parseJsonArray(value) {
+    if (!value?.trim()) {
+        return null;
+    }
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value, fallback) {
+    const text = String(value ?? "").trim();
+    return text || fallback;
+}
+function nullableString(value) {
+    const text = String(value ?? "").trim();
+    return text || null;
+}
+function splitList(value) {
+    return (value ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function envNameSuffix(value) {
+    return value.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}
+function safePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_") || "default";
+}

package/dist/apps/weixin-gateway/src/dev.js

@@ -0,0 +1,2 @@
+import { runCliFromProcess } from "./cli.js";
+void runCliFromProcess();

package/dist/apps/weixin-gateway/src/message-store.js

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+export class WeixinGatewayMessageStore {
+    filePath;
+    limit;
+    messages = [];
+    constructor(filePath, limit) {
+        this.filePath = filePath;
+        this.limit = limit;
+        this.loadFromDisk();
+    }
+    append(message) {
+        this.messages.push(message);
+        this.trimToLimit();
+        this.persistLine(message);
+    }
+    listRecent() {
+        return [...this.messages].reverse();
+    }
+    loadFromDisk() {
+        if (!fs.existsSync(this.filePath)) {
+            return;
+        }
+        const content = fs.readFileSync(this.filePath, "utf8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                this.messages.push(parsed);
+            }
+            catch {
+                // ignore malformed historical lines
+            }
+        }
+        this.trimToLimit();
+    }
+    persistLine(message) {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.appendFileSync(this.filePath, `${JSON.stringify(message)}\n`, "utf8");
+    }
+    trimToLimit() {
+        if (this.messages.length <= this.limit) {
+            return;
+        }
+        this.messages.splice(0, this.messages.length - this.limit);
+    }
+}

package/dist/apps/weixin-gateway/src/server.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { z } from "zod";
+import { WeixinGatewayMessageStore } from "./message-store.js";
+import { MediaArtifactKind } from "../../../packages/domain/src/message.js";
+const inboundTextPayloadSchema = z.object({
+    accountKey: z.string().min(1).optional(),
+    chatType: z.enum(["c2c", "group"]).optional(),
+    senderId: z.string().min(1),
+    peerId: z.string().min(1).optional(),
+    messageId: z.string().min(1),
+    text: z.string().min(1),
+    receivedAt: z.string().optional()
+});
+const mediaArtifactSchema = z.object({
+    kind: z.nativeEnum(MediaArtifactKind),
+    sourceUrl: z.string().min(1),
+    localPath: z.string().min(1),
+    mimeType: z.string().min(1),
+    fileSize: z.number().nonnegative(),
+    originalName: z.string().min(1),
+    transcript: z.string().nullable().optional(),
+    transcriptSource: z.enum(["stt", "asr", "fallback"]).nullable().optional(),
+    extractedText: z.string().nullable().optional()
+});
+const outboundMessagePayloadSchema = z.object({
+    accountKey: z.string().min(1).optional(),
+    accountId: z.string().min(1).optional(),
+    peerId: z.string().min(1),
+    chatType: z.enum(["c2c", "group"]),
+    content: z.string().min(1).optional(),
+    mediaArtifacts: z.array(mediaArtifactSchema).min(1).optional(),
+    replyToMessageId: z.string().min(1).optional()
+}).superRefine((payload, ctx) => {
+    if (!payload.content && !(payload.mediaArtifacts?.length)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "content or mediaArtifacts is required",
+            path: ["content"]
+        });
+    }
+});
+export function createWeixinGatewayServer(deps) {
+    const messageStore = deps.messageStore
+        ?? new WeixinGatewayMessageStore(deps.config.messageStorePath, deps.config.recentMessageLimit);
+    const fetchFn = deps.fetchFn ?? fetch;
+    return createServer(async (request, response) => {
+        try {
+            if (request.method === "GET" && request.url === "/health") {
+                writeJson(response, 200, { ok: true });
+                return;
+            }
+            if (request.method === "GET" && request.url === "/messages") {
+                writeJson(response, 200, {
+                    items: messageStore.listRecent()
+                });
+                return;
+            }
+            if (request.method !== "POST") {
+                writePlain(response, 405, "method not allowed");
+                return;
+            }
+            if (request.url === "/inbound/text") {
+                const payload = inboundTextPayloadSchema.parse(await readJsonBody(request));
+                const bridgePayload = {
+                    accountKey: payload.accountKey,
+                    chatType: payload.chatType ?? "c2c",
+                    senderId: payload.senderId,
+                    peerId: payload.peerId ?? payload.senderId,
+                    messageId: payload.messageId,
+                    text: payload.text,
+                    receivedAt: payload.receivedAt
+                };
+                const bridgeResponse = await fetchFn(`${deps.config.bridgeBaseUrl}${deps.config.bridgeWebhookPath}`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json"
+                    },
+                    body: JSON.stringify(bridgePayload)
+                });
+                if (!bridgeResponse.ok) {
+                    const bridgeText = await bridgeResponse.text().catch(() => "");
+                    throw new Error(`bridge webhook failed: ${bridgeResponse.status}${bridgeText ? ` ${bridgeText}` : ""}`);
+                }
+                writeJson(response, 202, {
+                    accepted: true
+                });
+                return;
+            }
+            if (request.url === "/messages") {
+                assertBearerToken(request, deps.config.expectedBearerToken);
+                const payload = outboundMessagePayloadSchema.parse(await readJsonBody(request));
+                const duplicate = findRecentDuplicateOutbound(messageStore.listRecent(), payload);
+                if (duplicate) {
+                    writeJson(response, 200, { id: duplicate.id, deduped: true });
+                    return;
+                }
+                const message = {
+                    id: randomUUID(),
+                    ...(payload.accountKey ? { accountKey: payload.accountKey } : {}),
+                    ...(payload.accountId ? { accountId: payload.accountId } : {}),
+                    peerId: payload.peerId,
+                    chatType: payload.chatType,
+                    ...(payload.content ? { content: payload.content } : {}),
+                    ...(payload.mediaArtifacts?.length ? { mediaArtifacts: payload.mediaArtifacts } : {}),
+                    ...(payload.replyToMessageId ? { replyToMessageId: payload.replyToMessageId } : {}),
+                    createdAt: new Date().toISOString()
+                };
+                messageStore.append(message);
+                if (deps.outboundSender) {
+                    if (payload.mediaArtifacts?.length && deps.outboundSender.sendMessage) {
+                        await deps.outboundSender.sendMessage({
+                            ...(payload.accountKey ? { accountKey: payload.accountKey } : {}),
+                            ...(payload.accountId ? { accountId: payload.accountId } : {}),
+                            peerId: payload.peerId,
+                            chatType: payload.chatType,
+                            ...(payload.content ? { content: payload.content } : {}),
+                            mediaArtifacts: payload.mediaArtifacts,
+                            ...(payload.replyToMessageId ? { replyToMessageId: payload.replyToMessageId } : {})
+                        });
+                    }
+                    else {
+                        await deps.outboundSender.sendTextMessage({
+                            ...(payload.accountKey ? { accountKey: payload.accountKey } : {}),
+                            ...(payload.accountId ? { accountId: payload.accountId } : {}),
+                            peerId: payload.peerId,
+                            chatType: payload.chatType,
+                            text: payload.content ?? "",
+                            ...(payload.replyToMessageId ? { replyToMessageId: payload.replyToMessageId } : {})
+                        });
+                    }
+                }
+                console.log("[weixin-gateway] outbound message", {
+                    id: message.id,
+                    chatType: message.chatType,
+                    peerId: message.peerId,
+                    preview: clipPreview(message.content ?? ""),
+                    mediaCount: message.mediaArtifacts?.length ?? 0
+                });
+                writeJson(response, 200, { id: message.id });
+                return;
+            }
+            writePlain(response, 404, "not found");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const statusCode = error instanceof z.ZodError ? 400 : 500;
+            writeJson(response, statusCode, {
+                error: message
+            });
+        }
+    });
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    return raw ? JSON.parse(raw) : {};
+}
+function assertBearerToken(request, expectedToken) {
+    if (!expectedToken) {
+        return;
+    }
+    const authHeader = request.headers.authorization;
+    if (authHeader !== `Bearer ${expectedToken}`) {
+        throw new Error("unauthorized");
+    }
+}
+function clipPreview(text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    return normalized.length > 80 ? `${normalized.slice(0, 77)}...` : normalized;
+}
+function findRecentDuplicateOutbound(recentMessages, payload) {
+    const fingerprint = buildOutboundFingerprint(payload);
+    if (!fingerprint) {
+        return null;
+    }
+    const now = Date.now();
+    for (const message of recentMessages) {
+        const createdAtMs = Date.parse(message.createdAt);
+        if (!Number.isFinite(createdAtMs) || now - createdAtMs > 120_000) {
+            continue;
+        }
+        if (buildOutboundFingerprint(message) === fingerprint) {
+            return message;
+        }
+    }
+    return null;
+}
+function buildOutboundFingerprint(message) {
+    const peerId = String(message.peerId ?? "").trim();
+    const chatType = String(message.chatType ?? "").trim();
+    const replyToMessageId = String(message.replyToMessageId ?? "").trim();
+    const content = String(message.content ?? "").replace(/\s+/g, " ").trim();
+    const mediaFingerprint = (message.mediaArtifacts ?? [])
+        .map((artifact) => [
+        artifact.kind,
+        artifact.localPath || "",
+        artifact.sourceUrl || "",
+        artifact.originalName || ""
+    ].join("::"))
+        .join("|");
+    return [peerId, chatType, replyToMessageId, content, mediaFingerprint].join("||");
+}
+function writeJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(payload));
+}
+function writePlain(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "text/plain; charset=utf-8");
+    response.end(payload);
+}

package/dist/apps/weixin-gateway/src/state.js

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+const EMPTY_STATE = {
+    syncCursor: "",
+    contextTokens: {},
+    accounts: {},
+    defaultAccountId: "default"
+};
+export class WeixinGatewayStateStore {
+    filePath;
+    state = structuredClone(EMPTY_STATE);
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.reload();
+    }
+    reload() {
+        this.state = loadStateFromDisk(this.filePath);
+    }
+    getSyncCursor() {
+        return this.state.syncCursor;
+    }
+    setSyncCursor(cursor) {
+        this.state.syncCursor = sanitizeText(cursor);
+        this.persist();
+    }
+    getContextToken(accountId, peerId) {
+        return this.state.contextTokens[buildContextTokenKey(accountId, peerId)] ?? "";
+    }
+    setContextToken(accountId, peerId, token) {
+        const key = buildContextTokenKey(accountId, peerId);
+        const normalizedToken = sanitizeText(token);
+        if (!key || !normalizedToken) {
+            return;
+        }
+        this.state.contextTokens[key] = normalizedToken;
+        this.persist();
+    }
+    getStoredAccount(accountId) {
+        const normalizedAccountId = sanitizeText(accountId) || this.state.defaultAccountId;
+        return this.state.accounts[normalizedAccountId] ?? null;
+    }
+    setStoredAccount(account) {
+        const normalizedAccountId = sanitizeText(account.accountId) || "default";
+        this.state.accounts[normalizedAccountId] = {
+            accountId: normalizedAccountId,
+            token: sanitizeText(account.token),
+            baseUrl: sanitizeText(account.baseUrl),
+            ...(sanitizeText(account.userId) ? { userId: sanitizeText(account.userId) } : {})
+        };
+        this.state.defaultAccountId = normalizedAccountId;
+        this.persist();
+    }
+    clearStoredAccount(accountId) {
+        const normalizedAccountId = sanitizeText(accountId) || this.state.defaultAccountId;
+        delete this.state.accounts[normalizedAccountId];
+        for (const key of Object.keys(this.state.contextTokens)) {
+            if (key.startsWith(`${normalizedAccountId}:`)) {
+                delete this.state.contextTokens[key];
+            }
+        }
+        if (this.state.defaultAccountId === normalizedAccountId) {
+            this.state.defaultAccountId = Object.keys(this.state.accounts)[0] ?? "default";
+        }
+        this.persist();
+    }
+    resolveRuntimeAccount(preferredAccountId, envOverride) {
+        const normalizedPreferred = sanitizeText(preferredAccountId) || this.state.defaultAccountId;
+        const stored = this.state.accounts[normalizedPreferred]
+            ?? this.state.accounts[this.state.defaultAccountId]
+            ?? null;
+        const token = sanitizeText(envOverride.token) || sanitizeText(stored?.token);
+        const baseUrl = sanitizeText(envOverride.baseUrl) || sanitizeText(stored?.baseUrl);
+        if (!token || !baseUrl) {
+            return null;
+        }
+        return {
+            accountId: sanitizeText(stored?.accountId) || normalizedPreferred || "default",
+            token,
+            baseUrl,
+            ...(sanitizeText(stored?.userId) ? { userId: sanitizeText(stored?.userId) } : {})
+        };
+    }
+    persist() {
+        persistStateToDisk(this.filePath, this.state);
+    }
+}
+function loadStateFromDisk(filePath) {
+    let raw = "";
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return structuredClone(EMPTY_STATE);
+        }
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            syncCursor: sanitizeText(parsed.syncCursor),
+            contextTokens: normalizeContextTokens(parsed.contextTokens),
+            accounts: normalizeAccounts(parsed.accounts),
+            defaultAccountId: sanitizeText(parsed.defaultAccountId) || "default"
+        };
+    }
+    catch {
+        return structuredClone(EMPTY_STATE);
+    }
+}
+function persistStateToDisk(filePath, state) {
+    const tempFile = `${filePath}.tmp`;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(tempFile, JSON.stringify(state, null, 2), "utf8");
+    fs.renameSync(tempFile, filePath);
+}
+function normalizeContextTokens(input) {
+    const result = {};
+    if (!input || typeof input !== "object") {
+        return result;
+    }
+    for (const [key, value] of Object.entries(input)) {
+        const normalizedKey = sanitizeText(key);
+        const normalizedValue = sanitizeText(value);
+        if (!normalizedKey || !normalizedValue) {
+            continue;
+        }
+        result[normalizedKey] = normalizedValue;
+    }
+    return result;
+}
+function normalizeAccounts(input) {
+    const result = {};
+    if (!input || typeof input !== "object") {
+        return result;
+    }
+    for (const [key, value] of Object.entries(input)) {
+        const accountId = sanitizeText(key);
+        const token = sanitizeText(value?.token);
+        const baseUrl = sanitizeText(value?.baseUrl);
+        if (!accountId || !token || !baseUrl) {
+            continue;
+        }
+        result[accountId] = {
+            accountId,
+            token,
+            baseUrl,
+            ...(sanitizeText(value?.userId) ? { userId: sanitizeText(value?.userId) } : {})
+        };
+    }
+    return result;
+}
+function buildContextTokenKey(accountId, peerId) {
+    const normalizedAccountId = sanitizeText(accountId);
+    const normalizedPeerId = sanitizeText(peerId);
+    if (!normalizedAccountId || !normalizedPeerId) {
+        return "";
+    }
+    return `${normalizedAccountId}:${normalizedPeerId}`;
+}
+function sanitizeText(value) {
+    return String(value ?? "").trim();
+}