@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/runtime/source-registry.ts

@@ -1,249 +0,0 @@
-export type WecomSourcePlane = "bot-ws" | "agent-callback";
-
-export type WecomSourceSnapshot = {
-  accountId: string;
-  source: WecomSourcePlane;
-  recordedAt: number;
-  messageId?: string;
-  sessionKey?: string;
-  sessionId?: string;
-  peerKind?: "direct" | "group";
-  peerId?: string;
-  upstreamCorpId?: string;
-};
-
-const MAX_MESSAGE_FACTS = 2048;
-const MAX_SESSION_SNAPSHOTS = 1024;
-const MAX_CONVERSATION_SNAPSHOTS = 1024;
-
-const messageFacts = new Map<string, WecomSourceSnapshot>();
-const sessionSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
-const sessionSnapshotsByLooseKey = new Map<string, WecomSourceSnapshot>();
-const conversationSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
-const conversationSnapshotsByLooseKey = 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 normalizePeerId(value: string | null | undefined): string | undefined {
-  const trimmed = String(value ?? "").trim();
-  return trimmed ? trimmed.toLowerCase() : undefined;
-}
-
-function normalizePeerKind(value: string | null | undefined): "direct" | "group" | undefined {
-  const trimmed = String(value ?? "").trim().toLowerCase();
-  return trimmed === "direct" || trimmed === "group" ? trimmed : undefined;
-}
-
-function accountScopedConversationKey(
-  accountId: string,
-  peerKind: "direct" | "group",
-  peerId: string,
-): string {
-  return `${accountId}::peer::${peerKind}::${peerId}`;
-}
-
-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);
-}
-
-function writeConversationSnapshot(snapshot: WecomSourceSnapshot): void {
-  const peerKind = normalizePeerKind(snapshot.peerKind);
-  const peerId = normalizePeerId(snapshot.peerId);
-  if (!peerKind || !peerId) {
-    return;
-  }
-  conversationSnapshotsByAccountKey.set(
-    accountScopedConversationKey(snapshot.accountId, peerKind, peerId),
-    {
-      ...snapshot,
-      peerKind,
-      peerId,
-    },
-  );
-  conversationSnapshotsByLooseKey.set(`peer::${peerKind}::${peerId}`, {
-    ...snapshot,
-    peerKind,
-    peerId,
-  });
-  pruneOldest(conversationSnapshotsByAccountKey, MAX_CONVERSATION_SNAPSHOTS);
-  pruneOldest(conversationSnapshotsByLooseKey, MAX_CONVERSATION_SNAPSHOTS);
-}
-
-export function registerWecomSourceSnapshot(params: {
-  accountId: string;
-  source: WecomSourcePlane;
-  messageId?: string | null;
-  sessionKey?: string | null;
-  sessionId?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-  upstreamCorpId?: 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) }
-      : {}),
-    ...(normalizePeerKind(params.peerKind) ? { peerKind: normalizePeerKind(params.peerKind) } : {}),
-    ...(normalizePeerId(params.peerId) ? { peerId: normalizePeerId(params.peerId) } : {}),
-    ...(normalizeOptional(params.upstreamCorpId)
-      ? { upstreamCorpId: normalizeOptional(params.upstreamCorpId) }
-      : {}),
-  };
-
-  if (snapshot.messageId) {
-    messageFacts.set(messageFactKey(accountId, snapshot.messageId), snapshot);
-    pruneOldest(messageFacts, MAX_MESSAGE_FACTS);
-  }
-
-  writeSessionSnapshot(snapshot);
-  writeConversationSnapshot(snapshot);
-}
-
-export function resolveWecomSourceSnapshot(params: {
-  accountId?: string | null;
-  sessionKey?: string | null;
-  sessionId?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-}): WecomSourceSnapshot | undefined {
-  const accountId = normalizeOptional(params.accountId);
-  const sessionKey = normalizeOptional(params.sessionKey);
-  const sessionId = normalizeOptional(params.sessionId);
-  const peerKind = normalizePeerKind(params.peerKind);
-  const peerId = normalizePeerId(params.peerId);
-
-  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;
-  }
-  if (accountId && peerKind && peerId) {
-    const scoped = conversationSnapshotsByAccountKey.get(
-      accountScopedConversationKey(accountId, peerKind, peerId),
-    );
-    if (scoped) return scoped;
-  }
-  if (peerKind && peerId) {
-    const loose = conversationSnapshotsByLooseKey.get(`peer::${peerKind}::${peerId}`);
-    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);
-    }
-  }
-  for (const [key, value] of conversationSnapshotsByAccountKey) {
-    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
-      conversationSnapshotsByAccountKey.delete(key);
-    }
-  }
-  for (const [key, value] of conversationSnapshotsByLooseKey) {
-    if (value.accountId === normalized) {
-      conversationSnapshotsByLooseKey.delete(key);
-    }
-  }
-}
-
-export function isWecomBotWsSource(params: {
-  accountId?: string | null;
-  sessionKey?: string | null;
-  sessionId?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-}): boolean {
-  return resolveWecomSourceSnapshot(params)?.source === "bot-ws";
-}
-
-export function isWecomAgentSource(params: {
-  accountId?: string | null;
-  sessionKey?: string | null;
-  sessionId?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-}): boolean {
-  return resolveWecomSourceSnapshot(params)?.source === "agent-callback";
-}

package/src/runtime.ts

@@ -1,14 +0,0 @@
-export {
-  getActiveBotWsReplyHandle,
-  getAccountRuntime,
-  getAccountRuntimeSnapshot,
-  getBotWsPushHandle,
-  getWecomRuntime,
-  registerActiveBotWsReplyHandle,
-  registerAccountRuntime,
-  registerBotWsPushHandle,
-  setWecomRuntime,
-  unregisterActiveBotWsReplyHandle,
-  unregisterBotWsPushHandle,
-  unregisterAccountRuntime,
-} from "./app/index.js";

package/src/shared/command-auth.ts

@@ -1,87 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
-import type { WecomAgentConfig, WecomBotConfig } from "../types/index.js";
-import { isWecomSenderAllowed, normalizeWecomAllowFromEntry } from "../domain/policies.js";
-
-type WecomCommandAuthAccountConfig = Pick<WecomBotConfig, "dm"> | Pick<WecomAgentConfig, "dm">;
-
-export async function resolveWecomCommandAuthorization(params: {
-  core: PluginRuntime;
-  cfg: OpenClawConfig;
-  accountConfig: WecomCommandAuthAccountConfig;
-  rawBody: string;
-  senderUserId: string;
-}): Promise<{
-  shouldComputeAuth: boolean;
-  dmPolicy: "pairing" | "allowlist" | "open" | "disabled";
-  senderAllowed: boolean;
-  authorizerConfigured: boolean;
-  commandAuthorized: boolean | undefined;
-  effectiveAllowFrom: string[];
-}> {
-  const { core, cfg, accountConfig, rawBody, senderUserId } = params;
-
-  const dmPolicy = (accountConfig.dm?.policy ?? "pairing") as "pairing" | "allowlist" | "open" | "disabled";
-  const configAllowFrom = (accountConfig.dm?.allowFrom ?? []).map((v) => String(v));
-
-  const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(rawBody, cfg);
-  // WeCom channel currently does NOT support the `openclaw pairing` CLI workflow
-  // ("Channel wecom does not support pairing"). So we must not rely on pairing
-  // store approvals for command authorization here.
-  //
-  // Policy semantics:
-  // - open: commands are allowed for everyone by default (unless higher-level access-groups deny).
-  // - allowlist: commands require allowFrom entries.
-  // - pairing: treated the same as allowlist for WeCom (since pairing CLI is unsupported).
-  const effectiveAllowFrom = dmPolicy === "open" ? ["*"] : configAllowFrom;
-
-  const senderAllowed = isWecomSenderAllowed(senderUserId, effectiveAllowFrom);
-  const allowAllConfigured = effectiveAllowFrom.some((entry) => normalizeWecomAllowFromEntry(entry) === "*");
-  const authorizerConfigured = allowAllConfigured || effectiveAllowFrom.length > 0;
-  const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-
-  const commandAuthorized = shouldComputeAuth
-    ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
-      useAccessGroups,
-      authorizers: [{ configured: authorizerConfigured, allowed: senderAllowed }],
-    })
-    : undefined;
-
-  return {
-    shouldComputeAuth,
-    dmPolicy,
-    senderAllowed,
-    authorizerConfigured,
-    commandAuthorized,
-    effectiveAllowFrom,
-  };
-}
-
-export function buildWecomUnauthorizedCommandPrompt(params: {
-  senderUserId: string;
-  dmPolicy: "pairing" | "allowlist" | "open" | "disabled";
-  scope: "bot" | "agent";
-}): string {
-  const user = params.senderUserId || "unknown";
-  const policy = params.dmPolicy;
-  const scopeLabel = params.scope === "bot" ? "Bot（智能机器人）" : "Agent（自建应用）";
-  const dmPrefix = params.scope === "bot" ? "channels.wecom.bot.dm" : "channels.wecom.agent.dm";
-  const allowCmd = (value: string) => `openclaw config set ${dmPrefix}.allowFrom '${value}'`;
-  const policyCmd = (value: string) => `openclaw config set ${dmPrefix}.policy "${value}"`;
-
-  if (policy === "disabled") {
-    return [
-      `无权限执行命令（${scopeLabel} 已禁用：dm.policy=disabled）`,
-      `触发者：${user}`,
-      `管理员：${policyCmd("open")}（全放开）或 ${policyCmd("allowlist")}（白名单）`,
-    ].join("\n");
-  }
-  // WeCom 不支持 pairing CLI，因此这里统一给出“open / allowlist”两种明确的配置指令
-  return [
-    `无权限执行命令（入口：${scopeLabel}，userid：${user}）`,
-    `管理员全放开：${policyCmd("open")}`,
-    `管理员放行该用户：${policyCmd("allowlist")}`,
-    `然后设置白名单：${allowCmd(JSON.stringify([user]))}`,
-    `如果仍被拦截：检查 commands.useAccessGroups/访问组`,
-  ].join("\n");
-}

package/src/shared/media-asset.ts

@@ -1,78 +0,0 @@
-import path from "node:path";
-
-import { resolveWecomEgressProxyUrlFromNetwork } from "../config/index.js";
-import { wecomFetch } from "../http.js";
-import type { WecomNetworkConfig } from "../types/index.js";
-
-function inferContentTypeFromFilePath(filePath: string): string {
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  const mimeTypes: Record<string, string> = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    bmp: "image/bmp",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    amr: "audio/amr",
-    mp4: "video/mp4",
-    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",
-    txt: "text/plain",
-    csv: "text/csv",
-    tsv: "text/tab-separated-values",
-    md: "text/markdown",
-    json: "application/json",
-    xml: "application/xml",
-    yaml: "application/yaml",
-    yml: "application/yaml",
-    zip: "application/zip",
-    rar: "application/vnd.rar",
-    "7z": "application/x-7z-compressed",
-    tar: "application/x-tar",
-    gz: "application/gzip",
-    tgz: "application/gzip",
-    rtf: "application/rtf",
-    odt: "application/vnd.oasis.opendocument.text",
-  };
-  return mimeTypes[ext] || "application/octet-stream";
-}
-
-export async function resolveOutboundMediaAsset(params: {
-  mediaUrl: string;
-  network?: WecomNetworkConfig;
-  timeoutMs?: number;
-}): Promise<{ buffer: Buffer; filename: string; contentType: string }> {
-  const { mediaUrl, network, timeoutMs = 30000 } = params;
-  if (/^https?:\/\//i.test(mediaUrl)) {
-    const response = await wecomFetch(
-      mediaUrl,
-      { method: "GET" },
-      {
-        proxyUrl: resolveWecomEgressProxyUrlFromNetwork(network),
-        timeoutMs,
-      },
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to download media: ${response.status}`);
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    const contentType = response.headers.get("content-type") || "application/octet-stream";
-    const filename = path.basename(new URL(mediaUrl).pathname) || "media";
-    return { buffer, filename, contentType };
-  }
-
-  const fs = await import("node:fs/promises");
-  const buffer = await fs.readFile(mediaUrl);
-  return {
-    buffer,
-    filename: path.basename(mediaUrl),
-    contentType: inferContentTypeFromFilePath(mediaUrl),
-  };
-}

package/src/shared/media-service.test.ts

@@ -1,111 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { WecomMediaService } from "./media-service.js";
-
-describe("WecomMediaService", () => {
-  const fetchRemoteMedia = vi.fn();
-  const saveMediaBuffer = vi.fn();
-
-  beforeEach(() => {
-    fetchRemoteMedia.mockReset();
-    saveMediaBuffer.mockReset();
-  });
-
-  it("passes configured wecom mediaMaxMb to remote attachment fetches and saves", async () => {
-    const service = new WecomMediaService(
-      {
-        channel: {
-          media: {
-            fetchRemoteMedia,
-            saveMediaBuffer,
-          },
-        },
-      } as never,
-      {
-        channels: {
-          wecom: {
-            mediaMaxMb: 24,
-          },
-        },
-      } as never,
-    );
-
-    fetchRemoteMedia.mockResolvedValue({
-      buffer: Buffer.from("file"),
-      contentType: "application/pdf",
-      fileName: "sample.pdf",
-    });
-    saveMediaBuffer.mockResolvedValue({
-      path: "/tmp/sample.pdf",
-    });
-
-    const event = {
-      accountId: "default",
-      attachments: [{ remoteUrl: "https://example.com/sample.pdf" }],
-    } as never;
-
-    const attachment = await service.normalizeFirstAttachment(event);
-
-    expect(fetchRemoteMedia).toHaveBeenCalledWith({
-      url: "https://example.com/sample.pdf",
-      maxBytes: 24 * 1024 * 1024,
-    });
-
-    await service.saveInboundAttachment(event, attachment!);
-
-    expect(saveMediaBuffer).toHaveBeenCalledWith(
-      expect.any(Buffer),
-      "application/pdf",
-      "inbound",
-      24 * 1024 * 1024,
-      "sample.pdf",
-    );
-  });
-
-  it("prefers account-specific mediaMaxMb for inbound saves", async () => {
-    const service = new WecomMediaService(
-      {
-        channel: {
-          media: {
-            fetchRemoteMedia,
-            saveMediaBuffer,
-          },
-        },
-      } as never,
-      {
-        channels: {
-          wecom: {
-            mediaMaxMb: 24,
-            accounts: {
-              ops: {
-                mediaMaxMb: 36,
-              },
-            },
-          },
-        },
-      } as never,
-    );
-
-    saveMediaBuffer.mockResolvedValue({
-      path: "/tmp/account-specific.pdf",
-    });
-
-    await service.saveInboundAttachment(
-      {
-        accountId: "ops",
-      } as never,
-      {
-        buffer: Buffer.from("file"),
-        contentType: "application/pdf",
-        filename: "ops.pdf",
-      },
-    );
-
-    expect(saveMediaBuffer).toHaveBeenCalledWith(
-      expect.any(Buffer),
-      "application/pdf",
-      "inbound",
-      36 * 1024 * 1024,
-      "ops.pdf",
-    );
-  });
-});

package/src/shared/media-service.ts

@@ -1,84 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-import { resolveWecomMediaMaxBytes } from "../config/index.js";
-import { decryptWecomMediaWithMeta } from "../media.js";
-import type { UnifiedInboundEvent } from "../types/index.js";
-import type { NormalizedMediaAttachment } from "./media-types.js";
-
-export class WecomMediaService {
-  constructor(
-    private readonly core: PluginRuntime,
-    private readonly cfg: OpenClawConfig,
-  ) {}
-
-  private resolveInboundMaxBytes(accountId: string): number {
-    return resolveWecomMediaMaxBytes(this.cfg, accountId);
-  }
-
-  async downloadRemoteMedia(params: {
-    url: string;
-    maxBytes: number;
-  }): Promise<NormalizedMediaAttachment> {
-    const loaded = await this.core.channel.media.fetchRemoteMedia({
-      url: params.url,
-      maxBytes: params.maxBytes,
-    });
-    return {
-      buffer: loaded.buffer,
-      contentType: loaded.contentType,
-      filename: loaded.fileName,
-    };
-  }
-
-  /**
-   * Download and decrypt WeCom AES-encrypted media.
-   * Bot-ws: each message carries a unique per-URL aeskey in the message body.
-   * Bot-webhook: uses the account-level EncodingAESKey.
-   * Both use AES-256-CBC with PKCS#7 padding (32-byte block), IV = key[:16].
-   */
-  async downloadEncryptedMedia(params: {
-    url: string;
-    aesKey: string;
-    maxBytes: number;
-  }): Promise<NormalizedMediaAttachment> {
-    const decrypted = await decryptWecomMediaWithMeta(params.url, params.aesKey, {
-      maxBytes: params.maxBytes,
-    });
-    return {
-      buffer: decrypted.buffer,
-      contentType: decrypted.sourceContentType,
-      filename: decrypted.sourceFilename,
-    };
-  }
-
-  async saveInboundAttachment(
-    event: UnifiedInboundEvent,
-    attachment: NormalizedMediaAttachment,
-  ): Promise<string> {
-    const maxBytes = this.resolveInboundMaxBytes(event.accountId);
-    const saved = await this.core.channel.media.saveMediaBuffer(
-      attachment.buffer,
-      attachment.contentType,
-      "inbound",
-      maxBytes,
-      attachment.filename,
-    );
-    return saved.path;
-  }
-
-  async normalizeFirstAttachment(
-    event: UnifiedInboundEvent,
-  ): Promise<NormalizedMediaAttachment | undefined> {
-    const first = event.attachments?.[0];
-    if (!first?.remoteUrl) {
-      return undefined;
-    }
-    // Keep fetch/decrypt/save on the same account-aware limit instead of falling back
-    // to the core media store default (5MB).
-    const maxBytes = this.resolveInboundMaxBytes(event.accountId);
-    // Bot-ws media is AES-encrypted; use decryption when aesKey is present
-    if (first.aesKey) {
-      return this.downloadEncryptedMedia({ url: first.remoteUrl, aesKey: first.aesKey, maxBytes });
-    }
-    return this.downloadRemoteMedia({ url: first.remoteUrl, maxBytes });
-  }
-}

package/src/shared/media-types.ts

@@ -1,5 +0,0 @@
-export type NormalizedMediaAttachment = {
-  filename?: string;
-  contentType?: string;
-  buffer: Buffer;
-};

package/src/shared/xml-parser.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { extractContent, extractFromUser, extractMediaId, extractMsgId, parseXml } from "./xml-parser.js";
-
-describe("wecom xml-parser", () => {
-  test("extractContent is robust to non-string Content", () => {
-    const msg: any = { MsgType: "text", Content: { "#text": "hello", "@_foo": "bar" } };
-    expect(extractContent(msg)).toBe("hello");
-  });
-
-  test("extractContent handles array content", () => {
-    const msg: any = { MsgType: "text", Content: ["a", "b"] };
-    expect(extractContent(msg)).toBe("a\nb");
-  });
-
-  test("extractContent handles file messages", () => {
-    const msg: any = { MsgType: "file", MediaId: "MEDIA123" };
-    expect(extractContent(msg)).toBe("[文件消息]");
-  });
-
-  test("extractMediaId handles object MediaId", () => {
-    const msg: any = { MediaId: { "#text": "MEDIA123", "@_foo": "bar" } };
-    expect(extractMediaId(msg)).toBe("MEDIA123");
-  });
-
-  test("extractMsgId handles number MsgId", () => {
-    const msg: any = { MsgId: 123456789 };
-    expect(extractMsgId(msg)).toBe("123456789");
-  });
-
-  test("parseXml preserves leading zero userid in FromUserName", () => {
-    const xml = `
-      <xml>
-        <FromUserName><![CDATA[0254571]]></FromUserName>
-      </xml>
-    `;
-    const msg = parseXml(xml);
-    expect(extractFromUser(msg)).toBe("0254571");
-  });
-
-  test("parseXml preserves 64-bit MsgId as string", () => {
-    const xml = `
-      <xml>
-        <MsgId>1234567890123456</MsgId>
-      </xml>
-    `;
-    const msg = parseXml(xml);
-    expect(extractMsgId(msg)).toBe("1234567890123456");
-  });
-});