@kodelyth/feishu 2026.5.42 → 2026.6.1

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

@@ -1,188 +0,0 @@
-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

@@ -1,264 +0,0 @@
-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);
-  });
-});