@yanhaidao/wecom 2.3.160 → 2.3.190

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

@@ -1,16 +1,24 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-
+import os from "node:os";
+import path from "node:path";
 import type { WSClient } from "@wecom/aibot-node-sdk";
-
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk";
+import { uploadAndSendBotWsMedia } from "./media.js";
 import { createBotWsReplyHandle } from "./reply.js";
 
+vi.mock("./media.js", () => ({
+  uploadAndSendBotWsMedia: vi.fn(),
+}));
+
 type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
 
 describe("createBotWsReplyHandle", () => {
   let mockClient: import("vitest").Mocked<WSClient>;
+  const uploadAndSendBotWsMediaMock = vi.mocked(uploadAndSendBotWsMedia);
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.useFakeTimers();
+    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-reply-state");
     mockClient = {
       replyStream: vi.fn(),
       sendMessage: vi.fn(),
@@ -19,12 +27,25 @@ describe("createBotWsReplyHandle", () => {
     mockClient.replyStream.mockResolvedValue({} as any);
     mockClient.sendMessage.mockResolvedValue({} as any);
     mockClient.replyWelcome.mockResolvedValue({} as any);
+    uploadAndSendBotWsMediaMock.mockReset();
+    uploadAndSendBotWsMediaMock.mockResolvedValue({ ok: true, messageId: "media-1" } as any);
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({
+          channels: {
+            wecom: {},
+          },
+        }),
+      },
+    } as any);
   });
 
   afterEach(() => {
     vi.clearAllTimers();
     vi.useRealTimers();
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
   });
 
   it("uses configured placeholder content for immediate ws ack", async () => {
@@ -43,10 +64,10 @@ describe("createBotWsReplyHandle", () => {
     vi.advanceTimersByTime(3000);
     // Let promises flush
     await Promise.resolve();
-    
+
     expect(mockClient.replyStream).toHaveBeenCalledWith(
       expect.objectContaining({
-        headers: { req_id: "req-1" }
+        headers: { req_id: "req-1" },
       }),
       expect.any(String),
       "正在思考...",
@@ -69,7 +90,7 @@ describe("createBotWsReplyHandle", () => {
     vi.advanceTimersByTime(3000);
     // Flush the microtasks so `placeholderInFlight` becomes false
     for (let i = 0; i < 10; i++) await Promise.resolve();
-    
+
     // Now trigger the next timer
     vi.advanceTimersByTime(3000);
     for (let i = 0; i < 10; i++) await Promise.resolve();
@@ -90,7 +111,7 @@ describe("createBotWsReplyHandle", () => {
     // Ensure interval is cleared
     vi.advanceTimersByTime(6000);
     await Promise.resolve();
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(3); 
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(3);
   });
 
   it("does not auto-send placeholder when disabled", async () => {
@@ -149,6 +170,180 @@ describe("createBotWsReplyHandle", () => {
     );
   });
 
+  it("streams block text even when media is deferred to final", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-block-media" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        text: "正文先发",
+        mediaUrls: ["/tmp/a.png", "/tmp/b.png"],
+        isReasoning: false,
+      },
+      { kind: "block" },
+    );
+
+    expect(mockClient.replyStream).toHaveBeenCalledWith(
+      expect.objectContaining({ headers: { req_id: "req-block-media" } }),
+      expect.any(String),
+      "正文先发",
+      false,
+    );
+  });
+
+  it("includes default global media local roots for final media sends", async () => {
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({}),
+      },
+    } as any);
+
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-final-media-roots" },
+        body: {
+          from: { userid: "hidao" },
+          chattype: "single",
+        },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
+        isReasoning: false,
+      },
+      { kind: "final" },
+    );
+
+    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "hidao",
+        maxBytes: 80 * 1024 * 1024,
+        mediaUrl: "/Users/YanHaidao/Downloads/01.png",
+        mediaLocalRoots: expect.arrayContaining([
+          path.resolve(resolvePreferredOpenClawTmpDir()),
+          "/tmp/wecom-reply-state",
+          "/tmp/wecom-reply-state/media",
+          path.resolve(os.homedir(), "Desktop"),
+          path.resolve(os.homedir(), "Documents"),
+          path.resolve(os.homedir(), "Downloads"),
+        ]),
+      }),
+    );
+    expect(mockClient.replyStream).toHaveBeenCalledWith(
+      expect.objectContaining({ headers: { req_id: "req-final-media-roots" } }),
+      expect.any(String),
+      "文件已发送。",
+      true,
+    );
+  });
+
+  it("passes configured mediaMaxMb to final media sends", async () => {
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({
+          agents: {
+            defaults: {
+              mediaMaxMb: 12,
+            },
+          },
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+              accounts: {
+                default: {
+                  mediaMaxMb: 40,
+                },
+              },
+            },
+          },
+        }),
+      },
+    } as any);
+
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-final-media-max-bytes" },
+        body: {
+          from: { userid: "hidao" },
+          chattype: "single",
+        },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
+        isReasoning: false,
+      },
+      { kind: "final" },
+    );
+
+    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "hidao",
+        maxBytes: 40 * 1024 * 1024,
+      }),
+    );
+  });
+
+  it("stops placeholder keepalive when the first block contains media", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-placeholder-media" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      placeholderContent: "正在思考...",
+    });
+
+    vi.advanceTimersByTime(3000);
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(1);
+
+    await handle.deliver(
+      {
+        text: "正文先发",
+        mediaUrls: ["/tmp/a.png"],
+        isReasoning: false,
+      },
+      { kind: "block" },
+    );
+
+    vi.advanceTimersByTime(6000);
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(2);
+    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ headers: { req_id: "req-placeholder-media" } }),
+      expect.any(String),
+      "正文先发",
+      false,
+    );
+  });
+
   it("swallows expired stream update errors during delivery", async () => {
     const expiredError = {
       headers: { req_id: "req-expired" },
@@ -157,7 +352,7 @@ describe("createBotWsReplyHandle", () => {
     };
     mockClient.replyStream.mockRejectedValueOnce(expiredError);
     const onFail = vi.fn();
-    
+
     const handle = createBotWsReplyHandle({
       client: mockClient,
       frame: {
@@ -178,7 +373,13 @@ describe("createBotWsReplyHandle", () => {
 
   it.each([
     [{ headers: { req_id: "req-invalid" }, errcode: 846605, errmsg: "invalid req_id" }],
-    [{ headers: { req_id: "req-expired" }, errcode: 846608, errmsg: "stream message update expired (>6 minutes), cannot update" }],
+    [
+      {
+        headers: { req_id: "req-expired" },
+        errcode: 846608,
+        errmsg: "stream message update expired (>6 minutes), cannot update",
+      },
+    ],
   ])("does not retry error reply when the ws reply window is already closed", async (error) => {
     const onFail = vi.fn();
     const handle = createBotWsReplyHandle({
@@ -218,13 +419,10 @@ describe("createBotWsReplyHandle", () => {
     handle.deliver({ text: "Event Reply", isReasoning: false }, { kind: "final" });
     await Promise.resolve();
 
-    expect(mockClient.sendMessage).toHaveBeenCalledWith(
-      "alice",
-      {
-        msgtype: "markdown",
-        markdown: { content: "Event Reply" },
-      }
-    );
+    expect(mockClient.sendMessage).toHaveBeenCalledWith("alice", {
+      msgtype: "markdown",
+      markdown: { content: "Event Reply" },
+    });
   });
 
   it("sends replyWelcome for welcome events", async () => {
@@ -246,7 +444,7 @@ describe("createBotWsReplyHandle", () => {
       {
         msgtype: "text",
         text: { content: "Hello Bob" },
-      }
+      },
     );
   });
 });

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

@@ -1,7 +1,15 @@
+import {
+  generateReqId,
+  type WsFrame,
+  type BaseMessage,
+  type EventMessage,
+  type WSClient,
+} from "@wecom/aibot-node-sdk";
 import { formatErrorMessage } from "openclaw/plugin-sdk";
-import { generateReqId, type WsFrame, type BaseMessage, type EventMessage, type WSClient } from "@wecom/aibot-node-sdk";
-
+import { resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots } from "../../config/index.js";
+import { getWecomRuntime } from "../../runtime.js";
 import type { ReplyHandle, ReplyPayload } from "../../types/index.js";
+import { uploadAndSendBotWsMedia } from "./media.js";
 
 const PLACEHOLDER_KEEPALIVE_MS = 3000;
 const MAX_KEEPALIVE_MS = 120 * 1000; // Force stop keepalive after 120s if ignored
@@ -32,7 +40,14 @@ function isAckTimeoutError(error: unknown): boolean {
 }
 
 function isTerminalReplyError(error: unknown): boolean {
-  return isInvalidReqIdError(error) || isExpiredStreamUpdateError(error) || isAckTimeoutError(error);
+  return (
+    isInvalidReqIdError(error) || isExpiredStreamUpdateError(error) || isAckTimeoutError(error)
+  );
+}
+
+function formatMediaFailure(mediaUrl: string, error?: string, rejectReason?: string): string {
+  const reason = rejectReason || error || "unknown";
+  return `媒体发送失败：${mediaUrl} (${reason})`;
 }
 
 // Global registry to track active keepalives by peerId
@@ -54,6 +69,7 @@ export function createBotWsReplyHandle(params: {
 }): ReplyHandle {
   let streamId: string | undefined;
   let accumulatedText = "";
+  let deferredMediaUrls: string[] = [];
   const resolveStreamId = () => {
     streamId ||= generateReqId("stream");
     return streamId;
@@ -68,11 +84,15 @@ export function createBotWsReplyHandle(params: {
   // Extract peerId for clustering handles
   const body = params.frame.body as any;
   const peerId = String(
-    (body?.chattype === "group" ? body?.chatid || body?.from?.userid : body?.from?.userid) || "unknown"
+    (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 isEvent =
+    params.inboundKind === "welcome" ||
+    params.inboundKind === "event" ||
+    params.inboundKind === "template-card-event";
 
   const stopPlaceholderKeepalive = () => {
     if (placeholderKeepalive) {
@@ -83,7 +103,7 @@ export function createBotWsReplyHandle(params: {
       clearTimeout(placeholderTimeout);
       placeholderTimeout = undefined;
     }
-    
+
     // Remove from registry
     const keepalives = activeKeepalivesByPeer.get(peerId);
     if (keepalives) {
@@ -107,7 +127,8 @@ export function createBotWsReplyHandle(params: {
   const sendPlaceholder = () => {
     if (streamSettled || placeholderInFlight || isEvent) return;
     placeholderInFlight = true;
-    params.client.replyStream(params.frame, resolveStreamId(), placeholderText, false)
+    params.client
+      .replyStream(params.frame, resolveStreamId(), placeholderText, false)
       .catch((error) => {
         if (!isTerminalReplyError(error)) {
           return;
@@ -134,13 +155,27 @@ export function createBotWsReplyHandle(params: {
     }
   };
 
+  const mergeDeferredMediaUrls = (urls: string[]): string[] => {
+    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 
+
+    // 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();
@@ -183,10 +218,22 @@ export function createBotWsReplyHandle(params: {
         return;
       }
 
-      const text = payload.text?.trim();
-      if (!text) 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;
       }
 
@@ -199,6 +246,51 @@ export function createBotWsReplyHandle(params: {
             : 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: string[] = [];
+        const mediaNotes: string[] = [];
+        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;
@@ -209,19 +301,19 @@ export function createBotWsReplyHandle(params: {
         if (params.inboundKind === "welcome") {
           await params.client.replyWelcome(params.frame, {
             msgtype: "text",
-            text: { content: outboundText },
+            text: { content: finalText },
           });
         } else if (isEvent) {
           // Send push message for other events
           await params.client.sendMessage(peerId, {
             msgtype: "markdown",
-            markdown: { content: outboundText },
+            markdown: { content: finalText },
           });
         } else {
           await params.client.replyStream(
             params.frame,
             resolveStreamId(),
-            outboundText,
+            finalText,
             info.kind === "final",
           );
         }
@@ -243,17 +335,20 @@ export function createBotWsReplyHandle(params: {
       }
       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 }});
+          await params.client.replyWelcome(params.frame, {
+            msgtype: "text",
+            text: { content: text },
+          });
         } else if (isEvent) {
-            await params.client.sendMessage(peerId, {
-              msgtype: "markdown",
-              markdown: { content: text },
-            });
+          await params.client.sendMessage(peerId, {
+            msgtype: "markdown",
+            markdown: { content: text },
+          });
         } else {
-            await params.client.replyStream(params.frame, resolveStreamId(), text, true);
+          await params.client.replyStream(params.frame, resolveStreamId(), text, true);
         }
       } catch (sendError) {
         params.onFail?.(sendError);

package/src/transport/bot-ws/sdk-adapter.test.ts

@@ -5,6 +5,7 @@ const sdkMockState = vi.hoisted(() => {
     readonly handlers = new Map<string, Array<(payload: any) => void>>();
     readonly isConnected = true;
     readonly replyStream = vi.fn().mockResolvedValue(undefined);
+    readonly replyWelcome = vi.fn().mockResolvedValue(undefined);
 
     constructor(_options: unknown) {
       sdkMockState.client = this;
@@ -117,7 +118,69 @@ describe("BotWsSdkAdapter", () => {
       }),
     );
     expect(log.error).toHaveBeenCalledWith(
-      expect.stringContaining("frame handler failed account=acc-1 reqId=req-1 message=frame exploded"),
+      expect.stringContaining(
+        "frame handler failed account=acc-1 reqId=req-1 message=frame exploded",
+      ),
+    );
+    expect(unhandledRejections).toHaveLength(0);
+  });
+
+  it("short-circuits enter_chat welcome events to a static ws welcome reply", async () => {
+    process.on("unhandledRejection", onUnhandledRejection);
+
+    const runtime = {
+      account: {
+        accountId: "acc-1",
+        bot: {
+          wsConfigured: true,
+          ws: {
+            botId: "bot-1",
+            secret: "secret-1",
+          },
+          config: {
+            welcomeText: "欢迎来到 WeCom",
+          },
+        },
+      },
+      handleEvent: vi.fn().mockResolvedValue(undefined),
+      updateTransportSession: vi.fn(),
+      touchTransportSession: vi.fn(),
+      recordOperationalIssue: vi.fn(),
+    };
+    const log = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    new BotWsSdkAdapter(runtime as any, log as any).start();
+
+    sdkMockState.client?.emit("event", {
+      cmd: "aibot_event_callback",
+      headers: { req_id: "req-welcome" },
+      body: {
+        msgid: "msg-welcome",
+        msgtype: "event",
+        chattype: "single",
+        from: { userid: "user-1" },
+        event: { eventtype: "enter_chat" },
+      },
+    });
+
+    await waitForAsyncCallbacks();
+
+    expect(runtime.handleEvent).not.toHaveBeenCalled();
+    expect(sdkMockState.client?.replyWelcome).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: { req_id: "req-welcome" },
+      }),
+      {
+        msgtype: "text",
+        text: { content: "欢迎来到 WeCom" },
+      },
+    );
+    expect(log.info).toHaveBeenCalledWith(
+      expect.stringContaining("static welcome delivered account=acc-1 messageId=msg-welcome"),
     );
     expect(unhandledRejections).toHaveLength(0);
   });