@yanhaidao/wecom 2.3.4 → 2.3.10

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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,41 @@
+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,18 +1,16 @@
-/**
- * WeCom 配置模块导出
- */
-
 export { WecomConfigSchema, type WecomConfigInput } from "./schema.js";
 export {
-    DEFAULT_ACCOUNT_ID,
-    detectMode,
-    listWecomAccountIds,
-    resolveDefaultWecomAccountId,
-    resolveWecomAccount,
-    resolveWecomAccountConflict,
-    resolveWecomAccounts,
-    isWecomEnabled,
+  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, resolveWecomMediaMaxBytes } from "./media.js";
 export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/src/config/runtime-config.ts

@@ -0,0 +1,46 @@
+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),
+  };
+}

package/src/config/schema.ts

@@ -1,143 +1,104 @@
-/**
- * WeCom 配置 Schema (Zod)
- */
-
 import { z } from "zod";
 
 function bindToJsonSchema<T extends z.ZodTypeAny>(schema: T): T {
-    const anySchema = schema as unknown as { toJSONSchema?: (...args: any[]) => unknown };
-    if (typeof anySchema.toJSONSchema === "function") {
-        anySchema.toJSONSchema = anySchema.toJSONSchema.bind(schema) as any;
-    }
-    return schema;
+  const schemaWithJson = schema as T & { toJSONSchema?: (...args: unknown[]) => unknown };
+  if (typeof schemaWithJson.toJSONSchema === "function") {
+    schemaWithJson.toJSONSchema = schemaWithJson.toJSONSchema.bind(schema);
+  }
+  return schema;
 }
 
-/**
- * **dmSchema (单聊配置)**
- * 
- * 控制单聊行为（如允许名单、策略）。
- * @property enabled - 是否启用单聊 [默认: true]
- * @property policy - 访问策略: "pairing" (需配对, 默认), "allowlist" (仅在名单), "open" (所有人), "disabled" (禁用)
- * @property allowFrom - 允许的用户ID或群ID列表 (仅当 policy="allowlist" 时生效)
- */
-const dmSchema = z.object({
-    enabled: z.boolean().optional(),
+const dmSchema = z
+  .object({
     policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **mediaSchema (媒体处理配置)**
- * 
- * 控制媒体文件的下载和缓存行为。
- * @property tempDir - 临时文件下载目录
- * @property retentionHours - 临时文件保留时间（小时）
- * @property cleanupOnStart - 启动时是否自动清理旧文件
- * @property maxBytes - 允许下载的最大字节数
- */
-const mediaSchema = z.object({
+const mediaSchema = z
+  .object({
     tempDir: z.string().optional(),
     retentionHours: z.number().optional(),
     cleanupOnStart: z.boolean().optional(),
     maxBytes: z.number().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **networkSchema (网络配置)**
- * 
- * 控制 HTTP 请求行为，特别是出站代理。
- * @property timeoutMs - 请求超时时间 (毫秒)
- * @property retries - 重试次数
- * @property retryDelayMs - 重试间隔 (毫秒)
- * @property egressProxyUrl - 出站 HTTP 代理 (如 "http://127.0.0.1:7890")
- */
-const networkSchema = z.object({
-    timeoutMs: z.number().optional(),
-    retries: z.number().optional(),
-    retryDelayMs: z.number().optional(),
+const networkSchema = z
+  .object({
     egressProxyUrl: z.string().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **routingSchema (路由策略配置)**
- *
- * 控制未命中 bindings 时的回退行为。
- * @property failClosedOnDefaultRoute - true=拒绝 default 回退，false=允许回退默认 agent
- */
-const routingSchema = z.object({
+const routingSchema = z
+  .object({
     failClosedOnDefaultRoute: z.boolean().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **botSchema (Bot 模式配置)**
- * 
- * 用于配置企业微信内部机器人 (Webhook 模式)。
- * @property token - 企业微信后台设置的 Token
- * @property encodingAESKey - 企业微信后台设置的 EncodingAESKey
- * @property receiveId - (可选) 接收者ID，通常不用填
- * @property streamPlaceholderContent - (可选) 流式响应中的占位符，默认为 "Thinking..."或空
- * @property welcomeText - (可选) 用户首次对话时的欢迎语
- * @property dm - 单聊策略覆盖配置
- */
-const botSchema = z.object({
-    aibotid: z.string().optional(),
+const botWsSchema = z
+  .object({
+    botId: z.string(),
+    secret: z.string(),
+  })
+  .optional();
+
+const botWebhookSchema = z
+  .object({
     token: z.string(),
     encodingAESKey: z.string(),
-    botIds: z.array(z.string()).optional(),
     receiveId: z.string().optional(),
+  })
+  .optional();
+
+const botSchema = z
+  .object({
+    primaryTransport: z.enum(["ws", "webhook"]).optional(),
     streamPlaceholderContent: z.string().optional(),
     welcomeText: z.string().optional(),
     dm: dmSchema,
-}).optional();
+    aibotid: z.string().optional(),
+    botIds: z.array(z.string()).optional(),
+    ws: botWsSchema,
+    webhook: botWebhookSchema,
+  })
+  .optional();
 
-/**
- * **agentSchema (Agent 模式配置)**
- * 
- * 用于配置企业微信自建应用 (Agent)。
- * @property corpId - 企业 ID (CorpID)
- * @property corpSecret - 应用 Secret
- * @property agentId - 应用 AgentId (数字，可选)
- * @property token - 回调配置 Token
- * @property encodingAESKey - 回调配置 EncodingAESKey
- * @property welcomeText - (可选) 欢迎语
- * @property dm - 单聊策略覆盖配置
- */
-const agentSchema = z.object({
+const agentSchema = z
+  .object({
     corpId: z.string(),
-    corpSecret: z.string(),
-    agentId: z.union([z.string(), z.number()]).optional(),
+    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,
-}).optional();
+  })
+  .refine((value) => Boolean(value.agentSecret?.trim() || value.corpSecret?.trim()), {
+    path: ["agentSecret"],
+    message: "agentSecret 不能为空",
+  })
+  .optional();
 
-/**
- * **dynamicAgentsSchema (动态 Agent 配置)**
- *
- * 控制是否按用户/群组自动创建独立 Agent 实例。
- * @property enabled - 是否启用动态 Agent
- * @property dmCreateAgent - 私聊是否为每个用户创建独立 Agent
- * @property groupEnabled - 群聊是否启用动态 Agent
- * @property adminUsers - 管理员列表（绕过动态路由）
- */
-const dynamicAgentsSchema = z.object({
+const dynamicAgentsSchema = z
+  .object({
     enabled: z.boolean().optional(),
     dmCreateAgent: z.boolean().optional(),
     groupEnabled: z.boolean().optional(),
     adminUsers: z.array(z.string()).optional(),
-}).optional();
+  })
+  .optional();
 
-/** Matrix 账号条目 */
 const accountSchema = z.object({
-    enabled: z.boolean().optional(),
-    name: z.string().optional(),
-    bot: botSchema,
-    agent: agentSchema,
+  enabled: z.boolean().optional(),
+  name: z.string().optional(),
+  bot: botSchema,
+  agent: agentSchema,
 });
 
-/** 顶层 WeCom 配置 Schema */
-export const WecomConfigSchema = bindToJsonSchema(z.object({
+export const WecomConfigSchema = bindToJsonSchema(
+  z.object({
     enabled: z.boolean().optional(),
     bot: botSchema,
     agent: agentSchema,
@@ -147,6 +108,7 @@ export const WecomConfigSchema = bindToJsonSchema(z.object({
     network: networkSchema,
     routing: routingSchema,
     dynamicAgents: dynamicAgentsSchema,
-}));
+  }),
+);
 
 export type WecomConfigInput = z.infer<typeof WecomConfigSchema>;

package/src/domain/models.ts

@@ -0,0 +1,7 @@
+import type { DeliveryTask, RawFrameReference, ReplyContext, TransportSessionSnapshot, UnifiedInboundEvent } from "../types/index.js";
+
+export type WecomConversation = UnifiedInboundEvent["conversation"];
+export type WecomRawEnvelope = RawFrameReference;
+export type WecomReplyContext = ReplyContext;
+export type WecomTransportSession = TransportSessionSnapshot;
+export type WecomDeliveryTask = DeliveryTask;

package/src/domain/policies.ts

@@ -0,0 +1,36 @@
+import type { ResolvedBotAccount, UnifiedInboundEvent } from "../types/index.js";
+
+export function assertBotPrimaryTransport(account: ResolvedBotAccount): void {
+  if (account.primaryTransport === "ws" && !account.wsConfigured) {
+    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.ws credentials.`);
+  }
+  if (account.primaryTransport === "webhook" && !account.webhookConfigured) {
+    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.webhook credentials.`);
+  }
+}
+
+export function buildDedupKey(event: UnifiedInboundEvent): string {
+  return `${event.accountId}:${event.transport}:${event.messageId}`;
+}
+
+export function resolveConversationKey(event: UnifiedInboundEvent): string {
+  const conversation = event.conversation;
+  return [event.accountId, conversation.peerKind, conversation.peerId, conversation.senderId].join(":");
+}
+
+export function normalizeWecomAllowFromEntry(raw: string): string {
+  return raw
+    .trim()
+    .toLowerCase()
+    .replace(/^wecom:/, "")
+    .replace(/^user:/, "")
+    .replace(/^userid:/, "");
+}
+
+export function isWecomSenderAllowed(senderUserId: string, allowFrom: string[]): boolean {
+  const list = allowFrom.map((entry) => normalizeWecomAllowFromEntry(entry)).filter(Boolean);
+  if (list.includes("*")) return true;
+  const normalizedSender = normalizeWecomAllowFromEntry(senderUserId);
+  if (!normalizedSender) return false;
+  return list.includes(normalizedSender);
+}

package/src/dynamic-agent.ts

@@ -48,6 +48,12 @@ export function generateAgentId(chatType: "dm" | "group", peerId: string, accoun
     return `wecom-${sanitizedAccountId}-${chatType}-${sanitizedPeer}`;
 }
 
+export function buildAgentSessionTarget(userId: string, accountId?: string): string {
+    const normalizedUserId = String(userId).trim();
+    const sanitizedAccountId = sanitizeDynamicIdPart(accountId ?? "default") || "default";
+    return `wecom-agent:${sanitizedAccountId}:${normalizedUserId}`;
+}
+
 /**
  * **shouldUseDynamicAgent (检查是否使用动态 Agent)**
  *