@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/transport/bot-ws/sdk-adapter.ts

@@ -1,314 +0,0 @@
-import crypto from "node:crypto";
-import AiBot, {
-  generateReqId,
-  type BaseMessage,
-  type EventMessage,
-  type WsFrame,
-} from "@wecom/aibot-node-sdk";
-import type { WecomAccountRuntime } from "../../app/account-runtime.js";
-import { registerBotWsPushHandle, unregisterBotWsPushHandle } from "../../app/index.js";
-import { clearWecomMcpAccountCache } from "../../capability/mcp/index.js";
-import type { RuntimeLogSink } from "../../types/index.js";
-import { mapBotWsFrameToInboundEvent } from "./inbound.js";
-import { uploadAndSendBotWsMedia } from "./media.js";
-import { createBotWsReplyHandle } from "./reply.js";
-import { createBotWsSessionSnapshot } from "./session.js";
-
-export class BotWsSdkAdapter {
-  private client?: AiBot.WSClient;
-  private readonly ownerId: string;
-
-  constructor(
-    private readonly runtime: WecomAccountRuntime,
-    private readonly log: RuntimeLogSink,
-  ) {
-    this.ownerId = `${this.runtime.account.accountId}:ws:${crypto.randomUUID().slice(0, 8)}`;
-  }
-
-  start(): void {
-    const bot = this.runtime.account.bot;
-    if (!bot?.wsConfigured || !bot.ws) {
-      throw new Error(`WeCom bot account "${this.runtime.account.accountId}" missing WS config.`);
-    }
-    this.log.info?.(
-      `[wecom-ws] start account=${this.runtime.account.accountId} botId=${bot.ws.botId} wsUrl=default heartbeat=default reconnectInterval=default`,
-    );
-    const client = new AiBot.WSClient({
-      botId: bot.ws.botId,
-      secret: bot.ws.secret,
-      logger: {
-        debug: (message, ...args) =>
-          this.log.info?.(`[wecom-ws] ${message} ${args.join(" ")}`.trim()),
-        info: (message, ...args) =>
-          this.log.info?.(`[wecom-ws] ${message} ${args.join(" ")}`.trim()),
-        warn: (message, ...args) =>
-          this.log.warn?.(`[wecom-ws] ${message} ${args.join(" ")}`.trim()),
-        error: (message, ...args) =>
-          this.log.error?.(`[wecom-ws] ${message} ${args.join(" ")}`.trim()),
-      },
-    });
-    this.client = client;
-    registerBotWsPushHandle(this.runtime.account.accountId, {
-      isConnected: () => client.isConnected,
-      replyCommand: async ({ cmd, body, headers }) => {
-        const replyHeaders = {
-          ...(headers ?? {}),
-          req_id: headers?.req_id ?? generateReqId("wecom_ws"),
-        };
-        const result = await client.reply({ headers: replyHeaders }, body ?? {}, cmd);
-        this.runtime.touchTransportSession("bot-ws", {
-          ownerId: this.ownerId,
-          running: true,
-          connected: client.isConnected,
-          authenticated: client.isConnected,
-          lastOutboundAt: Date.now(),
-          lastError: undefined,
-        });
-        return result as unknown as Record<string, unknown>;
-      },
-      sendMarkdown: async (chatId, content) => {
-        await client.sendMessage(chatId, {
-          msgtype: "markdown",
-          markdown: { content },
-        });
-        this.runtime.touchTransportSession("bot-ws", {
-          ownerId: this.ownerId,
-          running: true,
-          connected: client.isConnected,
-          authenticated: client.isConnected,
-          lastOutboundAt: Date.now(),
-          lastError: undefined,
-        });
-      },
-      sendMedia: async ({ chatId, mediaUrl, text, mediaLocalRoots, maxBytes }) => {
-        const result = await uploadAndSendBotWsMedia({
-          wsClient: client,
-          chatId,
-          mediaUrl,
-          mediaLocalRoots,
-          maxBytes,
-        });
-        if (result.ok && text?.trim()) {
-          await client.sendMessage(chatId, {
-            msgtype: "markdown",
-            markdown: { content: text.trim() },
-          });
-        }
-        this.runtime.touchTransportSession("bot-ws", {
-          ownerId: this.ownerId,
-          running: true,
-          connected: client.isConnected,
-          authenticated: client.isConnected,
-          lastOutboundAt: Date.now(),
-          lastError: result.ok ? undefined : result.error,
-        });
-        return result;
-      },
-    });
-
-    client.on("connected", () => {
-      this.log.info?.(`[wecom-ws] connected account=${this.runtime.account.accountId}`);
-      this.runtime.updateTransportSession(
-        createBotWsSessionSnapshot({
-          accountId: this.runtime.account.accountId,
-          ownerId: this.ownerId,
-          connected: true,
-          authenticated: false,
-        }),
-      );
-    });
-
-    client.on("authenticated", () => {
-      this.log.info?.(`[wecom-ws] authenticated account=${this.runtime.account.accountId}`);
-      this.runtime.updateTransportSession(
-        createBotWsSessionSnapshot({
-          accountId: this.runtime.account.accountId,
-          ownerId: this.ownerId,
-          connected: true,
-          authenticated: true,
-        }),
-      );
-    });
-
-    client.on("disconnected", (reason) => {
-      clearWecomMcpAccountCache(this.runtime.account.accountId);
-      const normalizedReason = String(reason ?? "").toLowerCase();
-      const kicked =
-        normalizedReason.includes("kick") ||
-        normalizedReason.includes("owner") ||
-        normalizedReason.includes("replaced");
-      this.log.warn?.(
-        `[wecom-ws] disconnected account=${this.runtime.account.accountId} kicked=${String(kicked)} reason=${reason ?? "unknown"}`,
-      );
-      if (kicked) {
-        this.runtime.recordOperationalIssue({
-          transport: "bot-ws",
-          category: "ws-kicked",
-          summary: `ws owner lost: ${reason ?? "unknown"}`,
-          error: reason ?? "unknown",
-        });
-      }
-      this.runtime.updateTransportSession(
-        createBotWsSessionSnapshot({
-          accountId: this.runtime.account.accountId,
-          ownerId: this.ownerId,
-          running: false,
-          connected: false,
-          authenticated: false,
-          lastDisconnectedAt: Date.now(),
-          lastError: reason,
-        }),
-      );
-    });
-
-    client.on("reconnecting", (attempt) => {
-      this.log.warn?.(
-        `[wecom-ws] reconnecting account=${this.runtime.account.accountId} attempt=${attempt}`,
-      );
-    });
-
-    client.on("error", (error) => {
-      this.log.error?.(
-        `[wecom-ws] error account=${this.runtime.account.accountId} message=${error.message}`,
-      );
-      this.runtime.updateTransportSession(
-        createBotWsSessionSnapshot({
-          accountId: this.runtime.account.accountId,
-          ownerId: this.ownerId,
-          running: false,
-          connected: client.isConnected,
-          authenticated: client.isConnected,
-          lastError: error.message,
-        }),
-      );
-    });
-
-    const handleFrame = async (frame: WsFrame<BaseMessage | EventMessage>) => {
-      const botAccount = this.runtime.account.bot;
-      if (!botAccount) {
-        return;
-      }
-      this.log.info?.(
-        `[wecom-ws] frame account=${this.runtime.account.accountId} cmd=${frame.cmd} reqId=${frame.headers.req_id ?? "n/a"}`,
-      );
-      this.runtime.touchTransportSession("bot-ws", {
-        ownerId: this.ownerId,
-        running: true,
-        connected: client.isConnected,
-        authenticated: client.isConnected,
-        lastInboundAt: Date.now(),
-      });
-      const event = mapBotWsFrameToInboundEvent({
-        account: botAccount,
-        frame,
-      });
-      const replyHandle = createBotWsReplyHandle({
-        client,
-        frame,
-        accountId: this.runtime.account.accountId,
-        inboundKind: event.inboundKind,
-        placeholderContent: botAccount.config.streamPlaceholderContent,
-        autoSendPlaceholder:
-          event.inboundKind === "text" ||
-          event.inboundKind === "image" ||
-          event.inboundKind === "file" ||
-          event.inboundKind === "voice" ||
-          event.inboundKind === "mixed",
-        onDeliver: () => {
-          this.runtime.touchTransportSession("bot-ws", {
-            ownerId: this.ownerId,
-            running: true,
-            connected: client.isConnected,
-            authenticated: client.isConnected,
-            lastOutboundAt: Date.now(),
-          });
-        },
-        onFail: (error) => {
-          this.runtime.touchTransportSession("bot-ws", {
-            ownerId: this.ownerId,
-            running: client.isConnected,
-            connected: client.isConnected,
-            authenticated: client.isConnected,
-            lastError: error instanceof Error ? error.message : String(error),
-          });
-        },
-      });
-
-      const staticWelcomeText =
-        event.inboundKind === "welcome" ? botAccount.config.welcomeText?.trim() : undefined;
-      if (staticWelcomeText) {
-        this.log.info?.(
-          `[wecom-ws] static welcome reply account=${this.runtime.account.accountId} messageId=${event.messageId} peer=${event.conversation.peerKind}:${event.conversation.peerId} len=${staticWelcomeText.length}`,
-        );
-        await replyHandle.deliver(
-          {
-            text: staticWelcomeText,
-          },
-          { kind: "final" },
-        );
-        this.log.info?.(
-          `[wecom-ws] static welcome delivered account=${this.runtime.account.accountId} messageId=${event.messageId}`,
-        );
-        return;
-      }
-
-      await this.runtime.handleEvent(event, replyHandle);
-    };
-
-    const runHandleFrame = (frame: WsFrame<BaseMessage | EventMessage>) => {
-      void handleFrame(frame).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        this.log.error?.(
-          `[wecom-ws] frame handler failed account=${this.runtime.account.accountId} reqId=${frame.headers?.req_id ?? "n/a"} message=${message}`,
-        );
-        this.runtime.recordOperationalIssue({
-          transport: "bot-ws",
-          category: "runtime-error",
-          messageId: frame.body?.msgid,
-          raw: {
-            transport: "bot-ws",
-            command: frame.cmd,
-            headers: frame.headers,
-            body: frame.body,
-            envelopeType: "ws",
-          },
-          summary: `bot-ws frame handler crashed reqId=${frame.headers?.req_id ?? "n/a"}`,
-          error: message,
-        });
-        this.runtime.touchTransportSession("bot-ws", {
-          ownerId: this.ownerId,
-          running: client.isConnected,
-          connected: client.isConnected,
-          authenticated: client.isConnected,
-          lastError: message,
-        });
-      });
-    };
-
-    client.on("message", (frame) => {
-      runHandleFrame(frame);
-    });
-    client.on("event", (frame) => {
-      runHandleFrame(frame);
-    });
-
-    client.connect();
-  }
-
-  stop(): void {
-    this.log.info?.(`[wecom-ws] stop account=${this.runtime.account.accountId}`);
-    clearWecomMcpAccountCache(this.runtime.account.accountId);
-    unregisterBotWsPushHandle(this.runtime.account.accountId);
-    this.runtime.updateTransportSession(
-      createBotWsSessionSnapshot({
-        accountId: this.runtime.account.accountId,
-        ownerId: this.ownerId,
-        running: false,
-        connected: false,
-        authenticated: false,
-        lastDisconnectedAt: Date.now(),
-      }),
-    );
-    this.client?.disconnect();
-  }
-}

package/src/transport/bot-ws/session.ts

@@ -1,28 +0,0 @@
-import type { TransportSessionSnapshot } from "../../types/index.js";
-
-export function createBotWsSessionSnapshot(params: {
-  accountId: string;
-  ownerId: string;
-  connected?: boolean;
-  authenticated?: boolean;
-  lastError?: string;
-  running?: boolean;
-  lastConnectedAt?: number;
-  lastDisconnectedAt?: number;
-  lastInboundAt?: number;
-  lastOutboundAt?: number;
-}): TransportSessionSnapshot {
-  return {
-    accountId: params.accountId,
-    transport: "bot-ws",
-    running: params.running ?? true,
-    ownerId: params.ownerId,
-    connected: params.connected,
-    authenticated: params.authenticated,
-    lastConnectedAt: params.lastConnectedAt ?? (params.connected ? Date.now() : undefined),
-    lastDisconnectedAt: params.lastDisconnectedAt,
-    lastInboundAt: params.lastInboundAt,
-    lastOutboundAt: params.lastOutboundAt,
-    lastError: params.lastError,
-  };
-}

package/src/transport/http/common.ts

@@ -1,109 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import { WEBHOOK_PATHS } from "../../types/constants.js";
-
-export type RouteFailureReason =
-  | "wecom_account_not_found"
-  | "wecom_account_conflict"
-  | "wecom_identity_mismatch"
-  | "wecom_matrix_path_required";
-
-export function normalizeWecomWebhookPath(raw: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed) return "/";
-  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  if (withSlash.length > 1 && withSlash.endsWith("/")) return withSlash.slice(0, -1);
-  return withSlash;
-}
-
-export function resolveQueryParams(req: IncomingMessage): URLSearchParams {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  return url.searchParams;
-}
-
-export function resolvePath(req: IncomingMessage): string {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  return normalizeWecomWebhookPath(url.pathname || "/");
-}
-
-export function resolveSignatureParam(params: URLSearchParams): string {
-  return params.get("msg_signature") ?? params.get("msgsignature") ?? params.get("signature") ?? "";
-}
-
-export function isAgentCallbackPathCandidate(path: string): boolean {
-  return (
-    path === WEBHOOK_PATHS.AGENT ||
-    path === WEBHOOK_PATHS.AGENT_PLUGIN ||
-    path.startsWith(`${WEBHOOK_PATHS.AGENT}/`) ||
-    path.startsWith(`${WEBHOOK_PATHS.AGENT_PLUGIN}/`)
-  );
-}
-
-export function isNonMatrixWecomBasePath(path: string): boolean {
-  return (
-    path === WEBHOOK_PATHS.BOT ||
-    path === WEBHOOK_PATHS.BOT_ALT ||
-    path === WEBHOOK_PATHS.AGENT ||
-    path === WEBHOOK_PATHS.BOT_PLUGIN ||
-    path === WEBHOOK_PATHS.AGENT_PLUGIN
-  );
-}
-
-function maskAccountId(accountId: string): string {
-  const normalized = accountId.trim();
-  if (!normalized) return "***";
-  if (normalized.length <= 4) return `${normalized[0] ?? "*"}***`;
-  return `${normalized.slice(0, 2)}***${normalized.slice(-2)}`;
-}
-
-export function logRouteFailure(params: {
-  reqId: string;
-  path: string;
-  method: string;
-  reason: RouteFailureReason;
-  candidateAccountIds: string[];
-}): void {
-  const payload = {
-    reqId: params.reqId,
-    path: params.path,
-    method: params.method,
-    reason: params.reason,
-    candidateAccountIds: params.candidateAccountIds.map(maskAccountId),
-  };
-  console.error(`[wecom] route-error ${JSON.stringify(payload)}`);
-}
-
-export function writeRouteFailure(
-  res: ServerResponse,
-  reason: RouteFailureReason,
-  message: string,
-): void {
-  res.statusCode = 401;
-  res.setHeader("Content-Type", "application/json; charset=utf-8");
-  res.end(JSON.stringify({ error: reason, message }));
-}
-
-export async function readTextBody(
-  req: IncomingMessage,
-  maxBytes: number,
-): Promise<{ ok: true; value: string } | { ok: false; error: string }> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  return await new Promise((resolve) => {
-    req.on("data", (chunk: Buffer) => {
-      total += chunk.length;
-      if (total > maxBytes) {
-        resolve({ ok: false as const, error: "payload too large" });
-        req.destroy();
-        return;
-      }
-      chunks.push(chunk);
-    });
-    req.on("end", () => {
-      resolve({ ok: true as const, value: Buffer.concat(chunks).toString("utf8") });
-    });
-    req.on("error", (err) => {
-      resolve({ ok: false as const, error: String(err) });
-    });
-  });
-}

package/src/transport/http/registry.ts

@@ -1,92 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
-
-import type { ResolvedAgentAccount, TransportSessionPatch } from "../../types/index.js";
-import { monitorState } from "../../monitor/state.js";
-import type { WecomRuntimeAuditEvent, WecomRuntimeEnv, WecomWebhookTarget } from "../../types/runtime-context.js";
-import { WEBHOOK_PATHS } from "../../types/constants.js";
-import { normalizeWecomWebhookPath } from "./common.js";
-
-export type AgentWebhookTarget = {
-  agent: ResolvedAgentAccount;
-  config: OpenClawConfig;
-  runtimeEnv: WecomRuntimeEnv;
-  path: string;
-  touchTransportSession?: (patch: TransportSessionPatch) => void;
-  auditSink?: (event: WecomRuntimeAuditEvent) => void;
-};
-
-const webhookTargets = new Map<string, WecomWebhookTarget[]>();
-const agentTargets = new Map<string, AgentWebhookTarget[]>();
-
-function ensurePruneTimer(): void {
-  monitorState.startPruning();
-}
-
-function checkPruneTimer(): void {
-  if (webhookTargets.size === 0 && agentTargets.size === 0) {
-    monitorState.stopPruning();
-  }
-}
-
-export function registerWecomWebhookTarget(target: WecomWebhookTarget): () => void {
-  const key = normalizeWecomWebhookPath(target.path);
-  const normalizedTarget = { ...target, path: key };
-  const existing = webhookTargets.get(key) ?? [];
-  webhookTargets.set(key, [...existing, normalizedTarget]);
-  ensurePruneTimer();
-  return () => {
-    const updated = (webhookTargets.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
-    if (updated.length > 0) webhookTargets.set(key, updated);
-    else webhookTargets.delete(key);
-    checkPruneTimer();
-  };
-}
-
-export function registerAgentWebhookTarget(target: AgentWebhookTarget): () => void {
-  const key = normalizeWecomWebhookPath(target.path);
-  const normalizedTarget = { ...target, path: key };
-  const existing = agentTargets.get(key) ?? [];
-  agentTargets.set(key, [...existing, normalizedTarget]);
-  ensurePruneTimer();
-  return () => {
-    const updated = (agentTargets.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
-    if (updated.length > 0) agentTargets.set(key, updated);
-    else agentTargets.delete(key);
-    checkPruneTimer();
-  };
-}
-
-export function getWecomWebhookTargets(path: string): WecomWebhookTarget[] {
-  return webhookTargets.get(normalizeWecomWebhookPath(path)) ?? [];
-}
-
-export function getAgentWebhookTargets(path: string): AgentWebhookTarget[] {
-  return agentTargets.get(normalizeWecomWebhookPath(path)) ?? [];
-}
-
-export function hasMatrixExplicitRoutesRegistered(): boolean {
-  for (const [key, targets] of webhookTargets.entries()) {
-    if (key.startsWith(`${WEBHOOK_PATHS.BOT_ALT}/`) && targets.some((target) => target.account.accountId !== DEFAULT_ACCOUNT_ID)) {
-      return true;
-    }
-    if (
-      key.startsWith(`${WEBHOOK_PATHS.BOT_PLUGIN}/`) &&
-      targets.some((target) => target.account.accountId !== DEFAULT_ACCOUNT_ID)
-    ) {
-      return true;
-    }
-  }
-  for (const [key, targets] of agentTargets.entries()) {
-    if (key.startsWith(`${WEBHOOK_PATHS.AGENT}/`) && targets.some((target) => target.agent.accountId !== DEFAULT_ACCOUNT_ID)) {
-      return true;
-    }
-    if (
-      key.startsWith(`${WEBHOOK_PATHS.AGENT_PLUGIN}/`) &&
-      targets.some((target) => target.agent.accountId !== DEFAULT_ACCOUNT_ID)
-    ) {
-      return true;
-    }
-  }
-  return false;
-}

package/src/transport/http/request-handler.ts

@@ -1,84 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import crypto from "node:crypto";
-
-import { handleAgentCallbackRequest } from "../agent-callback/request-handler.js";
-import type { WecomWebhookTarget } from "../../types/runtime-context.js";
-import { getAgentWebhookTargets, getWecomWebhookTargets, hasMatrixExplicitRoutesRegistered } from "./registry.js";
-import {
-  isAgentCallbackPathCandidate,
-  isNonMatrixWecomBasePath,
-  logRouteFailure,
-  resolvePath,
-  resolveQueryParams,
-  writeRouteFailure,
-} from "./common.js";
-
-export async function handleWecomHttpRequest(params: {
-  req: IncomingMessage;
-  res: ServerResponse;
-  handleBotWebhookRequest: (params: {
-    req: IncomingMessage;
-    res: ServerResponse;
-    path: string;
-    reqId: string;
-    targets: WecomWebhookTarget[];
-  }) => Promise<boolean>;
-}): Promise<boolean> {
-  const { req, res, handleBotWebhookRequest } = params;
-
-  const path = resolvePath(req);
-  const reqId = crypto.randomUUID().slice(0, 8);
-  const remote = req.socket?.remoteAddress ?? "unknown";
-  const ua = String(req.headers["user-agent"] ?? "");
-  const cl = String(req.headers["content-length"] ?? "");
-  const q = resolveQueryParams(req);
-  const hasTimestamp = Boolean(q.get("timestamp"));
-  const hasNonce = Boolean(q.get("nonce"));
-  const hasEchostr = Boolean(q.get("echostr"));
-  const hasMsgSig = Boolean(q.get("msg_signature"));
-  const hasSignature = Boolean(q.get("signature"));
-  console.log(
-    `[wecom] inbound(http): reqId=${reqId} path=${path} method=${req.method ?? "UNKNOWN"} remote=${remote} ua=${ua ? `"${ua}"` : "N/A"} contentLength=${cl || "N/A"} query={timestamp:${hasTimestamp},nonce:${hasNonce},echostr:${hasEchostr},msg_signature:${hasMsgSig},signature:${hasSignature}}`,
-  );
-
-  if (hasMatrixExplicitRoutesRegistered() && isNonMatrixWecomBasePath(path)) {
-    logRouteFailure({
-      reqId,
-      path,
-      method: req.method ?? "UNKNOWN",
-      reason: "wecom_matrix_path_required",
-      candidateAccountIds: [],
-    });
-    writeRouteFailure(
-      res,
-      "wecom_matrix_path_required",
-      "Matrix mode requires explicit account path. Use /plugins/wecom/bot/{accountId} or /plugins/wecom/agent/{accountId}.",
-    );
-    return true;
-  }
-
-  const agentTargets = getAgentWebhookTargets(path);
-  if (agentTargets.length > 0 || isAgentCallbackPathCandidate(path)) {
-    return handleAgentCallbackRequest({
-      req,
-      res,
-      path,
-      reqId,
-      targets: agentTargets,
-    });
-  }
-
-  const botTargets = getWecomWebhookTargets(path);
-  if (botTargets.length === 0) {
-    return false;
-  }
-
-  return handleBotWebhookRequest({
-    req,
-    res,
-    path,
-    reqId,
-    targets: botTargets,
-  });
-}

package/src/types/account.ts

@@ -1,72 +0,0 @@
-import type {
-  WecomAccountConfig,
-  WecomAgentConfig,
-  WecomBotConfig,
-  WecomBotPrimaryTransport,
-  WecomNetworkConfig,
-} from "./config.js";
-
-export type ResolvedMode = "disabled" | "legacy" | "matrix";
-
-export type ResolvedBotWsTransport = {
-  botId: string;
-  secret: string;
-};
-
-export type ResolvedBotWebhookTransport = {
-  token: string;
-  encodingAESKey: string;
-  receiveId: string;
-};
-
-export type ResolvedBotAccount = {
-  accountId: string;
-  configured: boolean;
-  primaryTransport: WecomBotPrimaryTransport;
-  wsConfigured: boolean;
-  webhookConfigured: boolean;
-  config: WecomBotConfig;
-  network?: WecomNetworkConfig;
-  ws?: ResolvedBotWsTransport;
-  webhook?: ResolvedBotWebhookTransport;
-  // Compatibility flattening for old webhook-centric helpers.
-  token: string;
-  encodingAESKey: string;
-  receiveId: string;
-  botId: string;
-  secret: string;
-};
-
-export type ResolvedAgentAccount = {
-  accountId: string;
-  configured: boolean;
-  callbackConfigured: boolean;
-  apiConfigured: boolean;
-  corpId: string;
-  corpSecret: string;
-  agentId?: number;
-  token: string;
-  encodingAESKey: string;
-  eventEnabled?: boolean;
-  allowedEventTypes?: string[];
-  config: WecomAgentConfig;
-  network?: WecomNetworkConfig;
-};
-
-export type ResolvedWecomAccount = {
-  accountId: string;
-  name?: string;
-  enabled: boolean;
-  configured: boolean;
-  config: WecomAccountConfig;
-  bot?: ResolvedBotAccount;
-  agent?: ResolvedAgentAccount;
-};
-
-export type ResolvedWecomAccounts = {
-  mode: ResolvedMode;
-  defaultAccountId: string;
-  accounts: Record<string, ResolvedWecomAccount>;
-  bot?: ResolvedBotAccount;
-  agent?: ResolvedAgentAccount;
-};