qq-codex-bridge 0.1.0

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

@@ -0,0 +1,62 @@
+import { normalizeC2CMessage, normalizeGroupMessage } from "./qq-normalizer.js";
+export class QqGateway {
+    config;
+    handler = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async onMessage(handler) {
+        this.handler = handler;
+    }
+    async start() {
+        // no-op: this class only normalizes and dispatches payloads.
+    }
+    async stop() {
+        // no-op: this class only normalizes and dispatches payloads.
+    }
+    async dispatch(message) {
+        if (this.handler) {
+            await this.handler(message);
+        }
+    }
+    async dispatchPayload(event) {
+        if (this.isC2CEvent(event)) {
+            const mediaArtifacts = await this.downloadMediaArtifacts(event.d.attachments);
+            await this.dispatch(normalizeC2CMessage(event.d, this.config.accountKey, mediaArtifacts));
+            return;
+        }
+        if (this.isGroupEvent(event)) {
+            const mediaArtifacts = await this.downloadMediaArtifacts(event.d.attachments);
+            await this.dispatch(normalizeGroupMessage(event.d, this.config.accountKey, mediaArtifacts));
+        }
+    }
+    isC2CEvent(event) {
+        return event.t === "C2C_MESSAGE_CREATE";
+    }
+    isGroupEvent(event) {
+        return event.t === "GROUP_AT_MESSAGE_CREATE" || event.t === "GROUP_MESSAGE_CREATE";
+    }
+    async downloadMediaArtifacts(attachments) {
+        if (!attachments?.length || !this.config.mediaDownloader) {
+            return [];
+        }
+        const settledArtifacts = await Promise.allSettled(attachments.map((attachment) => this.config.mediaDownloader.downloadMediaArtifact({
+            sourceUrl: attachment.url,
+            originalName: attachment.filename ?? null,
+            mimeType: attachment.content_type ?? null,
+            fileSize: attachment.size ?? null,
+            voiceWavUrl: attachment.voice_wav_url ?? null,
+            asrReferText: attachment.asr_refer_text ?? null
+        })));
+        const artifacts = settledArtifacts.flatMap((result) => {
+            if (result.status === "fulfilled") {
+                return [result.value];
+            }
+            console.error("[qq-codex-bridge] qq attachment download failed", {
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+            });
+            return [];
+        });
+        return artifacts;
+    }
+}

package/dist/packages/adapters/qq/src/qq-media-downloader.js

@@ -0,0 +1,246 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { MediaArtifactKind } from "../../../domain/src/message.js";
+import { transcribeAudioFile } from "./qq-stt.js";
+export class QqMediaDownloader {
+    options;
+    fetchFn;
+    sttFetchFn;
+    constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.sttFetchFn = options.sttFetchFn ?? fetch;
+    }
+    async downloadMediaArtifact(source) {
+        const normalizedSourceUrl = normalizeQqMediaUrl(source.voiceWavUrl || source.sourceUrl);
+        const response = await this.fetchFn(normalizedSourceUrl);
+        if (!response.ok) {
+            throw new Error(`QQ media download failed: ${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const mimeType = this.resolveMimeType(source.mimeType, response.headers.get("content-type"));
+        const originalName = this.resolveOriginalName(source.originalName, normalizedSourceUrl, mimeType, source.voiceWavUrl ?? null);
+        const kind = inferMediaArtifactKind(originalName, mimeType);
+        const localPath = this.writeLocalFile(originalName, buffer);
+        const transcript = await this.resolveTranscript({
+            kind,
+            localPath,
+            asrReferText: source.asrReferText
+        });
+        const artifact = {
+            kind,
+            sourceUrl: normalizedSourceUrl,
+            localPath,
+            mimeType,
+            fileSize: this.resolveFileSize(source.fileSize, response.headers.get("content-length"), buffer.length),
+            originalName,
+            transcript: transcript?.text ?? null,
+            transcriptSource: transcript?.source ?? null,
+            extractedText: extractReadableText({
+                kind,
+                originalName,
+                mimeType,
+                buffer,
+                transcript: transcript?.text ?? null
+            })
+        };
+        return artifact;
+    }
+    writeLocalFile(originalName, buffer) {
+        const resolvedBaseDir = path.resolve(this.options.baseDir);
+        mkdirSync(resolvedBaseDir, { recursive: true });
+        const parsed = path.parse(originalName);
+        const safeBaseName = sanitizeFileSegment(parsed.name || "qq-media");
+        const ext = parsed.ext || "";
+        const localPath = path.join(resolvedBaseDir, `${safeBaseName}-${randomUUID()}${ext}`);
+        writeFileSync(localPath, buffer);
+        return localPath;
+    }
+    resolveMimeType(sourceMimeType, responseMimeType) {
+        const mimeType = sourceMimeType ?? responseMimeType ?? "application/octet-stream";
+        return mimeType.split(";")[0]?.trim() || "application/octet-stream";
+    }
+    resolveOriginalName(originalName, sourceUrl, mimeType, voiceWavUrl) {
+        if (voiceWavUrl) {
+            const wavName = this.resolveNameFromUrl(voiceWavUrl);
+            if (wavName) {
+                return wavName;
+            }
+        }
+        if (originalName?.trim()) {
+            return originalName.trim();
+        }
+        const sourceName = this.resolveNameFromUrl(sourceUrl);
+        if (sourceName) {
+            return sourceName;
+        }
+        return `qq-media${extensionFromMimeType(mimeType)}`;
+    }
+    resolveNameFromUrl(sourceUrl) {
+        try {
+            const url = new URL(sourceUrl);
+            const urlName = path.basename(url.pathname);
+            if (urlName && urlName !== "/") {
+                return urlName;
+            }
+        }
+        catch {
+            // fall back to mime-derived extension
+        }
+        return null;
+    }
+    resolveFileSize(sourceFileSize, contentLength, fallbackSize) {
+        if (typeof sourceFileSize === "number" && Number.isFinite(sourceFileSize) && sourceFileSize >= 0) {
+            return sourceFileSize;
+        }
+        const parsedContentLength = contentLength ? Number(contentLength) : Number.NaN;
+        if (Number.isFinite(parsedContentLength) && parsedContentLength >= 0) {
+            return parsedContentLength;
+        }
+        return fallbackSize;
+    }
+    async resolveTranscript(input) {
+        if (input.kind !== MediaArtifactKind.Audio) {
+            return null;
+        }
+        const asrReferText = input.asrReferText?.trim();
+        const extension = path.extname(input.localPath).toLowerCase();
+        const shouldPreferAsrFallback = this.options.stt?.provider === "volcengine-flash" &&
+            [".amr", ".silk"].includes(extension) &&
+            Boolean(asrReferText);
+        if (this.options.stt && !shouldPreferAsrFallback) {
+            const startedAt = Date.now();
+            console.info("[qq-codex-bridge] qq stt started", {
+                provider: this.options.stt.provider,
+                file: input.localPath,
+                extension,
+                hasAsrReferText: Boolean(asrReferText)
+            });
+            try {
+                const text = await transcribeAudioFile(input.localPath, this.options.stt, this.sttFetchFn);
+                if (text) {
+                    console.info("[qq-codex-bridge] qq stt completed", {
+                        provider: this.options.stt.provider,
+                        file: input.localPath,
+                        durationMs: Date.now() - startedAt,
+                        transcriptPreview: text.slice(0, 80)
+                    });
+                    return {
+                        text,
+                        source: "stt"
+                    };
+                }
+                console.info("[qq-codex-bridge] qq stt produced no transcript", {
+                    provider: this.options.stt.provider,
+                    file: input.localPath,
+                    durationMs: Date.now() - startedAt
+                });
+            }
+            catch (error) {
+                console.error("[qq-codex-bridge] qq stt failed", {
+                    provider: this.options.stt.provider,
+                    error: error instanceof Error ? error.message : String(error),
+                    file: input.localPath,
+                    durationMs: Date.now() - startedAt
+                });
+            }
+        }
+        if (asrReferText) {
+            console.info("[qq-codex-bridge] qq stt fallback used", {
+                source: "asr",
+                file: input.localPath,
+                transcriptPreview: asrReferText.slice(0, 80)
+            });
+            return {
+                text: asrReferText,
+                source: "asr"
+            };
+        }
+        return null;
+    }
+}
+function normalizeQqMediaUrl(sourceUrl) {
+    if (sourceUrl.startsWith("//")) {
+        return `https:${sourceUrl}`;
+    }
+    return sourceUrl;
+}
+function sanitizeFileSegment(segment) {
+    return segment.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function extensionFromMimeType(mimeType) {
+    switch (mimeType) {
+        case "image/png":
+            return ".png";
+        case "image/jpeg":
+            return ".jpg";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        case "audio/mpeg":
+            return ".mp3";
+        case "audio/wav":
+        case "audio/x-wav":
+            return ".wav";
+        case "video/mp4":
+            return ".mp4";
+        default:
+            return "";
+    }
+}
+export function inferMediaArtifactKind(originalName, mimeType) {
+    if (mimeType.startsWith("image/")) {
+        return MediaArtifactKind.Image;
+    }
+    if (mimeType.startsWith("audio/")) {
+        return MediaArtifactKind.Audio;
+    }
+    if (mimeType.startsWith("video/")) {
+        return MediaArtifactKind.Video;
+    }
+    const extension = path.extname(originalName).toLowerCase();
+    if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"].includes(extension)) {
+        return MediaArtifactKind.Image;
+    }
+    if ([".amr", ".mp3", ".wav", ".ogg", ".aac", ".flac", ".silk", ".m4a"].includes(extension)) {
+        return MediaArtifactKind.Audio;
+    }
+    if ([".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(extension)) {
+        return MediaArtifactKind.Video;
+    }
+    return MediaArtifactKind.File;
+}
+function extractReadableText(input) {
+    if (input.kind === MediaArtifactKind.Audio && input.transcript?.trim()) {
+        return input.transcript.trim();
+    }
+    if (isTextLikeArtifact(input.originalName, input.mimeType)) {
+        const text = input.buffer.toString("utf8").trim();
+        return text ? text.slice(0, 4000) : null;
+    }
+    switch (input.kind) {
+        case MediaArtifactKind.Image:
+            return `图片附件：${input.originalName}`;
+        case MediaArtifactKind.Audio:
+            return `语音附件：${input.originalName}`;
+        case MediaArtifactKind.Video:
+            return `视频附件：${input.originalName}`;
+        case MediaArtifactKind.File:
+            return `文件附件：${input.originalName}`;
+        default:
+            return null;
+    }
+}
+function isTextLikeArtifact(originalName, mimeType) {
+    if (mimeType.startsWith("text/")) {
+        return true;
+    }
+    if (["application/json", "application/xml"].includes(mimeType)) {
+        return true;
+    }
+    const extension = path.extname(originalName).toLowerCase();
+    return [".txt", ".md", ".json", ".csv", ".log", ".xml", ".yaml", ".yml"].includes(extension);
+}

package/dist/packages/adapters/qq/src/qq-media-parser.js

@@ -0,0 +1,144 @@
+import path from "node:path";
+import { statSync, existsSync } from "node:fs";
+import { inferMediaArtifactKind } from "./qq-media-downloader.js";
+const MEDIA_SEGMENT_PATTERN = /<qqmedia>([\s\S]*?)<\/qqmedia>|!\[[^\]]*\]\(([^)]+)\)/g;
+export function parseQqMediaSegments(text) {
+    if (!text) {
+        return [];
+    }
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of text.matchAll(MEDIA_SEGMENT_PATTERN)) {
+        const fullMatch = match[0];
+        const matchIndex = match.index ?? 0;
+        if (matchIndex > lastIndex) {
+            segments.push({ type: "text", text: text.slice(lastIndex, matchIndex) });
+        }
+        const qqMediaReference = match[1]?.trim();
+        const markdownImageReference = match[2]?.trim();
+        if (qqMediaReference && isSupportedMediaReference(qqMediaReference)) {
+            segments.push({ type: "media", reference: qqMediaReference });
+        }
+        else if (markdownImageReference && shouldRouteMarkdownImageAsMedia(markdownImageReference)) {
+            segments.push({ type: "media", reference: markdownImageReference });
+        }
+        else {
+            segments.push({ type: "text", text: fullMatch });
+        }
+        lastIndex = matchIndex + fullMatch.length;
+    }
+    if (lastIndex < text.length) {
+        segments.push({ type: "text", text: text.slice(lastIndex) });
+    }
+    return mergeAdjacentTextSegments(segments);
+}
+export function buildMediaArtifactFromReference(reference) {
+    const mimeType = inferMimeType(reference);
+    const originalName = inferOriginalName(reference);
+    const isLocal = !reference.startsWith("http://") && !reference.startsWith("https://");
+    const fileSize = isLocal && existsSync(reference) ? statSync(reference).size : 0;
+    return {
+        kind: inferMediaArtifactKind(originalName, mimeType),
+        sourceUrl: reference,
+        localPath: reference,
+        mimeType,
+        fileSize,
+        originalName
+    };
+}
+function mergeAdjacentTextSegments(segments) {
+    const merged = [];
+    for (const segment of segments) {
+        const previous = merged.at(-1);
+        if (segment.type === "text" && previous?.type === "text") {
+            previous.text += segment.text;
+            continue;
+        }
+        if (segment.type === "text" && segment.text.length === 0) {
+            continue;
+        }
+        merged.push(segment);
+    }
+    return merged;
+}
+function isSupportedMediaReference(reference) {
+    return hasRecognizedExtension(reference) || reference.startsWith("/") || reference.startsWith("http://") || reference.startsWith("https://");
+}
+function shouldRouteMarkdownImageAsMedia(reference) {
+    return isLocalLikeReference(reference) || reference.startsWith("data:image/");
+}
+function isLocalLikeReference(reference) {
+    return reference.startsWith("/") || reference.startsWith("./") || reference.startsWith("../") || /^[A-Za-z]:[\\/]/.test(reference);
+}
+function hasRecognizedExtension(reference) {
+    const extension = path.extname(stripQuery(reference)).toLowerCase();
+    return [
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp",
+        ".mp3", ".wav", ".ogg", ".aac", ".flac", ".silk",
+        ".mp4", ".mov", ".avi", ".mkv", ".webm",
+        ".pdf", ".txt", ".md", ".json", ".csv", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".zip"
+    ].includes(extension);
+}
+function inferMimeType(reference) {
+    const extension = path.extname(stripQuery(reference)).toLowerCase();
+    switch (extension) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".bmp":
+            return "image/bmp";
+        case ".mp3":
+            return "audio/mpeg";
+        case ".wav":
+            return "audio/wav";
+        case ".ogg":
+            return "audio/ogg";
+        case ".aac":
+            return "audio/aac";
+        case ".flac":
+            return "audio/flac";
+        case ".silk":
+            return "audio/silk";
+        case ".mp4":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".avi":
+            return "video/x-msvideo";
+        case ".mkv":
+            return "video/x-matroska";
+        case ".webm":
+            return "video/webm";
+        case ".txt":
+            return "text/plain";
+        case ".md":
+            return "text/markdown";
+        case ".json":
+            return "application/json";
+        case ".csv":
+            return "text/csv";
+        case ".pdf":
+            return "application/pdf";
+        default:
+            return "application/octet-stream";
+    }
+}
+function inferOriginalName(reference) {
+    try {
+        const url = new URL(reference);
+        const name = path.basename(url.pathname);
+        return name || "qq-media";
+    }
+    catch {
+        return path.basename(reference) || "qq-media";
+    }
+}
+function stripQuery(reference) {
+    return reference.split("?")[0] ?? reference;
+}

package/dist/packages/adapters/qq/src/qq-normalizer.js

@@ -0,0 +1,35 @@
+import { buildPeerKey, buildSessionKey } from "../../../orchestrator/src/session-key.js";
+export function normalizeC2CMessage(event, accountKey, mediaArtifacts = []) {
+    const peerKey = buildPeerKey({
+        chatType: "c2c",
+        peerId: event.author.user_openid
+    });
+    return {
+        messageId: event.id,
+        accountKey,
+        sessionKey: buildSessionKey({ accountKey, peerKey }),
+        peerKey,
+        chatType: "c2c",
+        senderId: event.author.user_openid,
+        text: event.content,
+        ...(mediaArtifacts.length > 0 ? { mediaArtifacts } : {}),
+        receivedAt: event.timestamp
+    };
+}
+export function normalizeGroupMessage(event, accountKey, mediaArtifacts = []) {
+    const peerKey = buildPeerKey({
+        chatType: "group",
+        peerId: event.group_openid
+    });
+    return {
+        messageId: event.id,
+        accountKey,
+        sessionKey: buildSessionKey({ accountKey, peerKey }),
+        peerKey,
+        chatType: "group",
+        senderId: event.author.member_openid,
+        text: event.content,
+        ...(mediaArtifacts.length > 0 ? { mediaArtifacts } : {}),
+        receivedAt: event.timestamp
+    };
+}