@openclaw/feishu 2026.5.2 → 2026.5.3-beta.2

package/src/probe.test.ts

@@ -1,275 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { clearProbeCache, FEISHU_PROBE_REQUEST_TIMEOUT_MS, probeFeishu } from "./probe.js";
-
-const createFeishuClientMock = vi.hoisted(() => vi.fn());
-
-vi.mock("./client.js", () => ({
-  createFeishuClient: createFeishuClientMock,
-}));
-
-const DEFAULT_CREDS = { appId: "cli_123", appSecret: "secret" } as const; // pragma: allowlist secret
-const DEFAULT_SUCCESS_RESPONSE = {
-  code: 0,
-  data: { pingBotInfo: { botName: "TestBot", botID: "ou_abc123" } },
-} as const;
-const DEFAULT_SUCCESS_RESULT = {
-  ok: true,
-  appId: "cli_123",
-  botName: "TestBot",
-  botOpenId: "ou_abc123",
-} as const;
-const BOT1_RESPONSE = {
-  code: 0,
-  data: { pingBotInfo: { botName: "Bot1", botID: "ou_1" } },
-} as const;
-
-function makeRequestFn(response: Record<string, unknown>) {
-  return vi.fn().mockResolvedValue(response);
-}
-
-function setupClient(response: Record<string, unknown>) {
-  const requestFn = makeRequestFn(response);
-  createFeishuClientMock.mockReturnValue({ request: requestFn });
-  return requestFn;
-}
-
-function setupSuccessClient() {
-  return setupClient(DEFAULT_SUCCESS_RESPONSE);
-}
-
-async function expectDefaultSuccessResult(
-  creds = DEFAULT_CREDS,
-  expected: {
-    ok: true;
-    appId: string;
-    botName: string;
-    botOpenId: string;
-  } = DEFAULT_SUCCESS_RESULT,
-) {
-  const result = await probeFeishu(creds);
-  expect(result).toEqual(expected);
-}
-
-async function withFakeTimers(run: () => Promise<void>) {
-  vi.useFakeTimers();
-  try {
-    await run();
-  } finally {
-    vi.useRealTimers();
-  }
-}
-
-async function expectErrorResultCached(params: {
-  requestFn: ReturnType<typeof vi.fn>;
-  expectedError: string;
-  ttlMs: number;
-}) {
-  createFeishuClientMock.mockReturnValue({ request: params.requestFn });
-
-  const first = await probeFeishu(DEFAULT_CREDS);
-  const second = await probeFeishu(DEFAULT_CREDS);
-  expect(first).toMatchObject({ ok: false, error: params.expectedError });
-  expect(second).toMatchObject({ ok: false, error: params.expectedError });
-  expect(params.requestFn).toHaveBeenCalledTimes(1);
-
-  vi.advanceTimersByTime(params.ttlMs + 1);
-
-  await probeFeishu(DEFAULT_CREDS);
-  expect(params.requestFn).toHaveBeenCalledTimes(2);
-}
-
-async function expectFreshDefaultProbeAfter(
-  requestFn: ReturnType<typeof vi.fn>,
-  invalidate: () => void,
-) {
-  await probeFeishu(DEFAULT_CREDS);
-  expect(requestFn).toHaveBeenCalledTimes(1);
-
-  invalidate();
-
-  await probeFeishu(DEFAULT_CREDS);
-  expect(requestFn).toHaveBeenCalledTimes(2);
-}
-
-async function readSequentialDefaultProbePair() {
-  const first = await probeFeishu(DEFAULT_CREDS);
-  return { first, second: await probeFeishu(DEFAULT_CREDS) };
-}
-
-describe("probeFeishu", () => {
-  beforeEach(() => {
-    clearProbeCache();
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    clearProbeCache();
-  });
-
-  it("returns error when credentials are missing", async () => {
-    const result = await probeFeishu();
-    expect(result).toEqual({ ok: false, error: "missing credentials (appId, appSecret)" });
-  });
-
-  it("returns error when appId is missing", async () => {
-    const result = await probeFeishu({ appSecret: "secret" } as never); // pragma: allowlist secret
-    expect(result).toEqual({ ok: false, error: "missing credentials (appId, appSecret)" });
-  });
-
-  it("returns error when appSecret is missing", async () => {
-    const result = await probeFeishu({ appId: "cli_123" } as never);
-    expect(result).toEqual({ ok: false, error: "missing credentials (appId, appSecret)" });
-  });
-
-  it("returns bot info on successful probe", async () => {
-    const requestFn = setupSuccessClient();
-
-    await expectDefaultSuccessResult();
-    expect(requestFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("passes the probe timeout to the Feishu request", async () => {
-    const requestFn = setupSuccessClient();
-
-    await probeFeishu(DEFAULT_CREDS);
-
-    expect(requestFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        method: "POST",
-        url: "/open-apis/bot/v1/openclaw_bot/ping",
-        data: { needBotInfo: true },
-        timeout: FEISHU_PROBE_REQUEST_TIMEOUT_MS,
-      }),
-    );
-  });
-
-  it("returns timeout error when request exceeds timeout", async () => {
-    await withFakeTimers(async () => {
-      const requestFn = vi.fn().mockImplementation(() => new Promise(() => {}));
-      createFeishuClientMock.mockReturnValue({ request: requestFn });
-
-      const promise = probeFeishu(DEFAULT_CREDS, { timeoutMs: 1_000 });
-      await vi.advanceTimersByTimeAsync(1_000);
-      const result = await promise;
-
-      expect(result).toMatchObject({ ok: false, error: "probe timed out after 1000ms" });
-    });
-  });
-
-  it("returns aborted when abort signal is already aborted", async () => {
-    createFeishuClientMock.mockClear();
-    const abortController = new AbortController();
-    abortController.abort();
-
-    const result = await probeFeishu(
-      { appId: "cli_123", appSecret: "secret" }, // pragma: allowlist secret
-      { abortSignal: abortController.signal },
-    );
-
-    expect(result).toMatchObject({ ok: false, error: "probe aborted" });
-    expect(createFeishuClientMock).not.toHaveBeenCalled();
-  });
-  it("returns cached result on subsequent calls within TTL", async () => {
-    const requestFn = setupSuccessClient();
-
-    const { first, second } = await readSequentialDefaultProbePair();
-
-    expect(first).toEqual(second);
-    // Only one API call should have been made
-    expect(requestFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("makes a fresh API call after cache expires", async () => {
-    await withFakeTimers(async () => {
-      const requestFn = setupSuccessClient();
-
-      await expectFreshDefaultProbeAfter(requestFn, () => {
-        vi.advanceTimersByTime(10 * 60 * 1000 + 1);
-      });
-    });
-  });
-
-  it("caches failed probe results (API error) for the error TTL", async () => {
-    await withFakeTimers(async () => {
-      await expectErrorResultCached({
-        requestFn: makeRequestFn({ code: 99, msg: "token expired" }),
-        expectedError: "API error: token expired",
-        ttlMs: 60 * 1000,
-      });
-    });
-  });
-
-  it("caches thrown request errors for the error TTL", async () => {
-    await withFakeTimers(async () => {
-      await expectErrorResultCached({
-        requestFn: vi.fn().mockRejectedValue(new Error("network error")),
-        expectedError: "network error",
-        ttlMs: 60 * 1000,
-      });
-    });
-  });
-
-  it("caches per account independently", async () => {
-    const requestFn = setupClient(BOT1_RESPONSE);
-
-    await probeFeishu({ appId: "cli_aaa", appSecret: "s1" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(1);
-
-    // Different appId should trigger a new API call
-    await probeFeishu({ appId: "cli_bbb", appSecret: "s2" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(2);
-
-    // Same appId + appSecret as first call should return cached
-    await probeFeishu({ appId: "cli_aaa", appSecret: "s1" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(2);
-  });
-
-  it("does not share cache between accounts with same appId but different appSecret", async () => {
-    const requestFn = setupClient(BOT1_RESPONSE);
-
-    // First account with appId + secret A
-    await probeFeishu({ appId: "cli_shared", appSecret: "secret_aaa" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(1);
-
-    // Second account with same appId but different secret (e.g. after rotation)
-    // must NOT reuse the cached result
-    await probeFeishu({ appId: "cli_shared", appSecret: "secret_bbb" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(2);
-  });
-
-  it("uses accountId for cache key when available", async () => {
-    const requestFn = setupClient(BOT1_RESPONSE);
-
-    // Two accounts with same appId+appSecret but different accountIds are cached separately
-    await probeFeishu({ accountId: "acct-1", appId: "cli_123", appSecret: "secret" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(1);
-
-    await probeFeishu({ accountId: "acct-2", appId: "cli_123", appSecret: "secret" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(2);
-
-    // Same accountId should return cached
-    await probeFeishu({ accountId: "acct-1", appId: "cli_123", appSecret: "secret" }); // pragma: allowlist secret
-    expect(requestFn).toHaveBeenCalledTimes(2);
-  });
-
-  it("clearProbeCache forces fresh API call", async () => {
-    const requestFn = setupSuccessClient();
-
-    await expectFreshDefaultProbeAfter(requestFn, () => {
-      clearProbeCache();
-    });
-  });
-
-  it("handles response with pingBotInfo in data", async () => {
-    setupClient({
-      code: 0,
-      data: { pingBotInfo: { botName: "DataBot", botID: "ou_data" } },
-    });
-
-    await expectDefaultSuccessResult(DEFAULT_CREDS, {
-      ...DEFAULT_SUCCESS_RESULT,
-      botName: "DataBot",
-      botOpenId: "ou_data",
-    });
-  });
-});

package/src/probe.ts

@@ -1,166 +0,0 @@
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { raceWithTimeoutAndAbort } from "./async.js";
-import { createFeishuClient, type FeishuClientCredentials } from "./client.js";
-import type { FeishuProbeResult } from "./types.js";
-
-/** Cache probe results to reduce repeated health-check calls.
- * Gateway health checks call probeFeishu() every minute; without caching this
- * burns ~43,200 calls/month, easily exceeding Feishu's free-tier quota.
- * Successful bot info is effectively static, while failures are cached briefly
- * to avoid hammering the API during transient outages. */
-const probeCache = new Map<string, { result: FeishuProbeResult; expiresAt: number }>();
-const PROBE_SUCCESS_TTL_MS = 10 * 60 * 1000; // 10 minutes
-const PROBE_ERROR_TTL_MS = 60 * 1000; // 1 minute
-const MAX_PROBE_CACHE_SIZE = 64;
-export const FEISHU_PROBE_REQUEST_TIMEOUT_MS = 10_000;
-export type ProbeFeishuOptions = {
-  timeoutMs?: number;
-  abortSignal?: AbortSignal;
-};
-
-type FeishuPingResponse = {
-  code: number;
-  msg?: string;
-  data?: { pingBotInfo?: { botID?: string; botName?: string } };
-};
-
-type FeishuRequestClient = ReturnType<typeof createFeishuClient> & {
-  request(params: {
-    method: "POST";
-    url: string;
-    data: Record<string, unknown>;
-    timeout: number;
-  }): Promise<FeishuPingResponse>;
-};
-
-function setCachedProbeResult(
-  cacheKey: string,
-  result: FeishuProbeResult,
-  ttlMs: number,
-): FeishuProbeResult {
-  probeCache.set(cacheKey, { result, expiresAt: Date.now() + ttlMs });
-  if (probeCache.size > MAX_PROBE_CACHE_SIZE) {
-    const oldest = probeCache.keys().next().value;
-    if (oldest !== undefined) {
-      probeCache.delete(oldest);
-    }
-  }
-  return result;
-}
-
-export async function probeFeishu(
-  creds?: FeishuClientCredentials,
-  options: ProbeFeishuOptions = {},
-): Promise<FeishuProbeResult> {
-  if (!creds?.appId || !creds?.appSecret) {
-    return {
-      ok: false,
-      error: "missing credentials (appId, appSecret)",
-    };
-  }
-  if (options.abortSignal?.aborted) {
-    return {
-      ok: false,
-      appId: creds.appId,
-      error: "probe aborted",
-    };
-  }
-
-  const timeoutMs = options.timeoutMs ?? FEISHU_PROBE_REQUEST_TIMEOUT_MS;
-
-  // Return cached result if still valid.
-  // Use accountId when available; otherwise include appSecret prefix so two
-  // accounts sharing the same appId (e.g. after secret rotation) don't
-  // pollute each other's cache entry.
-  const cacheKey = creds.accountId ?? `${creds.appId}:${creds.appSecret.slice(0, 8)}`;
-  const cached = probeCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.result;
-  }
-
-  try {
-    const client = createFeishuClient(creds) as FeishuRequestClient;
-    // Feishu-provided endpoint for OpenClaw, supported on both Feishu (CN)
-    // and Lark (international). No OAuth scopes required. Validates
-    // credentials and registers the app as an AI agent (智能体).
-    const responseResult = await raceWithTimeoutAndAbort<FeishuPingResponse>(
-      client.request({
-        method: "POST",
-        url: "/open-apis/bot/v1/openclaw_bot/ping",
-        data: { needBotInfo: true },
-        timeout: timeoutMs,
-      }),
-      {
-        timeoutMs,
-        abortSignal: options.abortSignal,
-      },
-    );
-
-    if (responseResult.status === "aborted") {
-      return {
-        ok: false,
-        appId: creds.appId,
-        error: "probe aborted",
-      };
-    }
-    if (responseResult.status === "timeout") {
-      return setCachedProbeResult(
-        cacheKey,
-        {
-          ok: false,
-          appId: creds.appId,
-          error: `probe timed out after ${timeoutMs}ms`,
-        },
-        PROBE_ERROR_TTL_MS,
-      );
-    }
-
-    const response = responseResult.value;
-    if (options.abortSignal?.aborted) {
-      return {
-        ok: false,
-        appId: creds.appId,
-        error: "probe aborted",
-      };
-    }
-
-    if (response.code !== 0) {
-      return setCachedProbeResult(
-        cacheKey,
-        {
-          ok: false,
-          appId: creds.appId,
-          error: `API error: ${response.msg || `code ${response.code}`}`,
-        },
-        PROBE_ERROR_TTL_MS,
-      );
-    }
-
-    const botInfo = response.data?.pingBotInfo;
-    return setCachedProbeResult(
-      cacheKey,
-      {
-        ok: true,
-        appId: creds.appId,
-        botName: botInfo?.botName,
-        botOpenId: botInfo?.botID,
-      },
-      PROBE_SUCCESS_TTL_MS,
-    );
-  } catch (err) {
-    return setCachedProbeResult(
-      cacheKey,
-      {
-        ok: false,
-        appId: creds.appId,
-        error: formatErrorMessage(err),
-      },
-      PROBE_ERROR_TTL_MS,
-    );
-  }
-}
-
-/** Clear the probe cache (for testing). */
-export function clearProbeCache(): void {
-  probeCache.clear();
-}

package/src/processing-claims.ts

@@ -1,59 +0,0 @@
-const EVENT_DEDUP_TTL_MS = 5 * 60 * 1000;
-const EVENT_MEMORY_MAX_SIZE = 2_000;
-
-const processingClaims = new Map<string, number>();
-
-function resolveEventDedupeKey(
-  namespace: string,
-  messageId: string | undefined | null,
-): string | null {
-  const trimmed = messageId?.trim();
-  return trimmed ? `${namespace}:${trimmed}` : null;
-}
-
-function pruneProcessingClaims(now: number): void {
-  const cutoff = now - EVENT_DEDUP_TTL_MS;
-  for (const [key, seenAt] of processingClaims) {
-    if (seenAt < cutoff) {
-      processingClaims.delete(key);
-    }
-  }
-  while (processingClaims.size > EVENT_MEMORY_MAX_SIZE) {
-    const oldestKey = processingClaims.keys().next().value;
-    if (!oldestKey) {
-      return;
-    }
-    processingClaims.delete(oldestKey);
-  }
-}
-
-export function tryBeginFeishuMessageProcessing(
-  messageId: string | undefined | null,
-  namespace = "global",
-): boolean {
-  const key = resolveEventDedupeKey(namespace, messageId);
-  if (!key) {
-    return true;
-  }
-  const now = Date.now();
-  pruneProcessingClaims(now);
-  if (processingClaims.has(key)) {
-    processingClaims.delete(key);
-    processingClaims.set(key, now);
-    pruneProcessingClaims(now);
-    return false;
-  }
-  processingClaims.set(key, now);
-  pruneProcessingClaims(now);
-  return true;
-}
-
-export function releaseFeishuMessageProcessing(
-  messageId: string | undefined | null,
-  namespace = "global",
-): void {
-  const key = resolveEventDedupeKey(namespace, messageId);
-  if (key) {
-    processingClaims.delete(key);
-  }
-}

package/src/qr-terminal.ts

@@ -1 +0,0 @@
-export { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";

package/src/reactions.ts

@@ -1,123 +0,0 @@
-import type { ClawdbotConfig } from "../runtime-api.js";
-import { resolveFeishuRuntimeAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-
-type FeishuReaction = {
-  reactionId: string;
-  emojiType: string;
-  operatorType: "app" | "user";
-  operatorId: string;
-};
-
-function resolveConfiguredFeishuClient(params: { cfg: ClawdbotConfig; accountId?: string }) {
-  const account = resolveFeishuRuntimeAccount(params);
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-  return createFeishuClient(account);
-}
-
-function assertFeishuReactionApiSuccess(response: { code?: number; msg?: string }, action: string) {
-  if (response.code !== 0) {
-    throw new Error(`Feishu ${action} failed: ${response.msg || `code ${response.code}`}`);
-  }
-}
-
-/**
- * Add a reaction (emoji) to a message.
- * @param emojiType - Feishu emoji type, e.g., "SMILE", "THUMBSUP", "HEART"
- * @see https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
- */
-export async function addReactionFeishu(params: {
-  cfg: ClawdbotConfig;
-  messageId: string;
-  emojiType: string;
-  accountId?: string;
-}): Promise<{ reactionId: string }> {
-  const { cfg, messageId, emojiType, accountId } = params;
-  const client = resolveConfiguredFeishuClient({ cfg, accountId });
-
-  const response = (await client.im.messageReaction.create({
-    path: { message_id: messageId },
-    data: {
-      reaction_type: {
-        emoji_type: emojiType,
-      },
-    },
-  })) as {
-    code?: number;
-    msg?: string;
-    data?: { reaction_id?: string };
-  };
-
-  assertFeishuReactionApiSuccess(response, "add reaction");
-
-  const reactionId = response.data?.reaction_id;
-  if (!reactionId) {
-    throw new Error("Feishu add reaction failed: no reaction_id returned");
-  }
-
-  return { reactionId };
-}
-
-/**
- * Remove a reaction from a message.
- */
-export async function removeReactionFeishu(params: {
-  cfg: ClawdbotConfig;
-  messageId: string;
-  reactionId: string;
-  accountId?: string;
-}): Promise<void> {
-  const { cfg, messageId, reactionId, accountId } = params;
-  const client = resolveConfiguredFeishuClient({ cfg, accountId });
-
-  const response = (await client.im.messageReaction.delete({
-    path: {
-      message_id: messageId,
-      reaction_id: reactionId,
-    },
-  })) as { code?: number; msg?: string };
-
-  assertFeishuReactionApiSuccess(response, "remove reaction");
-}
-
-/**
- * List all reactions for a message.
- */
-export async function listReactionsFeishu(params: {
-  cfg: ClawdbotConfig;
-  messageId: string;
-  emojiType?: string;
-  accountId?: string;
-}): Promise<FeishuReaction[]> {
-  const { cfg, messageId, emojiType, accountId } = params;
-  const client = resolveConfiguredFeishuClient({ cfg, accountId });
-
-  const response = (await client.im.messageReaction.list({
-    path: { message_id: messageId },
-    params: emojiType ? { reaction_type: emojiType } : undefined,
-  })) as {
-    code?: number;
-    msg?: string;
-    data?: {
-      items?: Array<{
-        reaction_id?: string;
-        reaction_type?: { emoji_type?: string };
-        operator_type?: string;
-        operator_id?: { open_id?: string; user_id?: string; union_id?: string };
-      }>;
-    };
-  };
-
-  assertFeishuReactionApiSuccess(response, "list reactions");
-
-  const items = response.data?.items ?? [];
-  return items.map((item) => ({
-    reactionId: item.reaction_id ?? "",
-    emojiType: item.reaction_type?.emoji_type ?? "",
-    operatorType: item.operator_type === "app" ? "app" : "user",
-    operatorId:
-      item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
-  }));
-}

package/src/reasoning-preview.test.ts

@@ -1,59 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { resolveFeishuReasoningPreviewEnabled } from "./reasoning-preview.js";
-
-const { loadSessionStoreMock } = vi.hoisted(() => ({
-  loadSessionStoreMock: vi.fn(),
-}));
-
-vi.mock("./bot-runtime-api.js", async () => {
-  const actual =
-    await vi.importActual<typeof import("./bot-runtime-api.js")>("./bot-runtime-api.js");
-  return {
-    ...actual,
-    loadSessionStore: loadSessionStoreMock,
-  };
-});
-
-describe("resolveFeishuReasoningPreviewEnabled", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("enables previews only for stream reasoning sessions", () => {
-    loadSessionStoreMock.mockReturnValue({
-      "agent:main:feishu:dm:ou_sender_1": { reasoningLevel: "stream" },
-      "agent:main:feishu:dm:ou_sender_2": { reasoningLevel: "on" },
-    });
-
-    expect(
-      resolveFeishuReasoningPreviewEnabled({
-        storePath: "/tmp/feishu-sessions.json",
-        sessionKey: "agent:main:feishu:dm:ou_sender_1",
-      }),
-    ).toBe(true);
-    expect(
-      resolveFeishuReasoningPreviewEnabled({
-        storePath: "/tmp/feishu-sessions.json",
-        sessionKey: "agent:main:feishu:dm:ou_sender_2",
-      }),
-    ).toBe(false);
-  });
-
-  it("returns false for missing sessions or load failures", () => {
-    loadSessionStoreMock.mockImplementationOnce(() => {
-      throw new Error("disk unavailable");
-    });
-
-    expect(
-      resolveFeishuReasoningPreviewEnabled({
-        storePath: "/tmp/feishu-sessions.json",
-        sessionKey: "agent:main:feishu:dm:ou_sender_1",
-      }),
-    ).toBe(false);
-    expect(
-      resolveFeishuReasoningPreviewEnabled({
-        storePath: "/tmp/feishu-sessions.json",
-      }),
-    ).toBe(false);
-  });
-});

package/src/reasoning-preview.ts

@@ -1,20 +0,0 @@
-import { loadSessionStore, resolveSessionStoreEntry } from "./bot-runtime-api.js";
-
-export function resolveFeishuReasoningPreviewEnabled(params: {
-  storePath: string;
-  sessionKey?: string;
-}): boolean {
-  if (!params.sessionKey) {
-    return false;
-  }
-
-  try {
-    const store = loadSessionStore(params.storePath, { skipCache: true });
-    return (
-      resolveSessionStoreEntry({ store, sessionKey: params.sessionKey }).existing
-        ?.reasoningLevel === "stream"
-    );
-  } catch {
-    return false;
-  }
-}