@yanhaidao/wecom 2.4.120 → 2.5.110

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

@@ -0,0 +1,124 @@
+import { LIMITS } from "../../monitor/state.js";
+import { computeWecomMsgSignature, encryptWecomPlaintext } from "../../crypto.js";
+function truncateUtf8Bytes(text, maxBytes) {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.length <= maxBytes)
+        return text;
+    const slice = buf.subarray(buf.length - maxBytes);
+    return slice.toString("utf8");
+}
+export function jsonOk(res, body) {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+export async function readBotWebhookJsonBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    return await new Promise((resolve) => {
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                resolve({ ok: false, error: "payload too large" });
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                if (!raw.trim()) {
+                    resolve({ ok: false, error: "empty payload" });
+                    return;
+                }
+                resolve({ ok: true, value: JSON.parse(raw) });
+            }
+            catch (err) {
+                resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        req.on("error", (err) => {
+            resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+        });
+    });
+}
+export function buildEncryptedBotWebhookReply(params) {
+    const plaintext = JSON.stringify(params.plaintextJson ?? {});
+    const encrypt = encryptWecomPlaintext({
+        encodingAESKey: params.account.encodingAESKey ?? "",
+        receiveId: params.account.receiveId ?? "",
+        plaintext,
+    });
+    const msgsignature = computeWecomMsgSignature({
+        token: params.account.token ?? "",
+        timestamp: params.timestamp,
+        nonce: params.nonce,
+        encrypt,
+    });
+    return {
+        encrypt,
+        msgsignature,
+        timestamp: params.timestamp,
+        nonce: params.nonce,
+    };
+}
+export function resolveBotIdentitySet(target) {
+    const ids = new Set();
+    const single = target.account.config.aibotid?.trim();
+    if (single)
+        ids.add(single);
+    for (const botId of target.account.config.botIds ?? []) {
+        const normalized = String(botId ?? "").trim();
+        if (normalized)
+            ids.add(normalized);
+    }
+    return ids;
+}
+export function buildStreamPlaceholderReply(params) {
+    const content = params.placeholderContent?.trim() || "1";
+    return {
+        msgtype: "stream",
+        stream: {
+            id: params.streamId,
+            finish: false,
+            content,
+        },
+    };
+}
+export function buildStreamTextPlaceholderReply(params) {
+    return {
+        msgtype: "stream",
+        stream: {
+            id: params.streamId,
+            finish: false,
+            content: params.content.trim() || "1",
+        },
+    };
+}
+export function buildStreamReplyFromState(state) {
+    const content = truncateUtf8Bytes(state.content, LIMITS.STREAM_MAX_BYTES);
+    return {
+        msgtype: "stream",
+        stream: {
+            id: state.streamId,
+            finish: state.finished,
+            content,
+            ...(state.finished && state.images?.length
+                ? {
+                    msg_item: state.images.map((img) => ({
+                        msgtype: "image",
+                        image: { base64: img.base64, md5: img.md5 },
+                    })),
+                }
+                : {}),
+        },
+    };
+}
+export function parseWecomPlainMessage(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+        return {};
+    }
+    return parsed;
+}

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

@@ -0,0 +1,9 @@
+export function createBotWebhookReplyContext(params) {
+    return {
+        transport: "bot-webhook",
+        accountId: params.accountId,
+        responseUrl: params.responseUrl,
+        passiveWindowMs: 5_000,
+        raw: params.raw,
+    };
+}

package/dist/src/transport/bot-webhook/request-handler.js

@@ -0,0 +1,285 @@
+import { getWecomRuntime } from "../../runtime.js";
+import { decryptWecomEncrypted, verifyWecomSignature } from "../../crypto.js";
+import { resolveWecomEgressProxyUrl } from "../../config/index.js";
+import { logRouteFailure, resolveQueryParams, resolveSignatureParam, writeRouteFailure, } from "../http/common.js";
+import { buildEncryptedBotWebhookReply, buildStreamPlaceholderReply, buildStreamReplyFromState, buildStreamTextPlaceholderReply, jsonOk, parseWecomPlainMessage, readBotWebhookJsonBody, resolveBotIdentitySet, } from "./protocol.js";
+import { storeActiveReply } from "./active-reply.js";
+import { buildInboundBody, resolveWecomSenderUserId, shouldProcessBotInboundMessage } from "./message-shape.js";
+const ERROR_HELP = "\n\n遇到问题？联系作者: YanHaidao (微信: YanHaidao)";
+export function createBotWebhookRequestHandler(params) {
+    const { streamStore, logInfo, logVerbose, recordBotOperationalEvent, startAgentForStream } = params;
+    return async function handleBotWebhookRequest(args) {
+        const { req, res, path, reqId, targets } = args;
+        const query = resolveQueryParams(req);
+        const timestamp = query.get("timestamp") ?? "";
+        const nonce = query.get("nonce") ?? "";
+        const signature = resolveSignatureParam(query);
+        if (req.method === "GET") {
+            const echostr = query.get("echostr") ?? "";
+            const signatureMatches = targets.filter((target) => target.account.token &&
+                verifyWecomSignature({ token: target.account.token, timestamp, nonce, encrypt: echostr, signature }));
+            if (signatureMatches.length !== 1) {
+                const reason = signatureMatches.length === 0 ? "wecom_account_not_found" : "wecom_account_conflict";
+                const candidateIds = (signatureMatches.length > 0 ? signatureMatches : targets).map((target) => target.account.accountId);
+                logRouteFailure({
+                    reqId,
+                    path,
+                    method: "GET",
+                    reason,
+                    candidateAccountIds: candidateIds,
+                });
+                writeRouteFailure(res, reason, reason === "wecom_account_conflict"
+                    ? "Bot callback account conflict: multiple accounts matched signature."
+                    : "Bot callback account not found: signature verification failed.");
+                return true;
+            }
+            const target = signatureMatches[0];
+            try {
+                const plain = decryptWecomEncrypted({
+                    encodingAESKey: target.account.encodingAESKey,
+                    receiveId: target.account.receiveId,
+                    encrypt: echostr,
+                });
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "text/plain; charset=utf-8");
+                res.end(plain);
+                return true;
+            }
+            catch (err) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "text/plain; charset=utf-8");
+                res.end(`decrypt failed - 解密失败，请检查 EncodingAESKey${ERROR_HELP}`);
+                return true;
+            }
+        }
+        if (req.method !== "POST")
+            return false;
+        const body = await readBotWebhookJsonBody(req, 1024 * 1024);
+        if (!body.ok) {
+            res.statusCode = 400;
+            res.end(body.error || "invalid payload");
+            return true;
+        }
+        const record = body.value;
+        const encrypt = String(record?.encrypt ?? record?.Encrypt ?? "");
+        console.log(`[wecom] inbound(bot): reqId=${reqId} rawJsonBytes=${Buffer.byteLength(JSON.stringify(record), "utf8")} hasEncrypt=${Boolean(encrypt)} encryptLen=${encrypt.length}`);
+        const signatureMatches = targets.filter((target) => target.account.token && verifyWecomSignature({ token: target.account.token, timestamp, nonce, encrypt, signature }));
+        if (signatureMatches.length !== 1) {
+            const reason = signatureMatches.length === 0 ? "wecom_account_not_found" : "wecom_account_conflict";
+            const candidateIds = (signatureMatches.length > 0 ? signatureMatches : targets).map((target) => target.account.accountId);
+            logRouteFailure({
+                reqId,
+                path,
+                method: "POST",
+                reason,
+                candidateAccountIds: candidateIds,
+            });
+            writeRouteFailure(res, reason, reason === "wecom_account_conflict"
+                ? "Bot callback account conflict: multiple accounts matched signature."
+                : "Bot callback account not found: signature verification failed.");
+            return true;
+        }
+        const target = signatureMatches[0];
+        let msg;
+        try {
+            const plain = decryptWecomEncrypted({
+                encodingAESKey: target.account.encodingAESKey,
+                receiveId: target.account.receiveId,
+                encrypt,
+            });
+            msg = parseWecomPlainMessage(plain);
+        }
+        catch {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.end(`decrypt failed - 解密失败，请检查 EncodingAESKey${ERROR_HELP}`);
+            return true;
+        }
+        const expected = resolveBotIdentitySet(target);
+        if (expected.size > 0) {
+            const inboundAibotId = String(msg.aibotid ?? "").trim();
+            if (!inboundAibotId || !expected.has(inboundAibotId)) {
+                target.runtime.error?.(`[wecom] inbound(bot): reqId=${reqId} accountId=${target.account.accountId} aibotid_mismatch expected=${Array.from(expected).join(",")} actual=${inboundAibotId || "N/A"}`);
+            }
+        }
+        logInfo(target, `inbound(bot): reqId=${reqId} selectedAccount=${target.account.accountId} path=${path}`);
+        target.touchTransportSession?.({ lastInboundAt: Date.now(), running: true });
+        const msgtype = String(msg.msgtype ?? "").toLowerCase();
+        const proxyUrl = resolveWecomEgressProxyUrl(target.config);
+        if (msgtype === "event") {
+            const eventtype = String(msg.event?.eventtype ?? "").toLowerCase();
+            if (eventtype === "template_card_event") {
+                const msgid = msg.msgid ? String(msg.msgid) : undefined;
+                if (msgid && streamStore.getStreamByMsgId(msgid)) {
+                    logVerbose(target, `template_card_event: already processed msgid=${msgid}, skipping`);
+                    recordBotOperationalEvent(target, {
+                        category: "duplicate-reply",
+                        messageId: msgid,
+                        summary: `duplicate template card event msgid=${msgid}`,
+                        raw: {
+                            transport: "bot-webhook",
+                            envelopeType: "json",
+                            body: msg,
+                        },
+                    });
+                    jsonOk(res, buildEncryptedBotWebhookReply({ account: target.account, plaintextJson: {}, nonce, timestamp }));
+                    return true;
+                }
+                const cardEvent = msg.event?.template_card_event;
+                let interactionDesc = `[卡片交互] 按钮: ${cardEvent?.event_key || "unknown"}`;
+                if (cardEvent?.selected_items?.selected_item?.length) {
+                    const selects = cardEvent.selected_items.selected_item.map((i) => `${i.question_key}=${i.option_ids?.option_id?.join(",")}`);
+                    interactionDesc += ` 选择: ${selects.join("; ")}`;
+                }
+                if (cardEvent?.task_id)
+                    interactionDesc += ` (任务ID: ${cardEvent.task_id})`;
+                jsonOk(res, buildEncryptedBotWebhookReply({ account: target.account, plaintextJson: {}, nonce, timestamp }));
+                const streamId = streamStore.createStream({ msgid });
+                streamStore.markStarted(streamId);
+                storeActiveReply(streamId, msg.response_url);
+                const core = getWecomRuntime();
+                startAgentForStream({
+                    target: { ...target, core },
+                    accountId: target.account.accountId,
+                    msg: { ...msg, msgtype: "text", text: { content: interactionDesc } },
+                    streamId,
+                }).catch((err) => target.runtime.error?.(`interaction failed: ${String(err)}`));
+                return true;
+            }
+            if (eventtype === "enter_chat") {
+                const welcome = target.account.config.welcomeText?.trim();
+                jsonOk(res, buildEncryptedBotWebhookReply({
+                    account: target.account,
+                    plaintextJson: welcome ? { msgtype: "text", text: { content: welcome } } : {},
+                    nonce,
+                    timestamp,
+                }));
+                return true;
+            }
+            jsonOk(res, buildEncryptedBotWebhookReply({ account: target.account, plaintextJson: {}, nonce, timestamp }));
+            return true;
+        }
+        if (msgtype === "stream") {
+            const streamId = String(msg.stream?.id ?? "").trim();
+            const state = streamStore.getStream(streamId);
+            const reply = state
+                ? buildStreamReplyFromState(state)
+                : buildStreamReplyFromState({
+                    streamId: streamId || "unknown",
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                    started: true,
+                    finished: true,
+                    content: "",
+                });
+            jsonOk(res, buildEncryptedBotWebhookReply({ account: target.account, plaintextJson: reply, nonce, timestamp }));
+            return true;
+        }
+        try {
+            const decision = shouldProcessBotInboundMessage(msg);
+            if (!decision.shouldProcess) {
+                logInfo(target, `inbound: skipped msgtype=${msgtype} reason=${decision.reason} chattype=${String(msg.chattype ?? "")} chatid=${String(msg.chatid ?? "")} from=${resolveWecomSenderUserId(msg) || "N/A"}`);
+                jsonOk(res, buildEncryptedBotWebhookReply({ account: target.account, plaintextJson: {}, nonce, timestamp }));
+                return true;
+            }
+            const userid = decision.senderUserId;
+            const chatId = decision.chatId ?? userid;
+            const conversationKey = `wecom:${target.account.accountId}:${userid}:${chatId}`;
+            const msgContent = buildInboundBody(msg);
+            logInfo(target, `inbound: msgtype=${msgtype} chattype=${String(msg.chattype ?? "")} chatid=${String(msg.chatid ?? "")} from=${userid} msgid=${String(msg.msgid ?? "")} hasResponseUrl=${Boolean(msg.response_url)}`);
+            if (msg.msgid) {
+                const existingStreamId = streamStore.getStreamByMsgId(String(msg.msgid));
+                if (existingStreamId) {
+                    logInfo(target, `message: 重复的 msgid=${msg.msgid}，跳过处理并返回占位符 streamId=${existingStreamId}`);
+                    recordBotOperationalEvent(target, {
+                        category: "duplicate-reply",
+                        messageId: String(msg.msgid),
+                        summary: `duplicate inbound msgid=${String(msg.msgid)} streamId=${existingStreamId}`,
+                        raw: {
+                            transport: "bot-webhook",
+                            envelopeType: "json",
+                            body: msg,
+                        },
+                    });
+                    jsonOk(res, buildEncryptedBotWebhookReply({
+                        account: target.account,
+                        plaintextJson: buildStreamPlaceholderReply({
+                            streamId: existingStreamId,
+                            placeholderContent: target.account.config.streamPlaceholderContent,
+                        }),
+                        nonce,
+                        timestamp,
+                    }));
+                    return true;
+                }
+            }
+            const { streamId, status } = streamStore.addPendingMessage({
+                conversationKey,
+                target,
+                msg,
+                msgContent,
+                nonce,
+                timestamp,
+                debounceMs: target.account.config.debounceMs,
+            });
+            if (msg.response_url) {
+                storeActiveReply(streamId, msg.response_url, proxyUrl);
+            }
+            const defaultPlaceholder = target.account.config.streamPlaceholderContent;
+            const queuedPlaceholder = "已收到，已排队处理中...";
+            const mergedQueuedPlaceholder = "已收到，已合并排队处理中...";
+            if (status === "active_new") {
+                jsonOk(res, buildEncryptedBotWebhookReply({
+                    account: target.account,
+                    plaintextJson: buildStreamPlaceholderReply({
+                        streamId,
+                        placeholderContent: defaultPlaceholder,
+                    }),
+                    nonce,
+                    timestamp,
+                }));
+                return true;
+            }
+            if (status === "queued_new") {
+                logInfo(target, `queue: 已进入下一批次 streamId=${streamId} msgid=${String(msg.msgid ?? "")}`);
+                jsonOk(res, buildEncryptedBotWebhookReply({
+                    account: target.account,
+                    plaintextJson: buildStreamPlaceholderReply({
+                        streamId,
+                        placeholderContent: queuedPlaceholder,
+                    }),
+                    nonce,
+                    timestamp,
+                }));
+                return true;
+            }
+            const ackStreamId = streamStore.createStream({ msgid: String(msg.msgid ?? "") || undefined });
+            streamStore.updateStream(ackStreamId, (s) => {
+                s.finished = false;
+                s.started = true;
+                s.content = mergedQueuedPlaceholder;
+            });
+            if (msg.msgid)
+                streamStore.setStreamIdForMsgId(String(msg.msgid), ackStreamId);
+            streamStore.addAckStreamForBatch({ batchStreamId: streamId, ackStreamId });
+            logInfo(target, `queue: 已合并排队（回执流） ackStreamId=${ackStreamId} mergedIntoStreamId=${streamId} msgid=${String(msg.msgid ?? "")}`);
+            jsonOk(res, buildEncryptedBotWebhookReply({
+                account: target.account,
+                plaintextJson: buildStreamTextPlaceholderReply({ streamId: ackStreamId, content: mergedQueuedPlaceholder }),
+                nonce,
+                timestamp,
+            }));
+            return true;
+        }
+        catch (err) {
+            target.runtime.error?.(`[wecom] Bot message handler crashed: ${String(err)}`);
+            jsonOk(res, buildEncryptedBotWebhookReply({
+                account: target.account,
+                plaintextJson: { msgtype: "text", text: { content: "服务内部错误：Bot 处理异常，请稍后重试。" } },
+                nonce,
+                timestamp,
+            }));
+            return true;
+        }
+    };
+}

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

@@ -0,0 +1,15 @@
+export function createBotWebhookSessionSnapshot(params) {
+    return {
+        accountId: params.accountId,
+        transport: "bot-webhook",
+        running: params.running,
+        ownerId: `${params.accountId}:bot-webhook`,
+        connected: params.running,
+        authenticated: true,
+        lastConnectedAt: params.running ? Date.now() : undefined,
+        lastDisconnectedAt: params.running ? undefined : Date.now(),
+        lastInboundAt: params.lastInboundAt,
+        lastOutboundAt: params.lastOutboundAt,
+        lastError: params.lastError,
+    };
+}

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

@@ -0,0 +1,147 @@
+import { buildInboundBody } from "../bot-webhook/message-shape.js";
+function resolveInboundKind(message) {
+    if (message.msgtype === "event") {
+        const eventType = String(message.event?.eventtype ?? "").trim();
+        if (eventType === "enter_chat")
+            return "welcome";
+        if (eventType === "template_card_event")
+            return "template-card-event";
+        return "event";
+    }
+    switch (message.msgtype) {
+        case "image":
+            return "image";
+        case "file":
+            return "file";
+        case "voice":
+            return "voice";
+        case "video":
+            return "video";
+        case "mixed":
+            return "mixed";
+        default:
+            return "text";
+    }
+}
+function pushAttachment(list, name, remoteUrl, aesKey) {
+    if (!remoteUrl) {
+        return;
+    }
+    list.push({ name, remoteUrl, aesKey });
+}
+function resolveEventText(message, account) {
+    if (message.msgtype !== "event") {
+        return buildInboundBody(message);
+    }
+    const event = message;
+    if (event.event?.eventtype === "enter_chat" && account.config.welcomeText) {
+        return account.config.welcomeText;
+    }
+    return `[event:${String(event.event?.eventtype ?? "unknown")}]`;
+}
+export function mapBotWsFrameToInboundEvent(params) {
+    const { account, frame } = params;
+    const body = frame.body;
+    if (!body) {
+        throw new Error("Bot WS frame body is required");
+    }
+    const peerKind = body.chattype === "group" ? "group" : "direct";
+    const senderId = body.from?.userid ?? "unknown";
+    const peerId = peerKind === "group" ? body.chatid ?? senderId : senderId;
+    const inboundKind = resolveInboundKind(body);
+    let attachments;
+    const collected = [];
+    if (body.msgtype === "image") {
+        pushAttachment(collected, "image", body.image?.url, body.image?.aeskey);
+    }
+    else if (body.msgtype === "file") {
+        pushAttachment(collected, "file", body.file?.url, body.file?.aeskey);
+    }
+    else if (body.msgtype === "video") {
+        pushAttachment(collected, "video", body.video?.url, body.video?.aeskey);
+    }
+    else if (body.msgtype === "mixed") {
+        const items = body.mixed?.msg_item;
+        if (Array.isArray(items)) {
+            for (const item of items) {
+                const itemType = String(item.msgtype ?? "").toLowerCase();
+                if (itemType === "image") {
+                    pushAttachment(collected, "image", item.image?.url, item.image?.aeskey);
+                }
+                else if (itemType === "file") {
+                    pushAttachment(collected, "file", item.file?.url, item.file?.aeskey);
+                }
+                else if (itemType === "video") {
+                    pushAttachment(collected, "video", item.video?.url, item.video?.aeskey);
+                }
+            }
+        }
+    }
+    // 新增支持：如果没有顶层媒体，尝试从引用中提取媒体附件
+    // 优先级：quote.image/file/video 优先，其次 quote.mixed 中第一个图片
+    if (collected.length === 0) {
+        const quote = body.quote;
+        if (quote) {
+            const quoteType = String(quote.msgtype ?? "").toLowerCase();
+            // 处理单个媒体类型的引用
+            if (quoteType === "image") {
+                pushAttachment(collected, "image", quote.image?.url, quote.image?.aeskey);
+            }
+            else if (quoteType === "file") {
+                pushAttachment(collected, "file", quote.file?.url, quote.file?.aeskey);
+            }
+            else if (quoteType === "video") {
+                pushAttachment(collected, "video", quote.video?.url, quote.video?.aeskey);
+            }
+            // 处理图文混合类型：只提取第一个图片以保持与 webhook 一致
+            else 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") {
+                        pushAttachment(collected, "image", item.image?.url, item.image?.aeskey);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (collected.length > 0) {
+        attachments = collected;
+    }
+    return {
+        accountId: account.accountId,
+        capability: "bot",
+        transport: "bot-ws",
+        inboundKind,
+        messageId: body.msgid,
+        conversation: {
+            accountId: account.accountId,
+            peerKind,
+            peerId,
+            senderId,
+        },
+        senderName: senderId,
+        text: resolveEventText(body, account),
+        timestamp: typeof body.create_time === "number" ? body.create_time : Date.now(),
+        raw: {
+            transport: "bot-ws",
+            command: frame.cmd,
+            headers: frame.headers,
+            body,
+            envelopeType: "ws",
+        },
+        replyContext: {
+            transport: "bot-ws",
+            accountId: account.accountId,
+            reqId: frame.headers.req_id,
+            raw: {
+                transport: "bot-ws",
+                command: frame.cmd,
+                headers: frame.headers,
+                body,
+                envelopeType: "ws",
+            },
+        },
+        ...(attachments && { attachments }),
+    };
+}