@yanhaidao/wecom 2.3.160 → 2.3.190

package/src/config/media.ts

@@ -1,14 +1,141 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import os from "node:os";
+import path from "node:path";
+import {
+  resolveChannelMediaMaxBytes,
+  resolvePreferredOpenClawTmpDir,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk";
 
 // 默认给一个相对“够用”的上限（80MB），避免视频/较大文件频繁触发失败。
 // 仍保留上限以防止恶意大文件把进程内存打爆（下载实现会读入内存再保存）。
 export const DEFAULT_WECOM_MEDIA_MAX_BYTES = 80 * 1024 * 1024;
 
-export function resolveWecomMediaMaxBytes(cfg: OpenClawConfig): number {
+function parsePositiveNumber(value: unknown): number | undefined {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return undefined;
+  }
+  return parsed;
+}
+
+function resolveStateDirForWecomMedia(): string {
+  const stateOverride =
+    process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+  if (stateOverride) {
+    return stateOverride;
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+
+function normalizeWecomLocalRoot(root: string): string | undefined {
+  const trimmed = root.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  return path.resolve(trimmed.replace(/^~(?=\/|$)/, os.homedir()));
+}
+
+function getWecomCommonUserMediaLocalRoots(): readonly string[] {
+  const home = os.homedir();
+  return [
+    path.join(home, "Desktop"),
+    path.join(home, "Documents"),
+    path.join(home, "Downloads"),
+    path.join(home, "Movies"),
+    path.join(home, "Pictures"),
+  ];
+}
+
+export function getWecomDefaultMediaLocalRoots(): readonly string[] {
+  const stateDir = path.resolve(resolveStateDirForWecomMedia());
+  return [
+    path.resolve(resolvePreferredOpenClawTmpDir()),
+    stateDir,
+    path.join(stateDir, "media"),
+    path.join(stateDir, "agents"),
+    path.join(stateDir, "workspace"),
+    path.join(stateDir, "sandboxes"),
+    ...getWecomCommonUserMediaLocalRoots(),
+  ];
+}
+
+export function resolveWecomConfiguredMediaLocalRoots(cfg: OpenClawConfig): readonly string[] {
+  const rawWecom = cfg.channels?.wecom as
+    | {
+        media?: { localRoots?: unknown };
+        mediaLocalRoots?: unknown;
+      }
+    | undefined;
+  const configured = Array.isArray(rawWecom?.media?.localRoots)
+    ? rawWecom.media.localRoots
+    : Array.isArray(rawWecom?.mediaLocalRoots)
+      ? rawWecom.mediaLocalRoots
+      : [];
+  return configured
+    .filter((root): root is string => typeof root === "string")
+    .map(normalizeWecomLocalRoot)
+    .filter((root): root is string => Boolean(root));
+}
+
+export function resolveWecomMergedMediaLocalRoots(params: {
+  cfg: OpenClawConfig;
+  baseRoots?: readonly string[];
+}): readonly string[] {
+  const merged: string[] = [];
+  const seen = new Set<string>();
+  const pushRoot = (root: string) => {
+    const normalized = normalizeWecomLocalRoot(root);
+    if (!normalized || seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    merged.push(normalized);
+  };
+
+  for (const root of getWecomDefaultMediaLocalRoots()) {
+    pushRoot(root);
+  }
+  for (const root of params.baseRoots ?? []) {
+    pushRoot(root);
+  }
+  for (const root of resolveWecomConfiguredMediaLocalRoots(params.cfg)) {
+    pushRoot(root);
+  }
+  return merged;
+}
+
+function resolveLegacyWecomMediaMaxBytes(cfg: OpenClawConfig): number | undefined {
   const raw = (cfg.channels?.wecom as any)?.media?.maxBytes;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  if (Number.isFinite(n) && n > 0) {
-    return Math.floor(n);
+  const bytes = parsePositiveNumber(raw);
+  if (bytes) {
+    return Math.floor(bytes);
+  }
+  return undefined;
+}
+
+export function resolveWecomMediaMaxBytes(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): number {
+  const mediaMaxBytes = resolveChannelMediaMaxBytes({
+    cfg,
+    accountId,
+    resolveChannelLimitMb: ({ cfg, accountId }) => {
+      const wecom = cfg.channels?.wecom as
+        | {
+            mediaMaxMb?: unknown;
+            accounts?: Record<string, { mediaMaxMb?: unknown }>;
+          }
+        | undefined;
+      const accountLimitMb = parsePositiveNumber(wecom?.accounts?.[accountId]?.mediaMaxMb);
+      if (accountLimitMb) {
+        return accountLimitMb;
+      }
+      return parsePositiveNumber(wecom?.mediaMaxMb);
+    },
+  });
+  if (mediaMaxBytes) {
+    return mediaMaxBytes;
   }
-  return DEFAULT_WECOM_MEDIA_MAX_BYTES;
+  return resolveLegacyWecomMediaMaxBytes(cfg) ?? DEFAULT_WECOM_MEDIA_MAX_BYTES;
 }

package/src/config/schema.ts

@@ -1,114 +1,86 @@
-import { z } from "zod";
-
-function bindToJsonSchema<T extends z.ZodTypeAny>(schema: T): T {
-  const schemaWithJson = schema as T & { toJSONSchema?: (...args: unknown[]) => unknown };
-  if (typeof schemaWithJson.toJSONSchema === "function") {
-    schemaWithJson.toJSONSchema = schemaWithJson.toJSONSchema.bind(schema);
-  }
-  return schema;
+export interface DmConfig {
+  policy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: (string | number)[];
 }
 
-const dmSchema = z
-  .object({
-    policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-  })
-  .optional();
-
-const mediaSchema = z
-  .object({
-    tempDir: z.string().optional(),
-    retentionHours: z.number().optional(),
-    cleanupOnStart: z.boolean().optional(),
-    maxBytes: z.number().optional(),
-  })
-  .optional();
+export interface MediaConfig {
+  tempDir?: string;
+  retentionHours?: number;
+  cleanupOnStart?: boolean;
+  maxBytes?: number;
+  localRoots?: string[];
+}
 
-const networkSchema = z
-  .object({
-    egressProxyUrl: z.string().optional(),
-  })
-  .optional();
+export interface NetworkConfig {
+  egressProxyUrl?: string;
+}
 
-const routingSchema = z
-  .object({
-    failClosedOnDefaultRoute: z.boolean().optional(),
-  })
-  .optional();
+export interface RoutingConfig {
+  failClosedOnDefaultRoute?: boolean;
+}
 
-const botWsSchema = z
-  .object({
-    botId: z.string(),
-    secret: z.string(),
-  })
-  .optional();
+export interface BotWsConfig {
+  botId: string;
+  secret: string;
+}
 
-const botWebhookSchema = z
-  .object({
-    token: z.string(),
-    encodingAESKey: z.string(),
-    receiveId: z.string().optional(),
-  })
-  .optional();
+export interface BotWebhookConfig {
+  token: string;
+  encodingAESKey: string;
+  receiveId?: string;
+}
 
-const botSchema = z
-  .object({
-    primaryTransport: z.enum(["ws", "webhook"]).optional(),
-    streamPlaceholderContent: z.string().optional(),
-    welcomeText: z.string().optional(),
-    dm: dmSchema,
-    aibotid: z.string().optional(),
-    botIds: z.array(z.string()).optional(),
-    ws: botWsSchema,
-    webhook: botWebhookSchema,
-  })
-  .optional();
+export interface BotConfig {
+  primaryTransport?: "ws" | "webhook";
+  streamPlaceholderContent?: string;
+  welcomeText?: string;
+  dm?: DmConfig;
+  aibotid?: string;
+  botIds?: string[];
+  ws?: BotWsConfig;
+  webhook?: BotWebhookConfig;
+}
 
-const agentSchema = z
-  .object({
-    corpId: z.string(),
-    agentSecret: z.string().optional(),
-    corpSecret: z.string().optional(),
-    agentId: z.union([z.number(), z.string()]).optional(),
-    token: z.string(),
-    encodingAESKey: z.string(),
-    welcomeText: z.string().optional(),
-    dm: dmSchema,
-  })
-  .refine((value) => Boolean(value.agentSecret?.trim() || value.corpSecret?.trim()), {
-    path: ["agentSecret"],
-    message: "agentSecret 不能为空",
-  })
-  .optional();
+export interface AgentConfig {
+  corpId: string;
+  agentSecret?: string;
+  corpSecret?: string;
+  agentId?: number | string;
+  token: string;
+  encodingAESKey: string;
+  welcomeText?: string;
+  dm?: DmConfig;
+}
 
-const dynamicAgentsSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    dmCreateAgent: z.boolean().optional(),
-    groupEnabled: z.boolean().optional(),
-    adminUsers: z.array(z.string()).optional(),
-  })
-  .optional();
+export interface DynamicAgentsConfig {
+  enabled?: boolean;
+  dmCreateAgent?: boolean;
+  groupEnabled?: boolean;
+  adminUsers?: string[];
+}
 
-const accountSchema = z.object({
-  enabled: z.boolean().optional(),
-  name: z.string().optional(),
-  bot: botSchema,
-  agent: agentSchema,
-});
+export interface AccountConfig {
+  enabled?: boolean;
+  name?: string;
+  mediaMaxMb?: number;
+  bot?: BotConfig;
+  agent?: AgentConfig;
+}
 
-export const WecomConfigSchema = bindToJsonSchema(
-  z.object({
-    enabled: z.boolean().optional(),
-    bot: botSchema,
-    agent: agentSchema,
-    accounts: z.record(z.string(), accountSchema).optional(),
-    defaultAccount: z.string().optional(),
-    media: mediaSchema,
-    network: networkSchema,
-    routing: routingSchema,
-    dynamicAgents: dynamicAgentsSchema,
-  }),
-);
+export interface WecomConfigInput {
+  enabled?: boolean;
+  mediaMaxMb?: number;
+  bot?: BotConfig;
+  agent?: AgentConfig;
+  accounts?: Record<string, AccountConfig>;
+  defaultAccount?: string;
+  media?: MediaConfig;
+  network?: NetworkConfig;
+  routing?: RoutingConfig;
+  dynamicAgents?: DynamicAgentsConfig;
+}
 
-export type WecomConfigInput = z.infer<typeof WecomConfigSchema>;
+/**
+ * @deprecated No longer a Zod schema. Kept as a type-only export for backward compatibility.
+ */
+export const WecomConfigSchema = undefined;

package/src/outbound.test.ts

@@ -1,4 +1,5 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { BotWsPushHandle } from "./app/index.js";
 
 vi.mock("./transport/agent-api/core.js", () => ({
   sendText: vi.fn(),
@@ -7,6 +8,25 @@ vi.mock("./transport/agent-api/core.js", () => ({
 }));
 
 describe("wecomOutbound", () => {
+  const createBotWsHandle = (overrides: Partial<BotWsPushHandle> = {}): BotWsPushHandle => ({
+    isConnected: () => true,
+    sendMarkdown: vi.fn().mockResolvedValue(undefined),
+    replyCommand: vi.fn().mockResolvedValue({ errcode: 0 }),
+    sendMedia: vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-1" }),
+    ...overrides,
+  });
+
+  beforeEach(async () => {
+    const runtime = await import("./runtime.js");
+    runtime.setWecomRuntime({
+      channel: {
+        text: {
+          chunkText: (text: string) => [text],
+        },
+      },
+    } as any);
+  });
+
   afterEach(async () => {
     const runtime = await import("./runtime.js");
     runtime.unregisterBotWsPushHandle("default");
@@ -80,9 +100,9 @@ describe("wecomOutbound", () => {
     };
 
     // Chat ID (wr/wc) is intentionally NOT supported for Agent outbound.
-    await expect(wecomOutbound.sendText({ cfg, to: "wr123", text: "hello" } as any)).rejects.toThrow(
-      /不支持向群 chatId 发送/,
-    );
+    await expect(
+      wecomOutbound.sendText({ cfg, to: "wr123", text: "hello" } as any),
+    ).rejects.toThrow(/不支持向群 chatId 发送/);
     expect(api.sendText).not.toHaveBeenCalled();
 
     // Test: User ID (Default)
@@ -186,10 +206,12 @@ describe("wecomOutbound", () => {
     const api = await import("./transport/agent-api/core.js");
     const sendMarkdown = vi.fn().mockResolvedValue(undefined);
     const now = vi.spyOn(Date, "now").mockReturnValue(789);
-    runtime.registerBotWsPushHandle("acct-ws", {
-      isConnected: () => true,
-      sendMarkdown,
-    });
+    runtime.registerBotWsPushHandle(
+      "acct-ws",
+      createBotWsHandle({
+        sendMarkdown,
+      }),
+    );
     (api.sendText as any).mockClear();
 
     const cfg = {
@@ -271,15 +293,228 @@ describe("wecomOutbound", () => {
     expect(api.sendText).not.toHaveBeenCalled();
   });
 
-  it("keeps outbound media on Agent even when Bot WS is active", async () => {
+  it("prefers Bot WS for outbound media when ws is the active bot transport", async () => {
     const { wecomOutbound } = await import("./outbound.js");
     const runtime = await import("./runtime.js");
     const api = await import("./transport/agent-api/core.js");
-    const sendMarkdown = vi.fn().mockResolvedValue(undefined);
-    runtime.registerBotWsPushHandle("default", {
-      isConnected: () => true,
-      sendMarkdown,
+    const sendMedia = vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-1" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
+    (api.uploadMedia as any).mockResolvedValue("media-1");
+    (api.sendMedia as any).mockResolvedValue(undefined);
+    (api.sendMedia as any).mockClear();
+
+    const cfg = {
+      channels: {
+        wecom: {
+          enabled: true,
+          bot: {
+            primaryTransport: "ws",
+            ws: {
+              botId: "bot-1",
+              secret: "secret-1",
+            },
+          },
+          agent: {
+            corpId: "corp",
+            corpSecret: "secret",
+            agentId: 1000002,
+            token: "token",
+            encodingAESKey: "aes",
+          },
+        },
+      },
+    };
+
+    await wecomOutbound.sendMedia({
+      cfg,
+      to: "user:zhangsan",
+      text: "caption",
+      mediaUrl: "https://example.com/media.png",
+    } as any);
+
+    expect(sendMedia).toHaveBeenCalledWith({
+      chatId: "zhangsan",
+      maxBytes: 80 * 1024 * 1024,
+      mediaUrl: "https://example.com/media.png",
+      mediaLocalRoots: expect.any(Array),
+      text: "caption",
     });
+    expect(api.sendMedia).not.toHaveBeenCalled();
+  });
+
+  it("merges configured media local roots into Bot WS sends", async () => {
+    const { wecomOutbound } = await import("./outbound.js");
+    const runtime = await import("./runtime.js");
+    const sendMedia = vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-merged" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
+
+    const cfg = {
+      channels: {
+        wecom: {
+          enabled: true,
+          bot: {
+            primaryTransport: "ws",
+            ws: {
+              botId: "bot-1",
+              secret: "secret-1",
+            },
+          },
+          media: {
+            localRoots: ["/tmp/downloads"],
+          },
+        },
+      },
+    };
+
+    await wecomOutbound.sendMedia({
+      cfg,
+      to: "user:zhangsan",
+      mediaUrl: "/tmp/workspace-agent/01.png",
+      mediaLocalRoots: ["/tmp/workspace-agent"],
+    } as any);
+
+    expect(sendMedia).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "zhangsan",
+        mediaUrl: "/tmp/workspace-agent/01.png",
+        mediaLocalRoots: expect.arrayContaining(["/tmp/workspace-agent", "/tmp/downloads"]),
+        text: undefined,
+      }),
+    );
+  });
+
+  it("passes account-aware mediaMaxMb to Bot WS media sends", async () => {
+    const { wecomOutbound } = await import("./outbound.js");
+    const runtime = await import("./runtime.js");
+    const sendMedia = vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-limit" });
+    runtime.registerBotWsPushHandle(
+      "acct-ws",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
+
+    const cfg = {
+      agents: {
+        defaults: {
+          mediaMaxMb: 12,
+        },
+      },
+      channels: {
+        wecom: {
+          enabled: true,
+          mediaMaxMb: 24,
+          accounts: {
+            "acct-ws": {
+              enabled: true,
+              mediaMaxMb: 36,
+              bot: {
+                primaryTransport: "ws",
+                ws: {
+                  botId: "bot-1",
+                  secret: "secret-1",
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    await wecomOutbound.sendMedia({
+      cfg,
+      accountId: "acct-ws",
+      to: "user:zhangsan",
+      mediaUrl: "https://example.com/media.png",
+    } as any);
+
+    expect(sendMedia).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "zhangsan",
+        maxBytes: 36 * 1024 * 1024,
+      }),
+    );
+  });
+
+  it("does not fall back to Agent media when Bot WS conversation media delivery fails", async () => {
+    const { wecomOutbound } = await import("./outbound.js");
+    const runtime = await import("./runtime.js");
+    const api = await import("./transport/agent-api/core.js");
+    const sendMedia = vi.fn().mockResolvedValue({ ok: false, error: "upload failed" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
+    (api.uploadMedia as any).mockResolvedValue("media-1");
+    (api.sendMedia as any).mockResolvedValue(undefined);
+    (api.sendMedia as any).mockClear();
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer,
+        headers: new Headers({ "content-type": "image/png" }),
+      }),
+    );
+
+    const cfg = {
+      channels: {
+        wecom: {
+          enabled: true,
+          bot: {
+            primaryTransport: "ws",
+            ws: {
+              botId: "bot-1",
+              secret: "secret-1",
+            },
+          },
+          agent: {
+            corpId: "corp",
+            corpSecret: "secret",
+            agentId: 1000002,
+            token: "token",
+            encodingAESKey: "aes",
+          },
+        },
+      },
+    };
+
+    await expect(
+      wecomOutbound.sendMedia({
+        cfg,
+        to: "user:zhangsan",
+        text: "caption",
+        mediaUrl: "https://example.com/media.png",
+      } as any),
+    ).rejects.toThrow(/Bot WS media delivery failed/i);
+
+    expect(sendMedia).toHaveBeenCalledTimes(1);
+    expect(api.sendMedia).not.toHaveBeenCalled();
+  });
+
+  it("keeps explicit agent targets on the Agent media path", async () => {
+    const { wecomOutbound } = await import("./outbound.js");
+    const runtime = await import("./runtime.js");
+    const api = await import("./transport/agent-api/core.js");
+    const sendMedia = vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-1" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
     (api.uploadMedia as any).mockResolvedValue("media-1");
     (api.sendMedia as any).mockResolvedValue(undefined);
     (api.sendMedia as any).mockClear();
@@ -316,13 +551,13 @@ describe("wecomOutbound", () => {
 
     await wecomOutbound.sendMedia({
       cfg,
-      to: "user:zhangsan",
+      to: "wecom-agent:default:user:zhangsan",
       text: "caption",
       mediaUrl: "https://example.com/media.png",
     } as any);
 
+    expect(sendMedia).not.toHaveBeenCalled();
     expect(api.sendMedia).toHaveBeenCalledTimes(1);
-    expect(sendMarkdown).not.toHaveBeenCalled();
   });
 
   it("uses account-scoped agent config in matrix mode", async () => {