@yanhaidao/wecom 2.4.160 → 2.5.110

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

@@ -0,0 +1,236 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertLocalMediaAllowed, detectMime, fetchRemoteMedia, } from "openclaw/plugin-sdk/media-runtime";
+const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+const VIDEO_MAX_BYTES = 10 * 1024 * 1024;
+const VOICE_MAX_BYTES = 2 * 1024 * 1024;
+const FILE_MAX_BYTES = 20 * 1024 * 1024;
+const VOICE_SUPPORTED_MIMES = new Set(["audio/amr"]);
+function detectWeComMediaType(mimeType) {
+    const mime = mimeType.toLowerCase();
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime.startsWith("audio/") || mime === "application/ogg")
+        return "voice";
+    return "file";
+}
+function mimeToExtension(mime) {
+    const map = {
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/bmp": ".bmp",
+        "image/svg+xml": ".svg",
+        "video/mp4": ".mp4",
+        "video/quicktime": ".mov",
+        "video/x-msvideo": ".avi",
+        "video/webm": ".webm",
+        "audio/mpeg": ".mp3",
+        "audio/ogg": ".ogg",
+        "audio/wav": ".wav",
+        "audio/amr": ".amr",
+        "audio/aac": ".aac",
+        "application/pdf": ".pdf",
+        "application/zip": ".zip",
+        "application/msword": ".doc",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+        "application/vnd.ms-excel": ".xls",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+        "text/plain": ".txt",
+    };
+    return map[mime] || ".bin";
+}
+function extractFileName(mediaUrl, providedFileName, contentType) {
+    if (providedFileName)
+        return providedFileName;
+    try {
+        const url = new URL(mediaUrl, "file://");
+        const lastPart = url.pathname.split("/").filter(Boolean).pop();
+        if (lastPart && lastPart.includes(".")) {
+            return decodeURIComponent(lastPart);
+        }
+    }
+    catch {
+        const lastPart = mediaUrl.split("/").filter(Boolean).pop();
+        if (lastPart && lastPart.includes(".")) {
+            return lastPart;
+        }
+    }
+    return `media_${Date.now()}${mimeToExtension(contentType || "application/octet-stream")}`;
+}
+function resolveLocalMediaPath(mediaUrl) {
+    if (mediaUrl.startsWith("file://")) {
+        return fileURLToPath(mediaUrl);
+    }
+    return mediaUrl;
+}
+async function loadOutboundMediaFile(params) {
+    if (/^https?:\/\//i.test(params.mediaUrl)) {
+        return await fetchRemoteMedia({
+            url: params.mediaUrl,
+            maxBytes: params.maxBytes,
+            filePathHint: params.mediaUrl,
+        });
+    }
+    const mediaPath = resolveLocalMediaPath(params.mediaUrl);
+    await assertLocalMediaAllowed(mediaPath, params.mediaLocalRoots);
+    const buffer = await readFile(mediaPath);
+    if (buffer.length > params.maxBytes) {
+        throw new Error(`Media size ${(buffer.length / (1024 * 1024)).toFixed(2)}MB exceeds max ${(params.maxBytes /
+            (1024 * 1024)).toFixed(2)}MB`);
+    }
+    return {
+        buffer,
+        fileName: path.basename(mediaPath),
+    };
+}
+function applyFileSizeLimits(fileSize, detectedType, contentType) {
+    const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+    if (fileSize > FILE_MAX_BYTES) {
+        return {
+            finalType: detectedType,
+            shouldReject: true,
+            rejectReason: `文件大小 ${fileSizeMB}MB 超过了企业微信允许的最大限制 20MB，无法发送。`,
+            downgraded: false,
+        };
+    }
+    switch (detectedType) {
+        case "image":
+            if (fileSize > IMAGE_MAX_BYTES) {
+                return {
+                    finalType: "file",
+                    shouldReject: false,
+                    downgraded: true,
+                    downgradeNote: `图片大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+                };
+            }
+            break;
+        case "video":
+            if (fileSize > VIDEO_MAX_BYTES) {
+                return {
+                    finalType: "file",
+                    shouldReject: false,
+                    downgraded: true,
+                    downgradeNote: `视频大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+                };
+            }
+            break;
+        case "voice":
+            if (contentType && !VOICE_SUPPORTED_MIMES.has(contentType.toLowerCase())) {
+                return {
+                    finalType: "file",
+                    shouldReject: false,
+                    downgraded: true,
+                    downgradeNote: `语音格式 ${contentType} 不支持，企微仅支持 AMR 格式，已转为文件格式发送`,
+                };
+            }
+            if (fileSize > VOICE_MAX_BYTES) {
+                return {
+                    finalType: "file",
+                    shouldReject: false,
+                    downgraded: true,
+                    downgradeNote: `语音大小 ${fileSizeMB}MB 超过 2MB 限制，已转为文件格式发送`,
+                };
+            }
+            break;
+        default:
+            break;
+    }
+    return {
+        finalType: detectedType,
+        shouldReject: false,
+        downgraded: false,
+    };
+}
+async function resolveMediaFile(mediaUrl, mediaLocalRoots, maxBytes) {
+    const result = await loadOutboundMediaFile({
+        mediaUrl,
+        maxBytes: maxBytes ?? FILE_MAX_BYTES,
+        mediaLocalRoots,
+    });
+    let contentType = result.contentType || "application/octet-stream";
+    if (contentType === "application/octet-stream" || contentType === "text/plain") {
+        const detected = await detectMime({
+            buffer: result.buffer,
+            filePath: result.fileName ?? mediaUrl,
+        });
+        if (detected) {
+            contentType = detected;
+        }
+    }
+    return {
+        buffer: result.buffer,
+        contentType,
+        fileName: extractFileName(mediaUrl, result.fileName, contentType),
+    };
+}
+export async function uploadAndSendBotWsMedia(params) {
+    try {
+        const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots, params.maxBytes);
+        const detectedType = detectWeComMediaType(media.contentType);
+        const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
+        if (sizeCheck.shouldReject) {
+            return {
+                ok: false,
+                rejected: true,
+                rejectReason: sizeCheck.rejectReason,
+                finalType: sizeCheck.finalType,
+            };
+        }
+        const uploadResult = await params.wsClient.uploadMedia(media.buffer, {
+            type: sizeCheck.finalType,
+            filename: media.fileName,
+        });
+        const sendResult = await params.wsClient.sendMediaMessage(params.chatId, sizeCheck.finalType, uploadResult.media_id);
+        return {
+            ok: true,
+            messageId: sendResult?.headers?.req_id ?? `wecom-media-${Date.now()}`,
+            finalType: sizeCheck.finalType,
+            downgraded: sizeCheck.downgraded,
+            downgradeNote: sizeCheck.downgradeNote,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function uploadAndReplyBotWsMedia(params) {
+    try {
+        const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots, params.maxBytes);
+        const detectedType = detectWeComMediaType(media.contentType);
+        const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
+        if (sizeCheck.shouldReject) {
+            return {
+                ok: false,
+                rejected: true,
+                rejectReason: sizeCheck.rejectReason,
+                finalType: sizeCheck.finalType,
+            };
+        }
+        const uploadResult = await params.wsClient.uploadMedia(media.buffer, {
+            type: sizeCheck.finalType,
+            filename: media.fileName,
+        });
+        const replyResult = await params.wsClient.replyMedia(params.frame, sizeCheck.finalType, uploadResult.media_id);
+        return {
+            ok: true,
+            messageId: replyResult?.headers?.req_id ?? `wecom-reply-media-${Date.now()}`,
+            finalType: sizeCheck.finalType,
+            downgraded: sizeCheck.downgraded,
+            downgradeNote: sizeCheck.downgradeNote,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

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

@@ -0,0 +1,310 @@
+import { generateReqId, } from "@wecom/aibot-node-sdk";
+import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots } from "../../config/index.js";
+import { getWecomRuntime } from "../../runtime.js";
+import { toWeComMarkdownV2 } from "../../wecom_msg_adapter/markdown_adapter.js";
+import { uploadAndSendBotWsMedia } from "./media.js";
+const PLACEHOLDER_KEEPALIVE_MS = 3000;
+const MAX_KEEPALIVE_MS = 120 * 1000; // Force stop keepalive after 120s if ignored
+function isInvalidReqIdError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const errcode = "errcode" in error ? Number(error.errcode) : undefined;
+    const errmsg = "errmsg" in error ? String(error.errmsg ?? "") : "";
+    return errcode === 846605 || errmsg.includes("invalid req_id");
+}
+function isExpiredStreamUpdateError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const errcode = "errcode" in error ? Number(error.errcode) : undefined;
+    const errmsg = "errmsg" in error ? String(error.errmsg ?? "").toLowerCase() : "";
+    return errcode === 846608 || errmsg.includes("stream message update expired");
+}
+/** SDK rejects with a plain Error whose message contains "ack timeout" when
+ * the WeCom server does not acknowledge a reply within 5 s.  Once timed out
+ * the reqId slot is released; further replies on the same reqId will fail. */
+function isAckTimeoutError(error) {
+    return error instanceof Error && error.message.includes("ack timeout");
+}
+function isTerminalReplyError(error) {
+    return (isInvalidReqIdError(error) || isExpiredStreamUpdateError(error) || isAckTimeoutError(error));
+}
+function formatMediaFailure(mediaUrl, error, rejectReason) {
+    const reason = rejectReason || error || "unknown";
+    return `媒体发送失败：${mediaUrl} (${reason})`;
+}
+const activeKeepalivesByPeer = new Map();
+export function createBotWsReplyHandle(params) {
+    let streamId;
+    let accumulatedText = "";
+    let deferredMediaUrls = [];
+    const resolveStreamId = () => {
+        streamId ||= generateReqId("stream");
+        return streamId;
+    };
+    const placeholderText = params.placeholderContent?.trim() || "⏳ 正在思考中...\n\n";
+    let streamSettled = false;
+    let placeholderInFlight = false;
+    let placeholderKeepalive;
+    let placeholderTimeout;
+    // Extract peerId for clustering handles
+    const body = params.frame.body;
+    const peerId = String((body?.chattype === "group" ? body?.chatid || body?.from?.userid : body?.from?.userid) ||
+        "unknown");
+    const reqId = params.frame.headers.req_id || "unknown";
+    const isEvent = params.inboundKind === "welcome" ||
+        params.inboundKind === "event" ||
+        params.inboundKind === "template-card-event";
+    const stopPlaceholderKeepalive = () => {
+        if (placeholderKeepalive) {
+            clearInterval(placeholderKeepalive);
+            placeholderKeepalive = undefined;
+        }
+        if (placeholderTimeout) {
+            clearTimeout(placeholderTimeout);
+            placeholderTimeout = undefined;
+        }
+        // Remove from registry
+        const keepalives = activeKeepalivesByPeer.get(peerId);
+        if (keepalives) {
+            for (const ka of keepalives) {
+                if (ka.reqId === reqId) {
+                    keepalives.delete(ka);
+                }
+            }
+            if (keepalives.size === 0) {
+                activeKeepalivesByPeer.delete(peerId);
+            }
+        }
+    };
+    const settleStream = () => {
+        if (streamSettled)
+            return;
+        streamSettled = true;
+        stopPlaceholderKeepalive();
+    };
+    const sendPlaceholder = () => {
+        if (streamSettled || placeholderInFlight || isEvent)
+            return;
+        placeholderInFlight = true;
+        params.client
+            .replyStream(params.frame, resolveStreamId(), placeholderText, false)
+            .catch((error) => {
+            if (!isTerminalReplyError(error)) {
+                return;
+            }
+            settleStream();
+            params.onFail?.(error);
+        })
+            .finally(() => {
+            placeholderInFlight = false;
+        });
+    };
+    const notifyPeerActive = () => {
+        // A genuine reply or reasoning is happening on THIS handle.
+        // It means the core SDK has chosen this handle to deliver the response.
+        // We can safely terminate all other orphaned keepalives for this peer to prevent infinite loops.
+        const keepalives = activeKeepalivesByPeer.get(peerId);
+        if (keepalives) {
+            for (const ka of keepalives) {
+                if (ka.reqId !== reqId) {
+                    ka.stop();
+                }
+            }
+        }
+    };
+    const mergeDeferredMediaUrls = (urls) => {
+        if (urls.length === 0) {
+            return deferredMediaUrls;
+        }
+        const merged = [...deferredMediaUrls];
+        for (const url of urls) {
+            if (!merged.includes(url)) {
+                merged.push(url);
+            }
+        }
+        deferredMediaUrls = merged;
+        return deferredMediaUrls;
+    };
+    if (params.autoSendPlaceholder !== false && !isEvent) {
+        sendPlaceholder();
+        placeholderKeepalive = setInterval(() => {
+            sendPlaceholder();
+        }, PLACEHOLDER_KEEPALIVE_MS);
+        // Safety net: force stop keepalive after MAX_KEEPALIVE_MS
+        // in case the message is completely ignored by the core and never triggers deliver/fail
+        placeholderTimeout = setTimeout(() => {
+            stopPlaceholderKeepalive();
+        }, MAX_KEEPALIVE_MS);
+        // Register keepalive
+        let keepalives = activeKeepalivesByPeer.get(peerId);
+        if (!keepalives) {
+            keepalives = new Set();
+            activeKeepalivesByPeer.set(peerId, keepalives);
+        }
+        keepalives.add({ reqId, stop: stopPlaceholderKeepalive });
+    }
+    return {
+        context: {
+            transport: "bot-ws",
+            accountId: params.accountId,
+            reqId: params.frame.headers.req_id,
+            raw: {
+                transport: "bot-ws",
+                command: params.frame.cmd,
+                headers: params.frame.headers,
+                body: params.frame.body,
+                envelopeType: "ws",
+            },
+        },
+        deliver: async (payload, info) => {
+            // Mark this chat as active on this handle
+            notifyPeerActive();
+            if (payload.isReasoning) {
+                // We reset the safety timeout if reasoning is actively streaming
+                if (placeholderTimeout && !isEvent) {
+                    clearTimeout(placeholderTimeout);
+                    placeholderTimeout = setTimeout(() => {
+                        stopPlaceholderKeepalive();
+                    }, MAX_KEEPALIVE_MS);
+                }
+                return;
+            }
+            const text = payload.text?.trim() || "";
+            const incomingMediaUrls = payload.mediaUrls || (payload.mediaUrl ? [payload.mediaUrl] : []);
+            const hasIncomingMedia = incomingMediaUrls.length > 0;
+            if (info.kind !== "final" && hasIncomingMedia) {
+                mergeDeferredMediaUrls(incomingMediaUrls);
+            }
+            const mediaUrls = info.kind === "final" ? mergeDeferredMediaUrls(incomingMediaUrls) : incomingMediaUrls;
+            if (!text && mediaUrls.length === 0) {
+                return;
+            }
+            if (info.kind === "block") {
+                if (!text) {
+                    return;
+                }
+                accumulatedText = accumulatedText ? `${accumulatedText}\n${text}` : text;
+            }
+            const outboundText = info.kind === "final"
+                ? accumulatedText
+                    ? text
+                        ? `${accumulatedText}\n${text}`
+                        : accumulatedText
+                    : text
+                : accumulatedText || text;
+            let finalText = outboundText;
+            if (info.kind === "final" && mediaUrls.length > 0) {
+                const cfg = getWecomRuntime().config.loadConfig();
+                const mediaLocalRoots = resolveWecomMergedMediaLocalRoots({ cfg });
+                const mediaMaxBytes = resolveWecomMediaMaxBytes(cfg, params.accountId);
+                const mediaFailures = [];
+                const mediaNotes = [];
+                let mediaSent = 0;
+                for (const mediaUrl of mediaUrls) {
+                    const result = await uploadAndSendBotWsMedia({
+                        wsClient: params.client,
+                        chatId: peerId,
+                        mediaUrl,
+                        mediaLocalRoots,
+                        maxBytes: mediaMaxBytes,
+                    });
+                    if (result.ok) {
+                        mediaSent += 1;
+                        if (result.downgradeNote) {
+                            mediaNotes.push(result.downgradeNote);
+                        }
+                        continue;
+                    }
+                    mediaFailures.push(formatMediaFailure(mediaUrl, result.error, result.rejectReason));
+                }
+                if (!finalText && mediaSent > 0) {
+                    finalText = "文件已发送。";
+                }
+                if (mediaFailures.length > 0) {
+                    finalText = finalText
+                        ? `${finalText}\n\n${mediaFailures.join("\n")}`
+                        : mediaFailures.join("\n");
+                }
+                if (mediaNotes.length > 0) {
+                    finalText = finalText
+                        ? `${finalText}\n\n${mediaNotes.join("\n")}`
+                        : mediaNotes.join("\n");
+                }
+                deferredMediaUrls = [];
+            }
+            if (!finalText) {
+                return;
+            }
+            // Event frames do not support streaming chunks
+            if (isEvent && info.kind !== "final") {
+                return;
+            }
+            settleStream();
+            try {
+                if (params.inboundKind === "welcome") {
+                    await params.client.replyWelcome(params.frame, {
+                        msgtype: "text",
+                        text: { content: finalText },
+                    });
+                }
+                else if (isEvent) {
+                    // Send push message for other events
+                    await params.client.sendMessage(peerId, {
+                        msgtype: "markdown",
+                        markdown: { content: toWeComMarkdownV2(finalText) },
+                    });
+                }
+                else {
+                    await params.client.replyStream(params.frame, resolveStreamId(), toWeComMarkdownV2(finalText), info.kind === "final");
+                }
+            }
+            catch (error) {
+                if (isTerminalReplyError(error)) {
+                    params.onFail?.(error);
+                    return;
+                }
+                throw error;
+            }
+            params.onDeliver?.();
+        },
+        fail: async (error) => {
+            notifyPeerActive();
+            settleStream();
+            if (isTerminalReplyError(error)) {
+                params.onFail?.(error);
+                return;
+            }
+            const message = formatErrorMessage(error);
+            const text = `WeCom WS reply failed: ${message}`;
+            try {
+                if (params.inboundKind === "welcome") {
+                    await params.client.replyWelcome(params.frame, {
+                        msgtype: "text",
+                        text: { content: text },
+                    });
+                }
+                else if (isEvent) {
+                    await params.client.sendMessage(peerId, {
+                        msgtype: "markdown",
+                        markdown: { content: text },
+                    });
+                }
+                else {
+                    await params.client.replyStream(params.frame, resolveStreamId(), text, true);
+                }
+            }
+            catch (sendError) {
+                params.onFail?.(sendError);
+                return;
+            }
+            params.onFail?.(error);
+        },
+        markExternalActivity: () => {
+            notifyPeerActive();
+            stopPlaceholderKeepalive();
+        },
+    };
+}