@yanhaidao/wecom 2.3.270 → 2.4.160

package/src/transport/agent-api/upstream-delivery.ts

@@ -0,0 +1,45 @@
+import type { ResolvedAgentAccount } from "../../types/index.js";
+import type { WecomTarget } from "../../target.js";
+import { sendUpstreamAgentApiMediaReply, sendUpstreamAgentApiTextReply } from "./upstream-reply.js";
+
+export async function deliverUpstreamAgentApiText(params: {
+  upstreamAgent: ResolvedAgentAccount;
+  primaryAgent: ResolvedAgentAccount;
+  target: WecomTarget;
+  text: string;
+}): Promise<void> {
+  await sendUpstreamAgentApiTextReply(params);
+}
+
+export async function deliverUpstreamAgentApiMedia(params: {
+  upstreamAgent: ResolvedAgentAccount;
+  primaryAgent: ResolvedAgentAccount;
+  target: WecomTarget;
+  buffer: Buffer;
+  filename: string;
+  contentType: string;
+  text?: string;
+}): Promise<void> {
+  let mediaType: "image" | "voice" | "video" | "file" = "file";
+  if (params.contentType.startsWith("image/")) mediaType = "image";
+  else if (params.contentType.startsWith("audio/")) mediaType = "voice";
+  else if (params.contentType.startsWith("video/")) mediaType = "video";
+
+  const { uploadUpstreamAgentApiMedia } = await import("./upstream-media-upload.js");
+  const mediaId = await uploadUpstreamAgentApiMedia({
+    upstreamAgent: params.upstreamAgent,
+    primaryAgent: params.primaryAgent,
+    type: mediaType,
+    buffer: params.buffer,
+    filename: params.filename,
+  });
+  await sendUpstreamAgentApiMediaReply({
+    upstreamAgent: params.upstreamAgent,
+    primaryAgent: params.primaryAgent,
+    target: params.target,
+    mediaId,
+    mediaType,
+    title: mediaType === "video" ? params.text?.trim().slice(0, 64) : undefined,
+    description: mediaType === "video" ? params.text?.trim().slice(0, 512) : undefined,
+  });
+}

package/src/transport/agent-api/upstream-media-upload.ts

@@ -0,0 +1,70 @@
+import crypto from "node:crypto";
+
+import { resolveWecomEgressProxyUrlFromNetwork } from "../../config/index.js";
+import { LIMITS } from "../../types/constants.js";
+import { wecomFetch } from "../../http.js";
+import type { ResolvedAgentAccount } from "../../types/index.js";
+import { guessUploadContentType, normalizeUploadFilename } from "./core.js";
+import { getUpstreamAgentApiAccessToken } from "./client.js";
+
+export async function uploadUpstreamAgentApiMedia(params: {
+  upstreamAgent: ResolvedAgentAccount;
+  primaryAgent: ResolvedAgentAccount;
+  type: "image" | "voice" | "video" | "file";
+  buffer: Buffer;
+  filename: string;
+}): Promise<string> {
+  const { upstreamAgent, primaryAgent, type, buffer, filename } = params;
+  const safeFilename = normalizeUploadFilename(filename);
+  
+  // 使用下游企业的 access_token
+  const token = await getUpstreamAgentApiAccessToken({
+    primaryAgent,
+    upstreamCorpId: upstreamAgent.corpId,
+    upstreamAgentId: upstreamAgent.agentId!,
+  });
+  
+  const proxyUrl = resolveWecomEgressProxyUrlFromNetwork(upstreamAgent.network);
+  const url = `https://qyapi.weixin.qq.com/cgi-bin/media/upload?access_token=${encodeURIComponent(token)}&type=${encodeURIComponent(type)}&debug=1`;
+
+  const uploadOnce = async (fileContentType: string) => {
+    const boundary = `----WebKitFormBoundary${crypto.randomBytes(16).toString("hex")}`;
+    const header = Buffer.from(
+      `--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="media"; filename="${safeFilename}"; filelength=${buffer.length}\r\n` +
+        `Content-Type: ${fileContentType}\r\n\r\n`,
+    );
+    const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
+    const body = Buffer.concat([header, buffer, footer]);
+
+    const res = await wecomFetch(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": `multipart/form-data; boundary=${boundary}`,
+          "Content-Length": String(body.length),
+        },
+        body,
+      },
+      { proxyUrl, timeoutMs: LIMITS.REQUEST_TIMEOUT_MS },
+    );
+    const json = (await res.json()) as { media_id?: string; errcode?: number; errmsg?: string };
+    return json;
+  };
+
+  const preferredContentType = guessUploadContentType(safeFilename);
+  let json = await uploadOnce(preferredContentType);
+
+  if (!json?.media_id && preferredContentType !== "application/octet-stream") {
+    console.warn(
+      `[wecom-upstream-upload] Upload failed with ${preferredContentType}, retrying as application/octet-stream: ${json?.errcode} ${json?.errmsg}`,
+    );
+    json = await uploadOnce("application/octet-stream");
+  }
+
+  if (!json?.media_id) {
+    throw new Error(`upload failed: ${json?.errcode} ${json?.errmsg}`);
+  }
+  return json.media_id;
+}

package/src/transport/agent-api/upstream-reply.ts

@@ -0,0 +1,43 @@
+import type { ResolvedAgentAccount } from "../../types/index.js";
+import type { WecomTarget } from "../../target.js";
+import { sendUpstreamAgentApiMedia, sendUpstreamAgentApiText } from "./client.js";
+
+export async function sendUpstreamAgentApiTextReply(params: {
+  upstreamAgent: ResolvedAgentAccount;
+  primaryAgent: ResolvedAgentAccount;
+  target: WecomTarget;
+  text: string;
+}): Promise<void> {
+  await sendUpstreamAgentApiText({
+    upstreamAgent: params.upstreamAgent,
+    primaryAgent: params.primaryAgent,
+    toUser: params.target.touser,
+    toParty: params.target.toparty,
+    toTag: params.target.totag,
+    chatId: params.target.chatid,
+    text: params.text,
+  });
+}
+
+export async function sendUpstreamAgentApiMediaReply(params: {
+  upstreamAgent: ResolvedAgentAccount;
+  primaryAgent: ResolvedAgentAccount;
+  target: WecomTarget;
+  mediaId: string;
+  mediaType: "image" | "voice" | "video" | "file";
+  title?: string;
+  description?: string;
+}): Promise<void> {
+  await sendUpstreamAgentApiMedia({
+    upstreamAgent: params.upstreamAgent,
+    primaryAgent: params.primaryAgent,
+    toUser: params.target.touser,
+    toParty: params.target.toparty,
+    toTag: params.target.totag,
+    chatId: params.target.chatid,
+    mediaId: params.mediaId,
+    mediaType: params.mediaType,
+    title: params.title,
+    description: params.description,
+  });
+}

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

@@ -0,0 +1,433 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { processBotInboundMessage } from "./inbound-normalizer.js";
+import { decryptWecomMediaWithMeta } from "../../media.js";
+
+vi.mock("../../media.js", () => ({
+  decryptWecomMediaWithMeta: vi.fn(),
+}));
+
+describe("processBotInboundMessage quote media", () => {
+  const recordOperationalIssue = vi.fn();
+  const logError = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("downloads quote.file for text messages", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockResolvedValue({
+      buffer: Buffer.from("%PDF-1.7 test"),
+      sourceContentType: "application/pdf",
+      sourceFilename: "quoted.pdf",
+      sourceUrl: "https://example.com/quoted.pdf",
+    });
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-file",
+        msgtype: "text",
+        text: { content: "看这个引用" },
+        quote: {
+          msgtype: "file",
+          file: {
+            url: "https://example.com/quoted.pdf",
+          },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(decryptWecomMediaWithMeta).toHaveBeenCalledWith(
+      "https://example.com/quoted.pdf",
+      "account-aes-key",
+      expect.objectContaining({
+        maxBytes: 24 * 1024 * 1024,
+      }),
+    );
+    expect(result.media).toBeDefined();
+    expect(result.media?.contentType).toBe("application/pdf");
+    expect(result.body).toContain("[引用: 文件]");
+  });
+
+  it("keeps quote.voice as text only without media decryption", async () => {
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-voice",
+        msgtype: "text",
+        text: { content: "这个语音引用是什么意思" },
+        quote: {
+          msgtype: "voice",
+          voice: { content: "这里是语音转写文本" },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(result.media).toBeUndefined();
+    expect(result.body).toContain("[引用: 语音] 这里是语音转写文本");
+    expect(decryptWecomMediaWithMeta).not.toHaveBeenCalled();
+  });
+
+  it("extracts first image from quote.mixed", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockResolvedValue({
+      buffer: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+      sourceContentType: "image/png",
+      sourceFilename: "quoted.png",
+      sourceUrl: "https://example.com/quoted.png",
+    });
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-mixed",
+        msgtype: "text",
+        text: { content: "看这个图文引用" },
+        quote: {
+          msgtype: "mixed",
+          mixed: {
+            msg_item: [
+              { msgtype: "text", text: { content: "正文" } },
+              { msgtype: "image", image: { url: "https://example.com/quoted.png", aeskey: "item-aes-key" } },
+            ],
+          },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(result.media).toBeDefined();
+    expect(result.media?.contentType).toBe("image/png");
+    expect(decryptWecomMediaWithMeta).toHaveBeenCalledWith(
+      "https://example.com/quoted.png",
+      "item-aes-key",
+      expect.any(Object),
+    );
+  });
+
+  it("records expired_or_forbidden reason for quote media decrypt failure", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockRejectedValue(new Error("HTTP 403 forbidden"));
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-fail",
+        msgtype: "text",
+        text: { content: "读取这个引用" },
+        quote: {
+          msgtype: "file",
+          file: { url: "https://example.com/expired.pdf" },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(result.media).toBeUndefined();
+    expect(result.body).toContain("[quote:file]");
+    expect(recordOperationalIssue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        summary: expect.stringContaining("reason=expired_or_forbidden"),
+      }),
+    );
+  });
+
+  it("downloads quote.image for text messages", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockResolvedValue({
+      buffer: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+      sourceContentType: "image/png",
+      sourceFilename: "quoted.png",
+      sourceUrl: "https://example.com/quoted.png",
+    });
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-image",
+        msgtype: "text",
+        text: { content: "看这个引用图片" },
+        quote: {
+          msgtype: "image",
+          image: {
+            url: "https://example.com/quoted.png",
+          },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(decryptWecomMediaWithMeta).toHaveBeenCalledWith(
+      "https://example.com/quoted.png",
+      "account-aes-key",
+      expect.objectContaining({
+        maxBytes: 24 * 1024 * 1024,
+      }),
+    );
+    expect(result.media).toBeDefined();
+    expect(result.media?.contentType).toBe("image/png");
+    expect(result.body).toContain("[引用: 图片]");
+  });
+
+  it("downloads quote.video for text messages", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockResolvedValue({
+      buffer: Buffer.from([0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70]),
+      sourceContentType: "video/mp4",
+      sourceFilename: "quoted.mp4",
+      sourceUrl: "https://example.com/quoted.mp4",
+    });
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-video",
+        msgtype: "text",
+        text: { content: "看这个引用视频" },
+        quote: {
+          msgtype: "video",
+          video: {
+            url: "https://example.com/quoted.mp4",
+          },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(decryptWecomMediaWithMeta).toHaveBeenCalledWith(
+      "https://example.com/quoted.mp4",
+      "account-aes-key",
+      expect.objectContaining({
+        maxBytes: 24 * 1024 * 1024,
+      }),
+    );
+    expect(result.media).toBeDefined();
+    expect(result.media?.contentType).toBe("video/mp4");
+    expect(result.body).toContain("[引用: 视频]");
+  });
+
+  it("prioritizes top-level media over quote media", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockResolvedValue({
+      buffer: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+      sourceContentType: "image/png",
+      sourceFilename: "top-level.png",
+      sourceUrl: "https://example.com/top-level.png",
+    });
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-both-media",
+        msgtype: "image",
+        image: {
+          url: "https://example.com/top-level.png",
+        },
+        quote: {
+          msgtype: "file",
+          file: {
+            url: "https://example.com/quoted.pdf",
+          },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    // Should have downloaded top-level image, not quote file
+    expect(decryptWecomMediaWithMeta).toHaveBeenCalledWith(
+      "https://example.com/top-level.png",
+      "account-aes-key",
+      expect.any(Object),
+    );
+    expect(decryptWecomMediaWithMeta).not.toHaveBeenCalledWith(
+      expect.stringContaining("quoted.pdf"),
+      expect.any(String),
+      expect.any(Object),
+    );
+    expect(result.media?.contentType).toBe("image/png");
+    expect(result.body).toBe("[image]");
+  });
+
+  it("classifies timeout error for quote media", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockRejectedValue(new Error("Request timeout after 15000ms"));
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-timeout",
+        msgtype: "text",
+        text: { content: "下载这个文件" },
+        quote: {
+          msgtype: "file",
+          file: { url: "https://example.com/slow.pdf" },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(result.media).toBeUndefined();
+    expect(recordOperationalIssue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        summary: expect.stringContaining("reason=timeout"),
+      }),
+    );
+  });
+
+  it("classifies decrypt error for quote media", async () => {
+    vi.mocked(decryptWecomMediaWithMeta).mockRejectedValue(new Error("Bad decrypt"));
+
+    const result = await processBotInboundMessage({
+      target: {
+        account: {
+          accountId: "purple",
+          encodingAESKey: "account-aes-key",
+        },
+        config: {
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+            },
+          },
+        },
+        runtime: {
+          error: logError,
+        },
+      } as never,
+      msg: {
+        msgid: "msg-quote-decrypt-fail",
+        msgtype: "voice",
+        voice: { content: "这是语音转写" },
+        quote: {
+          msgtype: "image",
+          image: { url: "https://example.com/bad.png" },
+        },
+      } as never,
+      recordOperationalIssue,
+    });
+
+    expect(result.media).toBeUndefined();
+    expect(recordOperationalIssue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        summary: expect.stringContaining("reason=decrypt"),
+      }),
+    );
+  });
+});