@openclaw/feishu 2026.3.12 → 2026.5.1-beta.1

package/src/monitor.cleanup.test.ts

@@ -0,0 +1,376 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { botNames, botOpenIds, stopFeishuMonitorState, wsClients } from "./monitor.state.js";
+import type { ResolvedFeishuAccount } from "./types.js";
+
+const createFeishuWSClientMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./client.js", () => ({
+  createFeishuWSClient: createFeishuWSClientMock,
+}));
+
+import { monitorWebSocket } from "./monitor.transport.js";
+
+type MockWsClient = {
+  start: ReturnType<typeof vi.fn>;
+  close: ReturnType<typeof vi.fn>;
+};
+
+function createAccount(accountId: string): ResolvedFeishuAccount {
+  return {
+    accountId,
+    enabled: true,
+    configured: true,
+    appId: `cli_${accountId}`,
+    appSecret: `secret_${accountId}`, // pragma: allowlist secret
+    domain: "feishu",
+    config: {
+      enabled: true,
+      connectionMode: "websocket",
+    },
+  } as ResolvedFeishuAccount;
+}
+
+function createWsClient(): MockWsClient {
+  return {
+    start: vi.fn(),
+    close: vi.fn(),
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  stopFeishuMonitorState();
+  vi.clearAllMocks();
+});
+
+describe("feishu websocket cleanup", () => {
+  it("closes the websocket client when the monitor aborts", async () => {
+    const wsClient = createWsClient();
+    createFeishuWSClientMock.mockReturnValue(wsClient);
+
+    const abortController = new AbortController();
+    const accountId = "alpha";
+
+    botOpenIds.set(accountId, "ou_alpha");
+    botNames.set(accountId, "Alpha");
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount(accountId),
+      accountId,
+      runtime: {
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+      },
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(wsClient.start).toHaveBeenCalledTimes(1);
+      expect(wsClients.get(accountId)).toBe(wsClient);
+    });
+
+    abortController.abort();
+    await monitorPromise;
+
+    expect(wsClient.close).toHaveBeenCalledTimes(1);
+    expect(wsClients.has(accountId)).toBe(false);
+    expect(botOpenIds.has(accountId)).toBe(false);
+    expect(botNames.has(accountId)).toBe(false);
+  });
+
+  it("retries with backoff after websocket start rejects", async () => {
+    vi.useFakeTimers();
+    const failedClient = createWsClient();
+    failedClient.start.mockRejectedValueOnce(
+      new Error("connect failed\nAuthorization: Bearer token_abc appSecret=secret_abc"),
+    );
+    const recoveredClient = createWsClient();
+    createFeishuWSClientMock
+      .mockResolvedValueOnce(failedClient)
+      .mockResolvedValueOnce(recoveredClient);
+
+    const abortController = new AbortController();
+    const runtime = {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    };
+    const accountId = "retry";
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount(accountId),
+      accountId,
+      runtime,
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(failedClient.start).toHaveBeenCalledTimes(1);
+      expect(failedClient.close).toHaveBeenCalledTimes(1);
+      expect(wsClients.has(accountId)).toBe(false);
+    });
+
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    await vi.waitFor(() => {
+      expect(recoveredClient.start).toHaveBeenCalledTimes(1);
+      expect(wsClients.get(accountId)).toBe(recoveredClient);
+    });
+
+    abortController.abort();
+    await monitorPromise;
+
+    expect(createFeishuWSClientMock).toHaveBeenCalledTimes(2);
+    expect(recoveredClient.close).toHaveBeenCalledTimes(1);
+    expect(runtime.error).toHaveBeenCalledWith(
+      expect.stringContaining("WebSocket start failed, retrying in 1000ms"),
+    );
+    const errorMessage = String(runtime.error.mock.calls[0]?.[0] ?? "");
+    expect(errorMessage).not.toContain("\n");
+    expect(errorMessage).not.toContain("token_abc");
+    expect(errorMessage).not.toContain("secret_abc");
+    expect(errorMessage).toContain("Authorization: Bearer [redacted]");
+    expect(errorMessage).toContain("appSecret=[redacted]");
+  });
+
+  it("recreates the websocket client after sdk reconnect exhaustion", async () => {
+    vi.useFakeTimers();
+    const exhaustedClient = createWsClient();
+    const recoveredClient = createWsClient();
+    createFeishuWSClientMock
+      .mockResolvedValueOnce(exhaustedClient)
+      .mockResolvedValueOnce(recoveredClient);
+
+    const abortController = new AbortController();
+    const runtime = {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    };
+    const accountId = "exhausted";
+    botOpenIds.set(accountId, "ou_exhausted");
+    botNames.set(accountId, "Exhausted");
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount(accountId),
+      accountId,
+      runtime,
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(exhaustedClient.start).toHaveBeenCalledTimes(1);
+      expect(wsClients.get(accountId)).toBe(exhaustedClient);
+    });
+
+    const callbacks = createFeishuWSClientMock.mock.calls[0]?.[1] as
+      | { onError?: (err: Error) => void }
+      | undefined;
+    callbacks?.onError?.(
+      new Error("WebSocket reconnect exhausted after 3 attempts\nBearer token_abc"),
+    );
+
+    await vi.waitFor(() => {
+      expect(exhaustedClient.close).toHaveBeenCalledTimes(1);
+      expect(wsClients.has(accountId)).toBe(false);
+    });
+    expect(botOpenIds.get(accountId)).toBe("ou_exhausted");
+    expect(botNames.get(accountId)).toBe("Exhausted");
+
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    await vi.waitFor(() => {
+      expect(recoveredClient.start).toHaveBeenCalledTimes(1);
+      expect(wsClients.get(accountId)).toBe(recoveredClient);
+    });
+
+    abortController.abort();
+    await monitorPromise;
+
+    expect(createFeishuWSClientMock).toHaveBeenCalledTimes(2);
+    expect(recoveredClient.close).toHaveBeenCalledTimes(1);
+    expect(botOpenIds.has(accountId)).toBe(false);
+    expect(botNames.has(accountId)).toBe(false);
+    const errorMessage = String(runtime.error.mock.calls[0]?.[0] ?? "");
+    expect(errorMessage).toContain("WebSocket connection ended, recreating client in 1000ms");
+    expect(errorMessage).toContain("Bearer [redacted]");
+    expect(errorMessage).not.toContain("\n");
+    expect(errorMessage).not.toContain("token_abc");
+  });
+
+  it("keeps the websocket client alive after recoverable sdk callback errors", async () => {
+    vi.useFakeTimers();
+    const wsClient = createWsClient();
+    createFeishuWSClientMock.mockResolvedValueOnce(wsClient);
+
+    const abortController = new AbortController();
+    const runtime = {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    };
+    const accountId = "recoverable-callback";
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount(accountId),
+      accountId,
+      runtime,
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(wsClient.start).toHaveBeenCalledTimes(1);
+      expect(wsClients.get(accountId)).toBe(wsClient);
+    });
+
+    const callbacks = createFeishuWSClientMock.mock.calls[0]?.[1] as
+      | { onError?: (err: Error) => void }
+      | undefined;
+    callbacks?.onError?.(new Error("temporary callback failure\nBearer token_abc"));
+
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    expect(createFeishuWSClientMock).toHaveBeenCalledTimes(1);
+    expect(wsClient.close).not.toHaveBeenCalled();
+    expect(wsClients.get(accountId)).toBe(wsClient);
+    const errorMessage = String(runtime.error.mock.calls[0]?.[0] ?? "");
+    expect(errorMessage).toContain("WebSocket SDK reported recoverable error");
+    expect(errorMessage).toContain("Bearer [redacted]");
+    expect(errorMessage).not.toContain("\n");
+    expect(errorMessage).not.toContain("token_abc");
+
+    abortController.abort();
+    await monitorPromise;
+
+    expect(createFeishuWSClientMock).toHaveBeenCalledTimes(1);
+    expect(wsClient.close).toHaveBeenCalledTimes(1);
+  });
+
+  it("clears identity without recreating a websocket when aborted during reconnect backoff", async () => {
+    vi.useFakeTimers();
+    const exhaustedClient = createWsClient();
+    createFeishuWSClientMock.mockResolvedValueOnce(exhaustedClient);
+
+    const abortController = new AbortController();
+    const accountId = "abort-backoff";
+    botOpenIds.set(accountId, "ou_abort");
+    botNames.set(accountId, "Abort");
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount(accountId),
+      accountId,
+      runtime: {
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+      },
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(exhaustedClient.start).toHaveBeenCalledTimes(1);
+    });
+
+    const callbacks = createFeishuWSClientMock.mock.calls[0]?.[1] as
+      | { onError?: (err: Error) => void }
+      | undefined;
+    callbacks?.onError?.(new Error("WebSocket reconnect exhausted after 3 attempts"));
+
+    await vi.waitFor(() => {
+      expect(exhaustedClient.close).toHaveBeenCalledTimes(1);
+    });
+
+    abortController.abort();
+    await monitorPromise;
+
+    expect(createFeishuWSClientMock).toHaveBeenCalledTimes(1);
+    expect(wsClients.has(accountId)).toBe(false);
+    expect(botOpenIds.has(accountId)).toBe(false);
+    expect(botNames.has(accountId)).toBe(false);
+  });
+
+  it("redacts websocket close errors during abort cleanup", async () => {
+    const wsClient = createWsClient();
+    wsClient.close.mockImplementationOnce(() => {
+      throw new Error("close failed\naccess_token=secret_token");
+    });
+    createFeishuWSClientMock.mockReturnValue(wsClient);
+
+    const abortController = new AbortController();
+    const runtime = {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+    };
+
+    const monitorPromise = monitorWebSocket({
+      account: createAccount("close-error"),
+      accountId: "close-error",
+      runtime,
+      abortSignal: abortController.signal,
+      eventDispatcher: {} as never,
+    });
+
+    await vi.waitFor(() => {
+      expect(wsClient.start).toHaveBeenCalledTimes(1);
+    });
+
+    abortController.abort();
+    await monitorPromise;
+
+    const errorMessage = String(runtime.error.mock.calls[0]?.[0] ?? "");
+    expect(errorMessage).toContain("error closing WebSocket client");
+    expect(errorMessage).toContain("access_token=[redacted]");
+    expect(errorMessage).not.toContain("\n");
+    expect(errorMessage).not.toContain("secret_token");
+  });
+
+  it("closes targeted websocket clients during stop cleanup", () => {
+    const alphaClient = createWsClient();
+    const betaClient = createWsClient();
+
+    wsClients.set("alpha", alphaClient as never);
+    wsClients.set("beta", betaClient as never);
+    botOpenIds.set("alpha", "ou_alpha");
+    botOpenIds.set("beta", "ou_beta");
+    botNames.set("alpha", "Alpha");
+    botNames.set("beta", "Beta");
+
+    stopFeishuMonitorState("alpha");
+
+    expect(alphaClient.close).toHaveBeenCalledTimes(1);
+    expect(betaClient.close).not.toHaveBeenCalled();
+    expect(wsClients.has("alpha")).toBe(false);
+    expect(wsClients.has("beta")).toBe(true);
+    expect(botOpenIds.has("alpha")).toBe(false);
+    expect(botOpenIds.has("beta")).toBe(true);
+    expect(botNames.has("alpha")).toBe(false);
+    expect(botNames.has("beta")).toBe(true);
+  });
+
+  it("closes all websocket clients during global stop cleanup", () => {
+    const alphaClient = createWsClient();
+    const betaClient = createWsClient();
+
+    wsClients.set("alpha", alphaClient as never);
+    wsClients.set("beta", betaClient as never);
+    botOpenIds.set("alpha", "ou_alpha");
+    botOpenIds.set("beta", "ou_beta");
+    botNames.set("alpha", "Alpha");
+    botNames.set("beta", "Beta");
+
+    stopFeishuMonitorState();
+
+    expect(alphaClient.close).toHaveBeenCalledTimes(1);
+    expect(betaClient.close).toHaveBeenCalledTimes(1);
+    expect(wsClients.size).toBe(0);
+    expect(botOpenIds.size).toBe(0);
+    expect(botNames.size).toBe(0);
+  });
+});

package/src/monitor.comment-notice-handler.ts

@@ -0,0 +1,105 @@
+import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
+import { handleFeishuCommentEvent } from "./comment-handler.js";
+import {
+  claimUnprocessedFeishuMessage,
+  recordProcessedFeishuMessage,
+  releaseFeishuMessageProcessing,
+} from "./dedup.js";
+import { parseFeishuDriveCommentNoticeEventPayload } from "./monitor.comment.js";
+import { botOpenIds } from "./monitor.state.js";
+import { isFeishuRetryableSyntheticEventError } from "./monitor.synthetic-error.js";
+import { createSequentialQueue } from "./sequential-queue.js";
+
+function buildCommentNoticeQueueKey(event: {
+  notice_meta?: {
+    file_type?: string;
+    file_token?: string;
+  };
+}): string {
+  const fileType = event.notice_meta?.file_type?.trim() || "unknown";
+  const fileToken = event.notice_meta?.file_token?.trim() || "unknown";
+  return `comment-doc:${fileType}:${fileToken}`;
+}
+
+export function createFeishuDriveCommentNoticeHandler(params: {
+  cfg: ClawdbotConfig;
+  accountId: string;
+  runtime?: RuntimeEnv;
+  fireAndForget?: boolean;
+  getBotOpenId?: (accountId: string) => string | undefined;
+}): (data: unknown) => Promise<void> {
+  const { cfg, accountId, runtime, fireAndForget } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+  const enqueue = createSequentialQueue();
+  const getBotOpenId = params.getBotOpenId ?? ((id) => botOpenIds.get(id));
+
+  const runFeishuHandler = async (task: () => Promise<void>) => {
+    const promise = task().catch((err) => {
+      error(`feishu[${accountId}]: error handling drive comment notice: ${String(err)}`);
+    });
+    if (!fireAndForget) {
+      await promise;
+    }
+  };
+
+  return async (data: unknown) => {
+    await runFeishuHandler(async () => {
+      const event = parseFeishuDriveCommentNoticeEventPayload(data);
+      if (!event) {
+        error(`feishu[${accountId}]: ignoring malformed drive comment notice payload`);
+        return;
+      }
+      const eventId = event.event_id?.trim();
+      const syntheticMessageId = eventId ? `drive-comment:${eventId}` : undefined;
+      if (syntheticMessageId) {
+        const claim = await claimUnprocessedFeishuMessage({
+          messageId: syntheticMessageId,
+          namespace: accountId,
+          log,
+        });
+        if (claim === "duplicate") {
+          log(`feishu[${accountId}]: dropping duplicate comment event ${syntheticMessageId}`);
+          return;
+        }
+        if (claim === "inflight") {
+          log(`feishu[${accountId}]: dropping in-flight comment event ${syntheticMessageId}`);
+          return;
+        }
+      }
+      log(
+        `feishu[${accountId}]: received drive comment notice ` +
+          `event=${event.event_id ?? "unknown"} ` +
+          `type=${event.notice_meta?.notice_type ?? "unknown"} ` +
+          `file=${event.notice_meta?.file_type ?? "unknown"}:${event.notice_meta?.file_token ?? "unknown"} ` +
+          `comment=${event.comment_id ?? "unknown"} ` +
+          `reply=${event.reply_id ?? "none"} ` +
+          `from=${event.notice_meta?.from_user_id?.open_id ?? "unknown"} ` +
+          `mentioned=${event.is_mentioned === true ? "yes" : "no"}`,
+      );
+      try {
+        await enqueue(buildCommentNoticeQueueKey(event), async () => {
+          await handleFeishuCommentEvent({
+            cfg,
+            accountId,
+            event,
+            botOpenId: getBotOpenId(accountId),
+            runtime,
+          });
+        });
+        if (syntheticMessageId) {
+          await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+        }
+      } catch (err) {
+        if (syntheticMessageId && !isFeishuRetryableSyntheticEventError(err)) {
+          await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+        }
+        throw err;
+      } finally {
+        if (syntheticMessageId) {
+          releaseFeishuMessageProcessing(syntheticMessageId, accountId);
+        }
+      }
+    });
+  };
+}