@yanhaidao/wecom 2.4.120 → 2.5.110

package/dist/src/transport/bot-webhook/inbound-normalizer.js

@@ -0,0 +1,496 @@
+import { decryptWecomMediaWithMeta } from "../../media.js";
+import { resolveWecomEgressProxyUrl, resolveWecomMediaDownloadTimeoutMs, resolveWecomMediaMaxBytes, } from "../../config/index.js";
+import { buildInboundBody } from "./message-shape.js";
+const MIME_BY_EXT = {
+    txt: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    csv: "text/csv",
+    html: "text/html",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    bmp: "image/bmp",
+    ogg: "audio/ogg",
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    zip: "application/zip",
+    bin: "application/octet-stream",
+};
+const EXT_BY_MIME = {
+    ...Object.fromEntries(Object.entries(MIME_BY_EXT).map(([ext, mime]) => [mime, ext])),
+    "application/octet-stream": "bin",
+};
+const GENERIC_CONTENT_TYPES = new Set([
+    "application/octet-stream",
+    "binary/octet-stream",
+    "application/download",
+]);
+function normalizeContentType(raw) {
+    const normalized = String(raw ?? "").trim().split(";")[0]?.trim().toLowerCase();
+    return normalized || undefined;
+}
+function isGenericContentType(raw) {
+    const normalized = normalizeContentType(raw);
+    if (!normalized)
+        return true;
+    return GENERIC_CONTENT_TYPES.has(normalized);
+}
+export function guessContentTypeFromPath(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (!ext)
+        return undefined;
+    return MIME_BY_EXT[ext];
+}
+function guessExtensionFromContentType(contentType) {
+    const normalized = normalizeContentType(contentType);
+    if (!normalized)
+        return undefined;
+    if (normalized === "image/jpeg")
+        return "jpg";
+    return EXT_BY_MIME[normalized];
+}
+function extractFileNameFromUrl(rawUrl) {
+    const s = String(rawUrl ?? "").trim();
+    if (!s)
+        return undefined;
+    try {
+        const u = new URL(s);
+        const name = decodeURIComponent(u.pathname.split("/").pop() ?? "").trim();
+        return name || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeInboundFilename(raw) {
+    const s = String(raw ?? "").trim();
+    if (!s)
+        return undefined;
+    const base = s.split(/[\\/]/).pop()?.trim() ?? "";
+    if (!base)
+        return undefined;
+    const sanitized = base.replace(/[\u0000-\u001f<>:"|?*]/g, "_").trim();
+    return sanitized || undefined;
+}
+function hasLikelyExtension(name) {
+    if (!name)
+        return false;
+    return /\.[a-z0-9]{1,16}$/i.test(name);
+}
+function detectMimeFromBuffer(buffer) {
+    if (!buffer || buffer.length < 4)
+        return undefined;
+    if (buffer.length >= 8 &&
+        buffer[0] === 0x89 &&
+        buffer[1] === 0x50 &&
+        buffer[2] === 0x4e &&
+        buffer[3] === 0x47 &&
+        buffer[4] === 0x0d &&
+        buffer[5] === 0x0a &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0x0a) {
+        return "image/png";
+    }
+    if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
+        return "image/gif";
+    }
+    if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    if (buffer[0] === 0x42 && buffer[1] === 0x4d) {
+        return "image/bmp";
+    }
+    if (buffer.subarray(0, 5).toString("ascii") === "%PDF-") {
+        return "application/pdf";
+    }
+    if (buffer.subarray(0, 4).toString("ascii") === "OggS") {
+        return "audio/ogg";
+    }
+    if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WAVE") {
+        return "audio/wav";
+    }
+    if (buffer.subarray(0, 3).toString("ascii") === "ID3" || (buffer[0] === 0xff && (buffer[1] & 0xe0) === 0xe0)) {
+        return "audio/mpeg";
+    }
+    if (buffer.length >= 12 && buffer.subarray(4, 8).toString("ascii") === "ftyp") {
+        return "video/mp4";
+    }
+    if (buffer.length >= 8 &&
+        buffer[0] === 0xd0 &&
+        buffer[1] === 0xcf &&
+        buffer[2] === 0x11 &&
+        buffer[3] === 0xe0 &&
+        buffer[4] === 0xa1 &&
+        buffer[5] === 0xb1 &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0xe1) {
+        return "application/msword";
+    }
+    const zipMagic = (buffer[0] === 0x50 && buffer[1] === 0x4b && buffer[2] === 0x03 && buffer[3] === 0x04) ||
+        (buffer[0] === 0x50 && buffer[1] === 0x4b && buffer[2] === 0x05 && buffer[3] === 0x06) ||
+        (buffer[0] === 0x50 && buffer[1] === 0x4b && buffer[2] === 0x07 && buffer[3] === 0x08);
+    if (zipMagic) {
+        const probe = buffer.subarray(0, Math.min(buffer.length, 512 * 1024));
+        if (probe.includes(Buffer.from("word/")))
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        if (probe.includes(Buffer.from("xl/")))
+            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        if (probe.includes(Buffer.from("ppt/")))
+            return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        return "application/zip";
+    }
+    const sample = buffer.subarray(0, Math.min(buffer.length, 4096));
+    let printable = 0;
+    for (const b of sample) {
+        if (b === 0x00)
+            return undefined;
+        if (b === 0x09 || b === 0x0a || b === 0x0d || (b >= 0x20 && b <= 0x7e)) {
+            printable += 1;
+        }
+    }
+    if (sample.length > 0 && printable / sample.length > 0.95) {
+        return "text/plain";
+    }
+    return undefined;
+}
+function resolveInlineFileName(input) {
+    return sanitizeInboundFilename(String(input ?? "").trim());
+}
+function pickBotFileName(msg, item) {
+    const fromItem = item
+        ? resolveInlineFileName(item?.filename ?? item?.file_name ?? item?.fileName ?? item?.name ?? item?.title)
+        : undefined;
+    if (fromItem)
+        return fromItem;
+    return resolveInlineFileName(msg?.file?.filename ??
+        msg?.file?.file_name ??
+        msg?.file?.fileName ??
+        msg?.file?.name ??
+        msg?.file?.title ??
+        msg?.filename ??
+        msg?.fileName ??
+        msg?.FileName);
+}
+function inferInboundMediaMeta(params) {
+    const headerType = normalizeContentType(params.sourceContentType);
+    const magicType = detectMimeFromBuffer(params.buffer);
+    const rawUrlName = sanitizeInboundFilename(extractFileNameFromUrl(params.sourceUrl));
+    const guessedByUrl = hasLikelyExtension(rawUrlName) ? rawUrlName : undefined;
+    const explicitName = sanitizeInboundFilename(params.explicitFilename);
+    const sourceName = sanitizeInboundFilename(params.sourceFilename);
+    const chosenName = explicitName || sourceName || guessedByUrl;
+    const typeByName = chosenName ? guessContentTypeFromPath(chosenName) : undefined;
+    let contentType;
+    if (params.kind === "image") {
+        if (magicType?.startsWith("image/"))
+            contentType = magicType;
+        else if (headerType?.startsWith("image/"))
+            contentType = headerType;
+        else if (typeByName?.startsWith("image/"))
+            contentType = typeByName;
+        else
+            contentType = "image/jpeg";
+    }
+    else {
+        contentType = magicType || (!isGenericContentType(headerType) ? headerType : undefined) || typeByName || "application/octet-stream";
+    }
+    const hasExt = Boolean(chosenName && /\.[a-z0-9]{1,16}$/i.test(chosenName));
+    const ext = guessExtensionFromContentType(contentType) || (params.kind === "image" ? "jpg" : "bin");
+    const filename = chosenName ? (hasExt ? chosenName : `${chosenName}.${ext}`) : `${params.kind}.${ext}`;
+    return { contentType, filename };
+}
+export function looksLikeSendLocalFileIntent(rawBody) {
+    const t = rawBody.trim();
+    if (!t)
+        return false;
+    return /(发送|发给|发到|转发|把.*发|把.*发送|帮我发|给我发)/.test(t);
+}
+/**
+ * 根据错误信息对媒体下载/解密失败进行分类。
+ * 用于区分不同的失败原因：URL 过期、网络超时、文件超大、解密异常。
+ */
+function classifyMediaFailure(error) {
+    const message = String(error instanceof Error ? error.message : error).toLowerCase();
+    // 优先检查 URL 过期或禁止访问（403/401 或签名过期）
+    if (message.includes("403") ||
+        message.includes("forbidden") ||
+        message.includes("expired") ||
+        message.includes("signature") ||
+        message.includes("status=401")) {
+        return "expired_or_forbidden";
+    }
+    // 检查网络超时（5 分钟 URL 时效窗口内的超时属于此类）
+    if (message.includes("timeout") || message.includes("timed out") || message.includes("abort")) {
+        return "timeout";
+    }
+    // 检查文件大小超限
+    if (message.includes("maxbytes") ||
+        message.includes("exceed") ||
+        message.includes("too large") ||
+        message.includes("payload too large")) {
+        return "size_limit";
+    }
+    // 其他错误默认归类为解密失败
+    return "decrypt";
+}
+/**
+ * 从引用消息中选择并提取第一个可用的媒体候选。
+ *
+ * 优先级规则：
+ * 1. quote.image / quote.file / quote.video：单个媒体类型直接提取
+ * 2. quote.mixed：从多个 msg_item 中提取第一个 image
+ * 3. URI 过期约 5 分钟，必须尽快下载/解密
+ *
+ * @returns 包含 kind、url、aesKey、filename 的候选项，或 undefined
+ */
+function resolveQuoteMediaCandidate(msg) {
+    const quote = msg?.quote;
+    const quoteType = String(quote?.msgtype ?? "").toLowerCase();
+    // 处理单个媒体类型：image、file、video
+    if (quoteType === "image" || quoteType === "file" || quoteType === "video") {
+        const kind = quoteType;
+        const url = String(quote?.[kind]?.url ?? "").trim();
+        if (!url)
+            return undefined;
+        return {
+            kind,
+            url,
+            aesKey: quote?.[kind]?.aeskey,
+            explicitFilename: pickBotFileName(msg, quote?.[kind]),
+        };
+    }
+    // 处理混合消息类型：从 msg_item 数组中提取第一个图片
+    if (quoteType === "mixed" && Array.isArray(quote?.mixed?.msg_item)) {
+        for (const item of quote.mixed.msg_item) {
+            const itemType = String(item?.msgtype ?? "").toLowerCase();
+            if (itemType !== "image") {
+                continue;
+            }
+            const url = String(item?.image?.url ?? "").trim();
+            if (!url) {
+                continue;
+            }
+            return {
+                kind: "image",
+                url,
+                aesKey: item?.image?.aeskey,
+                explicitFilename: pickBotFileName(msg, item?.image),
+            };
+        }
+    }
+    return undefined;
+}
+export async function processBotInboundMessage(params) {
+    const { target, msg, recordOperationalIssue } = params;
+    const msgtype = String(msg.msgtype ?? "").toLowerCase();
+    const aesKey = target.account.encodingAESKey;
+    const maxBytes = resolveWecomMediaMaxBytes(target.config, target.account.accountId);
+    const proxyUrl = resolveWecomEgressProxyUrl(target.config);
+    const mediaTimeoutMs = resolveWecomMediaDownloadTimeoutMs(target.config);
+    const handleMediaFailure = (payload) => {
+        const reason = classifyMediaFailure(payload.error);
+        const hint = reason === "timeout"
+            ? `可调大 channels.wecom.media.downloadTimeoutMs（当前=${mediaTimeoutMs}ms）例如：openclaw config set channels.wecom.media.downloadTimeoutMs 45000`
+            : `可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`;
+        target.runtime.error?.(`Failed to decrypt ${payload.scope} ${payload.kind}: ${String(payload.error)} reason=${reason}; ${hint}`);
+        recordOperationalIssue({
+            category: "media-decrypt-failed",
+            messageId: msg.msgid ? String(msg.msgid) : undefined,
+            summary: `${payload.scope} ${payload.kind} decrypt failed reason=${reason} url=${payload.url}`,
+            raw: { transport: "bot-webhook", envelopeType: "json", body: msg },
+            error: payload.error instanceof Error ? payload.error.message : String(payload.error),
+        });
+        const errorMessage = typeof payload.error === "object" && payload.error
+            ? `${payload.error.message}${payload.error.cause ? ` (cause: ${String(payload.error.cause)})` : ""}`
+            : String(payload.error);
+        return { body: `${payload.bodyFallback} (decryption failed: ${errorMessage})` };
+    };
+    const tryDecryptMedia = async (payload) => {
+        const urlHost = (() => { try {
+            return new URL(payload.url).hostname;
+        }
+        catch {
+            return "?";
+        } })();
+        const t0 = Date.now();
+        console.log(`[wecom-media] download-start kind=${payload.kind} host=${urlHost} aesKey=${payload.aesKey ? "payload" : "account"} timeoutMs=${mediaTimeoutMs} proxy=${proxyUrl || "none"}`);
+        const decrypted = await decryptWecomMediaWithMeta(payload.url, payload.aesKey ?? aesKey, {
+            maxBytes,
+            http: { proxyUrl, timeoutMs: mediaTimeoutMs },
+        });
+        console.log(`[wecom-media] download-ok kind=${payload.kind} host=${urlHost} durationMs=${Date.now() - t0} bytes=${decrypted.buffer.length} contentType=${decrypted.sourceContentType ?? "?"}`);
+        const inferred = inferInboundMediaMeta({
+            kind: payload.kind === "image" ? "image" : "file",
+            buffer: decrypted.buffer,
+            sourceUrl: decrypted.sourceUrl || payload.url,
+            sourceContentType: decrypted.sourceContentType,
+            sourceFilename: decrypted.sourceFilename,
+            explicitFilename: payload.explicitFilename,
+        });
+        return {
+            buffer: decrypted.buffer,
+            contentType: inferred.contentType,
+            filename: inferred.filename,
+        };
+    };
+    if (msgtype === "image") {
+        const url = String(msg.image?.url ?? "").trim();
+        if (url && aesKey) {
+            try {
+                const media = await tryDecryptMedia({
+                    kind: "image",
+                    url,
+                    explicitFilename: pickBotFileName(msg),
+                    aesKey: msg.image?.aeskey,
+                });
+                return { body: "[image]", media };
+            }
+            catch (err) {
+                return handleMediaFailure({
+                    scope: "inbound",
+                    kind: "image",
+                    url,
+                    error: err,
+                    bodyFallback: "[image]",
+                });
+            }
+        }
+    }
+    if (msgtype === "file") {
+        const url = String(msg.file?.url ?? "").trim();
+        if (url && aesKey) {
+            try {
+                const media = await tryDecryptMedia({
+                    kind: "file",
+                    url,
+                    explicitFilename: pickBotFileName(msg),
+                    aesKey: msg.file?.aeskey,
+                });
+                return { body: "[file]", media };
+            }
+            catch (err) {
+                return handleMediaFailure({
+                    scope: "inbound",
+                    kind: "file",
+                    url,
+                    error: err,
+                    bodyFallback: "[file]",
+                });
+            }
+        }
+    }
+    if (msgtype === "video") {
+        const url = String(msg.video?.url ?? "").trim();
+        if (url && aesKey) {
+            try {
+                const media = await tryDecryptMedia({
+                    kind: "video",
+                    url,
+                    explicitFilename: pickBotFileName(msg),
+                    aesKey: msg.video?.aeskey,
+                });
+                return { body: "[video]", media };
+            }
+            catch (err) {
+                return handleMediaFailure({
+                    scope: "inbound",
+                    kind: "video",
+                    url,
+                    error: err,
+                    bodyFallback: "[video]",
+                });
+            }
+        }
+    }
+    if (msgtype === "mixed") {
+        const items = msg.mixed?.msg_item;
+        if (Array.isArray(items)) {
+            let foundMedia;
+            const bodyParts = [];
+            for (const item of items) {
+                const t = String(item.msgtype ?? "").toLowerCase();
+                if (t === "text") {
+                    const content = String(item.text?.content ?? "").trim();
+                    if (content)
+                        bodyParts.push(content);
+                    continue;
+                }
+                if ((t === "image" || t === "file" || t === "video") && !foundMedia && aesKey) {
+                    const mediaKind = t;
+                    const url = String(item[mediaKind]?.url ?? "").trim();
+                    if (url) {
+                        try {
+                            foundMedia = await tryDecryptMedia({
+                                kind: mediaKind,
+                                url,
+                                explicitFilename: pickBotFileName(msg, item?.[mediaKind]),
+                                aesKey: item?.[mediaKind]?.aeskey,
+                            });
+                            bodyParts.push(`[${t}]`);
+                            continue;
+                        }
+                        catch (err) {
+                            const failed = handleMediaFailure({
+                                scope: "mixed",
+                                kind: mediaKind,
+                                url,
+                                error: err,
+                                bodyFallback: `[${t}]`,
+                            });
+                            bodyParts.push(failed.body);
+                            continue;
+                        }
+                    }
+                }
+                bodyParts.push(`[${t}]`);
+            }
+            return { body: bodyParts.join("\n"), media: foundMedia };
+        }
+    }
+    if (msgtype === "text" || msgtype === "voice") {
+        const baseBody = buildInboundBody(msg);
+        // 新增支持：尝试从引用中提取候选媒体（支持 quote.image/file/video/mixed）
+        // 优先级：顶层媒体已在上面处理，如果没有顶层媒体才检查引用
+        const candidate = resolveQuoteMediaCandidate(msg);
+        if (candidate?.url && aesKey) {
+            const qHost = (() => { try {
+                return new URL(candidate.url).hostname;
+            }
+            catch {
+                return "?";
+            } })();
+            console.log(`[wecom-media] quote-candidate msgtype=${msgtype} kind=${candidate.kind} host=${qHost} aesKey=${candidate.aesKey ? "payload" : "account"} msgid=${msg.msgid ?? "?"}`);
+            try {
+                // 尽快下载并解密媒体（应对 5 分钟 URL 时效窗口）
+                const media = await tryDecryptMedia(candidate);
+                return { body: baseBody, media };
+            }
+            catch (err) {
+                // 下载或解密失败则降级，保留文本但记录失败原因便于调试
+                const failed = handleMediaFailure({
+                    scope: "quote",
+                    kind: candidate.kind,
+                    url: candidate.url,
+                    error: err,
+                    bodyFallback: `${baseBody}\n[quote:${candidate.kind}]`,
+                });
+                return failed;
+            }
+        }
+    }
+    return { body: buildInboundBody(msg) };
+}

package/dist/src/transport/bot-webhook/inbound.js

@@ -0,0 +1,4 @@
+import { resolveDerivedPathSummary } from "../../config/index.js";
+export function resolveBotWebhookPaths(accountId) {
+    return resolveDerivedPathSummary(accountId).botWebhook;
+}

package/dist/src/transport/bot-webhook/message-shape.js

@@ -0,0 +1,98 @@
+export function resolveWecomSenderUserId(msg) {
+    const direct = msg.from?.userid?.trim();
+    if (direct)
+        return direct;
+    const legacy = String(msg.fromuserid ?? msg.from_userid ?? msg.fromUserId ?? "").trim();
+    return legacy || undefined;
+}
+export function shouldProcessBotInboundMessage(msg) {
+    const senderUserId = resolveWecomSenderUserId(msg)?.trim();
+    if (!senderUserId) {
+        return { shouldProcess: false, reason: "missing_sender" };
+    }
+    if (senderUserId.toLowerCase() === "sys") {
+        return { shouldProcess: false, reason: "system_sender" };
+    }
+    const chatType = String(msg.chattype ?? "").trim().toLowerCase();
+    if (chatType === "group") {
+        const chatId = msg.chatid?.trim();
+        if (!chatId) {
+            return { shouldProcess: false, reason: "missing_chatid", senderUserId };
+        }
+        return { shouldProcess: true, reason: "user_message", senderUserId, chatId };
+    }
+    return { shouldProcess: true, reason: "user_message", senderUserId, chatId: senderUserId };
+}
+function formatQuote(quote) {
+    const type = quote.msgtype ?? "";
+    if (type === "text")
+        return quote.text?.content || "";
+    if (type === "image")
+        return `[引用: 图片] ${quote.image?.url || ""}`;
+    if (type === "mixed" && quote.mixed?.msg_item) {
+        const items = quote.mixed.msg_item
+            .map((item) => {
+            if (item.msgtype === "text")
+                return item.text?.content;
+            if (item.msgtype === "image")
+                return `[图片] ${item.image?.url || ""}`;
+            return "";
+        })
+            .filter(Boolean)
+            .join(" ");
+        return `[引用: 图文] ${items}`;
+    }
+    if (type === "voice")
+        return `[引用: 语音] ${quote.voice?.content || ""}`;
+    if (type === "file")
+        return `[引用: 文件] ${quote.file?.url || ""}`;
+    // 新增支持：引用视频类型 - 将在入站正规化中提取媒体并落盘
+    if (type === "video")
+        return `[引用: 视频] ${quote.video?.url || ""}`;
+    return "";
+}
+export function buildInboundBody(msg) {
+    let body = "";
+    const msgtype = String(msg.msgtype ?? "").toLowerCase();
+    if (msgtype === "text")
+        body = msg.text?.content || "";
+    else if (msgtype === "voice")
+        body = msg.voice?.content || "[voice]";
+    else if (msgtype === "mixed") {
+        const items = msg.mixed?.msg_item;
+        if (Array.isArray(items)) {
+            body = items
+                .map((item) => {
+                const t = String(item?.msgtype ?? "").toLowerCase();
+                if (t === "text")
+                    return item?.text?.content || "";
+                if (t === "image")
+                    return `[image] ${item?.image?.url || ""}`;
+                return `[${t || "item"}]`;
+            })
+                .filter(Boolean)
+                .join("\n");
+        }
+        else
+            body = "[mixed]";
+    }
+    else if (msgtype === "image")
+        body = `[image] ${msg.image?.url || ""}`;
+    else if (msgtype === "file")
+        body = `[file] ${msg.file?.url || ""}`;
+    else if (msgtype === "video")
+        body = `[video] ${msg.video?.url || ""}`;
+    else if (msgtype === "event")
+        body = `[event] ${msg.event?.eventtype || ""}`;
+    else if (msgtype === "stream")
+        body = `[stream_refresh] ${msg.stream?.id || ""}`;
+    else
+        body = msgtype ? `[${msgtype}]` : "";
+    const quote = msg.quote;
+    if (quote) {
+        const quoteText = formatQuote(quote).trim();
+        if (quoteText)
+            body += `\n\n> ${quoteText}`;
+    }
+    return body;
+}