@kodelyth/feishu 2026.5.39 → 2026.5.42

package/src/approval-auth.ts

@@ -0,0 +1,25 @@
+import {
+  createResolvedApproverActionAuthAdapter,
+  resolveApprovalApprovers,
+} from "klaw/plugin-sdk/approval-auth-runtime";
+import { normalizeOptionalLowercaseString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { resolveFeishuAccount } from "./accounts.js";
+import { normalizeFeishuTarget } from "./targets.js";
+
+function normalizeFeishuApproverId(value: string | number): string | undefined {
+  const normalized = normalizeFeishuTarget(String(value));
+  const trimmed = normalizeOptionalLowercaseString(normalized);
+  return trimmed?.startsWith("ou_") ? trimmed : undefined;
+}
+
+export const feishuApprovalAuth = createResolvedApproverActionAuthAdapter({
+  channelLabel: "Feishu",
+  resolveApprovers: ({ cfg, accountId }) => {
+    const account = resolveFeishuAccount({ cfg, accountId }).config;
+    return resolveApprovalApprovers({
+      allowFrom: account.allowFrom,
+      normalizeApprover: normalizeFeishuApproverId,
+    });
+  },
+  normalizeSenderId: (value) => normalizeFeishuApproverId(value),
+});

package/src/async.test.ts

@@ -0,0 +1,35 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { waitForAbortableDelay } from "./async.js";
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("waitForAbortableDelay", () => {
+  it("resolves false immediately when already aborted", async () => {
+    vi.useFakeTimers();
+    const abortController = new AbortController();
+    abortController.abort();
+
+    await expect(waitForAbortableDelay(60_000, abortController.signal)).resolves.toBe(false);
+  });
+
+  it("resolves false immediately when aborted during backoff", async () => {
+    vi.useFakeTimers();
+    const abortController = new AbortController();
+
+    const delay = waitForAbortableDelay(60_000, abortController.signal);
+    abortController.abort();
+
+    await expect(delay).resolves.toBe(false);
+  });
+
+  it("resolves true after the full delay when not aborted", async () => {
+    vi.useFakeTimers();
+
+    const delay = waitForAbortableDelay(500);
+    await vi.advanceTimersByTimeAsync(500);
+
+    await expect(delay).resolves.toBe(true);
+  });
+});

package/src/async.ts

@@ -0,0 +1,104 @@
+const RACE_TIMEOUT = Symbol("race-timeout");
+const RACE_ABORT = Symbol("race-abort");
+
+type RaceWithTimeoutAndAbortResult<T> =
+  | { status: "resolved"; value: T }
+  | { status: "timeout" }
+  | { status: "aborted" };
+
+export async function raceWithTimeoutAndAbort<T>(
+  promise: Promise<T>,
+  options: {
+    timeoutMs?: number;
+    abortSignal?: AbortSignal;
+  } = {},
+): Promise<RaceWithTimeoutAndAbortResult<T>> {
+  if (options.abortSignal?.aborted) {
+    return { status: "aborted" };
+  }
+
+  if (options.timeoutMs === undefined && !options.abortSignal) {
+    return { status: "resolved", value: await promise };
+  }
+
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  let abortHandler: (() => void) | undefined;
+  const contenders: Array<Promise<T | typeof RACE_TIMEOUT | typeof RACE_ABORT>> = [promise];
+
+  if (options.timeoutMs !== undefined) {
+    contenders.push(
+      new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => resolve(RACE_TIMEOUT), options.timeoutMs);
+      }),
+    );
+  }
+
+  if (options.abortSignal) {
+    contenders.push(
+      new Promise((resolve) => {
+        abortHandler = () => resolve(RACE_ABORT);
+        options.abortSignal?.addEventListener("abort", abortHandler, { once: true });
+      }),
+    );
+  }
+
+  try {
+    const result = await Promise.race(contenders);
+    if (result === RACE_TIMEOUT) {
+      return { status: "timeout" };
+    }
+    if (result === RACE_ABORT) {
+      return { status: "aborted" };
+    }
+    return { status: "resolved", value: result };
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+    if (abortHandler) {
+      options.abortSignal?.removeEventListener("abort", abortHandler);
+    }
+  }
+}
+
+export function waitForAbortableDelay(
+  delayMs: number,
+  abortSignal?: AbortSignal,
+): Promise<boolean> {
+  if (abortSignal?.aborted) {
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let handleAbort: (() => void) | undefined;
+
+    const finish = (value: boolean) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      if (handleAbort) {
+        abortSignal?.removeEventListener("abort", handleAbort);
+      }
+      resolve(value);
+    };
+
+    handleAbort = () => {
+      finish(false);
+    };
+
+    abortSignal?.addEventListener("abort", handleAbort, { once: true });
+    if (abortSignal?.aborted) {
+      finish(false);
+      return;
+    }
+
+    timer = setTimeout(() => finish(true), delayMs);
+    timer.unref?.();
+  });
+}

package/src/audio-preflight.runtime.ts

@@ -0,0 +1,9 @@
+import { transcribeFirstAudio as transcribeFirstAudioImpl } from "klaw/plugin-sdk/media-runtime";
+
+type TranscribeFirstAudio = typeof import("klaw/plugin-sdk/media-runtime").transcribeFirstAudio;
+
+export async function transcribeFirstAudio(
+  ...args: Parameters<TranscribeFirstAudio>
+): ReturnType<TranscribeFirstAudio> {
+  return await transcribeFirstAudioImpl(...args);
+}

package/src/bitable.test.ts

@@ -0,0 +1,136 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { KlawPluginApi } from "../runtime-api.js";
+import { createToolFactoryHarness } from "./tool-factory-test-harness.js";
+
+const createFeishuClientMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./client.js", () => ({
+  createFeishuClient: createFeishuClientMock,
+}));
+
+import { registerFeishuBitableTools } from "./bitable.js";
+
+type MockRecord = {
+  record_id?: string;
+  fields?: Record<string, unknown>;
+};
+
+function createConfig(): KlawPluginApi["config"] {
+  return {
+    channels: {
+      feishu: {
+        enabled: true,
+        accounts: {
+          default: {
+            appId: "cli_default",
+            appSecret: "secret_default", // pragma: allowlist secret
+          },
+        },
+      },
+    },
+  } as KlawPluginApi["config"];
+}
+
+function createBitableClient(records: MockRecord[]) {
+  const batchDelete = vi.fn(async () => ({ code: 0 }));
+  const client = {
+    bitable: {
+      app: {
+        create: vi.fn(async () => ({
+          code: 0,
+          data: {
+            app: {
+              app_token: "app_token",
+              name: "Project Tracker",
+              url: "https://example.feishu.cn/base/app_token",
+            },
+          },
+        })),
+      },
+      appTable: {
+        list: vi.fn(async () => ({
+          code: 0,
+          data: { items: [{ table_id: "tbl_main", name: "Table 1" }] },
+        })),
+      },
+      appTableField: {
+        list: vi.fn(async () => ({ code: 0, data: { items: [] } })),
+        update: vi.fn(async () => ({ code: 0 })),
+        delete: vi.fn(async () => ({ code: 0 })),
+      },
+      appTableRecord: {
+        list: vi.fn(async () => ({ code: 0, data: { items: records } })),
+        batchDelete,
+        delete: vi.fn(async () => ({ code: 0 })),
+      },
+    },
+  } as unknown as Lark.Client;
+
+  return { batchDelete, client };
+}
+
+describe("feishu bitable create app cleanup", () => {
+  afterAll(() => {
+    vi.doUnmock("./client.js");
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    createFeishuClientMock.mockReset();
+  });
+
+  it("deletes placeholder rows whose fields contain only default empty values", async () => {
+    const { batchDelete, client } = createBitableClient([
+      { record_id: "rec_missing_fields" },
+      { record_id: "rec_empty_fields", fields: {} },
+      {
+        record_id: "rec_empty_defaults",
+        fields: {
+          Name: "",
+          Status: [],
+          Attachments: [],
+          Started: null,
+          EmptyObject: {},
+        },
+      },
+      {
+        record_id: "rec_empty_rich_text",
+        fields: { Notes: [{ type: "text", text: "" }] },
+      },
+      {
+        record_id: "rec_empty_nested",
+        fields: { Notes: { value: "", segments: [{ type: "text", text: "" }] } },
+      },
+      { record_id: "rec_text", fields: { Name: "Milestone" } },
+      { record_id: "rec_number", fields: { Estimate: 0 } },
+      { record_id: "rec_boolean", fields: { Done: false } },
+      { record_id: "rec_link", fields: { Link: { text: "", link: "https://example.com" } } },
+      { record_id: "rec_attachment", fields: { Attachments: [{ file_token: "boxcn_token" }] } },
+      { record_id: "rec_user", fields: { Assignee: [{ id: "ou_1", name: "" }] } },
+      { record_id: "rec_location", fields: { Location: { name: "", location: "116,39" } } },
+    ]);
+    createFeishuClientMock.mockReturnValue(client);
+
+    const { api, resolveTool } = createToolFactoryHarness(createConfig());
+    registerFeishuBitableTools(api);
+
+    const result = await resolveTool("feishu_bitable_create_app").execute("call", {
+      name: "Project Tracker",
+    });
+
+    expect(result.details.cleaned_placeholder_rows).toBe(5);
+    expect(batchDelete).toHaveBeenCalledWith({
+      path: { app_token: "app_token", table_id: "tbl_main" },
+      data: {
+        records: [
+          "rec_missing_fields",
+          "rec_empty_fields",
+          "rec_empty_defaults",
+          "rec_empty_rich_text",
+          "rec_empty_nested",
+        ],
+      },
+    });
+  });
+});