@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/config/derived-paths.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
-import { resolveDerivedPathSummary } from "./derived-paths.js";
-import {
-  hasMatrixExplicitRoutesRegistered,
-  registerAgentWebhookTarget,
-  registerWecomWebhookTarget,
-} from "../transport/http/registry.js";
-import type { ResolvedAgentAccount, ResolvedBotAccount } from "../types/index.js";
-
-function createBotAccount(accountId: string): ResolvedBotAccount {
-  return {
-    accountId,
-    configured: true,
-    primaryTransport: "webhook",
-    wsConfigured: false,
-    webhookConfigured: true,
-    config: {} as ResolvedBotAccount["config"],
-    token: "token",
-    encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
-    receiveId: "",
-    botId: "",
-    secret: "",
-    webhook: {
-      token: "token",
-      encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
-      receiveId: "",
-    },
-  };
-}
-
-function createAgentAccount(accountId: string): ResolvedAgentAccount {
-  return {
-    accountId,
-    configured: true,
-    callbackConfigured: true,
-    apiConfigured: true,
-    corpId: `corp-${accountId}`,
-    corpSecret: `secret-${accountId}`,
-    agentId: 1001,
-    token: "token",
-    encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
-    config: {} as ResolvedAgentAccount["config"],
-  };
-}
-
-const emptyConfig = {} as OpenClawConfig;
-const emptyCore = {} as PluginRuntime;
-
-describe("resolveDerivedPathSummary", () => {
-  it("registers scoped aliases first for the default account", () => {
-    expect(resolveDerivedPathSummary("default")).toEqual({
-      botWebhook: [
-        "/plugins/wecom/bot/default",
-        "/wecom/bot/default",
-        "/plugins/wecom/bot",
-        "/wecom",
-        "/wecom/bot",
-      ],
-      agentCallback: [
-        "/plugins/wecom/agent/default",
-        "/wecom/agent/default",
-        "/plugins/wecom/agent",
-        "/wecom/agent",
-      ],
-    });
-  });
-});
-
-describe("hasMatrixExplicitRoutesRegistered", () => {
-  it("ignores default-account scoped aliases", () => {
-    const unregisterBot = registerWecomWebhookTarget({
-      account: createBotAccount("default"),
-      config: emptyConfig,
-      runtime: {},
-      core: emptyCore,
-      path: "/plugins/wecom/bot/default",
-    });
-    const unregisterAgent = registerAgentWebhookTarget({
-      agent: createAgentAccount("default"),
-      config: emptyConfig,
-      runtimeEnv: {},
-      path: "/plugins/wecom/agent/default",
-    });
-
-    try {
-      expect(hasMatrixExplicitRoutesRegistered()).toBe(false);
-    } finally {
-      unregisterAgent();
-      unregisterBot();
-    }
-  });
-
-  it("detects non-default explicit account routes", () => {
-    const unregister = registerWecomWebhookTarget({
-      account: createBotAccount("acct-a"),
-      config: emptyConfig,
-      runtime: {},
-      core: emptyCore,
-      path: "/plugins/wecom/bot/acct-a",
-    });
-
-    try {
-      expect(hasMatrixExplicitRoutesRegistered()).toBe(true);
-    } finally {
-      unregister();
-    }
-  });
-});

package/src/config/derived-paths.ts

@@ -1,41 +0,0 @@
-import { DEFAULT_ACCOUNT_ID } from "./accounts.js";
-import type { WecomTransportKind } from "../types/runtime.js";
-import { WEBHOOK_PATHS } from "../types/constants.js";
-
-export function resolveDerivedPath(params: {
-  accountId: string;
-  transport: Extract<WecomTransportKind, "bot-webhook" | "agent-callback">;
-  includeLegacy?: boolean;
-}): string[] {
-  const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
-  const isDefault = accountId === DEFAULT_ACCOUNT_ID;
-  if (params.transport === "bot-webhook") {
-    return isDefault
-      ? [
-          `${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`,
-          `${WEBHOOK_PATHS.BOT}/${accountId}`,
-          WEBHOOK_PATHS.BOT_PLUGIN,
-          WEBHOOK_PATHS.BOT_ALT,
-          WEBHOOK_PATHS.BOT,
-        ]
-      : [`${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`];
-  }
-  return isDefault
-    ? [
-        `${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`,
-        `${WEBHOOK_PATHS.AGENT}/${accountId}`,
-        WEBHOOK_PATHS.AGENT_PLUGIN,
-        WEBHOOK_PATHS.AGENT,
-      ]
-    : [`${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`];
-}
-
-export function resolveDerivedPathSummary(accountId: string): {
-  botWebhook: string[];
-  agentCallback: string[];
-} {
-  return {
-    botWebhook: resolveDerivedPath({ accountId, transport: "bot-webhook" }),
-    agentCallback: resolveDerivedPath({ accountId, transport: "agent-callback" }),
-  };
-}

package/src/config/index.ts

@@ -1,22 +0,0 @@
-export { WecomConfigSchema, type WecomConfigInput } from "./schema.js";
-export {
-  DEFAULT_ACCOUNT_ID,
-  detectMode,
-  listWecomAccountIds,
-  resolveDefaultWecomAccountId,
-  resolveWecomAccount,
-  resolveWecomAccountConflict,
-  resolveWecomAccounts,
-  isWecomEnabled,
-} from "./accounts.js";
-export { resolveWecomRuntimeAccount, resolveWecomRuntimeConfig, type ResolvedRuntimeAccount, type ResolvedRuntimeConfig } from "./runtime-config.js";
-export { resolveDerivedPath, resolveDerivedPathSummary } from "./derived-paths.js";
-export { resolveWecomEgressProxyUrl, resolveWecomEgressProxyUrlFromNetwork } from "./network.js";
-export {
-  DEFAULT_WECOM_MEDIA_MAX_BYTES,
-  getWecomDefaultMediaLocalRoots,
-  resolveWecomConfiguredMediaLocalRoots,
-  resolveWecomMediaMaxBytes,
-  resolveWecomMergedMediaLocalRoots,
-} from "./media.js";
-export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/src/config/media.test.ts

@@ -1,113 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
-import { resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots } from "./media.js";
-
-describe("resolveWecomMergedMediaLocalRoots", () => {
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it("merges defaults with configured local roots", () => {
-    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-state");
-
-    const roots = resolveWecomMergedMediaLocalRoots({
-      cfg: {
-        channels: {
-          wecom: {
-            media: {
-              localRoots: ["~/Downloads", "/tmp/custom-root"],
-            },
-          },
-        },
-      } as never,
-    });
-
-    expect(roots).toEqual(
-      expect.arrayContaining([
-        path.resolve(resolvePreferredOpenClawTmpDir()),
-        "/tmp/wecom-state",
-        "/tmp/wecom-state/media",
-        "/tmp/wecom-state/agents",
-        "/tmp/wecom-state/workspace",
-        "/tmp/wecom-state/sandboxes",
-        path.resolve(os.homedir(), "Desktop"),
-        path.resolve(os.homedir(), "Documents"),
-        path.resolve(os.homedir(), "Downloads"),
-        path.resolve(os.homedir(), "Movies"),
-        path.resolve(os.homedir(), "Pictures"),
-        "/tmp/custom-root",
-      ]),
-    );
-  });
-
-  it("keeps defaults, base roots, and configured roots without duplicates", () => {
-    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-state");
-
-    const roots = resolveWecomMergedMediaLocalRoots({
-      cfg: {
-        channels: {
-          wecom: {
-            media: {
-              localRoots: ["/tmp/agent-root", "/tmp/downloads"],
-            },
-          },
-        },
-      } as never,
-      baseRoots: ["/tmp/agent-root", "/tmp/workspace-agent"],
-    });
-
-    expect(roots).toEqual(
-      expect.arrayContaining([
-        path.resolve(resolvePreferredOpenClawTmpDir()),
-        "/tmp/wecom-state",
-        "/tmp/workspace-agent",
-        "/tmp/agent-root",
-        "/tmp/downloads",
-      ]),
-    );
-    expect(roots.filter((root) => root === "/tmp/agent-root")).toHaveLength(1);
-  });
-});
-
-describe("resolveWecomMediaMaxBytes", () => {
-  it("prefers account mediaMaxMb over channel and agent defaults", () => {
-    expect(
-      resolveWecomMediaMaxBytes(
-        {
-          agents: {
-            defaults: {
-              mediaMaxMb: 12,
-            },
-          },
-          channels: {
-            wecom: {
-              mediaMaxMb: 24,
-              accounts: {
-                ops: {
-                  mediaMaxMb: 32,
-                },
-              },
-            },
-          },
-        } as never,
-        "ops",
-      ),
-    ).toBe(32 * 1024 * 1024);
-  });
-
-  it("falls back to legacy channels.wecom.media.maxBytes when mediaMaxMb is unset", () => {
-    expect(
-      resolveWecomMediaMaxBytes({
-        channels: {
-          wecom: {
-            media: {
-              maxBytes: 15 * 1024 * 1024,
-            },
-          },
-        },
-      } as never),
-    ).toBe(15 * 1024 * 1024);
-  });
-});

package/src/config/media.ts

@@ -1,139 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
-import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
-
-// 默认给一个相对“够用”的上限（80MB），避免视频/较大文件频繁触发失败。
-// 仍保留上限以防止恶意大文件把进程内存打爆（下载实现会读入内存再保存）。
-export const DEFAULT_WECOM_MEDIA_MAX_BYTES = 80 * 1024 * 1024;
-
-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 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 resolveLegacyWecomMediaMaxBytes(cfg) ?? DEFAULT_WECOM_MEDIA_MAX_BYTES;
-}

package/src/config/network.ts

@@ -1,20 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import type { WecomConfig, WecomNetworkConfig } from "../types/index.js";
-
-export function resolveWecomEgressProxyUrlFromNetwork(network?: WecomNetworkConfig): string | undefined {
-  const proxyUrl = network?.egressProxyUrl ??
-    process.env.OPENCLAW_WECOM_EGRESS_PROXY_URL ??
-    process.env.WECOM_EGRESS_PROXY_URL ??
-    process.env.HTTPS_PROXY ??
-    process.env.ALL_PROXY ??
-    process.env.HTTP_PROXY ??
-    "";
-    
-  return proxyUrl.trim() || undefined;
-}
-
-export function resolveWecomEgressProxyUrl(cfg: OpenClawConfig): string | undefined {
-  const wecom = cfg.channels?.wecom as WecomConfig | undefined;
-  return resolveWecomEgressProxyUrlFromNetwork(wecom?.network);
-}

package/src/config/routing.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";
-
-describe("resolveWecomFailClosedOnDefaultRoute", () => {
-    it("defaults to true in matrix mode", () => {
-        const cfg: OpenClawConfig = {
-            channels: {
-                wecom: {
-                    enabled: true,
-                    accounts: {
-                        a: { enabled: true, bot: { token: "t1", encodingAESKey: "k1" } },
-                    },
-                },
-            },
-        } as OpenClawConfig;
-        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(true);
-    });
-
-    it("defaults to false in legacy mode", () => {
-        const cfg: OpenClawConfig = {
-            channels: {
-                wecom: {
-                    enabled: true,
-                    bot: { token: "t1", encodingAESKey: "k1" },
-                },
-            },
-        } as OpenClawConfig;
-        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(false);
-    });
-
-    it("respects explicit override", () => {
-        const cfg: OpenClawConfig = {
-            channels: {
-                wecom: {
-                    enabled: true,
-                    bot: { token: "t1", encodingAESKey: "k1" },
-                    routing: { failClosedOnDefaultRoute: true },
-                },
-            },
-        } as OpenClawConfig;
-        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(true);
-    });
-});
-
-describe("shouldRejectWecomDefaultRoute", () => {
-    const matrixCfg = {
-        channels: {
-            wecom: {
-                enabled: true,
-                accounts: {
-                    a: { enabled: true, bot: { token: "t1", encodingAESKey: "k1" } },
-                },
-            },
-        },
-    } as OpenClawConfig;
-
-    it("rejects default route in matrix mode when dynamic agent is disabled", () => {
-        expect(
-            shouldRejectWecomDefaultRoute({
-                cfg: matrixCfg,
-                matchedBy: "default",
-                useDynamicAgent: false,
-            }),
-        ).toBe(true);
-    });
-
-    it("does not reject when route already matched a binding", () => {
-        expect(
-            shouldRejectWecomDefaultRoute({
-                cfg: matrixCfg,
-                matchedBy: "binding.account",
-                useDynamicAgent: false,
-            }),
-        ).toBe(false);
-    });
-
-    it("does not reject when dynamic agent routing is enabled", () => {
-        expect(
-            shouldRejectWecomDefaultRoute({
-                cfg: matrixCfg,
-                matchedBy: "default",
-                useDynamicAgent: true,
-            }),
-        ).toBe(false);
-    });
-});

package/src/config/routing.ts

@@ -1,26 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import type { WecomConfig } from "../types/index.js";
-import { detectMode } from "./accounts.js";
-
-/**
- * 默认策略：
- * - matrix（多账号）: 开启 fail-closed，防止未绑定账号回退到 main
- * - legacy（单账号兼容）: 维持历史行为，不强制拦截
- */
-export function resolveWecomFailClosedOnDefaultRoute(cfg: OpenClawConfig): boolean {
-    const wecom = cfg.channels?.wecom as WecomConfig | undefined;
-    const explicit = wecom?.routing?.failClosedOnDefaultRoute;
-    if (typeof explicit === "boolean") return explicit;
-    return detectMode(wecom) === "matrix";
-}
-
-export function shouldRejectWecomDefaultRoute(params: {
-    cfg: OpenClawConfig;
-    matchedBy: string;
-    useDynamicAgent: boolean;
-}): boolean {
-    if (params.matchedBy !== "default") return false;
-    if (params.useDynamicAgent) return false;
-    return resolveWecomFailClosedOnDefaultRoute(params.cfg);
-}

package/src/config/runtime-config.ts

@@ -1,46 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import { resolveDerivedPathSummary } from "./derived-paths.js";
-import { DEFAULT_ACCOUNT_ID, resolveWecomAccount, resolveWecomAccounts } from "./accounts.js";
-import type { ResolvedWecomAccount, WecomConfig } from "../types/index.js";
-
-export type ResolvedRuntimeAccount = {
-  account: ResolvedWecomAccount;
-  derivedPaths: ReturnType<typeof resolveDerivedPathSummary>;
-};
-
-export type ResolvedRuntimeConfig = {
-  raw: WecomConfig | undefined;
-  defaultAccountId: string;
-  accounts: Record<string, ResolvedRuntimeAccount>;
-};
-
-export function resolveWecomRuntimeConfig(cfg: OpenClawConfig): ResolvedRuntimeConfig {
-  const raw = cfg.channels?.wecom as WecomConfig | undefined;
-  const resolved = resolveWecomAccounts(cfg);
-  const accounts = Object.fromEntries(
-    Object.entries(resolved.accounts).map(([accountId, account]) => [
-      accountId,
-      {
-        account,
-        derivedPaths: resolveDerivedPathSummary(accountId),
-      },
-    ]),
-  );
-  return {
-    raw,
-    defaultAccountId: resolved.defaultAccountId || DEFAULT_ACCOUNT_ID,
-    accounts,
-  };
-}
-
-export function resolveWecomRuntimeAccount(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): ResolvedRuntimeAccount {
-  const account = resolveWecomAccount(params);
-  return {
-    account,
-    derivedPaths: resolveDerivedPathSummary(account.accountId),
-  };
-}