@kodelyth/feishu 2026.5.39 → 2026.5.42

package/src/monitor.bot-menu.test.ts

@@ -0,0 +1,188 @@
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClawdbotConfig } from "../runtime-api.js";
+import { expectFirstSentCardUsesFillWidthOnly } from "./card-test-helpers.js";
+import { createFeishuBotMenuHandler } from "./monitor.bot-menu-handler.js";
+
+const handleFeishuMessageMock = vi.hoisted(() => vi.fn(async (_params?: unknown) => {}));
+const parseFeishuMessageEventMock = vi.hoisted(() => vi.fn());
+const sendCardFeishuMock = vi.hoisted(() =>
+  vi.fn(async (_params?: unknown) => ({ messageId: "m1", chatId: "c1" })),
+);
+const getMessageFeishuMock = vi.hoisted(() => vi.fn());
+
+const originalStateDir = process.env.KLAW_STATE_DIR;
+
+vi.mock("./bot.js", () => {
+  return {
+    handleFeishuMessage: handleFeishuMessageMock,
+    parseFeishuMessageEvent: parseFeishuMessageEventMock,
+  };
+});
+
+vi.mock("./send.js", () => {
+  return {
+    sendCardFeishu: sendCardFeishuMock,
+    getMessageFeishu: getMessageFeishuMock,
+  };
+});
+
+function createBotMenuEvent(params: { eventKey: string; timestamp: string }) {
+  return {
+    event_key: params.eventKey,
+    timestamp: params.timestamp,
+    operator: {
+      operator_id: {
+        open_id: "ou_user1",
+        user_id: "user_1",
+        union_id: "union_1",
+      },
+    },
+  };
+}
+
+async function registerHandlers() {
+  return createFeishuBotMenuHandler({
+    cfg: {} as ClawdbotConfig,
+    accountId: "default",
+    runtime: {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    },
+    chatHistories: new Map(),
+    fireAndForget: true,
+    getBotOpenId: () => "ou_bot",
+    getBotName: () => "Bot",
+  });
+}
+
+function firstMockArg(mock: { mock: { calls: Array<readonly unknown[]> } }, label: string) {
+  const call = mock.mock.calls[0];
+  if (!call) {
+    throw new Error(`expected ${label} call`);
+  }
+  return call[0];
+}
+
+describe("Feishu bot menu handler", () => {
+  afterAll(() => {
+    vi.doUnmock("./bot.js");
+    vi.doUnmock("./send.js");
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.KLAW_STATE_DIR = `/tmp/klaw-feishu-bot-menu-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  });
+
+  afterEach(() => {
+    if (originalStateDir === undefined) {
+      delete process.env.KLAW_STATE_DIR;
+      return;
+    }
+    process.env.KLAW_STATE_DIR = originalStateDir;
+  });
+
+  it("opens the quick-action launcher card at the webhook/event layer", async () => {
+    const onBotMenu = await registerHandlers();
+
+    await onBotMenu(createBotMenuEvent({ eventKey: "quick-actions", timestamp: "1700000000000" }));
+
+    expect(sendCardFeishuMock).toHaveBeenCalledTimes(1);
+    const sendArgs = firstMockArg(sendCardFeishuMock, "Feishu card send") as
+      | {
+          accountId?: string;
+          card?: {
+            config?: { width_mode?: string };
+            header?: { title?: { content?: string } };
+          };
+          to?: string;
+        }
+      | undefined;
+    expect(sendArgs?.to).toBe("user:ou_user1");
+    expect(sendArgs?.accountId).toBe("default");
+    expect(sendArgs?.card?.config?.width_mode).toBe("fill");
+    expect(sendArgs?.card?.header?.title?.content).toBe("Quick actions");
+    expect(handleFeishuMessageMock).not.toHaveBeenCalled();
+  });
+
+  it("does not block bot-menu handling on quick-action launcher send", async () => {
+    const onBotMenu = await registerHandlers();
+    let resolveSend: (() => void) | undefined;
+    sendCardFeishuMock.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveSend = () => resolve({ messageId: "m1", chatId: "c1" });
+        }),
+    );
+
+    const pending = onBotMenu(
+      createBotMenuEvent({ eventKey: "quick-actions", timestamp: "1700000000001" }),
+    );
+    let settled = false;
+    void pending.finally(() => {
+      settled = true;
+    });
+
+    await vi.waitFor(() => {
+      expect(settled).toBe(true);
+    });
+
+    resolveSend?.();
+    await pending;
+  });
+
+  it("falls back to the legacy /menu synthetic message path for unrelated bot menu keys", async () => {
+    const onBotMenu = await registerHandlers();
+
+    await onBotMenu(createBotMenuEvent({ eventKey: "custom-key", timestamp: "1700000000002" }));
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const handleArgs = firstMockArg(handleFeishuMessageMock, "Feishu synthetic message") as
+      | { event?: { message?: { content?: string } } }
+      | undefined;
+    expect(handleArgs?.event?.message?.content).toBe('{"text":"/menu custom-key"}');
+    expect(sendCardFeishuMock).not.toHaveBeenCalled();
+  });
+
+  it("falls back to the legacy /menu path when launcher rendering fails", async () => {
+    const onBotMenu = await registerHandlers();
+    sendCardFeishuMock.mockRejectedValueOnce(new Error("boom"));
+
+    await onBotMenu(createBotMenuEvent({ eventKey: "quick-actions", timestamp: "1700000000003" }));
+
+    await vi.waitFor(() => {
+      expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    });
+    const handleArgs = firstMockArg(handleFeishuMessageMock, "Feishu fallback message") as
+      | { event?: { message?: { content?: string } } }
+      | undefined;
+    expect(handleArgs?.event?.message?.content).toBe('{"text":"/menu quick-actions"}');
+    expectFirstSentCardUsesFillWidthOnly(sendCardFeishuMock);
+  });
+
+  it("reopens replay for explicit retryable fallback failures", async () => {
+    const onBotMenu = await registerHandlers();
+    sendCardFeishuMock
+      .mockImplementationOnce(async () => {
+        throw new Error("boom");
+      })
+      .mockImplementationOnce(async () => {
+        throw new Error("boom");
+      });
+    handleFeishuMessageMock
+      .mockRejectedValueOnce(
+        Object.assign(new Error("retry me"), {
+          name: "FeishuRetryableSyntheticEventError",
+        }),
+      )
+      .mockResolvedValueOnce(undefined);
+
+    await onBotMenu(createBotMenuEvent({ eventKey: "quick-actions", timestamp: "1700000000004" }));
+    await onBotMenu(createBotMenuEvent({ eventKey: "quick-actions", timestamp: "1700000000004" }));
+
+    expect(sendCardFeishuMock).toHaveBeenCalledTimes(2);
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/monitor.broadcast.reply-once.lifecycle.test-support.ts

@@ -0,0 +1,264 @@
+import "./lifecycle.test-support.js";
+import { createNonExitingRuntimeEnv } from "klaw/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
+import { FeishuConfigSchema } from "./config-schema.js";
+import {
+  getFeishuLifecycleTestMocks,
+  resetFeishuLifecycleTestMocks,
+} from "./lifecycle.test-support.js";
+import {
+  createFeishuTextMessageEvent,
+  createFeishuLifecycleReplyDispatcher,
+  installFeishuLifecycleReplyRuntime,
+  mockFeishuReplyOnceDispatch,
+  restoreFeishuLifecycleStateDir,
+  runFeishuLifecycleSequence,
+  setFeishuLifecycleStateDir,
+  setupFeishuLifecycleHandler,
+} from "./test-support/lifecycle-test-support.js";
+import type { FeishuConfig, ResolvedFeishuAccount } from "./types.js";
+
+const {
+  createEventDispatcherMock,
+  createFeishuReplyDispatcherMock,
+  dispatchReplyFromConfigMock,
+  finalizeInboundContextMock,
+  resolveAgentRouteMock,
+  resolveBoundConversationMock,
+  withReplyDispatcherMock,
+} = getFeishuLifecycleTestMocks();
+
+let handlersByAccount = new Map<string, Record<string, (data: unknown) => Promise<void>>>();
+let runtimesByAccount = new Map<string, RuntimeEnv>();
+const originalStateDir = process.env.KLAW_STATE_DIR;
+
+function createLifecycleConfig(): ClawdbotConfig {
+  return {
+    broadcast: {
+      oc_broadcast_group: ["susan", "main"],
+    },
+    agents: {
+      list: [{ id: "main" }, { id: "susan" }],
+    },
+    channels: {
+      feishu: {
+        enabled: true,
+        groupPolicy: "open",
+        requireMention: false,
+        resolveSenderNames: false,
+        accounts: {
+          "account-A": {
+            enabled: true,
+            appId: "cli_a",
+            appSecret: "secret_a", // pragma: allowlist secret
+            connectionMode: "websocket",
+            groupPolicy: "open",
+            requireMention: false,
+            resolveSenderNames: false,
+            groups: {
+              oc_broadcast_group: {
+                requireMention: false,
+              },
+            },
+          },
+          "account-B": {
+            enabled: true,
+            appId: "cli_b",
+            appSecret: "secret_b", // pragma: allowlist secret
+            connectionMode: "websocket",
+            groupPolicy: "open",
+            requireMention: false,
+            resolveSenderNames: false,
+            groups: {
+              oc_broadcast_group: {
+                requireMention: false,
+              },
+            },
+          },
+        },
+      },
+    },
+    messages: {
+      inbound: {
+        debounceMs: 0,
+        byChannel: {
+          feishu: 0,
+        },
+      },
+    },
+  } as ClawdbotConfig;
+}
+
+function createLifecycleAccount(accountId: "account-A" | "account-B"): ResolvedFeishuAccount {
+  const config: FeishuConfig = FeishuConfigSchema.parse({
+    enabled: true,
+    connectionMode: "websocket",
+    groupPolicy: "open",
+    requireMention: false,
+    resolveSenderNames: false,
+    groups: {
+      oc_broadcast_group: {
+        requireMention: false,
+      },
+    },
+  });
+  return {
+    accountId,
+    selectionSource: "explicit",
+    enabled: true,
+    configured: true,
+    appId: accountId === "account-A" ? "cli_a" : "cli_b",
+    appSecret: accountId === "account-A" ? "secret_a" : "secret_b", // pragma: allowlist secret
+    domain: "feishu",
+    config,
+  };
+}
+
+async function setupLifecycleMonitor(accountId: "account-A" | "account-B") {
+  const runtime = createNonExitingRuntimeEnv();
+  runtimesByAccount.set(accountId, runtime);
+  return setupFeishuLifecycleHandler({
+    createEventDispatcherMock,
+    onRegister: (registered) => {
+      handlersByAccount.set(accountId, registered);
+    },
+    runtime,
+    cfg: createLifecycleConfig(),
+    account: createLifecycleAccount(accountId),
+    handlerKey: "im.message.receive_v1",
+    missingHandlerMessage: `missing im.message.receive_v1 handler for ${accountId}`,
+    once: true,
+  });
+}
+
+describe("Feishu broadcast reply-once lifecycle", () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+    resetFeishuLifecycleTestMocks();
+    handlersByAccount = new Map();
+    runtimesByAccount = new Map();
+    setFeishuLifecycleStateDir("klaw-feishu-broadcast");
+
+    createFeishuReplyDispatcherMock.mockReturnValue(createFeishuLifecycleReplyDispatcher());
+
+    resolveBoundConversationMock.mockReturnValue(null);
+    resolveAgentRouteMock.mockReturnValue({
+      agentId: "main",
+      channel: "feishu",
+      accountId: "account-A",
+      sessionKey: "agent:main:feishu:group:oc_broadcast_group",
+      mainSessionKey: "agent:main:main",
+      matchedBy: "default",
+    });
+
+    mockFeishuReplyOnceDispatch({
+      dispatchReplyFromConfigMock,
+      replyText: "broadcast reply once",
+      shouldSendFinalReply: (ctx) =>
+        typeof (ctx as { SessionKey?: string } | undefined)?.SessionKey === "string" &&
+        (ctx as { SessionKey: string }).SessionKey.includes("agent:main:"),
+    });
+
+    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
+
+    installFeishuLifecycleReplyRuntime({
+      resolveAgentRouteMock,
+      finalizeInboundContextMock,
+      dispatchReplyFromConfigMock,
+      withReplyDispatcherMock,
+      storePath: "/tmp/feishu-broadcast-sessions.json",
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    restoreFeishuLifecycleStateDir(originalStateDir);
+  });
+
+  it("uses one active reply path when the same broadcast event reaches two accounts", async () => {
+    const onMessageA = await setupLifecycleMonitor("account-A");
+    const onMessageB = await setupLifecycleMonitor("account-B");
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_broadcast_once",
+      chatId: "oc_broadcast_group",
+      text: "hello broadcast",
+    });
+
+    await runFeishuLifecycleSequence(
+      [() => onMessageA(event), () => onMessageB(event)],
+      [
+        () => {
+          expect(dispatchReplyFromConfigMock.mock.calls.length).toBeGreaterThan(0);
+        },
+        () => {
+          expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+          expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+        },
+      ],
+    );
+
+    expect(runtimesByAccount.get("account-A")?.error).not.toHaveBeenCalled();
+    expect(runtimesByAccount.get("account-B")?.error).not.toHaveBeenCalled();
+
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "account-a",
+        chatId: "oc_broadcast_group",
+        replyToMessageId: "om_broadcast_once",
+      }),
+    );
+
+    const sessionKeys = finalizeInboundContextMock.mock.calls.map(
+      (call) => (call[0] as { SessionKey?: string }).SessionKey,
+    );
+    expect(sessionKeys).toContain("agent:main:feishu:group:oc_broadcast_group");
+    expect(sessionKeys).toContain("agent:susan:feishu:group:oc_broadcast_group");
+
+    const activeDispatcher = createFeishuReplyDispatcherMock.mock.results[0]?.value.dispatcher as {
+      sendFinalReply: ReturnType<typeof vi.fn>;
+    };
+    expect(activeDispatcher.sendFinalReply).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not duplicate delivery after a post-send failure on the first account", async () => {
+    const onMessageA = await setupLifecycleMonitor("account-A");
+    const onMessageB = await setupLifecycleMonitor("account-B");
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_broadcast_retry",
+      chatId: "oc_broadcast_group",
+      text: "hello broadcast",
+    });
+
+    dispatchReplyFromConfigMock.mockImplementationOnce(async ({ ctx, dispatcher }) => {
+      if (typeof ctx?.SessionKey === "string" && ctx.SessionKey.includes("agent:susan:")) {
+        return { queuedFinal: false, counts: { final: 0 } };
+      }
+      await dispatcher.sendFinalReply({ text: "broadcast reply once" });
+      throw new Error("post-send failure");
+    });
+
+    await runFeishuLifecycleSequence(
+      [() => onMessageA(event), () => onMessageB(event)],
+      [
+        () => {
+          expect(dispatchReplyFromConfigMock.mock.calls.length).toBeGreaterThan(0);
+        },
+        () => {
+          expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+        },
+      ],
+    );
+
+    expect(runtimesByAccount.get("account-A")?.error).not.toHaveBeenCalled();
+    expect(runtimesByAccount.get("account-B")?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+
+    const activeDispatcher = createFeishuReplyDispatcherMock.mock.results[0]?.value.dispatcher as {
+      sendFinalReply: ReturnType<typeof vi.fn>;
+    };
+    expect(activeDispatcher.sendFinalReply).toHaveBeenCalledTimes(1);
+  });
+});