@kodelyth/feishu 2026.5.42 → 2026.6.1

package/src/approval-auth.ts

@@ -1,25 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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