@yanhaidao/wecom 2.4.160 → 2.5.110

package/src/channel.config.test.ts

@@ -1,147 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { describe, expect, it } from "vitest";
-
-import { wecomPlugin } from "./channel.js";
-
-describe("wecomPlugin config.deleteAccount", () => {
-  it("removes only the target matrix account", () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: {
-                token: "token-a",
-                encodingAESKey: "aes-a",
-              },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: {
-                token: "token-b",
-                encodingAESKey: "aes-b",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const next = wecomPlugin.config.deleteAccount!({ cfg, accountId: "acct-a" });
-    const accounts = (next.channels?.wecom as { accounts?: Record<string, unknown> } | undefined)
-      ?.accounts;
-
-    expect(accounts?.["acct-a"]).toBeUndefined();
-    expect(accounts?.["acct-b"]).toBeDefined();
-    expect(next.channels?.wecom).toBeDefined();
-  });
-
-  it("removes legacy wecom section when deleting default account", () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          bot: {
-            token: "token",
-            encodingAESKey: "aes",
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const next = wecomPlugin.config.deleteAccount!({ cfg, accountId: "default" });
-    expect(next.channels?.wecom).toBeUndefined();
-  });
-});
-
-describe("wecomPlugin account conflict guards", () => {
-  it("marks duplicate bot token account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: { token: "token-shared", encodingAESKey: "aes-a" },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: { token: "token-shared", encodingAESKey: "aes-b" },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountA = wecomPlugin.config.resolveAccount(cfg, "acct-a");
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountA, cfg)).toBe(true);
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain("Duplicate WeCom bot token");
-  });
-
-  it("marks duplicate bot aibotid account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: { token: "token-a", encodingAESKey: "aes-a", aibotid: "BOT_001" },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: { token: "token-b", encodingAESKey: "aes-b", aibotid: "BOT_001" },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain("Duplicate WeCom bot aibotid");
-  });
-
-  it("marks duplicate corpId/agentId account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              agent: {
-                corpId: "corp-1",
-                corpSecret: "secret-a",
-                agentId: 1001,
-                token: "token-a",
-                encodingAESKey: "aes-a",
-              },
-            },
-            "acct-b": {
-              enabled: true,
-              agent: {
-                corpId: "corp-1",
-                corpSecret: "secret-b",
-                agentId: 1001,
-                token: "token-b",
-                encodingAESKey: "aes-b",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain(
-      "Duplicate WeCom agent identity",
-    );
-  });
-});

package/src/channel.lifecycle.test.ts

@@ -1,255 +0,0 @@
-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 createWebhookBotConfig(params: {
-  token: string;
-  encodingAESKey: string;
-  receiveId?: string;
-}): OpenClawConfig {
-  return {
-    channels: {
-      wecom: {
-        enabled: true,
-        bot: {
-          primaryTransport: "webhook",
-          webhook: {
-            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 = createWebhookBotConfig({ 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 = createWebhookBotConfig({ 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.meta.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { wecomPlugin } from "./channel.js";
-
-describe("wecomPlugin meta", () => {
-  it("uses chinese-facing labels in channel selection", () => {
-    expect(wecomPlugin.meta.label).toBe("WeCom (企业微信)");
-    expect(wecomPlugin.meta.selectionLabel).toBe("WeCom (企业微信)");
-    expect(wecomPlugin.meta.blurb).toContain("企业微信官方推荐三方插件");
-    expect(wecomPlugin.meta.docsLabel).toBe("企业微信");
-    expect(wecomPlugin.meta.selectionDocsPrefix).toBe("文档：");
-  });
-
-  it("exposes a setupWizard for guided setup discovery", () => {
-    expect(wecomPlugin.setupWizard?.channel).toBe("wecom");
-  });
-
-  it("preserves fully qualified WeCom messaging targets during normalization", () => {
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom:user:zhangsan")).toBe(
-      "wecom:user:zhangsan",
-    );
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom-agent:blue:user:zhangsan")).toBe(
-      "wecom-agent:blue:user:zhangsan",
-    );
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom:zhangsan")).toBe("zhangsan");
-  });
-});

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(),
-      });
-    },
-  },
-};