@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/channel.ts

@@ -1,256 +0,0 @@
-import type { ChannelAccountSnapshot, ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
-import {
-  deleteAccountFromConfigSection,
-  setAccountEnabledInConfigSection,
-} from "openclaw/plugin-sdk/core";
-import {
-  DEFAULT_ACCOUNT_ID,
-  listWecomAccountIds,
-  resolveDerivedPathSummary,
-  resolveDefaultWecomAccountId,
-  resolveWecomAccount,
-  resolveWecomAccountConflict,
-} from "./config/index.js";
-import { monitorWecomProvider } from "./gateway-monitor.js";
-import { wecomSetupWizard } from "./onboarding.js";
-import { wecomOutbound } from "./outbound.js";
-import type { ResolvedWecomAccount } from "./types/index.js";
-
-const meta = {
-  id: "wecom",
-  label: "WeCom (企业微信)",
-  selectionLabel: "WeCom (企业微信)",
-  docsPath: "/channels/wecom",
-  docsLabel: "企业微信",
-  blurb: "企业微信官方推荐三方插件，默认 Bot WS 配置简单，支持主动发消息与 Agent 全能力。",
-  selectionDocsPrefix: "文档：",
-  aliases: ["wechatwork", "wework", "qywx", "企微", "企业微信"],
-  order: 85,
-  quickstartAllowFrom: true,
-};
-
-function resolveAccountInboundPath(account: ResolvedWecomAccount): string | undefined {
-  const derivedPaths = resolveDerivedPathSummary(account.accountId);
-  if (account.bot?.primaryTransport === "webhook" && account.bot.webhookConfigured) {
-    return derivedPaths.botWebhook[0];
-  }
-  if (account.agent?.callbackConfigured) {
-    return derivedPaths.agentCallback[0];
-  }
-  return undefined;
-}
-
-function normalizeWecomMessagingTarget(raw: string): string | undefined {
-  const trimmed = raw.trim();
-  if (!trimmed) return undefined;
-  if (/^wecom-agent(?:-upstream)?:/i.test(trimmed)) {
-    return trimmed;
-  }
-  if (/^(wecom|wechatwork|wework|qywx):(user|group|chat|party|dept|tag|context):/i.test(trimmed)) {
-    return trimmed;
-  }
-  return trimmed.replace(/^(wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
-}
-
-export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
-  id: "wecom",
-  meta,
-  setupWizard: wecomSetupWizard,
-  capabilities: {
-    chatTypes: ["direct", "group"],
-    media: true,
-    reactions: false,
-    threads: false,
-    polls: false,
-    nativeCommands: false,
-    blockStreaming: false,
-  },
-  reload: { configPrefixes: ["channels.wecom"] },
-  // A permissive schema keeps config UX working while preventing startup failures.
-  configSchema: {
-    schema: {
-      type: "object",
-      additionalProperties: true,
-      properties: {},
-    },
-  },
-  config: {
-    listAccountIds: (cfg) => listWecomAccountIds(cfg as OpenClawConfig),
-    resolveAccount: (cfg, accountId) =>
-      resolveWecomAccount({ cfg: cfg as OpenClawConfig, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultWecomAccountId(cfg as OpenClawConfig),
-    setAccountEnabled: ({ cfg, accountId, enabled }) =>
-      setAccountEnabledInConfigSection({
-        cfg: cfg as OpenClawConfig,
-        sectionKey: "wecom",
-        accountId,
-        enabled,
-        allowTopLevel: true,
-      }),
-    deleteAccount: ({ cfg, accountId }) =>
-      deleteAccountFromConfigSection({
-        cfg: cfg as OpenClawConfig,
-        sectionKey: "wecom",
-        accountId,
-        clearBaseFields: ["bot", "agent"],
-      }),
-    isConfigured: (account, cfg) => {
-      if (!account.configured) {
-        return false;
-      }
-      return !resolveWecomAccountConflict({
-        cfg: cfg as OpenClawConfig,
-        accountId: account.accountId,
-      });
-    },
-    unconfiguredReason: (account, cfg) =>
-      resolveWecomAccountConflict({
-        cfg: cfg as OpenClawConfig,
-        accountId: account.accountId,
-      })?.message ?? "not configured",
-    describeAccount: (account, cfg): ChannelAccountSnapshot => {
-      const conflict = resolveWecomAccountConflict({
-        cfg: cfg as OpenClawConfig,
-        accountId: account.accountId,
-      });
-      return {
-        accountId: account.accountId,
-        name: account.name,
-        enabled: account.enabled,
-        configured: account.configured && !conflict,
-        webhookPath: resolveAccountInboundPath(account),
-      };
-    },
-    resolveAllowFrom: ({ cfg, accountId }) => {
-      const account = resolveWecomAccount({
-        cfg: cfg as OpenClawConfig,
-        accountId,
-      });
-      // 与其他渠道保持一致：直接返回 allowFrom，空则允许所有人
-      const allowFrom =
-        account.agent?.config.dm?.allowFrom ?? account.bot?.config.dm?.allowFrom ?? [];
-      return allowFrom.map((entry) => String(entry));
-    },
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => String(entry).trim())
-        .filter(Boolean)
-        .map((entry) => entry.toLowerCase()),
-  },
-  // security 配置在 WeCom 中不需要，框架会通过 resolveAllowFrom 自动判断
-  groups: {
-    // WeCom bots are usually mention-gated by the platform in groups already.
-    resolveRequireMention: () => true,
-  },
-  threading: {
-    resolveReplyToMode: () => "off",
-  },
-  messaging: {
-    normalizeTarget: normalizeWecomMessagingTarget,
-    targetResolver: {
-      looksLikeId: (raw) => Boolean(raw.trim()),
-      hint: "<userid|chatid>",
-    },
-  },
-  outbound: {
-    ...wecomOutbound,
-  },
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      webhookPath: snapshot.webhookPath ?? null,
-      transport: (snapshot as { transport?: string }).transport ?? null,
-      ownerId: (snapshot as { ownerId?: string }).ownerId ?? null,
-      health: (snapshot as { health?: string }).health ?? "idle",
-      ownerDriftAt: (snapshot as { ownerDriftAt?: number | null }).ownerDriftAt ?? null,
-      connected: (snapshot as { connected?: boolean }).connected,
-      authenticated: (snapshot as { authenticated?: boolean }).authenticated,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      lastErrorAt: (snapshot as { lastErrorAt?: number | null }).lastErrorAt ?? null,
-      lastInboundAt: snapshot.lastInboundAt ?? null,
-      lastOutboundAt: snapshot.lastOutboundAt ?? null,
-      recentInboundSummary:
-        (snapshot as { recentInboundSummary?: string | null }).recentInboundSummary ?? null,
-      recentOutboundSummary:
-        (snapshot as { recentOutboundSummary?: string | null }).recentOutboundSummary ?? null,
-      recentIssueCategory:
-        (snapshot as { recentIssueCategory?: string | null }).recentIssueCategory ?? null,
-      recentIssueSummary:
-        (snapshot as { recentIssueSummary?: string | null }).recentIssueSummary ?? null,
-      transportSessions: (snapshot as { transportSessions?: string[] }).transportSessions ?? [],
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? null,
-    }),
-    probeAccount: async () => ({ ok: true }),
-    buildAccountSnapshot: ({ account, runtime, cfg }) => {
-      const conflict = resolveWecomAccountConflict({
-        cfg: cfg as OpenClawConfig,
-        accountId: account.accountId,
-      });
-      return {
-        accountId: account.accountId,
-        name: account.name,
-        enabled: account.enabled,
-        configured: account.configured && !conflict,
-        webhookPath: resolveAccountInboundPath(account),
-        primaryTransport:
-          account.bot?.primaryTransport ?? (account.agent ? "agent-callback" : null),
-        transport: (runtime as { transport?: string } | undefined)?.transport ?? null,
-        ownerId: (runtime as { ownerId?: string } | undefined)?.ownerId ?? null,
-        health: (runtime as { health?: string } | undefined)?.health ?? "idle",
-        ownerDriftAt:
-          (runtime as { ownerDriftAt?: number | null } | undefined)?.ownerDriftAt ?? null,
-        connected: (runtime as { connected?: boolean } | undefined)?.connected,
-        authenticated: (runtime as { authenticated?: boolean } | undefined)?.authenticated,
-        running: runtime?.running ?? false,
-        lastStartAt: runtime?.lastStartAt ?? null,
-        lastStopAt: runtime?.lastStopAt ?? null,
-        lastError: runtime?.lastError ?? conflict?.message ?? null,
-        lastErrorAt: (runtime as { lastErrorAt?: number | null } | undefined)?.lastErrorAt ?? null,
-        lastInboundAt: runtime?.lastInboundAt ?? null,
-        lastOutboundAt: runtime?.lastOutboundAt ?? null,
-        recentInboundSummary:
-          (runtime as { recentInboundSummary?: string | null } | undefined)?.recentInboundSummary ??
-          null,
-        recentOutboundSummary:
-          (runtime as { recentOutboundSummary?: string | null } | undefined)
-            ?.recentOutboundSummary ?? null,
-        recentIssueCategory:
-          (runtime as { recentIssueCategory?: string | null } | undefined)?.recentIssueCategory ??
-          null,
-        recentIssueSummary:
-          (runtime as { recentIssueSummary?: string | null } | undefined)?.recentIssueSummary ??
-          null,
-        transportSessions:
-          (runtime as { transportSessions?: string[] } | undefined)?.transportSessions ?? [],
-        dmPolicy: account.bot?.config.dm?.policy ?? "pairing",
-      };
-    },
-  },
-  gateway: {
-    /**
-     * **startAccount (启动账号)**
-     *
-     * WeCom lifecycle is long-running: keep webhook targets active until
-     * gateway stop/reload aborts the account.
-     */
-    startAccount: monitorWecomProvider,
-    stopAccount: async (ctx) => {
-      ctx.setStatus({
-        accountId: ctx.account.accountId,
-        running: false,
-        lastStopAt: Date.now(),
-      });
-    },
-  },
-};

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,312 +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 normalizeAllowedEventTypes(value: string[] | undefined): string[] | undefined {
-  // 配置层允许大小写/空白混写，这里统一规整为去重后的小写列表
-  if (!Array.isArray(value)) return undefined;
-  const normalized = value
-    .map((entry) => String(entry ?? "").trim().toLowerCase())
-    .filter(Boolean);
-  return normalized.length > 0 ? Array.from(new Set(normalized)) : 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);
-  // 将 event 相关策略提前归一到运行态，避免每次消息都重复解析配置
-  const eventEnabled = config.inboundPolicy?.eventEnabled;
-  const allowedEventTypes = normalizeAllowedEventTypes(
-    config.inboundPolicy?.eventPolicy?.allowedEventTypes,
-  );
-  return {
-    accountId,
-    configured: callbackConfigured || apiConfigured,
-    callbackConfigured,
-    apiConfigured,
-    corpId: config.corpId,
-    corpSecret: normalizedAgentSecret,
-    agentId,
-    token: config.token,
-    encodingAESKey: config.encodingAESKey,
-    eventEnabled,
-    allowedEventTypes,
-    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);
-}