@yanhaidao/wecom 2.3.160 → 2.3.190

package/src/runtime/source-registry.ts

@@ -0,0 +1,165 @@
+export type WecomSourcePlane = "bot-ws" | "agent-callback";
+
+export type WecomSourceSnapshot = {
+  accountId: string;
+  source: WecomSourcePlane;
+  recordedAt: number;
+  messageId?: string;
+  sessionKey?: string;
+  sessionId?: string;
+};
+
+const MAX_MESSAGE_FACTS = 2048;
+const MAX_SESSION_SNAPSHOTS = 1024;
+
+const messageFacts = new Map<string, WecomSourceSnapshot>();
+const sessionSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
+const sessionSnapshotsByLooseKey = new Map<string, WecomSourceSnapshot>();
+
+function normalizeOptional(value: string | null | undefined): string | undefined {
+  const trimmed = String(value ?? "").trim();
+  return trimmed || undefined;
+}
+
+function messageFactKey(accountId: string, messageId: string): string {
+  return `${accountId}::${messageId}`;
+}
+
+function accountScopedSessionKey(
+  accountId: string,
+  kind: "sessionKey" | "sessionId",
+  value: string,
+): string {
+  return `${accountId}::${kind}::${value}`;
+}
+
+function pruneOldest<T>(map: Map<string, T>, maxSize: number): void {
+  while (map.size > maxSize) {
+    const oldestKey = map.keys().next().value;
+    if (!oldestKey) return;
+    map.delete(oldestKey);
+  }
+}
+
+function writeSessionSnapshot(snapshot: WecomSourceSnapshot): void {
+  const sessionKey = normalizeOptional(snapshot.sessionKey);
+  const sessionId = normalizeOptional(snapshot.sessionId);
+  if (sessionKey) {
+    sessionSnapshotsByAccountKey.set(
+      accountScopedSessionKey(snapshot.accountId, "sessionKey", sessionKey),
+      snapshot,
+    );
+    sessionSnapshotsByLooseKey.set(`sessionKey::${sessionKey}`, snapshot);
+  }
+  if (sessionId) {
+    sessionSnapshotsByAccountKey.set(
+      accountScopedSessionKey(snapshot.accountId, "sessionId", sessionId),
+      snapshot,
+    );
+    sessionSnapshotsByLooseKey.set(`sessionId::${sessionId}`, snapshot);
+  }
+  pruneOldest(sessionSnapshotsByAccountKey, MAX_SESSION_SNAPSHOTS * 2);
+  pruneOldest(sessionSnapshotsByLooseKey, MAX_SESSION_SNAPSHOTS * 2);
+}
+
+export function registerWecomSourceSnapshot(params: {
+  accountId: string;
+  source: WecomSourcePlane;
+  messageId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): void {
+  const accountId = normalizeOptional(params.accountId);
+  if (!accountId) return;
+
+  const snapshot: WecomSourceSnapshot = {
+    accountId,
+    source: params.source,
+    recordedAt: Date.now(),
+    ...(normalizeOptional(params.messageId)
+      ? { messageId: normalizeOptional(params.messageId) }
+      : {}),
+    ...(normalizeOptional(params.sessionKey)
+      ? { sessionKey: normalizeOptional(params.sessionKey) }
+      : {}),
+    ...(normalizeOptional(params.sessionId)
+      ? { sessionId: normalizeOptional(params.sessionId) }
+      : {}),
+  };
+
+  if (snapshot.messageId) {
+    messageFacts.set(messageFactKey(accountId, snapshot.messageId), snapshot);
+    pruneOldest(messageFacts, MAX_MESSAGE_FACTS);
+  }
+
+  writeSessionSnapshot(snapshot);
+}
+
+export function resolveWecomSourceSnapshot(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): WecomSourceSnapshot | undefined {
+  const accountId = normalizeOptional(params.accountId);
+  const sessionKey = normalizeOptional(params.sessionKey);
+  const sessionId = normalizeOptional(params.sessionId);
+
+  if (accountId && sessionKey) {
+    const scoped = sessionSnapshotsByAccountKey.get(
+      accountScopedSessionKey(accountId, "sessionKey", sessionKey),
+    );
+    if (scoped) return scoped;
+  }
+  if (accountId && sessionId) {
+    const scoped = sessionSnapshotsByAccountKey.get(
+      accountScopedSessionKey(accountId, "sessionId", sessionId),
+    );
+    if (scoped) return scoped;
+  }
+  if (sessionKey) {
+    const loose = sessionSnapshotsByLooseKey.get(`sessionKey::${sessionKey}`);
+    if (loose) return loose;
+  }
+  if (sessionId) {
+    const loose = sessionSnapshotsByLooseKey.get(`sessionId::${sessionId}`);
+    if (loose) return loose;
+  }
+  return undefined;
+}
+
+export function clearWecomSourceAccount(accountId: string): void {
+  const normalized = normalizeOptional(accountId);
+  if (!normalized) return;
+
+  for (const [key, value] of messageFacts) {
+    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
+      messageFacts.delete(key);
+    }
+  }
+  for (const [key, value] of sessionSnapshotsByAccountKey) {
+    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
+      sessionSnapshotsByAccountKey.delete(key);
+    }
+  }
+  for (const [key, value] of sessionSnapshotsByLooseKey) {
+    if (value.accountId === normalized) {
+      sessionSnapshotsByLooseKey.delete(key);
+    }
+  }
+}
+
+export function isWecomBotWsSource(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): boolean {
+  return resolveWecomSourceSnapshot(params)?.source === "bot-ws";
+}
+
+export function isWecomAgentSource(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): boolean {
+  return resolveWecomSourceSnapshot(params)?.source === "agent-callback";
+}

package/src/transport/bot-webhook/inbound-normalizer.ts

@@ -257,7 +257,7 @@ 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);
+  const maxBytes = resolveWecomMediaMaxBytes(target.config, target.account.accountId);
   const proxyUrl = resolveWecomEgressProxyUrl(target.config);
 
   if (msgtype === "image") {
@@ -275,7 +275,7 @@ export async function processBotInboundMessage(params: {
         });
         return { body: "[image]", media: { buffer: decrypted.buffer, contentType: inferred.contentType, filename: inferred.filename } };
       } catch (err) {
-        target.runtime.error?.(`图片解密失败: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+        target.runtime.error?.(`图片解密失败: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
         recordOperationalIssue({
           category: "media-decrypt-failed",
           messageId: msg.msgid ? String(msg.msgid) : undefined,
@@ -304,7 +304,7 @@ export async function processBotInboundMessage(params: {
         });
         return { body: "[file]", media: { buffer: decrypted.buffer, contentType: inferred.contentType, filename: inferred.filename } };
       } catch (err) {
-        target.runtime.error?.(`Failed to decrypt inbound file: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+        target.runtime.error?.(`Failed to decrypt inbound file: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
         recordOperationalIssue({
           category: "media-decrypt-failed",
           messageId: msg.msgid ? String(msg.msgid) : undefined,
@@ -347,7 +347,7 @@ export async function processBotInboundMessage(params: {
               bodyParts.push(`[${t}]`);
               continue;
             } catch (err) {
-              target.runtime.error?.(`Failed to decrypt mixed ${t}: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+              target.runtime.error?.(`Failed to decrypt mixed ${t}: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
               recordOperationalIssue({
                 category: "media-decrypt-failed",
                 messageId: msg.msgid ? String(msg.msgid) : undefined,

package/src/transport/bot-ws/media.test.ts

@@ -0,0 +1,44 @@
+import type { WSClient } from "@wecom/aibot-node-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { uploadAndSendBotWsMedia } from "./media.js";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk";
+
+vi.mock("openclaw/plugin-sdk", () => ({
+  detectMime: vi.fn(),
+  loadOutboundMediaFromUrl: vi.fn(),
+}));
+
+describe("uploadAndSendBotWsMedia", () => {
+  const loadOutboundMediaFromUrlMock = vi.mocked(loadOutboundMediaFromUrl);
+
+  beforeEach(() => {
+    loadOutboundMediaFromUrlMock.mockReset();
+    loadOutboundMediaFromUrlMock.mockResolvedValue({
+      buffer: Buffer.from("png"),
+      contentType: "image/png",
+      fileName: "sample.png",
+    } as never);
+  });
+
+  it("passes the configured maxBytes to outbound media loading", async () => {
+    const wsClient = {
+      uploadMedia: vi.fn().mockResolvedValue({ media_id: "media-1" }),
+      sendMediaMessage: vi.fn().mockResolvedValue({ headers: { req_id: "req-1" } }),
+    } as unknown as WSClient;
+
+    await uploadAndSendBotWsMedia({
+      wsClient,
+      chatId: "hidao",
+      mediaUrl: "https://example.com/sample.png",
+      maxBytes: 42 * 1024 * 1024,
+    });
+
+    expect(loadOutboundMediaFromUrlMock).toHaveBeenCalledWith(
+      "https://example.com/sample.png",
+      expect.objectContaining({
+        maxBytes: 42 * 1024 * 1024,
+      }),
+    );
+  });
+});

package/src/transport/bot-ws/media.ts

@@ -0,0 +1,272 @@
+import type { WeComMediaType, WsFrameHeaders, WSClient } from "@wecom/aibot-node-sdk";
+import { detectMime, loadOutboundMediaFromUrl } from "openclaw/plugin-sdk";
+
+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;
+
+type FileSizeCheckResult = {
+  finalType: WeComMediaType;
+  shouldReject: boolean;
+  rejectReason?: string;
+  downgraded: boolean;
+  downgradeNote?: string;
+};
+
+export type BotWsMediaSendResult = {
+  ok: boolean;
+  messageId?: string;
+  finalType?: WeComMediaType;
+  rejected?: boolean;
+  rejectReason?: string;
+  downgraded?: boolean;
+  downgradeNote?: string;
+  error?: string;
+};
+
+type ResolvedMediaFile = {
+  buffer: Buffer;
+  contentType: string;
+  fileName: string;
+};
+
+const VOICE_SUPPORTED_MIMES = new Set(["audio/amr"]);
+
+function detectWeComMediaType(mimeType: string): WeComMediaType {
+  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: string): string {
+  const map: Record<string, string> = {
+    "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: string,
+  providedFileName?: string,
+  contentType?: string,
+): string {
+  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 applyFileSizeLimits(
+  fileSize: number,
+  detectedType: WeComMediaType,
+  contentType?: string,
+): FileSizeCheckResult {
+  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: string,
+  mediaLocalRoots?: readonly string[],
+  maxBytes?: number,
+): Promise<ResolvedMediaFile> {
+  const result = await loadOutboundMediaFromUrl(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: {
+  wsClient: WSClient;
+  mediaUrl: string;
+  chatId: string;
+  mediaLocalRoots?: readonly string[];
+  maxBytes?: number;
+}): Promise<BotWsMediaSendResult> {
+  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: {
+  wsClient: WSClient;
+  frame: WsFrameHeaders;
+  mediaUrl: string;
+  mediaLocalRoots?: readonly string[];
+  maxBytes?: number;
+}): Promise<BotWsMediaSendResult> {
+  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),
+    };
+  }
+}