qq-codex-bridge 0.1.3 → 0.1.4

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();
+}