@openclaw/feishu 2026.3.13 → 2026.5.2-beta.1

package/src/event-types.ts

@@ -0,0 +1,45 @@
+export type FeishuMessageEvent = {
+  sender: {
+    sender_id: {
+      open_id?: string;
+      user_id?: string;
+      union_id?: string;
+    };
+    sender_type?: string;
+    tenant_key?: string;
+  };
+  message: {
+    message_id: string;
+    reply_target_message_id?: string;
+    suppress_reply_target?: boolean;
+    root_id?: string;
+    parent_id?: string;
+    thread_id?: string;
+    chat_id: string;
+    chat_type: "p2p" | "group" | "topic_group" | "private";
+    message_type: string;
+    content: string;
+    create_time?: string;
+    mentions?: Array<{
+      key: string;
+      id: {
+        open_id?: string;
+        user_id?: string;
+        union_id?: string;
+      };
+      name: string;
+      tenant_key?: string;
+    }>;
+  };
+};
+
+export type FeishuBotAddedEvent = {
+  chat_id: string;
+  operator_id: {
+    open_id?: string;
+    user_id?: string;
+    union_id?: string;
+  };
+  external: boolean;
+  operator_tenant_key?: string;
+};

package/src/external-keys.ts

@@ -1,4 +1,4 @@
-const CONTROL_CHARS_RE = /[\u0000-\u001f\u007f]/;
+const CONTROL_CHARS_RE = /\p{Cc}/u;
 const MAX_EXTERNAL_KEY_LENGTH = 512;
 
 export function normalizeFeishuExternalKey(value: unknown): string | undefined {

package/src/lifecycle.test-support.ts

@@ -0,0 +1,220 @@
+import { vi, type Mock } from "vitest";
+
+type BoundConversation = {
+  bindingId: string;
+  targetSessionKey: string;
+};
+type UnknownMock = Mock<(...args: unknown[]) => unknown>;
+type AsyncUnknownMock = Mock<(...args: unknown[]) => Promise<unknown>>;
+type FinalizeInboundContextMock = Mock<
+  (ctx: Record<string, unknown>, opts?: unknown) => Record<string, unknown>
+>;
+type DispatchReplyCounts = {
+  final: number;
+  block?: number;
+  tool?: number;
+};
+type DispatchReplyContext = Record<string, unknown> & {
+  SessionKey?: string;
+};
+type DispatchReplyDispatcher = {
+  sendFinalReply: (payload: { text: string }) => unknown;
+};
+type FeishuReplyDispatcherMockValue = {
+  dispatcher: DispatchReplyDispatcher;
+  replyOptions: Record<string, never>;
+  markDispatchIdle: () => unknown;
+};
+type CreateFeishuReplyDispatcherMock = Mock<(params?: unknown) => FeishuReplyDispatcherMockValue>;
+type DispatchReplyFromConfigMock = Mock<
+  (params: {
+    ctx: DispatchReplyContext;
+    dispatcher: DispatchReplyDispatcher;
+  }) => Promise<{ queuedFinal: boolean; counts: DispatchReplyCounts }>
+>;
+type WithReplyDispatcherMock = Mock<
+  (params: {
+    dispatcher?: DispatchReplyDispatcher;
+    onSettled?: () => unknown;
+    run: () => unknown;
+  }) => Promise<unknown>
+>;
+type FeishuLifecycleTestMocks = {
+  createEventDispatcherMock: UnknownMock;
+  monitorWebSocketMock: AsyncUnknownMock;
+  monitorWebhookMock: AsyncUnknownMock;
+  createFeishuThreadBindingManagerMock: UnknownMock;
+  createFeishuReplyDispatcherMock: CreateFeishuReplyDispatcherMock;
+  resolveBoundConversationMock: Mock<(ref?: unknown) => BoundConversation | null>;
+  touchBindingMock: UnknownMock;
+  resolveAgentRouteMock: UnknownMock;
+  resolveConfiguredBindingRouteMock: UnknownMock;
+  ensureConfiguredBindingRouteReadyMock: UnknownMock;
+  dispatchReplyFromConfigMock: DispatchReplyFromConfigMock;
+  withReplyDispatcherMock: WithReplyDispatcherMock;
+  finalizeInboundContextMock: FinalizeInboundContextMock;
+  getMessageFeishuMock: AsyncUnknownMock;
+  listFeishuThreadMessagesMock: AsyncUnknownMock;
+  sendMessageFeishuMock: AsyncUnknownMock;
+  sendCardFeishuMock: AsyncUnknownMock;
+};
+
+const feishuLifecycleTestMocks = vi.hoisted(
+  (): FeishuLifecycleTestMocks => ({
+    createEventDispatcherMock: vi.fn(),
+    monitorWebSocketMock: vi.fn(async () => {}),
+    monitorWebhookMock: vi.fn(async () => {}),
+    createFeishuThreadBindingManagerMock: vi.fn(() => ({ stop: vi.fn() })),
+    createFeishuReplyDispatcherMock: vi.fn(),
+    resolveBoundConversationMock: vi.fn<(ref?: unknown) => BoundConversation | null>(() => null),
+    touchBindingMock: vi.fn(),
+    resolveAgentRouteMock: vi.fn(),
+    resolveConfiguredBindingRouteMock: vi.fn(),
+    ensureConfiguredBindingRouteReadyMock: vi.fn(),
+    dispatchReplyFromConfigMock: vi.fn(),
+    withReplyDispatcherMock: vi.fn(),
+    finalizeInboundContextMock: vi.fn((ctx) => ctx),
+    getMessageFeishuMock: vi.fn(async () => null),
+    listFeishuThreadMessagesMock: vi.fn(async () => []),
+    sendMessageFeishuMock: vi.fn(async () => ({ messageId: "om_sent", chatId: "chat_default" })),
+    sendCardFeishuMock: vi.fn(async () => ({ messageId: "om_card", chatId: "chat_default" })),
+  }),
+);
+
+export function getFeishuLifecycleTestMocks(): FeishuLifecycleTestMocks {
+  return feishuLifecycleTestMocks;
+}
+
+export function resetFeishuLifecycleTestMocks(): void {
+  for (const mock of Object.values(feishuLifecycleTestMocks)) {
+    mock.mockReset();
+  }
+  feishuLifecycleTestMocks.monitorWebSocketMock.mockResolvedValue(undefined);
+  feishuLifecycleTestMocks.monitorWebhookMock.mockResolvedValue(undefined);
+  feishuLifecycleTestMocks.createFeishuThreadBindingManagerMock.mockReturnValue({ stop: vi.fn() });
+  feishuLifecycleTestMocks.resolveBoundConversationMock.mockReturnValue(null);
+  feishuLifecycleTestMocks.finalizeInboundContextMock.mockImplementation((ctx) => ctx);
+  feishuLifecycleTestMocks.getMessageFeishuMock.mockResolvedValue(null);
+  feishuLifecycleTestMocks.listFeishuThreadMessagesMock.mockResolvedValue([]);
+  feishuLifecycleTestMocks.sendMessageFeishuMock.mockResolvedValue({
+    messageId: "om_sent",
+    chatId: "chat_default",
+  });
+  feishuLifecycleTestMocks.sendCardFeishuMock.mockResolvedValue({
+    messageId: "om_card",
+    chatId: "chat_default",
+  });
+}
+
+const {
+  createEventDispatcherMock,
+  monitorWebSocketMock,
+  monitorWebhookMock,
+  createFeishuThreadBindingManagerMock,
+  createFeishuReplyDispatcherMock,
+  resolveBoundConversationMock,
+  touchBindingMock,
+  resolveConfiguredBindingRouteMock,
+  ensureConfiguredBindingRouteReadyMock,
+  getMessageFeishuMock,
+  listFeishuThreadMessagesMock,
+  sendMessageFeishuMock,
+  sendCardFeishuMock,
+} = feishuLifecycleTestMocks;
+
+vi.mock("./client.js", () => {
+  return {
+    FEISHU_HTTP_TIMEOUT_ENV_VAR: "OPENCLAW_FEISHU_HTTP_TIMEOUT_MS",
+    FEISHU_HTTP_TIMEOUT_MAX_MS: 300_000,
+    FEISHU_HTTP_TIMEOUT_MS: 30_000,
+    FEISHU_USER_AGENT: "openclaw-feishu-test",
+    clearClientCache: vi.fn(),
+    createFeishuClient: vi.fn(() => {
+      throw new Error("unexpected Feishu client call in lifecycle test");
+    }),
+    createFeishuWSClient: vi.fn(async () => ({
+      close: vi.fn(),
+      start: vi.fn(),
+    })),
+    createEventDispatcher: createEventDispatcherMock,
+    getFeishuClient: vi.fn(() => null),
+    getFeishuUserAgent: vi.fn(() => "openclaw-feishu-test"),
+    pluginVersion: "test",
+    setFeishuClientRuntimeForTest: vi.fn(),
+  };
+});
+
+vi.mock("./monitor.transport.js", () => ({
+  monitorWebSocket: monitorWebSocketMock,
+  monitorWebhook: monitorWebhookMock,
+}));
+
+vi.mock("./thread-bindings.js", () => ({
+  createFeishuThreadBindingManager: createFeishuThreadBindingManagerMock,
+}));
+
+vi.mock("./reply-dispatcher.js", () => ({
+  createFeishuReplyDispatcher: createFeishuReplyDispatcherMock,
+}));
+
+vi.mock("./send.js", () => ({
+  sendCardFeishu: sendCardFeishuMock,
+  getMessageFeishu: getMessageFeishuMock,
+  listFeishuThreadMessages: listFeishuThreadMessagesMock,
+  sendMessageFeishu: sendMessageFeishuMock,
+}));
+
+vi.mock("openclaw/plugin-sdk/conversation-runtime", async () => {
+  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/conversation-runtime")>(
+    "openclaw/plugin-sdk/conversation-runtime",
+  );
+  return {
+    ...actual,
+    resolveConfiguredBindingRoute: (
+      params: Parameters<typeof actual.resolveConfiguredBindingRoute>[0],
+    ) =>
+      resolveConfiguredBindingRouteMock.getMockImplementation()
+        ? resolveConfiguredBindingRouteMock(params)
+        : actual.resolveConfiguredBindingRoute(params),
+    resolveRuntimeConversationBindingRoute: (
+      params: Parameters<typeof actual.resolveRuntimeConversationBindingRoute>[0],
+    ) => {
+      const conversation =
+        "conversation" in params
+          ? params.conversation
+          : {
+              channel: params.channel,
+              accountId: params.accountId,
+              conversationId: params.conversationId,
+              parentConversationId: params.parentConversationId,
+            };
+      const bindingRecord = resolveBoundConversationMock(conversation);
+      const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
+      if (!bindingRecord || !boundSessionKey) {
+        return { bindingRecord: null, route: params.route };
+      }
+      touchBindingMock(bindingRecord.bindingId);
+      return {
+        bindingRecord,
+        boundSessionKey,
+        boundAgentId: params.route.agentId,
+        route: {
+          ...params.route,
+          sessionKey: boundSessionKey,
+          lastRoutePolicy: boundSessionKey === params.route.mainSessionKey ? "main" : "session",
+          matchedBy: "binding.channel",
+        },
+      };
+    },
+    ensureConfiguredBindingRouteReady: (
+      params: Parameters<typeof actual.ensureConfiguredBindingRouteReady>[0],
+    ) =>
+      ensureConfiguredBindingRouteReadyMock.getMockImplementation()
+        ? ensureConfiguredBindingRouteReadyMock(params)
+        : actual.ensureConfiguredBindingRouteReady(params),
+    getSessionBindingService: () => ({
+      resolveByConversation: resolveBoundConversationMock,
+      touch: touchBindingMock,
+    }),
+  };
+});