@kodelyth/feishu 2026.5.42 → 2026.6.2

package/src/monitor.cleanup.test.ts

@@ -1,383 +0,0 @@
-import { afterAll, 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(),
-  };
-}
-
-function firstRuntimeError(runtime: { error: ReturnType<typeof vi.fn> }): string {
-  return String(runtime.error.mock.calls[0]?.[0] ?? "");
-}
-
-function firstWsCallbacks(): { onError?: (err: Error) => void } {
-  const callbacks = createFeishuWSClientMock.mock.calls[0]?.[1];
-  if (!callbacks || typeof callbacks !== "object") {
-    throw new Error("expected Feishu websocket callbacks");
-  }
-  return callbacks as { onError?: (err: Error) => void };
-}
-
-afterEach(() => {
-  vi.useRealTimers();
-  stopFeishuMonitorState();
-  vi.clearAllMocks();
-});
-
-afterAll(() => {
-  vi.doUnmock("./client.js");
-  vi.resetModules();
-});
-
-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).toHaveBeenCalledTimes(1);
-    const errorMessage = firstRuntimeError(runtime);
-    expect(errorMessage).toContain("WebSocket start failed, retrying in 1000ms");
-    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);
-    });
-
-    firstWsCallbacks().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 = firstRuntimeError(runtime);
-    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);
-    });
-
-    firstWsCallbacks().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 = firstRuntimeError(runtime);
-    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);
-    });
-
-    firstWsCallbacks().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 = firstRuntimeError(runtime);
-    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

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