@yanhaidao/wecom 2.4.160 → 2.5.110

package/src/config/accounts.resolve.test.ts

@@ -1,75 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { describe, expect, it } from "vitest";
-
-import { resolveWecomAccount } from "./accounts.js";
-
-describe("resolveWecomAccount", () => {
-  const cfg: OpenClawConfig = {
-    channels: {
-      wecom: {
-        enabled: true,
-        defaultAccount: "acct-a",
-        accounts: {
-          "acct-a": {
-            enabled: true,
-            bot: {
-              primaryTransport: "webhook",
-              webhook: {
-                token: "token-a",
-                encodingAESKey: "aes-a",
-              },
-            },
-          },
-        },
-      },
-    },
-  } as OpenClawConfig;
-
-  it("does not fall back when explicit accountId does not exist", () => {
-    const account = resolveWecomAccount({ cfg, accountId: "missing" });
-    expect(account.accountId).toBe("missing");
-    expect(account.enabled).toBe(false);
-    expect(account.configured).toBe(false);
-  });
-
-  it("uses configured default account when accountId is omitted", () => {
-    const account = resolveWecomAccount({ cfg });
-    expect(account.accountId).toBe("acct-a");
-    expect(account.enabled).toBe(true);
-    expect(account.configured).toBe(true);
-  });
-
-  it("treats literal default as an alias for configured default account", () => {
-    const account = resolveWecomAccount({ cfg, accountId: "default" });
-    expect(account.accountId).toBe("acct-a");
-    expect(account.enabled).toBe(true);
-    expect(account.configured).toBe(true);
-  });
-
-  it("accepts agentSecret for fresh configs and normalizes it for runtime use", () => {
-    const agentCfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          defaultAccount: "acct-agent",
-          accounts: {
-            "acct-agent": {
-              enabled: true,
-              agent: {
-                corpId: "corp-id",
-                agentSecret: "agent-secret",
-                agentId: 1000001,
-                token: "token",
-                encodingAESKey: "1234567890123456789012345678901234567890123",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const account = resolveWecomAccount({ cfg: agentCfg });
-    expect(account.agent?.apiConfigured).toBe(true);
-    expect(account.agent?.corpSecret).toBe("agent-secret");
-  });
-});

package/src/config/accounts.ts

@@ -1,296 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import type {
-  ResolvedAgentAccount,
-  ResolvedBotAccount,
-  ResolvedMode,
-  ResolvedWecomAccount,
-  ResolvedWecomAccounts,
-  WecomAccountConfig,
-  WecomAgentConfig,
-  WecomBotConfig,
-  WecomConfig,
-  WecomNetworkConfig,
-} from "../types/index.js";
-
-export const DEFAULT_ACCOUNT_ID = "default";
-
-export type WecomAccountConflict = {
-  type: "duplicate_bot_id" | "duplicate_agent_id";
-  accountId: string;
-  ownerAccountId: string;
-  message: string;
-};
-
-function toNumber(value: number | string | undefined): number | undefined {
-  if (value == null) return undefined;
-  const parsed = typeof value === "number" ? value : Number(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function resolveBotAccount(
-  accountId: string,
-  config: WecomBotConfig,
-  network?: WecomNetworkConfig,
-): ResolvedBotAccount {
-  const primaryTransport = config.primaryTransport ?? (config.ws ? "ws" : "webhook");
-  const wsConfigured = Boolean(config.ws?.botId && config.ws?.secret);
-  const webhookConfigured = Boolean(config.webhook?.token && config.webhook?.encodingAESKey);
-  const configured = primaryTransport === "ws" ? wsConfigured : webhookConfigured;
-  return {
-    accountId,
-    configured,
-    primaryTransport,
-    wsConfigured,
-    webhookConfigured,
-    config,
-    network,
-    ws: config.ws
-      ? {
-          botId: config.ws.botId,
-          secret: config.ws.secret,
-        }
-      : undefined,
-    webhook: config.webhook
-      ? {
-          token: config.webhook.token,
-          encodingAESKey: config.webhook.encodingAESKey,
-          receiveId: config.webhook.receiveId?.trim() ?? "",
-        }
-      : undefined,
-    token: config.webhook?.token ?? "",
-    encodingAESKey: config.webhook?.encodingAESKey ?? "",
-    receiveId: config.webhook?.receiveId?.trim() ?? "",
-    botId: config.ws?.botId ?? "",
-    secret: config.ws?.secret ?? "",
-  };
-}
-
-function resolveAgentAccount(
-  accountId: string,
-  config: WecomAgentConfig,
-  network?: WecomNetworkConfig,
-): ResolvedAgentAccount {
-  const agentId = toNumber(config.agentId);
-  const callbackConfigured = Boolean(config.token && config.encodingAESKey);
-  const normalizedAgentSecret = config.agentSecret?.trim() || config.corpSecret?.trim() || "";
-  const apiConfigured = Boolean(config.corpId && normalizedAgentSecret && agentId);
-  return {
-    accountId,
-    configured: callbackConfigured || apiConfigured,
-    callbackConfigured,
-    apiConfigured,
-    corpId: config.corpId,
-    corpSecret: normalizedAgentSecret,
-    agentId,
-    token: config.token,
-    encodingAESKey: config.encodingAESKey,
-    config,
-    network,
-  };
-}
-
-function toResolvedAccount(params: {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  config: WecomAccountConfig;
-  network?: WecomNetworkConfig;
-}): ResolvedWecomAccount {
-  const bot = params.config.bot
-    ? resolveBotAccount(params.accountId, params.config.bot, params.network)
-    : undefined;
-  const agent = params.config.agent
-    ? resolveAgentAccount(params.accountId, params.config.agent, params.network)
-    : undefined;
-  return {
-    accountId: params.accountId,
-    name: params.name,
-    enabled: params.enabled,
-    configured: Boolean(bot?.configured || agent?.configured),
-    config: params.config,
-    bot,
-    agent,
-  };
-}
-
-function createMissingResolvedAccount(accountId: string): ResolvedWecomAccount {
-  return {
-    accountId,
-    enabled: false,
-    configured: false,
-    config: {},
-  };
-}
-
-export function detectMode(config: WecomConfig | undefined): ResolvedMode {
-  if (!config || config.enabled === false) return "disabled";
-  if (config.accounts && Object.keys(config.accounts).length > 0) {
-    return "matrix";
-  }
-  if (config.bot || config.agent) {
-    return "legacy";
-  }
-  return "disabled";
-}
-
-function resolveMatrixAccounts(wecom: WecomConfig): Record<string, ResolvedWecomAccount> {
-  const resolved: Record<string, ResolvedWecomAccount> = {};
-  for (const [rawId, entry] of Object.entries(wecom.accounts ?? {})) {
-    const accountId = rawId.trim();
-    if (!accountId || !entry) continue;
-    resolved[accountId] = toResolvedAccount({
-      accountId,
-      enabled: wecom.enabled !== false && entry.enabled !== false,
-      name: entry.name,
-      config: entry,
-      network: wecom.network,
-    });
-  }
-  return resolved;
-}
-
-function resolveLegacyAccounts(wecom: WecomConfig): Record<string, ResolvedWecomAccount> {
-  const config: WecomAccountConfig = {
-    bot: wecom.bot,
-    agent: wecom.agent,
-  };
-  return {
-    [DEFAULT_ACCOUNT_ID]: toResolvedAccount({
-      accountId: DEFAULT_ACCOUNT_ID,
-      enabled: wecom.enabled !== false,
-      config,
-      network: wecom.network,
-    }),
-  };
-}
-
-function normalizeKey(value: string): string {
-  return value.trim().toLowerCase();
-}
-
-function collectWecomAccountConflicts(cfg: OpenClawConfig): Map<string, WecomAccountConflict> {
-  const resolved = resolveWecomAccounts(cfg);
-  const conflicts = new Map<string, WecomAccountConflict>();
-  const botOwners = new Map<string, string>();
-  const agentOwners = new Map<string, string>();
-
-  for (const accountId of Object.keys(resolved.accounts).sort((a, b) => a.localeCompare(b))) {
-    const account = resolved.accounts[accountId];
-    if (!account || account.enabled === false) continue;
-
-    const botId = account.bot?.botId?.trim();
-    if (botId) {
-      const key = normalizeKey(botId);
-      const owner = botOwners.get(key);
-      if (owner && owner !== accountId) {
-        conflicts.set(accountId, {
-          type: "duplicate_bot_id",
-          accountId,
-          ownerAccountId: owner,
-          message:
-            `Duplicate WeCom botId: account "${accountId}" shares botId with account "${owner}". ` +
-            "Keep one owner account per botId.",
-        });
-      } else {
-        botOwners.set(key, accountId);
-      }
-    }
-
-    const corpId = account.agent?.corpId?.trim();
-    const agentId = account.agent?.agentId;
-    if (corpId && typeof agentId === "number") {
-      const key = `${normalizeKey(corpId)}:${agentId}`;
-      const owner = agentOwners.get(key);
-      if (owner && owner !== accountId) {
-        conflicts.set(accountId, {
-          type: "duplicate_agent_id",
-          accountId,
-          ownerAccountId: owner,
-          message:
-            `Duplicate WeCom agent identity: account "${accountId}" shares corpId/agentId (${corpId}/${agentId}) with account "${owner}". ` +
-            "Keep one owner account per corpId/agentId pair.",
-        });
-      } else {
-        agentOwners.set(key, accountId);
-      }
-    }
-  }
-
-  return conflicts;
-}
-
-export function resolveWecomAccountConflict(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-}): WecomAccountConflict | undefined {
-  return collectWecomAccountConflicts(params.cfg).get(params.accountId);
-}
-
-export function listWecomAccountIds(cfg: OpenClawConfig): string[] {
-  const wecom = cfg.channels?.wecom as WecomConfig | undefined;
-  const mode = detectMode(wecom);
-  if (mode === "matrix") {
-    return Object.keys(wecom?.accounts ?? {})
-      .map((value) => value.trim())
-      .filter(Boolean)
-      .sort((a, b) => a.localeCompare(b));
-  }
-  if (mode === "legacy") {
-    return [DEFAULT_ACCOUNT_ID];
-  }
-  return [];
-}
-
-export function resolveDefaultWecomAccountId(cfg: OpenClawConfig): string {
-  const wecom = cfg.channels?.wecom as WecomConfig | undefined;
-  const ids = listWecomAccountIds(cfg);
-  if (wecom?.defaultAccount && ids.includes(wecom.defaultAccount)) {
-    return wecom.defaultAccount;
-  }
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
-
-export function resolveWecomAccounts(cfg: OpenClawConfig): ResolvedWecomAccounts {
-  const wecom = (cfg.channels?.wecom as WecomConfig | undefined) ?? {};
-  const mode = detectMode(wecom);
-  const accounts = mode === "matrix" ? resolveMatrixAccounts(wecom) : mode === "legacy" ? resolveLegacyAccounts(wecom) : {};
-  const defaultAccountId = resolveDefaultWecomAccountId(cfg);
-  return {
-    mode,
-    defaultAccountId,
-    accounts,
-    bot: accounts[defaultAccountId]?.bot,
-    agent: accounts[defaultAccountId]?.agent,
-  };
-}
-
-export function resolveWecomAccount(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): ResolvedWecomAccount {
-  const resolved = resolveWecomAccounts(params.cfg);
-  const explicitAccountId = params.accountId?.trim();
-  const accountId = explicitAccountId || resolved.defaultAccountId;
-  const direct = resolved.accounts[accountId];
-  if (direct) {
-    return direct;
-  }
-
-  // Treat the literal "default" as an alias for the configured default account.
-  // This keeps generic onboarding flows working even when the first WeCom account
-  // was created under a custom id like "haidao" instead of a literal "default".
-  if (explicitAccountId === DEFAULT_ACCOUNT_ID) {
-    const fallback = resolved.accounts[resolved.defaultAccountId];
-    if (fallback) {
-      return fallback;
-    }
-  }
-
-  return createMissingResolvedAccount(accountId);
-}
-
-export function isWecomEnabled(cfg: OpenClawConfig): boolean {
-  const resolved = resolveWecomAccounts(cfg);
-  return Object.values(resolved.accounts).some((account) => account.enabled && account.configured);
-}

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,26 +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,
-  resolveWecomMediaDownloadTimeoutMs,
-} 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);
-  });
-});