@mocrane/wecom 2026.2.27 → 2026.3.4

package/src/channel.lifecycle.test.ts

@@ -0,0 +1,252 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Socket } from "node:net";
+
+import {
+  type ChannelAccountSnapshot,
+  type ChannelGatewayContext,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk";
+import { describe, expect, it, vi } from "vitest";
+
+import { createRuntimeEnv } from "../../test-utils/runtime-env.js";
+import { computeWecomMsgSignature, encryptWecomPlaintext } from "./crypto.js";
+import { wecomPlugin } from "./channel.js";
+import { handleWecomWebhookRequest } from "./monitor.js";
+import type { ResolvedWecomAccount } from "./types/index.js";
+
+function createMockRequest(params: {
+  method: "GET" | "POST";
+  url: string;
+  body?: unknown;
+}): IncomingMessage {
+  const socket = new Socket();
+  const req = new IncomingMessage(socket);
+  req.method = params.method;
+  req.url = params.url;
+  if (params.method === "POST") {
+    req.push(JSON.stringify(params.body ?? {}));
+  }
+  req.push(null);
+  return req;
+}
+
+function createMockResponse(): ServerResponse & {
+  _getData: () => string;
+  _getStatusCode: () => number;
+} {
+  type MockResponse = ServerResponse & {
+    _getData: () => string;
+    _getStatusCode: () => number;
+  };
+  const req = new IncomingMessage(new Socket());
+  const res = new ServerResponse(req) as MockResponse;
+  let data = "";
+  res.write = (chunk: string | Uint8Array) => {
+    data += String(chunk);
+    return true;
+  };
+  res.end = ((chunk?: string | Uint8Array) => {
+    if (chunk) data += String(chunk);
+    return res;
+  }) as MockResponse["end"];
+  res._getData = () => data;
+  res._getStatusCode = () => res.statusCode;
+  return res;
+}
+
+function createCtx(params: {
+  cfg: OpenClawConfig;
+  accountId?: string;
+  abortController: AbortController;
+}): ChannelGatewayContext<ResolvedWecomAccount> & {
+  statusUpdates: Array<Partial<ChannelAccountSnapshot>>;
+} {
+  const accountId = params.accountId ?? "default";
+  const account = wecomPlugin.config.resolveAccount(
+    params.cfg,
+    accountId,
+  ) as ResolvedWecomAccount;
+  const snapshot: ChannelAccountSnapshot = {
+    accountId,
+    configured: true,
+    enabled: true,
+    running: false,
+  };
+  const statusUpdates: Array<Partial<ChannelAccountSnapshot>> = [];
+  return {
+    cfg: params.cfg,
+    accountId,
+    account,
+    runtime: createRuntimeEnv(),
+    abortSignal: params.abortController.signal,
+    log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    getStatus: () => snapshot,
+    setStatus: (next) => {
+      statusUpdates.push(next);
+      Object.assign(snapshot, next);
+    },
+    statusUpdates,
+  };
+}
+
+function createLegacyBotConfig(params: {
+  token: string;
+  encodingAESKey: string;
+  receiveId?: string;
+}): OpenClawConfig {
+  return {
+    channels: {
+      wecom: {
+        enabled: true,
+        bot: {
+          token: params.token,
+          encodingAESKey: params.encodingAESKey,
+          receiveId: params.receiveId ?? "",
+        },
+      },
+    },
+  } as OpenClawConfig;
+}
+
+async function sendWecomGetVerify(params: {
+  path: string;
+  token: string;
+  encodingAESKey: string;
+  receiveId: string;
+}): Promise<{ handled: boolean; status: number; body: string }> {
+  const timestamp = "1700000000";
+  const nonce = "nonce";
+  const echostr = encryptWecomPlaintext({
+    encodingAESKey: params.encodingAESKey,
+    receiveId: params.receiveId,
+    plaintext: "ping",
+  });
+  const msgSignature = computeWecomMsgSignature({
+    token: params.token,
+    timestamp,
+    nonce,
+    encrypt: echostr,
+  });
+  const req = createMockRequest({
+    method: "GET",
+    url:
+      `${params.path}?msg_signature=${encodeURIComponent(msgSignature)}` +
+      `&timestamp=${encodeURIComponent(timestamp)}` +
+      `&nonce=${encodeURIComponent(nonce)}` +
+      `&echostr=${encodeURIComponent(echostr)}`,
+  });
+  const res = createMockResponse();
+  const handled = await handleWecomWebhookRequest(req, res);
+  return {
+    handled,
+    status: res._getStatusCode(),
+    body: res._getData(),
+  };
+}
+
+describe("wecomPlugin gateway lifecycle", () => {
+  it("keeps startAccount pending until abort signal", async () => {
+    const token = "token";
+    const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
+    const cfg = createLegacyBotConfig({ token, encodingAESKey });
+    const abortController = new AbortController();
+    const ctx = createCtx({ cfg, abortController });
+
+    const startPromise = wecomPlugin.gateway!.startAccount!(ctx);
+    let resolved = false;
+    void startPromise.then(() => {
+      resolved = true;
+    });
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+
+    abortController.abort();
+    await startPromise;
+    expect(resolved).toBe(true);
+  });
+
+  it("unregisters webhook targets after abort", async () => {
+    const token = "token";
+    const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
+    const receiveId = "";
+    const cfg = createLegacyBotConfig({ token, encodingAESKey, receiveId });
+    const abortController = new AbortController();
+    const ctx = createCtx({ cfg, abortController });
+
+    const startPromise = wecomPlugin.gateway!.startAccount!(ctx);
+    await Promise.resolve();
+
+    const activeLegacyRoute = await sendWecomGetVerify({
+      path: "/wecom/bot",
+      token,
+      encodingAESKey,
+      receiveId,
+    });
+    expect(activeLegacyRoute.handled).toBe(true);
+    expect(activeLegacyRoute.status).toBe(200);
+    expect(activeLegacyRoute.body).toBe("ping");
+
+    const activePluginRoute = await sendWecomGetVerify({
+      path: "/plugins/wecom/bot",
+      token,
+      encodingAESKey,
+      receiveId,
+    });
+    expect(activePluginRoute.handled).toBe(true);
+    expect(activePluginRoute.status).toBe(200);
+    expect(activePluginRoute.body).toBe("ping");
+
+    abortController.abort();
+    await startPromise;
+
+    const inactiveLegacyRoute = await sendWecomGetVerify({
+      path: "/wecom/bot",
+      token,
+      encodingAESKey,
+      receiveId,
+    });
+    expect(inactiveLegacyRoute.handled).toBe(false);
+
+    const inactivePluginRoute = await sendWecomGetVerify({
+      path: "/plugins/wecom/bot",
+      token,
+      encodingAESKey,
+      receiveId,
+    });
+    expect(inactivePluginRoute.handled).toBe(false);
+  });
+
+  it("rejects startup when matrix account credentials conflict", async () => {
+    const cfg = {
+      channels: {
+        wecom: {
+          enabled: true,
+          accounts: {
+            "acct-a": {
+              enabled: true,
+              bot: {
+                token: "token-shared",
+                encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
+              },
+            },
+            "acct-b": {
+              enabled: true,
+              bot: {
+                token: "token-shared",
+                encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
+              },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+    const abortController = new AbortController();
+    const ctx = createCtx({ cfg, accountId: "acct-b", abortController });
+
+    await expect(wecomPlugin.gateway!.startAccount!(ctx)).rejects.toThrow(
+      /Duplicate WeCom bot token/i,
+    );
+  });
+});

package/src/channel.ts

@@ -4,17 +4,22 @@ import type {
   OpenClawConfig,
 } from "openclaw/plugin-sdk";
 import {
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID,
+  deleteAccountFromConfigSection,
   setAccountEnabledInConfigSection,
 } from "openclaw/plugin-sdk";
 
-import { resolveWecomAccounts } from "./config/index.js";
-import { WecomConfigSchema } from "./config/index.js";
-import type { ResolvedAgentAccount, ResolvedBotAccount } from "./types/index.js";
-import { registerAgentWebhookTarget, registerWecomWebhookTarget } from "./monitor.js";
+import {
+  DEFAULT_ACCOUNT_ID,
+  listWecomAccountIds,
+  resolveDefaultWecomAccountId,
+  resolveWecomAccount,
+  resolveWecomAccountConflict,
+} from "./config/index.js";
+import type { ResolvedWecomAccount } from "./types/index.js";
+import { monitorWecomProvider } from "./gateway-monitor.js";
 import { wecomOnboardingAdapter } from "./onboarding.js";
 import { wecomOutbound } from "./outbound.js";
+import { WEBHOOK_PATHS } from "./types/constants.js";
 
 const meta = {
   id: "wecom",
@@ -34,36 +39,6 @@ function normalizeWecomMessagingTarget(raw: string): string | undefined {
   return trimmed.replace(/^(wecom-agent|wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
 }
 
-type ResolvedWecomAccount = {
-  accountId: string;
-  name?: string;
-  enabled: boolean;
-  configured: boolean;
-  bot?: ResolvedBotAccount;
-  agent?: ResolvedAgentAccount;
-};
-
-/**
- * **resolveWecomAccount (解析账号配置)**
- * 
- * 从全局配置中解析出 WeCom 渠道的配置状态。
- * 兼容 Bot 和 Agent 两种模式的配置检查。
- */
-function resolveWecomAccount(cfg: OpenClawConfig): ResolvedWecomAccount {
-  const enabled = (cfg.channels?.wecom as { enabled?: boolean } | undefined)?.enabled !== false;
-  const accounts = resolveWecomAccounts(cfg);
-  const bot = accounts.bot;
-  const agent = accounts.agent;
-  const configured = Boolean(bot?.configured || agent?.configured);
-  return {
-    accountId: DEFAULT_ACCOUNT_ID,
-    enabled,
-    configured,
-    bot,
-    agent,
-  };
-}
-
 export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
   id: "wecom",
   meta,
@@ -78,11 +53,21 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
     blockStreaming: true,
   },
   reload: { configPrefixes: ["channels.wecom"] },
-  configSchema: buildChannelConfigSchema(WecomConfigSchema),
+  // NOTE: We intentionally avoid Zod -> JSON Schema conversion at plugin-load time.
+  // Some OpenClaw runtime environments load plugin modules via jiti in a way that can
+  // surface zod `toJSONSchema()` binding issues (e.g. `this` undefined leading to `_zod` errors).
+  // A permissive schema keeps config UX working while preventing startup failures.
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: true,
+      properties: {},
+    },
+  },
   config: {
-    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg) => resolveWecomAccount(cfg as OpenClawConfig),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    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,
@@ -91,25 +76,47 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         enabled,
         allowTopLevel: true,
       }),
-    deleteAccount: ({ cfg }) => {
-      const next = { ...(cfg as OpenClawConfig) };
-      if (next.channels?.wecom) {
-        const channels = { ...(next.channels ?? {}) } as Record<string, unknown>;
-        delete (channels as Record<string, unknown>).wecom;
-        return { ...next, channels } as OpenClawConfig;
+    deleteAccount: ({ cfg, accountId }) =>
+      deleteAccountFromConfigSection({
+        cfg: cfg as OpenClawConfig,
+        sectionKey: "wecom",
+        accountId,
+        clearBaseFields: ["bot", "agent"],
+      }),
+    isConfigured: (account, cfg) => {
+      if (!account.configured) {
+        return false;
       }
-      return next;
+      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 matrixMode = account.accountId !== DEFAULT_ACCOUNT_ID;
+      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: account.bot?.config
+          ? (matrixMode ? `${WEBHOOK_PATHS.BOT_PLUGIN}/${account.accountId}` : WEBHOOK_PATHS.BOT_PLUGIN)
+          : account.agent?.config
+            ? (matrixMode ? `${WEBHOOK_PATHS.AGENT_PLUGIN}/${account.accountId}` : WEBHOOK_PATHS.AGENT_PLUGIN)
+            : WEBHOOK_PATHS.BOT_PLUGIN,
+      };
     },
-    isConfigured: (account) => account.configured,
-    describeAccount: (account): ChannelAccountSnapshot => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      webhookPath: account.bot?.config ? "/wecom/bot" : account.agent?.config ? "/wecom/agent" : "/wecom",
-    }),
     resolveAllowFrom: ({ cfg, accountId }) => {
-      const account = resolveWecomAccount(cfg as OpenClawConfig);
+      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));
@@ -159,95 +166,43 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
       lastProbeAt: snapshot.lastProbeAt ?? null,
     }),
     probeAccount: async () => ({ ok: true }),
-    buildAccountSnapshot: ({ account, runtime }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      webhookPath: account.bot?.config ? "/wecom/bot" : account.agent?.config ? "/wecom/agent" : "/wecom",
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      lastInboundAt: runtime?.lastInboundAt ?? null,
-      lastOutboundAt: runtime?.lastOutboundAt ?? null,
-      dmPolicy: account.bot?.config.dm?.policy ?? "pairing",
-    }),
-  },
-  gateway: {
-    /**
-     * **startAccount (启动账号)**
-     * 
-     * 插件生命周期：启动
-     * 职责：
-     * 1. 检查配置是否有效。
-     * 2. 注册 Bot Webhook (`/wecom`, `/wecom/bot`)。
-     * 3. 注册 Agent Webhook (`/wecom/agent`)。
-     * 4. 更新运行时状态 (Running)。
-     * 5. 返回停止回调 (Cleanup)。
-     */
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      const bot = account.bot;
-      const agent = account.agent;
-      const botConfigured = Boolean(bot?.configured);
-      const agentConfigured = Boolean(agent?.configured);
-
-      if (!botConfigured && !agentConfigured) {
-        ctx.log?.warn(`[${account.accountId}] wecom not configured; skipping webhook registration`);
-        ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
-        return { stop: () => { } };
-      }
-
-      const unregisters: Array<() => void> = [];
-      if (bot && botConfigured) {
-        for (const path of ["/wecom", "/wecom/bot"]) {
-          unregisters.push(
-            registerWecomWebhookTarget({
-              account: bot,
-              config: ctx.cfg as OpenClawConfig,
-              runtime: ctx.runtime,
-              // The HTTP handler resolves the active PluginRuntime via getWecomRuntime().
-              // The stored target only needs to be decrypt/verify-capable.
-              core: ({} as unknown) as any,
-              path,
-              statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
-            }),
-          );
-        }
-        ctx.log?.info(`[${account.accountId}] wecom bot webhook registered at /wecom and /wecom/bot`);
-      }
-      if (agent && agentConfigured) {
-        unregisters.push(
-          registerAgentWebhookTarget({
-            agent,
-            config: ctx.cfg as OpenClawConfig,
-            runtime: ctx.runtime,
-          }),
-        );
-        ctx.log?.info(`[${account.accountId}] wecom agent webhook registered at /wecom/agent`);
-      }
-
-      ctx.setStatus({
+    buildAccountSnapshot: ({ account, runtime, cfg }) => {
+      const conflict = resolveWecomAccountConflict({
+        cfg: cfg as OpenClawConfig,
         accountId: account.accountId,
-        running: true,
-        configured: true,
-        webhookPath: botConfigured ? "/wecom/bot" : "/wecom/agent",
-        lastStartAt: Date.now(),
       });
       return {
-        stop: () => {
-          for (const unregister of unregisters) {
-            unregister();
-          }
-          ctx.setStatus({
-            accountId: account.accountId,
-            running: false,
-            lastStopAt: Date.now(),
-          });
-        },
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured && !conflict,
+        webhookPath: account.bot?.config
+          ? (account.accountId === DEFAULT_ACCOUNT_ID
+              ? WEBHOOK_PATHS.BOT_PLUGIN
+              : `${WEBHOOK_PATHS.BOT_PLUGIN}/${account.accountId}`)
+          : account.agent?.config
+            ? (account.accountId === DEFAULT_ACCOUNT_ID
+                ? WEBHOOK_PATHS.AGENT_PLUGIN
+                : `${WEBHOOK_PATHS.AGENT_PLUGIN}/${account.accountId}`)
+            : WEBHOOK_PATHS.BOT_PLUGIN,
+        running: runtime?.running ?? false,
+        lastStartAt: runtime?.lastStartAt ?? null,
+        lastStopAt: runtime?.lastStopAt ?? null,
+        lastError: runtime?.lastError ?? conflict?.message ?? null,
+        lastInboundAt: runtime?.lastInboundAt ?? null,
+        lastOutboundAt: runtime?.lastOutboundAt ?? null,
+        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,

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

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