@yanhaidao/wecom 2.2.7 → 2.2.28

package/src/gateway-monitor.ts

@@ -0,0 +1,200 @@
+import type {
+  ChannelGatewayContext,
+  OpenClawConfig,
+  PluginRuntime,
+} from "openclaw/plugin-sdk";
+
+import {
+  detectMode,
+  listWecomAccountIds,
+  resolveWecomAccount,
+  resolveWecomAccountConflict,
+} from "./config/index.js";
+import { registerAgentWebhookTarget, registerWecomWebhookTarget } from "./monitor.js";
+import type { ResolvedWecomAccount, WecomConfig } from "./types/index.js";
+
+type AccountRouteRegistryItem = {
+  botPaths: string[];
+  agentPath?: string;
+};
+
+const accountRouteRegistry = new Map<string, AccountRouteRegistryItem>();
+
+function logRegisteredRouteSummary(
+  ctx: ChannelGatewayContext<ResolvedWecomAccount>,
+  preferredOrder: string[],
+): void {
+  const seen = new Set<string>();
+  const orderedAccountIds = [
+    ...preferredOrder.filter((accountId) => accountRouteRegistry.has(accountId)),
+    ...Array.from(accountRouteRegistry.keys())
+      .filter((accountId) => !seen.has(accountId))
+      .sort((a, b) => a.localeCompare(b)),
+  ].filter((accountId) => {
+    if (seen.has(accountId)) return false;
+    seen.add(accountId);
+    return true;
+  });
+
+  const entries = orderedAccountIds
+    .map((accountId) => {
+      const routes = accountRouteRegistry.get(accountId);
+      if (!routes) return undefined;
+      const botText = routes.botPaths.length > 0 ? routes.botPaths.join(", ") : "未启用";
+      const agentText = routes.agentPath ?? "未启用";
+      return `accountId=${accountId}（Bot: ${botText}；Agent: ${agentText}）`;
+    })
+    .filter((entry): entry is string => Boolean(entry));
+  const summary = entries.length > 0 ? entries.join("； ") : "无";
+  ctx.log?.info(`[${ctx.account.accountId}] 已注册账号路由汇总：${summary}`);
+}
+
+function resolveExpectedRouteSummaryAccountIds(cfg: OpenClawConfig): string[] {
+  return listWecomAccountIds(cfg)
+    .filter((accountId) => {
+      const conflict = resolveWecomAccountConflict({ cfg, accountId });
+      if (conflict) return false;
+      const account = resolveWecomAccount({ cfg, accountId });
+      if (!account.enabled || !account.configured) return false;
+      return Boolean(account.bot?.configured || account.agent?.configured);
+    })
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function waitForAbortSignal(abortSignal: AbortSignal): Promise<void> {
+  if (abortSignal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise<void>((resolve) => {
+    const onAbort = () => {
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/**
+ * Keeps WeCom webhook targets registered for the account lifecycle.
+ * The promise only settles after gateway abort/reload signals shutdown.
+ */
+export async function monitorWecomProvider(
+  ctx: ChannelGatewayContext<ResolvedWecomAccount>,
+): Promise<void> {
+  const account = ctx.account;
+  const cfg = ctx.cfg as OpenClawConfig;
+  const expectedRouteSummaryAccountIds = resolveExpectedRouteSummaryAccountIds(cfg);
+  const conflict = resolveWecomAccountConflict({
+    cfg,
+    accountId: account.accountId,
+  });
+  if (conflict) {
+    ctx.setStatus({
+      accountId: account.accountId,
+      running: false,
+      configured: false,
+      lastError: conflict.message,
+    });
+    throw new Error(conflict.message);
+  }
+  const mode = detectMode(cfg.channels?.wecom as WecomConfig | undefined);
+  const matrixMode = mode === "matrix";
+  const bot = account.bot;
+  const agent = account.agent;
+  const botConfigured = Boolean(bot?.configured);
+  const agentConfigured = Boolean(agent?.configured);
+
+  if (mode === "legacy" && (botConfigured || agentConfigured)) {
+    if (agentConfigured && !botConfigured) {
+      ctx.log?.warn(
+        `[${account.accountId}] 检测到仍在使用单 Agent 兼容模式。建议尽快升级为多账号模式：` +
+        `将 channels.wecom.agent 迁移到 channels.wecom.accounts.<accountId>.agent，` +
+        `并设置 channels.wecom.defaultAccount。`,
+      );
+    } else {
+      ctx.log?.warn(
+        `[${account.accountId}] 检测到仍在使用单账号兼容模式。建议尽快升级为多账号模式：` +
+        `将 channels.wecom.bot/agent 迁移到 channels.wecom.accounts.<accountId>.bot/agent，` +
+        `并设置 channels.wecom.defaultAccount。`,
+      );
+    }
+  }
+
+  if (!botConfigured && !agentConfigured) {
+    ctx.log?.warn(`[${account.accountId}] wecom not configured; channel is idle`);
+    ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
+    await waitForAbortSignal(ctx.abortSignal);
+    return;
+  }
+
+  const unregisters: Array<() => void> = [];
+  const botPaths: string[] = [];
+  let agentPath: string | undefined;
+  try {
+    if (bot && botConfigured) {
+      const paths = matrixMode
+        ? [`/wecom/bot/${account.accountId}`]
+        : ["/wecom", "/wecom/bot"];
+      for (const path of paths) {
+        unregisters.push(
+          registerWecomWebhookTarget({
+            account: bot,
+            config: cfg,
+            runtime: ctx.runtime,
+            // The HTTP handler resolves the active PluginRuntime via getWecomRuntime().
+            // The stored target only needs to be decrypt/verify-capable.
+            core: {} as PluginRuntime,
+            path,
+            statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
+          }),
+        );
+      }
+      botPaths.push(...paths);
+      ctx.log?.info(`[${account.accountId}] wecom bot webhook registered at ${paths.join(", ")}`);
+    }
+
+    if (agent && agentConfigured) {
+      const path = matrixMode ? `/wecom/agent/${account.accountId}` : "/wecom/agent";
+      unregisters.push(
+        registerAgentWebhookTarget({
+          agent,
+          config: cfg,
+          runtime: ctx.runtime,
+          path,
+        }),
+      );
+      agentPath = path;
+      ctx.log?.info(`[${account.accountId}] wecom agent webhook registered at ${path}`);
+    }
+
+    accountRouteRegistry.set(account.accountId, { botPaths, agentPath });
+    const shouldLogSummary =
+      expectedRouteSummaryAccountIds.length <= 1 ||
+      expectedRouteSummaryAccountIds.every((accountId) => accountRouteRegistry.has(accountId));
+    if (shouldLogSummary) {
+      logRegisteredRouteSummary(ctx, expectedRouteSummaryAccountIds);
+    }
+
+    ctx.setStatus({
+      accountId: account.accountId,
+      running: true,
+      configured: true,
+      webhookPath: botConfigured
+        ? (matrixMode ? `/wecom/bot/${account.accountId}` : "/wecom/bot")
+        : (matrixMode ? `/wecom/agent/${account.accountId}` : "/wecom/agent"),
+      lastStartAt: Date.now(),
+    });
+
+    await waitForAbortSignal(ctx.abortSignal);
+  } finally {
+    for (const unregister of unregisters) {
+      unregister();
+    }
+    accountRouteRegistry.delete(account.accountId);
+    ctx.setStatus({
+      accountId: account.accountId,
+      running: false,
+      lastStopAt: Date.now(),
+    });
+  }
+}

package/src/monitor/state.queue.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test, vi } from "vitest";
 
-import type { WecomInboundMessage } from "../types.js";
+import type { WecomBotInboundMessage as WecomInboundMessage } from "../types/index.js";
 import type { WecomWebhookTarget } from "./types.js";
 import { StreamStore } from "./state.js";
 

package/src/monitor/state.ts

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import type { StreamState, PendingInbound, ActiveReplyState, WecomWebhookTarget } from "./types.js";
-import type { WecomInboundMessage } from "../types.js";
+import type { WecomBotInboundMessage as WecomInboundMessage } from "../types/index.js";
 
 // Constants
 export const LIMITS = {

package/src/monitor/types.ts

@@ -1,7 +1,7 @@
 
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
 import type { ResolvedBotAccount } from "../types/index.js";
-import type { WecomInboundMessage } from "../types.js";
+import type { WecomBotInboundMessage as WecomInboundMessage } from "../types/index.js";
 
 /**
  * **WecomRuntimeEnv (运行时环境)**

package/src/monitor.active.test.ts

@@ -45,6 +45,7 @@ function createMockResponse(): ServerResponse {
 
 describe("Monitor Active Features", () => {
     let capturedDeliver: ((payload: { text: string }) => Promise<void>) | undefined;
+    let unregisterTarget: (() => void) | undefined;
     let mockCore: any;
     let msgSeq = 0;
     let senderUserId = "";
@@ -109,7 +110,7 @@ describe("Monitor Active Features", () => {
                         return;
                     }
                 },
-                routing: { resolveAgentRoute: () => ({ agentId: "1", sessionKey: "1", accountId: "1" }) },
+                routing: { resolveAgentRoute: () => ({ agentId: "1", sessionKey: "1", accountId: "default" }) },
                 session: {
                     resolveStorePath: () => "",
                     readSessionUpdatedAt: () => 0,
@@ -121,8 +122,8 @@ describe("Monitor Active Features", () => {
 
         vi.spyOn(runtime, "getWecomRuntime").mockReturnValue(mockCore);
 
-        registerWecomWebhookTarget({
-            account: { accountId: "1", enabled: true, configured: true, token: "T", encodingAESKey: validKey, receiveId: "R", config: {} as any },
+        unregisterTarget = registerWecomWebhookTarget({
+            account: { accountId: "default", enabled: true, configured: true, token: "T", encodingAESKey: validKey, receiveId: "R", config: {} as any },
             config: {
                 channels: {
                     wecom: {
@@ -144,6 +145,8 @@ describe("Monitor Active Features", () => {
     });
 
     afterEach(() => {
+        unregisterTarget?.();
+        unregisterTarget = undefined;
         vi.useRealTimers();
     });
 

package/src/monitor.inbound-filter.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+
+import { shouldProcessBotInboundMessage } from "./monitor.js";
+
+describe("shouldProcessBotInboundMessage", () => {
+  it("skips payloads without sender id", () => {
+    const result = shouldProcessBotInboundMessage({
+      msgtype: "text",
+      from: {},
+      text: { content: "hello" },
+    });
+    expect(result.shouldProcess).toBe(false);
+    expect(result.reason).toBe("missing_sender");
+  });
+
+  it("skips system sender payloads", () => {
+    const result = shouldProcessBotInboundMessage({
+      msgtype: "text",
+      from: { userid: "sys" },
+      text: { content: "hello" },
+    });
+    expect(result.shouldProcess).toBe(false);
+    expect(result.reason).toBe("system_sender");
+  });
+
+  it("skips group payloads without chatid", () => {
+    const result = shouldProcessBotInboundMessage({
+      msgtype: "text",
+      chattype: "group",
+      from: { userid: "zhangsan" },
+      text: { content: "hello" },
+    });
+    expect(result.shouldProcess).toBe(false);
+    expect(result.reason).toBe("missing_chatid");
+  });
+
+  it("accepts normal direct-user messages", () => {
+    const result = shouldProcessBotInboundMessage({
+      msgtype: "text",
+      chattype: "single",
+      from: { userid: "zhangsan" },
+      text: { content: "hello" },
+    });
+    expect(result.shouldProcess).toBe(true);
+    expect(result.reason).toBe("user_message");
+    expect(result.senderUserId).toBe("zhangsan");
+    expect(result.chatId).toBe("zhangsan");
+  });
+
+  it("accepts normal group messages with chatid", () => {
+    const result = shouldProcessBotInboundMessage({
+      msgtype: "text",
+      chattype: "group",
+      chatid: "wr123",
+      from: { userid: "zhangsan" },
+      text: { content: "hello" },
+    });
+    expect(result.shouldProcess).toBe(true);
+    expect(result.reason).toBe("user_message");
+    expect(result.senderUserId).toBe("zhangsan");
+    expect(result.chatId).toBe("wr123");
+  });
+});