@openclaw/feishu 2026.3.1 → 2026.3.7

package/src/monitor.reaction.test.ts

@@ -1,6 +1,41 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import { describe, expect, it, vi } from "vitest";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk/feishu";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { hasControlCommand } from "../../../src/auto-reply/command-detection.js";
+import {
+  createInboundDebouncer,
+  resolveInboundDebounceMs,
+} from "../../../src/auto-reply/inbound-debounce.js";
+import { createPluginRuntimeMock } from "../../test-utils/plugin-runtime-mock.js";
+import { parseFeishuMessageEvent, type FeishuMessageEvent } from "./bot.js";
+import * as dedup from "./dedup.js";
+import { monitorSingleAccount } from "./monitor.account.js";
 import { resolveReactionSyntheticEvent, type FeishuReactionCreatedEvent } from "./monitor.js";
+import { setFeishuRuntime } from "./runtime.js";
+import type { ResolvedFeishuAccount } from "./types.js";
+
+const handleFeishuMessageMock = vi.hoisted(() => vi.fn(async (_params: { event?: unknown }) => {}));
+const createEventDispatcherMock = vi.hoisted(() => vi.fn());
+const monitorWebSocketMock = vi.hoisted(() => vi.fn(async () => {}));
+const monitorWebhookMock = vi.hoisted(() => vi.fn(async () => {}));
+
+let handlers: Record<string, (data: unknown) => Promise<void>> = {};
+
+vi.mock("./client.js", () => ({
+  createEventDispatcher: createEventDispatcherMock,
+}));
+
+vi.mock("./bot.js", async () => {
+  const actual = await vi.importActual<typeof import("./bot.js")>("./bot.js");
+  return {
+    ...actual,
+    handleFeishuMessage: handleFeishuMessageMock,
+  };
+});
+
+vi.mock("./monitor.transport.js", () => ({
+  monitorWebSocket: monitorWebSocketMock,
+  monitorWebhook: monitorWebhookMock,
+}));
 
 const cfg = {} as ClawdbotConfig;
 
@@ -16,6 +51,155 @@ function makeReactionEvent(
   };
 }
 
+function createFetchedReactionMessage(chatId: string) {
+  return {
+    messageId: "om_msg1",
+    chatId,
+    senderOpenId: "ou_bot",
+    content: "hello",
+    contentType: "text",
+  };
+}
+
+async function resolveReactionWithLookup(params: {
+  event?: FeishuReactionCreatedEvent;
+  lookupChatId: string;
+}) {
+  return await resolveReactionSyntheticEvent({
+    cfg,
+    accountId: "default",
+    event: params.event ?? makeReactionEvent(),
+    botOpenId: "ou_bot",
+    fetchMessage: async () => createFetchedReactionMessage(params.lookupChatId),
+    uuid: () => "fixed-uuid",
+  });
+}
+
+type FeishuMention = NonNullable<FeishuMessageEvent["message"]["mentions"]>[number];
+
+function buildDebounceConfig(): ClawdbotConfig {
+  return {
+    messages: {
+      inbound: {
+        debounceMs: 0,
+        byChannel: {
+          feishu: 20,
+        },
+      },
+    },
+    channels: {
+      feishu: {
+        enabled: true,
+      },
+    },
+  } as ClawdbotConfig;
+}
+
+function buildDebounceAccount(): ResolvedFeishuAccount {
+  return {
+    accountId: "default",
+    enabled: true,
+    configured: true,
+    appId: "cli_test",
+    appSecret: "secret_test", // pragma: allowlist secret
+    domain: "feishu",
+    config: {
+      enabled: true,
+      connectionMode: "websocket",
+    },
+  } as ResolvedFeishuAccount;
+}
+
+function createTextEvent(params: {
+  messageId: string;
+  text: string;
+  senderId?: string;
+  mentions?: FeishuMention[];
+}): FeishuMessageEvent {
+  const senderId = params.senderId ?? "ou_sender";
+  return {
+    sender: {
+      sender_id: { open_id: senderId },
+      sender_type: "user",
+    },
+    message: {
+      message_id: params.messageId,
+      chat_id: "oc_group_1",
+      chat_type: "group",
+      message_type: "text",
+      content: JSON.stringify({ text: params.text }),
+      mentions: params.mentions,
+    },
+  };
+}
+
+async function setupDebounceMonitor(params?: {
+  botOpenId?: string;
+  botName?: string;
+}): Promise<(data: unknown) => Promise<void>> {
+  const register = vi.fn((registered: Record<string, (data: unknown) => Promise<void>>) => {
+    handlers = registered;
+  });
+  createEventDispatcherMock.mockReturnValue({ register });
+
+  await monitorSingleAccount({
+    cfg: buildDebounceConfig(),
+    account: buildDebounceAccount(),
+    runtime: {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    } as RuntimeEnv,
+    botOpenIdSource: {
+      kind: "prefetched",
+      botOpenId: params?.botOpenId ?? "ou_bot",
+      botName: params?.botName,
+    },
+  });
+
+  const onMessage = handlers["im.message.receive_v1"];
+  if (!onMessage) {
+    throw new Error("missing im.message.receive_v1 handler");
+  }
+  return onMessage;
+}
+
+function getFirstDispatchedEvent(): FeishuMessageEvent {
+  const firstCall = handleFeishuMessageMock.mock.calls[0];
+  if (!firstCall) {
+    throw new Error("missing dispatch call");
+  }
+  const firstParams = firstCall[0] as { event?: FeishuMessageEvent } | undefined;
+  if (!firstParams?.event) {
+    throw new Error("missing dispatched event payload");
+  }
+  return firstParams.event;
+}
+
+function setDedupPassThroughMocks(): void {
+  vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
+  vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
+  vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
+  vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
+}
+
+function createMention(params: { openId: string; name: string; key?: string }): FeishuMention {
+  return {
+    key: params.key ?? "@_user_1",
+    id: { open_id: params.openId },
+    name: params.name,
+  };
+}
+
+async function enqueueDebouncedMessage(
+  onMessage: (data: unknown) => Promise<void>,
+  event: FeishuMessageEvent,
+): Promise<void> {
+  await onMessage(event);
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
 describe("resolveReactionSyntheticEvent", () => {
   it("filters app self-reactions", async () => {
     const event = makeReactionEvent({ operator_type: "app" });
@@ -136,23 +320,12 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("uses event chat context when provided", async () => {
-    const event = makeReactionEvent({
-      chat_id: "oc_group_from_event",
-      chat_type: "group",
-    });
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "oc_group_from_lookup",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
+    const result = await resolveReactionWithLookup({
+      event: makeReactionEvent({
+        chat_id: "oc_group_from_event",
+        chat_type: "group",
       }),
-      uuid: () => "fixed-uuid",
+      lookupChatId: "oc_group_from_lookup",
     });
 
     expect(result).toEqual({
@@ -173,20 +346,8 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("falls back to reacted message chat_id when event chat_id is absent", async () => {
-    const event = makeReactionEvent();
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "oc_group_from_lookup",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
-      }),
-      uuid: () => "fixed-uuid",
+    const result = await resolveReactionWithLookup({
+      lookupChatId: "oc_group_from_lookup",
     });
 
     expect(result?.message.chat_id).toBe("oc_group_from_lookup");
@@ -194,20 +355,8 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("falls back to sender p2p chat when lookup returns empty chat_id", async () => {
-    const event = makeReactionEvent();
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
-      }),
-      uuid: () => "fixed-uuid",
+    const result = await resolveReactionWithLookup({
+      lookupChatId: "",
     });
 
     expect(result?.message.chat_id).toBe("p2p:ou_user1");
@@ -233,3 +382,203 @@ describe("resolveReactionSyntheticEvent", () => {
     );
   });
 });
+
+describe("Feishu inbound debounce regressions", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    handlers = {};
+    handleFeishuMessageMock.mockClear();
+    setFeishuRuntime(
+      createPluginRuntimeMock({
+        channel: {
+          debounce: {
+            createInboundDebouncer,
+            resolveInboundDebounceMs,
+          },
+          text: {
+            hasControlCommand,
+          },
+        },
+      }),
+    );
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("keeps bot mention when per-message mention keys collide across non-forward messages", async () => {
+    setDedupPassThroughMocks();
+    const onMessage = await setupDebounceMonitor();
+
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_1",
+        text: "first",
+        mentions: [createMention({ openId: "ou_user_a", name: "user-a" })],
+      }),
+    );
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_2",
+        text: "@bot second",
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
+      }),
+    );
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const dispatched = getFirstDispatchedEvent();
+    const mergedMentions = dispatched.message.mentions ?? [];
+    expect(mergedMentions.some((mention) => mention.id.open_id === "ou_bot")).toBe(true);
+    expect(mergedMentions.some((mention) => mention.id.open_id === "ou_user_a")).toBe(false);
+  });
+
+  it("passes prefetched botName through to handleFeishuMessage", async () => {
+    vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
+    vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
+    vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
+    vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
+    const onMessage = await setupDebounceMonitor({ botName: "OpenClaw Bot" });
+
+    await onMessage(
+      createTextEvent({
+        messageId: "om_name_passthrough",
+        text: "@bot hello",
+        mentions: [
+          {
+            key: "@_user_1",
+            id: { open_id: "ou_bot" },
+            name: "OpenClaw Bot",
+          },
+        ],
+      }),
+    );
+    await Promise.resolve();
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const firstParams = handleFeishuMessageMock.mock.calls[0]?.[0] as
+      | { botName?: string }
+      | undefined;
+    expect(firstParams?.botName).toBe("OpenClaw Bot");
+  });
+
+  it("does not synthesize mention-forward intent across separate messages", async () => {
+    setDedupPassThroughMocks();
+    const onMessage = await setupDebounceMonitor();
+
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_user_mention",
+        text: "@alice first",
+        mentions: [createMention({ openId: "ou_alice", name: "alice" })],
+      }),
+    );
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_bot_mention",
+        text: "@bot second",
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
+      }),
+    );
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const dispatched = getFirstDispatchedEvent();
+    const parsed = parseFeishuMessageEvent(dispatched, "ou_bot");
+    expect(parsed.mentionedBot).toBe(true);
+    expect(parsed.mentionTargets).toBeUndefined();
+    const mergedMentions = dispatched.message.mentions ?? [];
+    expect(mergedMentions.every((mention) => mention.id.open_id === "ou_bot")).toBe(true);
+  });
+
+  it("preserves bot mention signal when the latest merged message has no mentions", async () => {
+    setDedupPassThroughMocks();
+    const onMessage = await setupDebounceMonitor();
+
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_bot_first",
+        text: "@bot first",
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
+      }),
+    );
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_plain_second",
+        text: "plain follow-up",
+      }),
+    );
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const dispatched = getFirstDispatchedEvent();
+    const parsed = parseFeishuMessageEvent(dispatched, "ou_bot");
+    expect(parsed.mentionedBot).toBe(true);
+  });
+
+  it("excludes previously processed retries from combined debounce text", async () => {
+    vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
+    vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
+    vi.spyOn(dedup, "hasRecordedMessage").mockImplementation((key) => key.endsWith(":om_old"));
+    vi.spyOn(dedup, "hasRecordedMessagePersistent").mockImplementation(
+      async (messageId) => messageId === "om_old",
+    );
+    const onMessage = await setupDebounceMonitor();
+
+    await onMessage(createTextEvent({ messageId: "om_old", text: "stale" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await onMessage(createTextEvent({ messageId: "om_new_1", text: "first" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await onMessage(createTextEvent({ messageId: "om_old", text: "stale" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await onMessage(createTextEvent({ messageId: "om_new_2", text: "second" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const dispatched = getFirstDispatchedEvent();
+    expect(dispatched.message.message_id).toBe("om_new_2");
+    const combined = JSON.parse(dispatched.message.content) as { text?: string };
+    expect(combined.text).toBe("first\nsecond");
+  });
+
+  it("uses latest fresh message id when debounce batch ends with stale retry", async () => {
+    const recordSpy = vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
+    vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
+    vi.spyOn(dedup, "hasRecordedMessage").mockImplementation((key) => key.endsWith(":om_old"));
+    vi.spyOn(dedup, "hasRecordedMessagePersistent").mockImplementation(
+      async (messageId) => messageId === "om_old",
+    );
+    const onMessage = await setupDebounceMonitor();
+
+    await onMessage(createTextEvent({ messageId: "om_new", text: "fresh" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await onMessage(createTextEvent({ messageId: "om_old", text: "stale" }));
+    await Promise.resolve();
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const dispatched = getFirstDispatchedEvent();
+    expect(dispatched.message.message_id).toBe("om_new");
+    const combined = JSON.parse(dispatched.message.content) as { text?: string };
+    expect(combined.text).toBe("fresh");
+    expect(recordSpy).toHaveBeenCalledWith("default:om_old");
+    expect(recordSpy).not.toHaveBeenCalledWith("default:om_new");
+  });
+});

package/src/monitor.startup.test.ts

@@ -1,18 +1,35 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { monitorFeishuProvider, stopFeishuMonitor } from "./monitor.js";
 
 const probeFeishuMock = vi.hoisted(() => vi.fn());
+const feishuClientMockModule = vi.hoisted(() => ({
+  createFeishuWSClient: vi.fn(() => ({ start: vi.fn() })),
+  createEventDispatcher: vi.fn(() => ({ register: vi.fn() })),
+}));
+const feishuRuntimeMockModule = vi.hoisted(() => ({
+  getFeishuRuntime: () => ({
+    channel: {
+      debounce: {
+        resolveInboundDebounceMs: () => 0,
+        createInboundDebouncer: () => ({
+          enqueue: async () => {},
+          flushKey: async () => {},
+        }),
+      },
+      text: {
+        hasControlCommand: () => false,
+      },
+    },
+  }),
+}));
 
 vi.mock("./probe.js", () => ({
   probeFeishu: probeFeishuMock,
 }));
 
-vi.mock("./client.js", () => ({
-  createFeishuWSClient: vi.fn(() => ({ start: vi.fn() })),
-  createEventDispatcher: vi.fn(() => ({ register: vi.fn() })),
-}));
-
-import { monitorFeishuProvider, stopFeishuMonitor } from "./monitor.js";
+vi.mock("./client.js", () => feishuClientMockModule);
+vi.mock("./runtime.js", () => feishuRuntimeMockModule);
 
 function buildMultiAccountWebsocketConfig(accountIds: string[]): ClawdbotConfig {
   return {
@@ -25,7 +42,7 @@ function buildMultiAccountWebsocketConfig(accountIds: string[]): ClawdbotConfig
             {
               enabled: true,
               appId: `cli_${accountId}`,
-              appSecret: `secret_${accountId}`,
+              appSecret: `secret_${accountId}`, // pragma: allowlist secret
               connectionMode: "websocket",
             },
           ]),

package/src/monitor.startup.ts

@@ -1,4 +1,4 @@
-import type { RuntimeEnv } from "openclaw/plugin-sdk";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/feishu";
 import { probeFeishu } from "./probe.js";
 import type { ResolvedFeishuAccount } from "./types.js";
 
@@ -10,6 +10,11 @@ type FetchBotOpenIdOptions = {
   timeoutMs?: number;
 };
 
+export type FeishuMonitorBotIdentity = {
+  botOpenId?: string;
+  botName?: string;
+};
+
 function isTimeoutErrorMessage(message: string | undefined): boolean {
   return message?.toLowerCase().includes("timeout") || message?.toLowerCase().includes("timed out")
     ? true
@@ -20,12 +25,12 @@ function isAbortErrorMessage(message: string | undefined): boolean {
   return message?.toLowerCase().includes("aborted") ?? false;
 }
 
-export async function fetchBotOpenIdForMonitor(
+export async function fetchBotIdentityForMonitor(
   account: ResolvedFeishuAccount,
   options: FetchBotOpenIdOptions = {},
-): Promise<string | undefined> {
+): Promise<FeishuMonitorBotIdentity> {
   if (options.abortSignal?.aborted) {
-    return undefined;
+    return {};
   }
 
   const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
@@ -34,11 +39,11 @@ export async function fetchBotOpenIdForMonitor(
     abortSignal: options.abortSignal,
   });
   if (result.ok) {
-    return result.botOpenId;
+    return { botOpenId: result.botOpenId, botName: result.botName };
   }
 
   if (options.abortSignal?.aborted || isAbortErrorMessage(result.error)) {
-    return undefined;
+    return {};
   }
 
   if (isTimeoutErrorMessage(result.error)) {
@@ -47,5 +52,13 @@ export async function fetchBotOpenIdForMonitor(
       `feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`,
     );
   }
-  return undefined;
+  return {};
+}
+
+export async function fetchBotOpenIdForMonitor(
+  account: ResolvedFeishuAccount,
+  options: FetchBotOpenIdOptions = {},
+): Promise<string | undefined> {
+  const identity = await fetchBotIdentityForMonitor(account, options);
+  return identity.botOpenId;
 }

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

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import {
+  resolveFeishuWebhookAnomalyDefaultsForTest,
+  resolveFeishuWebhookRateLimitDefaultsForTest,
+} from "./monitor.state.js";
+
+describe("feishu monitor state defaults", () => {
+  it("falls back to hard defaults when sdk defaults are missing", () => {
+    expect(resolveFeishuWebhookRateLimitDefaultsForTest(undefined)).toEqual({
+      windowMs: 60_000,
+      maxRequests: 120,
+      maxTrackedKeys: 4_096,
+    });
+    expect(resolveFeishuWebhookAnomalyDefaultsForTest(undefined)).toEqual({
+      maxTrackedKeys: 4_096,
+      ttlMs: 21_600_000,
+      logEvery: 25,
+    });
+  });
+
+  it("keeps valid sdk values and repairs invalid fields", () => {
+    expect(
+      resolveFeishuWebhookRateLimitDefaultsForTest({
+        windowMs: 45_000,
+        maxRequests: 0,
+        maxTrackedKeys: -1,
+      }),
+    ).toEqual({
+      windowMs: 45_000,
+      maxRequests: 120,
+      maxTrackedKeys: 4_096,
+    });
+
+    expect(
+      resolveFeishuWebhookAnomalyDefaultsForTest({
+        maxTrackedKeys: 2048,
+        ttlMs: Number.NaN,
+        logEvery: 10,
+      }),
+    ).toEqual({
+      maxTrackedKeys: 2048,
+      ttlMs: 21_600_000,
+      logEvery: 10,
+    });
+  });
+});