@kodelyth/feishu 2026.5.42 → 2026.6.1

package/src/monitor.startup.test.ts

@@ -1,213 +0,0 @@
-import { createNonExitingRuntimeEnv } from "klaw/plugin-sdk/plugin-test-runtime";
-import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
-import type { ClawdbotConfig } from "../runtime-api.js";
-import { monitorFeishuProvider, stopFeishuMonitor } from "./monitor.js";
-
-const probeFeishuMock = vi.hoisted(() => vi.fn());
-
-vi.mock("./probe.js", () => ({
-  probeFeishu: probeFeishuMock,
-}));
-
-vi.mock("./client.js", async () => {
-  const { createFeishuClientMockModule } = await import("./monitor.test-mocks.js");
-  return createFeishuClientMockModule();
-});
-vi.mock("./runtime.js", async () => {
-  const { createFeishuRuntimeMockModule } = await import("./monitor.test-mocks.js");
-  return createFeishuRuntimeMockModule();
-});
-
-function buildMultiAccountWebsocketConfig(accountIds: string[]): ClawdbotConfig {
-  return {
-    channels: {
-      feishu: {
-        enabled: true,
-        accounts: Object.fromEntries(
-          accountIds.map((accountId) => [
-            accountId,
-            {
-              enabled: true,
-              appId: `cli_${accountId}`,
-              appSecret: `secret_${accountId}`, // pragma: allowlist secret
-              connectionMode: "websocket",
-            },
-          ]),
-        ),
-      },
-    },
-  } as ClawdbotConfig;
-}
-
-async function waitForStartedAccount(started: string[], accountId: string) {
-  await vi.waitFor(
-    () => {
-      expect(started).toContain(accountId);
-    },
-    { timeout: 10_000 },
-  );
-}
-
-afterEach(() => {
-  stopFeishuMonitor();
-});
-
-afterAll(() => {
-  vi.doUnmock("./probe.js");
-  vi.doUnmock("./client.js");
-  vi.doUnmock("./runtime.js");
-  vi.resetModules();
-});
-
-describe("Feishu monitor startup preflight", () => {
-  it("starts account probes sequentially to avoid startup bursts", async () => {
-    let inFlight = 0;
-    let maxInFlight = 0;
-    const started: string[] = [];
-    let releaseProbes: (() => void) | undefined;
-    const probesReleased = new Promise<void>((resolve) => {
-      releaseProbes = () => resolve();
-    });
-    if (!releaseProbes) {
-      throw new Error("Expected probe release callback to be initialized");
-    }
-    const releaseStartedProbes = releaseProbes;
-    probeFeishuMock.mockImplementation(async (account: { accountId: string }) => {
-      started.push(account.accountId);
-      inFlight += 1;
-      maxInFlight = Math.max(maxInFlight, inFlight);
-      await probesReleased;
-      inFlight -= 1;
-      return { ok: true, botOpenId: `bot_${account.accountId}` };
-    });
-
-    const abortController = new AbortController();
-    const monitorPromise = monitorFeishuProvider({
-      config: buildMultiAccountWebsocketConfig(["alpha", "beta", "gamma"]),
-      abortSignal: abortController.signal,
-    });
-
-    try {
-      await waitForStartedAccount(started, "alpha");
-      expect(started).toEqual(["alpha"]);
-      expect(maxInFlight).toBe(1);
-    } finally {
-      releaseStartedProbes();
-      abortController.abort();
-      await monitorPromise;
-    }
-  });
-
-  it("does not refetch bot info after a failed sequential preflight", async () => {
-    const started: string[] = [];
-    let releaseBetaProbe: (() => void) | undefined;
-    const betaProbeReleased = new Promise<void>((resolve) => {
-      releaseBetaProbe = () => resolve();
-    });
-    if (!releaseBetaProbe) {
-      throw new Error("Expected beta probe release callback to be initialized");
-    }
-    const releaseStartedBetaProbe = releaseBetaProbe;
-
-    probeFeishuMock.mockImplementation(async (account: { accountId: string }) => {
-      started.push(account.accountId);
-      if (account.accountId === "alpha") {
-        return { ok: false };
-      }
-      await betaProbeReleased;
-      return { ok: true, botOpenId: `bot_${account.accountId}` };
-    });
-
-    const abortController = new AbortController();
-    const monitorPromise = monitorFeishuProvider({
-      config: buildMultiAccountWebsocketConfig(["alpha", "beta"]),
-      abortSignal: abortController.signal,
-    });
-
-    try {
-      await waitForStartedAccount(started, "beta");
-      expect(started).toEqual(["alpha", "beta"]);
-      expect(started.reduce((count, accountId) => count + (accountId === "alpha" ? 1 : 0), 0)).toBe(
-        1,
-      );
-    } finally {
-      releaseStartedBetaProbe();
-      abortController.abort();
-      await monitorPromise;
-    }
-  });
-
-  it("continues startup when probe layer reports timeout", async () => {
-    const started: string[] = [];
-    let releaseBetaProbe: (() => void) | undefined;
-    const betaProbeReleased = new Promise<void>((resolve) => {
-      releaseBetaProbe = () => resolve();
-    });
-    if (!releaseBetaProbe) {
-      throw new Error("Expected beta probe release callback to be initialized");
-    }
-    const releaseStartedBetaProbe = releaseBetaProbe;
-
-    probeFeishuMock.mockImplementation((account: { accountId: string }) => {
-      started.push(account.accountId);
-      if (account.accountId === "alpha") {
-        return Promise.resolve({ ok: false, error: "probe timed out after 10000ms" });
-      }
-      return betaProbeReleased.then(() => ({ ok: true, botOpenId: `bot_${account.accountId}` }));
-    });
-
-    const abortController = new AbortController();
-    const runtime = createNonExitingRuntimeEnv();
-    const monitorPromise = monitorFeishuProvider({
-      config: buildMultiAccountWebsocketConfig(["alpha", "beta"]),
-      runtime,
-      abortSignal: abortController.signal,
-    });
-
-    try {
-      await waitForStartedAccount(started, "beta");
-      expect(started).toEqual(["alpha", "beta"]);
-      expect(runtime.error).toHaveBeenCalledWith(
-        "feishu[alpha]: bot info probe timed out after 30000ms; continuing startup",
-      );
-    } finally {
-      releaseStartedBetaProbe();
-      abortController.abort();
-      await monitorPromise;
-    }
-  });
-
-  it("stops sequential preflight when aborted during probe", async () => {
-    const started: string[] = [];
-    probeFeishuMock.mockImplementation(
-      (account: { accountId: string }, options: { abortSignal?: AbortSignal }) => {
-        started.push(account.accountId);
-        return new Promise((resolve) => {
-          options.abortSignal?.addEventListener(
-            "abort",
-            () => resolve({ ok: false, error: "probe aborted" }),
-            { once: true },
-          );
-        });
-      },
-    );
-
-    const abortController = new AbortController();
-    const monitorPromise = monitorFeishuProvider({
-      config: buildMultiAccountWebsocketConfig(["alpha", "beta"]),
-      abortSignal: abortController.signal,
-    });
-
-    try {
-      await waitForStartedAccount(started, "alpha");
-      expect(started).toEqual(["alpha"]);
-
-      abortController.abort();
-      await monitorPromise;
-
-      expect(started).toEqual(["alpha"]);
-    } finally {
-      abortController.abort();
-    }
-  });
-});

package/src/monitor.startup.ts

@@ -1,74 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { RuntimeEnv } from "../runtime-api.js";
-import { probeFeishu } from "./probe.js";
-import type { ResolvedFeishuAccount } from "./types.js";
-
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS = 30_000;
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV = "KLAW_FEISHU_STARTUP_PROBE_TIMEOUT_MS";
-
-function resolveStartupProbeTimeoutMs(): number {
-  const raw = process.env[FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV];
-  if (raw) {
-    const parsed = Number(raw);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return Math.floor(parsed);
-    }
-    console.warn(
-      `[feishu] ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV}="${raw}" is invalid; using default ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS}ms`,
-    );
-  }
-  return FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS;
-}
-
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS = resolveStartupProbeTimeoutMs();
-
-type FetchBotOpenIdOptions = {
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  timeoutMs?: number;
-};
-
-export type FeishuMonitorBotIdentity = {
-  botOpenId?: string;
-  botName?: string;
-};
-
-function isTimeoutErrorMessage(message: string | undefined): boolean {
-  const lower = normalizeLowercaseStringOrEmpty(message);
-  return lower.includes("timeout") || lower.includes("timed out");
-}
-
-function isAbortErrorMessage(message: string | undefined): boolean {
-  return normalizeLowercaseStringOrEmpty(message).includes("aborted");
-}
-
-export async function fetchBotIdentityForMonitor(
-  account: ResolvedFeishuAccount,
-  options: FetchBotOpenIdOptions = {},
-): Promise<FeishuMonitorBotIdentity> {
-  if (options.abortSignal?.aborted) {
-    return {};
-  }
-
-  const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
-  const result = await probeFeishu(account, {
-    timeoutMs,
-    abortSignal: options.abortSignal,
-  });
-  if (result.ok) {
-    return { botOpenId: result.botOpenId, botName: result.botName };
-  }
-
-  const probeError = result.error ?? undefined;
-  if (options.abortSignal?.aborted || isAbortErrorMessage(probeError)) {
-    return {};
-  }
-
-  if (isTimeoutErrorMessage(probeError)) {
-    const error = options.runtime?.error ?? console.error;
-    error(
-      `feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`,
-    );
-  }
-  return {};
-}

package/src/monitor.state.defaults.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  resolveFeishuWebhookAnomalyDefaultsForTest,
-  resolveFeishuWebhookRateLimitDefaultsForTest,
-} from "./monitor.state.js";
-
-describe("feishu monitor state defaults", () => {
-  it("falls back to hard defaults when sdk defaults are missing", () => {
-    expect(resolveFeishuWebhookRateLimitDefaultsForTest(undefined)).toEqual({
-      windowMs: 60_000,
-      maxRequests: 120,
-      maxTrackedKeys: 4_096,
-    });
-    expect(resolveFeishuWebhookAnomalyDefaultsForTest(undefined)).toEqual({
-      maxTrackedKeys: 4_096,
-      ttlMs: 21_600_000,
-      logEvery: 25,
-    });
-  });
-
-  it("keeps valid sdk values and repairs invalid fields", () => {
-    expect(
-      resolveFeishuWebhookRateLimitDefaultsForTest({
-        windowMs: 45_000,
-        maxRequests: 0,
-        maxTrackedKeys: -1,
-      }),
-    ).toEqual({
-      windowMs: 45_000,
-      maxRequests: 120,
-      maxTrackedKeys: 4_096,
-    });
-
-    expect(
-      resolveFeishuWebhookAnomalyDefaultsForTest({
-        maxTrackedKeys: 2048,
-        ttlMs: Number.NaN,
-        logEvery: 10,
-      }),
-    ).toEqual({
-      maxTrackedKeys: 2048,
-      ttlMs: 21_600_000,
-      logEvery: 10,
-    });
-  });
-});

package/src/monitor.state.ts

@@ -1,170 +0,0 @@
-import * as http from "node:http";
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import {
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  type RuntimeEnv,
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS as WEBHOOK_ANOMALY_COUNTER_DEFAULTS_FROM_SDK,
-  WEBHOOK_RATE_LIMIT_DEFAULTS as WEBHOOK_RATE_LIMIT_DEFAULTS_FROM_SDK,
-} from "./monitor-state-runtime-api.js";
-
-export const wsClients = new Map<string, Lark.WSClient>();
-export const httpServers = new Map<string, http.Server>();
-export const botOpenIds = new Map<string, string>();
-export const botNames = new Map<string, string>();
-
-export const FEISHU_WEBHOOK_MAX_BODY_BYTES = 64 * 1024;
-export const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 5_000;
-
-type WebhookRateLimitDefaults = {
-  windowMs: number;
-  maxRequests: number;
-  maxTrackedKeys: number;
-};
-
-type WebhookAnomalyDefaults = {
-  maxTrackedKeys: number;
-  ttlMs: number;
-  logEvery: number;
-};
-
-const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS: WebhookRateLimitDefaults = {
-  windowMs: 60_000,
-  maxRequests: 120,
-  maxTrackedKeys: 4_096,
-};
-
-const FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS: WebhookAnomalyDefaults = {
-  maxTrackedKeys: 4_096,
-  ttlMs: 6 * 60 * 60_000,
-  logEvery: 25,
-};
-
-function coercePositiveInt(value: unknown, fallback: number): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return fallback;
-  }
-  const normalized = Math.floor(value);
-  return normalized > 0 ? normalized : fallback;
-}
-
-export function resolveFeishuWebhookRateLimitDefaultsForTest(
-  defaults: unknown,
-): WebhookRateLimitDefaults {
-  const resolved = defaults as Partial<WebhookRateLimitDefaults> | null | undefined;
-  return {
-    windowMs: coercePositiveInt(
-      resolved?.windowMs,
-      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.windowMs,
-    ),
-    maxRequests: coercePositiveInt(
-      resolved?.maxRequests,
-      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxRequests,
-    ),
-    maxTrackedKeys: coercePositiveInt(
-      resolved?.maxTrackedKeys,
-      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxTrackedKeys,
-    ),
-  };
-}
-
-export function resolveFeishuWebhookAnomalyDefaultsForTest(
-  defaults: unknown,
-): WebhookAnomalyDefaults {
-  const resolved = defaults as Partial<WebhookAnomalyDefaults> | null | undefined;
-  return {
-    maxTrackedKeys: coercePositiveInt(
-      resolved?.maxTrackedKeys,
-      FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.maxTrackedKeys,
-    ),
-    ttlMs: coercePositiveInt(resolved?.ttlMs, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.ttlMs),
-    logEvery: coercePositiveInt(
-      resolved?.logEvery,
-      FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.logEvery,
-    ),
-  };
-}
-
-const feishuWebhookRateLimitDefaults = resolveFeishuWebhookRateLimitDefaultsForTest(
-  WEBHOOK_RATE_LIMIT_DEFAULTS_FROM_SDK,
-);
-const feishuWebhookAnomalyDefaults = resolveFeishuWebhookAnomalyDefaultsForTest(
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS_FROM_SDK,
-);
-
-export const feishuWebhookRateLimiter = createFixedWindowRateLimiter({
-  windowMs: feishuWebhookRateLimitDefaults.windowMs,
-  maxRequests: feishuWebhookRateLimitDefaults.maxRequests,
-  maxTrackedKeys: feishuWebhookRateLimitDefaults.maxTrackedKeys,
-});
-
-const feishuWebhookAnomalyTracker = createWebhookAnomalyTracker({
-  maxTrackedKeys: feishuWebhookAnomalyDefaults.maxTrackedKeys,
-  ttlMs: feishuWebhookAnomalyDefaults.ttlMs,
-  logEvery: feishuWebhookAnomalyDefaults.logEvery,
-});
-
-function closeWsClient(client: Lark.WSClient | undefined): void {
-  if (!client) {
-    return;
-  }
-  try {
-    client.close();
-  } catch {
-    /* Best-effort cleanup */
-  }
-}
-
-export function clearFeishuWebhookRateLimitStateForTest(): void {
-  feishuWebhookRateLimiter.clear();
-  feishuWebhookAnomalyTracker.clear();
-}
-
-export function getFeishuWebhookRateLimitStateSizeForTest(): number {
-  return feishuWebhookRateLimiter.size();
-}
-
-export function isWebhookRateLimitedForTest(key: string, nowMs: number): boolean {
-  return feishuWebhookRateLimiter.isRateLimited(key, nowMs);
-}
-
-export function recordWebhookStatus(
-  runtime: RuntimeEnv | undefined,
-  accountId: string,
-  path: string,
-  statusCode: number,
-): void {
-  feishuWebhookAnomalyTracker.record({
-    key: `${accountId}:${path}:${statusCode}`,
-    statusCode,
-    log: runtime?.log ?? console.log,
-    message: (count) =>
-      `feishu[${accountId}]: webhook anomaly path=${path} status=${statusCode} count=${count}`,
-  });
-}
-
-export function stopFeishuMonitorState(accountId?: string): void {
-  if (accountId) {
-    closeWsClient(wsClients.get(accountId));
-    wsClients.delete(accountId);
-    const server = httpServers.get(accountId);
-    if (server) {
-      server.close();
-      httpServers.delete(accountId);
-    }
-    botOpenIds.delete(accountId);
-    botNames.delete(accountId);
-    return;
-  }
-
-  for (const client of wsClients.values()) {
-    closeWsClient(client);
-  }
-  wsClients.clear();
-  for (const server of httpServers.values()) {
-    server.close();
-  }
-  httpServers.clear();
-  botOpenIds.clear();
-  botNames.clear();
-}

package/src/monitor.synthetic-error.ts

@@ -1,18 +0,0 @@
-export class FeishuRetryableSyntheticEventError extends Error {
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = "FeishuRetryableSyntheticEventError";
-  }
-}
-
-export function isFeishuRetryableSyntheticEventError(
-  error: unknown,
-): error is FeishuRetryableSyntheticEventError {
-  return (
-    error instanceof FeishuRetryableSyntheticEventError ||
-    (typeof error === "object" &&
-      error !== null &&
-      "name" in error &&
-      error.name === "FeishuRetryableSyntheticEventError")
-  );
-}

package/src/monitor.test-mocks.ts

@@ -1,46 +0,0 @@
-import { vi } from "vitest";
-
-export function createFeishuClientMockModule(): {
-  createFeishuWSClient: () => { start: () => void; close: () => void };
-  createEventDispatcher: () => { register: () => void };
-} {
-  return {
-    createFeishuWSClient: vi.fn(() => ({ start: vi.fn(), close: vi.fn() })),
-    createEventDispatcher: vi.fn(() => ({ register: vi.fn() })),
-  };
-}
-
-export function createFeishuRuntimeMockModule(): {
-  getFeishuRuntime: () => {
-    channel: {
-      debounce: {
-        resolveInboundDebounceMs: () => number;
-        createInboundDebouncer: () => {
-          enqueue: () => Promise<void>;
-          flushKey: () => Promise<void>;
-        };
-      };
-      text: {
-        hasControlCommand: () => boolean;
-      };
-    };
-  };
-} {
-  return {
-    getFeishuRuntime: () => ({
-      channel: {
-        debounce: {
-          resolveInboundDebounceMs: () => 0,
-          createInboundDebouncer: () => ({
-            enqueue: async () => {},
-            flushKey: async () => {},
-            cancelKey: () => false,
-          }),
-        },
-        text: {
-          hasControlCommand: () => false,
-        },
-      },
-    }),
-  };
-}