@yanhaidao/wecom 2.3.260 → 2.3.270

package/src/outbound.ts

@@ -1,6 +1,5 @@
-import type { ChannelOutboundAdapter, ChannelOutboundContext } from "openclaw/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/channel-send-result";
 import { WecomAgentDeliveryService } from "./capability/agent/index.js";
-import { toWeComMarkdownV2 } from "./wecom_msg_adapter/markdown_adapter.js";
 import {
   resolveWecomMergedMediaLocalRoots,
   resolveWecomMediaMaxBytes,
@@ -16,9 +15,16 @@ import {
 } from "./runtime.js";
 import { resolveWecomSourceSnapshot } from "./runtime/source-registry.js";
 import { resolveScopedWecomTarget } from "./target.js";
+import { toWeComMarkdownV2 } from "./wecom_msg_adapter/markdown_adapter.js";
+
+type WecomOutboundBaseContext = Parameters<NonNullable<ChannelOutboundAdapter["sendText"]>>[0];
+type WecomOutboundContext = WecomOutboundBaseContext & {
+  sessionKey?: string | null;
+};
+type WecomOutboundConfig = WecomOutboundContext["cfg"];
 
 function resolveOutboundAccountOrThrow(params: {
-  cfg: ChannelOutboundContext["cfg"];
+  cfg: WecomOutboundConfig;
   accountId?: string | null;
 }) {
   const resolvedAccounts = resolveWecomAccounts(params.cfg);
@@ -46,7 +52,7 @@ function resolveOutboundAccountOrThrow(params: {
 }
 
 function resolveAgentConfigOrThrow(params: {
-  cfg: ChannelOutboundContext["cfg"];
+  cfg: WecomOutboundConfig;
   accountId?: string | null;
 }) {
   const account = resolveOutboundAccountOrThrow(params).agent;
@@ -114,7 +120,7 @@ function resolveOutboundPeer(params: {
 }
 
 function shouldPreferBotWsOutbound(params: {
-  cfg: ChannelOutboundContext["cfg"];
+  cfg: WecomOutboundConfig;
   accountId?: string | null;
   to: string | undefined;
   sessionKey?: string | null;
@@ -167,7 +173,7 @@ function markActiveBotWsReplyHandleActivity(params: {
 }
 
 async function sendTextViaBotWs(params: {
-  cfg: ChannelOutboundContext["cfg"];
+  cfg: WecomOutboundConfig;
   accountId?: string | null;
   to: string | undefined;
   text: string;
@@ -210,7 +216,7 @@ async function sendTextViaBotWs(params: {
 }
 
 async function sendMediaViaBotWs(params: {
-  cfg: ChannelOutboundContext["cfg"];
+  cfg: WecomOutboundConfig;
   accountId?: string | null;
   to: string | undefined;
   mediaUrl: string;
@@ -276,14 +282,14 @@ export const wecomOutbound: ChannelOutboundAdapter = {
   deliveryMode: "direct",
   chunkerMode: "text",
   textChunkLimit: 20480,
-  chunker: (text, limit) => {
+  chunker: (text: string, limit: number) => {
     try {
       return getWecomRuntime().channel.text.chunkText(text, limit);
     } catch {
       return [text];
     }
   },
-  sendText: async ({ cfg, to, text, accountId, sessionKey }: ChannelOutboundContext) => {
+  sendText: async ({ cfg, to, text, accountId, sessionKey }: WecomOutboundContext) => {
     // signal removed - not supported in current SDK
     // Defer Agent resolution until the Agent fallback path
     // sendTextViaBotWs() can already deliver without Agent mode
@@ -316,7 +322,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
     }
 
     let sentViaBotWs = false;
-    let agent: any = null;
+    let agent: ReturnType<typeof resolveAgentConfigOrThrow> | null = null;
 
     try {
       sentViaBotWs = await sendTextViaBotWs({
@@ -362,7 +368,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
     accountId,
     mediaLocalRoots,
     sessionKey,
-  }: ChannelOutboundContext) => {
+  }: WecomOutboundContext) => {
     // signal removed - not supported in current SDK
     if (!mediaUrl) {
       throw new Error("WeCom outbound requires mediaUrl.");

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

@@ -1,20 +1,20 @@
 import type { WSClient } from "@wecom/aibot-node-sdk";
+import { fetchRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/media-runtime";
-
 import { uploadAndSendBotWsMedia } from "./media.js";
 
 vi.mock("openclaw/plugin-sdk/media-runtime", () => ({
+  assertLocalMediaAllowed: vi.fn(),
   detectMime: vi.fn(),
-  loadOutboundMediaFromUrl: vi.fn(),
+  fetchRemoteMedia: vi.fn(),
 }));
 
 describe("uploadAndSendBotWsMedia", () => {
-  const loadOutboundMediaFromUrlMock = vi.mocked(loadOutboundMediaFromUrl);
+  const fetchRemoteMediaMock = vi.mocked(fetchRemoteMedia);
 
   beforeEach(() => {
-    loadOutboundMediaFromUrlMock.mockReset();
-    loadOutboundMediaFromUrlMock.mockResolvedValue({
+    fetchRemoteMediaMock.mockReset();
+    fetchRemoteMediaMock.mockResolvedValue({
       buffer: Buffer.from("png"),
       contentType: "image/png",
       fileName: "sample.png",
@@ -34,9 +34,9 @@ describe("uploadAndSendBotWsMedia", () => {
       maxBytes: 42 * 1024 * 1024,
     });
 
-    expect(loadOutboundMediaFromUrlMock).toHaveBeenCalledWith(
-      "https://example.com/sample.png",
+    expect(fetchRemoteMediaMock).toHaveBeenCalledWith(
       expect.objectContaining({
+        url: "https://example.com/sample.png",
         maxBytes: 42 * 1024 * 1024,
       }),
     );

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

@@ -1,5 +1,12 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { WeComMediaType, WsFrameHeaders, WSClient } from "@wecom/aibot-node-sdk";
-import { detectMime, loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/media-runtime";
+import {
+  assertLocalMediaAllowed,
+  detectMime,
+  fetchRemoteMedia,
+} from "openclaw/plugin-sdk/media-runtime";
 
 const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
 const VIDEO_MAX_BYTES = 10 * 1024 * 1024;
@@ -90,6 +97,47 @@ function extractFileName(
   return `media_${Date.now()}${mimeToExtension(contentType || "application/octet-stream")}`;
 }
 
+function resolveLocalMediaPath(mediaUrl: string): string {
+  if (mediaUrl.startsWith("file://")) {
+    return fileURLToPath(mediaUrl);
+  }
+  return mediaUrl;
+}
+
+async function loadOutboundMediaFile(params: {
+  mediaUrl: string;
+  mediaLocalRoots?: readonly string[];
+  maxBytes: number;
+}): Promise<{
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+}> {
+  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: number,
   detectedType: WeComMediaType,
@@ -160,7 +208,8 @@ async function resolveMediaFile(
   mediaLocalRoots?: readonly string[],
   maxBytes?: number,
 ): Promise<ResolvedMediaFile> {
-  const result = await loadOutboundMediaFromUrl(mediaUrl, {
+  const result = await loadOutboundMediaFile({
+    mediaUrl,
     maxBytes: maxBytes ?? FILE_MAX_BYTES,
     mediaLocalRoots,
   });

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

@@ -51,11 +51,11 @@ export class BotWsSdkAdapter {
     registerBotWsPushHandle(this.runtime.account.accountId, {
       isConnected: () => client.isConnected,
       replyCommand: async ({ cmd, body, headers }) => {
-        const result = await client.reply(
-          { headers: headers ?? { req_id: generateReqId("wecom_ws") } },
-          body ?? {},
-          cmd,
-        );
+        const replyHeaders = {
+          ...(headers ?? {}),
+          req_id: headers?.req_id ?? generateReqId("wecom_ws"),
+        };
+        const result = await client.reply({ headers: replyHeaders }, body ?? {}, cmd);
         this.runtime.touchTransportSession("bot-ws", {
           ownerId: this.ownerId,
           running: true,
@@ -64,7 +64,7 @@ export class BotWsSdkAdapter {
           lastOutboundAt: Date.now(),
           lastError: undefined,
         });
-        return result as Record<string, unknown>;
+        return result as unknown as Record<string, unknown>;
       },
       sendMarkdown: async (chatId, content) => {
         await client.sendMessage(chatId, {