@nextclaw/channel-plugin-feishu 0.2.18 → 0.2.20

package/src/reply-dispatcher.threading.test.ts

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const resolveFeishuAccountMock = vi.hoisted(() => vi.fn());
+const getFeishuRuntimeMock = vi.hoisted(() => vi.fn());
+const sendMessageFeishuMock = vi.hoisted(() => vi.fn());
+const sendMarkdownCardFeishuMock = vi.hoisted(() => vi.fn());
+const sendMediaFeishuMock = vi.hoisted(() => vi.fn());
+const createFeishuClientMock = vi.hoisted(() => vi.fn());
+const resolveReceiveIdTypeMock = vi.hoisted(() => vi.fn());
+const createReplyDispatcherWithTypingMock = vi.hoisted(() => vi.fn());
+const addTypingIndicatorMock = vi.hoisted(() => vi.fn(async () => ({ messageId: "om_msg" })));
+const removeTypingIndicatorMock = vi.hoisted(() => vi.fn(async () => {}));
+const streamingInstances = vi.hoisted(() => [] as any[]);
+
+vi.mock("./accounts.js", () => ({ resolveFeishuAccount: resolveFeishuAccountMock }));
+vi.mock("./runtime.js", () => ({ getFeishuRuntime: getFeishuRuntimeMock }));
+vi.mock("./send.js", () => ({
+  sendMessageFeishu: sendMessageFeishuMock,
+  sendMarkdownCardFeishu: sendMarkdownCardFeishuMock,
+}));
+vi.mock("./media.js", () => ({ sendMediaFeishu: sendMediaFeishuMock }));
+vi.mock("./client.js", () => ({ createFeishuClient: createFeishuClientMock }));
+vi.mock("./targets.js", () => ({ resolveReceiveIdType: resolveReceiveIdTypeMock }));
+vi.mock("./typing.js", () => ({
+  addTypingIndicator: addTypingIndicatorMock,
+  removeTypingIndicator: removeTypingIndicatorMock,
+}));
+vi.mock("./streaming-card.js", async () => {
+  const actual = await vi.importActual<typeof import("./streaming-card.js")>("./streaming-card.js");
+  return {
+    mergeStreamingText: actual.mergeStreamingText,
+    FeishuStreamingSession: class {
+      active = false;
+      start = vi.fn(async () => {
+        this.active = true;
+      });
+      update = vi.fn(async () => {});
+      close = vi.fn(async () => {
+        this.active = false;
+      });
+      isActive = vi.fn(() => this.active);
+
+      constructor() {
+        streamingInstances.push(this);
+      }
+    },
+  };
+});
+
+import { createFeishuReplyDispatcher } from "./reply-dispatcher.js";
+
+describe("createFeishuReplyDispatcher threading behavior", () => {
+  type ReplyDispatcherArgs = Parameters<typeof createFeishuReplyDispatcher>[0];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    streamingInstances.length = 0;
+    sendMediaFeishuMock.mockResolvedValue(undefined);
+
+    resolveFeishuAccountMock.mockReturnValue({
+      accountId: "main",
+      appId: "app_id",
+      appSecret: "app_secret",
+      domain: "feishu",
+      config: {
+        renderMode: "auto",
+        streaming: true,
+      },
+    });
+
+    resolveReceiveIdTypeMock.mockReturnValue("chat_id");
+    createFeishuClientMock.mockReturnValue({});
+
+    createReplyDispatcherWithTypingMock.mockImplementation((opts) => ({
+      dispatcher: {},
+      replyOptions: {},
+      markDispatchIdle: vi.fn(),
+      _opts: opts,
+    }));
+
+    getFeishuRuntimeMock.mockReturnValue({
+      channel: {
+        text: {
+          resolveTextChunkLimit: vi.fn(() => 4000),
+          resolveChunkMode: vi.fn(() => "line"),
+          resolveMarkdownTableMode: vi.fn(() => "preserve"),
+          convertMarkdownTables: vi.fn((text) => text),
+          chunkTextWithMode: vi.fn((text) => [text]),
+        },
+        reply: {
+          createReplyDispatcherWithTyping: createReplyDispatcherWithTypingMock,
+          resolveHumanDelayConfig: vi.fn(() => undefined),
+        },
+      },
+    });
+  });
+
+  function createRuntimeLogger() {
+    return { log: vi.fn(), error: vi.fn() } as never;
+  }
+
+  function createDispatcherHarness(overrides: Partial<ReplyDispatcherArgs> = {}) {
+    createFeishuReplyDispatcher({
+      cfg: {} as never,
+      agentId: "agent",
+      runtime: {} as never,
+      chatId: "oc_chat",
+      ...overrides,
+    });
+
+    return {
+      options: createReplyDispatcherWithTypingMock.mock.calls.at(-1)?.[0],
+    };
+  }
+
+  it("passes replyInThread to sendMessageFeishu for plain text", async () => {
+    const { options } = createDispatcherHarness({
+      replyToMessageId: "om_msg",
+      replyInThread: true,
+    });
+    await options.deliver({ text: "plain text" }, { kind: "final" });
+
+    expect(sendMessageFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        replyToMessageId: "om_msg",
+        replyInThread: true,
+      }),
+    );
+  });
+
+  it("passes replyInThread to sendMarkdownCardFeishu for card text", async () => {
+    resolveFeishuAccountMock.mockReturnValue({
+      accountId: "main",
+      appId: "app_id",
+      appSecret: "app_secret",
+      domain: "feishu",
+      config: {
+        renderMode: "card",
+        streaming: false,
+      },
+    });
+
+    const { options } = createDispatcherHarness({
+      replyToMessageId: "om_msg",
+      replyInThread: true,
+    });
+    await options.deliver({ text: "card text" }, { kind: "final" });
+
+    expect(sendMarkdownCardFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        replyToMessageId: "om_msg",
+        replyInThread: true,
+      }),
+    );
+  });
+
+  it("passes replyToMessageId and replyInThread to streaming.start()", async () => {
+    const { options } = createDispatcherHarness({
+      runtime: createRuntimeLogger(),
+      replyToMessageId: "om_msg",
+      replyInThread: true,
+    });
+    await options.deliver({ text: "```ts\nconst x = 1\n```" }, { kind: "final" });
+
+    expect(streamingInstances).toHaveLength(1);
+    expect(streamingInstances[0].start).toHaveBeenCalledWith("oc_chat", "chat_id", {
+      replyToMessageId: "om_msg",
+      replyInThread: true,
+    });
+  });
+
+  it("disables streaming for thread replies and keeps reply metadata", async () => {
+    const { options } = createDispatcherHarness({
+      runtime: createRuntimeLogger(),
+      replyToMessageId: "om_msg",
+      replyInThread: false,
+      threadReply: true,
+      rootId: "om_root_topic",
+    });
+    await options.deliver({ text: "```ts\nconst x = 1\n```" }, { kind: "final" });
+
+    expect(streamingInstances).toHaveLength(0);
+    expect(sendMarkdownCardFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        replyToMessageId: "om_msg",
+        replyInThread: true,
+      }),
+    );
+  });
+
+  it("passes replyInThread to media attachments", async () => {
+    const { options } = createDispatcherHarness({
+      replyToMessageId: "om_msg",
+      replyInThread: true,
+    });
+    await options.deliver({ mediaUrl: "https://example.com/a.png" }, { kind: "final" });
+
+    expect(sendMediaFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        replyToMessageId: "om_msg",
+        replyInThread: true,
+      }),
+    );
+  });
+});

package/src/reply-dispatcher.ts

@@ -266,9 +266,6 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
       onReplyStart: () => {
         deliveredFinalTexts.clear();
-        if (streamingEnabled && renderMode === "card") {
-          startStreaming();
-        }
         void typingCallbacks.onReplyStart?.();
       },
       deliver: async (payload: ReplyPayload, info) => {

package/src/sheets-shared.ts

@@ -0,0 +1,318 @@
+import type { createToolContext } from "./user-tool-helpers.js";
+import { assertLarkOk, json } from "./user-tool-helpers.js";
+import { wwwDomain } from "./domains.js";
+
+const MAX_READ_ROWS = 200;
+const MAX_WRITE_ROWS = 5000;
+const MAX_WRITE_COLS = 100;
+
+type UserToolClient = ReturnType<ReturnType<typeof createToolContext>["toolClient"]>;
+
+export type SheetParams = {
+  action: "info" | "read" | "write" | "append" | "find" | "create" | "export";
+  url?: string;
+  spreadsheet_token?: string;
+  range?: string;
+  sheet_id?: string;
+  value_render_option?: "FormattedValue" | "UnformattedValue" | "Formula" | "ToString";
+  values?: unknown[][];
+  find?: string;
+  match_case?: boolean;
+  match_entire_cell?: boolean;
+  search_by_regex?: boolean;
+  include_formulas?: boolean;
+  title?: string;
+  folder_token?: string;
+  headers?: unknown[];
+  data?: unknown[][];
+  file_extension?: "xlsx" | "csv";
+};
+
+export type SheetTokenInfo = {
+  token: string;
+  sheetId?: string;
+};
+
+function parseSheetUrl(url: string): SheetTokenInfo | null {
+  try {
+    const parsed = new URL(url);
+    const match = parsed.pathname.match(/\/sheets\/([^/?#]+)/);
+    if (!match) return null;
+    return { token: match[1], sheetId: parsed.searchParams.get("sheet") || undefined };
+  } catch {
+    return null;
+  }
+}
+
+export function resolveToken(params: SheetParams): SheetTokenInfo | null {
+  if (params.spreadsheet_token) return { token: params.spreadsheet_token };
+  if (params.url) return parseSheetUrl(params.url);
+  return null;
+}
+
+function colLetter(n: number): string {
+  let result = "";
+  let value = n;
+  while (value > 0) {
+    value -= 1;
+    result = String.fromCharCode(65 + (value % 26)) + result;
+    value = Math.floor(value / 26);
+  }
+  return result;
+}
+
+function flattenCellValue(cell: unknown): unknown {
+  if (!Array.isArray(cell)) return cell;
+  if (cell.length > 0 && cell.every((segment) => segment && typeof segment === "object" && "text" in (segment as object))) {
+    return cell.map((segment) => String((segment as { text?: unknown }).text ?? "")).join("");
+  }
+  return cell;
+}
+
+async function resolveSheetRange(
+  client: UserToolClient,
+  token: string,
+  range?: string,
+  sheetId?: string,
+) {
+  if (range) return range;
+  if (sheetId) return sheetId;
+  const response = await client.invoke(
+    "feishu_sheet.info",
+    (sdk, opts) => sdk.sheets.spreadsheetSheet.query({ path: { spreadsheet_token: token } }, opts),
+    { as: "user" },
+  );
+  assertLarkOk(response);
+  const firstSheet = (response.data as { sheets?: Array<{ sheet_id?: string }> } | undefined)?.sheets?.[0];
+  if (!firstSheet?.sheet_id) {
+    throw new Error("Spreadsheet has no worksheets.");
+  }
+  return firstSheet.sheet_id;
+}
+
+export async function handleCreate(client: UserToolClient, payload: SheetParams) {
+  const createResponse = await client.invoke(
+    "feishu_sheet.create",
+    (sdk, opts) =>
+      sdk.sheets.spreadsheet.create(
+        { data: { title: payload.title, folder_token: payload.folder_token } },
+        opts,
+      ),
+    { as: "user" },
+  );
+  assertLarkOk(createResponse);
+  const spreadsheet = (createResponse.data as { spreadsheet?: { spreadsheet_token?: string; title?: string } } | undefined)?.spreadsheet;
+  const token = spreadsheet?.spreadsheet_token;
+  if (!token) {
+    return json({ error: "创建电子表格失败，未返回 spreadsheet_token。" });
+  }
+  const allRows = [
+    ...(payload.headers ? [payload.headers] : []),
+    ...((payload.data as unknown[][] | undefined) ?? []),
+  ];
+  if (allRows.length > 0) {
+    const sheetsResponse = await client.invoke(
+      "feishu_sheet.create",
+      (sdk, opts) => sdk.sheets.spreadsheetSheet.query({ path: { spreadsheet_token: token } }, opts),
+      { as: "user" },
+    );
+    assertLarkOk(sheetsResponse);
+    const firstSheet = (sheetsResponse.data as { sheets?: Array<{ sheet_id?: string }> } | undefined)?.sheets?.[0];
+    if (firstSheet?.sheet_id) {
+      const numCols = Math.max(...allRows.map((row) => row.length), 1);
+      const range = `${firstSheet.sheet_id}!A1:${colLetter(numCols)}${allRows.length}`;
+      await client.invokeByPath("feishu_sheet.create", `/open-apis/sheets/v2/spreadsheets/${token}/values`, {
+        method: "PUT",
+        body: { valueRange: { range, values: allRows } },
+        as: "user",
+      });
+    }
+  }
+  return json({
+    spreadsheet_token: token,
+    title: spreadsheet?.title ?? payload.title,
+    url: `${wwwDomain(client.account.domain)}/sheets/${token}`,
+  });
+}
+
+export async function handleInfo(client: UserToolClient, token: string) {
+  const [spreadsheetRes, sheetsRes] = await Promise.all([
+    client.invoke(
+      "feishu_sheet.info",
+      (sdk, opts) => sdk.sheets.spreadsheet.get({ path: { spreadsheet_token: token } }, opts),
+      { as: "user" },
+    ),
+    client.invoke(
+      "feishu_sheet.info",
+      (sdk, opts) => sdk.sheets.spreadsheetSheet.query({ path: { spreadsheet_token: token } }, opts),
+      { as: "user" },
+    ),
+  ]);
+  assertLarkOk(spreadsheetRes);
+  assertLarkOk(sheetsRes);
+  return json({
+    title: (spreadsheetRes.data as { spreadsheet?: { title?: string } } | undefined)?.spreadsheet?.title,
+    spreadsheet_token: token,
+    url: `${wwwDomain(client.account.domain)}/sheets/${token}`,
+    sheets:
+      ((sheetsRes.data as { sheets?: Array<Record<string, unknown>> } | undefined)?.sheets ?? []).map((sheet) => ({
+        sheet_id: sheet.sheet_id,
+        title: sheet.title,
+        index: sheet.index,
+        row_count: (sheet.grid_properties as { row_count?: number } | undefined)?.row_count,
+        column_count: (sheet.grid_properties as { column_count?: number } | undefined)?.column_count,
+      })),
+  });
+}
+
+export async function handleRead(client: UserToolClient, tokenInfo: SheetTokenInfo, payload: SheetParams) {
+  const range = await resolveSheetRange(client, tokenInfo.token, payload.range, payload.sheet_id ?? tokenInfo.sheetId);
+  const response = await client.invokeByPath<{
+    data?: { valueRange?: { range?: string; values?: unknown[][] } };
+  }>("feishu_sheet.read", `/open-apis/sheets/v2/spreadsheets/${tokenInfo.token}/values/${encodeURIComponent(range)}`, {
+    method: "GET",
+    query: {
+      valueRenderOption: payload.value_render_option ?? "ToString",
+      dateTimeRenderOption: "FormattedString",
+    },
+    as: "user",
+  });
+  const values = (response.data?.valueRange?.values ?? []).map((row) => row.map(flattenCellValue));
+  return json({
+    range: response.data?.valueRange?.range,
+    values: values.slice(0, MAX_READ_ROWS),
+    ...(values.length > MAX_READ_ROWS
+      ? {
+          truncated: true,
+          total_rows: values.length,
+          hint: `结果超过 ${MAX_READ_ROWS} 行，已截断。请缩小 range 后重试。`,
+        }
+      : {}),
+  });
+}
+
+export async function handleWrite(client: UserToolClient, tokenInfo: SheetTokenInfo, payload: SheetParams) {
+  if ((payload.values?.length ?? 0) > MAX_WRITE_ROWS) {
+    return json({ error: `写入行数超过限制 ${MAX_WRITE_ROWS}` });
+  }
+  if ((payload.values ?? []).some((row) => row.length > MAX_WRITE_COLS)) {
+    return json({ error: `写入列数超过限制 ${MAX_WRITE_COLS}` });
+  }
+  const range = await resolveSheetRange(client, tokenInfo.token, payload.range, payload.sheet_id ?? tokenInfo.sheetId);
+  const response = await client.invokeByPath<{
+    data?: {
+      updatedRange?: string;
+      updatedRows?: number;
+      updatedColumns?: number;
+      updatedCells?: number;
+      revision?: number;
+      updates?: {
+        updatedRange?: string;
+        updatedRows?: number;
+        updatedColumns?: number;
+        updatedCells?: number;
+        revision?: number;
+      };
+    };
+  }>(
+    payload.action === "write" ? "feishu_sheet.write" : "feishu_sheet.append",
+    `/open-apis/sheets/v2/spreadsheets/${tokenInfo.token}/${payload.action === "write" ? "values" : "values_append"}`,
+    {
+      method: payload.action === "write" ? "PUT" : "POST",
+      body: { valueRange: { range, values: payload.values } },
+      as: "user",
+    },
+  );
+  const updates = response.data?.updates ?? response.data;
+  return json({
+    updated_range: updates?.updatedRange,
+    updated_rows: updates?.updatedRows,
+    updated_columns: updates?.updatedColumns,
+    updated_cells: updates?.updatedCells,
+    revision: updates?.revision,
+  });
+}
+
+export async function handleFind(client: UserToolClient, token: string, payload: SheetParams) {
+  const response = await client.invoke(
+    "feishu_sheet.find",
+    (sdk, opts) =>
+      sdk.sheets.spreadsheetSheet.find(
+        {
+          path: { spreadsheet_token: token, sheet_id: payload.sheet_id! },
+          data: {
+            find: payload.find,
+            find_condition: {
+              range: payload.range ? `${payload.sheet_id}!${payload.range}` : payload.sheet_id,
+              ...(payload.match_case !== undefined ? { match_case: !payload.match_case } : {}),
+              ...(payload.match_entire_cell !== undefined ? { match_entire_cell: payload.match_entire_cell } : {}),
+              ...(payload.search_by_regex !== undefined ? { search_by_regex: payload.search_by_regex } : {}),
+              ...(payload.include_formulas !== undefined ? { include_formulas: payload.include_formulas } : {}),
+            },
+          },
+        },
+        opts,
+      ),
+    { as: "user" },
+  );
+  assertLarkOk(response);
+  return json({
+    matched_cells: (response.data as { find_result?: { matched_cells?: unknown[] } } | undefined)?.find_result?.matched_cells ?? [],
+    matched_formula_cells:
+      (response.data as { find_result?: { matched_formula_cells?: unknown[] } } | undefined)?.find_result?.matched_formula_cells ?? [],
+  });
+}
+
+export async function handleExport(client: UserToolClient, token: string, payload: SheetParams) {
+  const exportCreate = await client.invoke(
+    "feishu_sheet.export",
+    (sdk, opts) =>
+      sdk.drive.exportTask.create(
+        {
+          data: {
+            file_extension: payload.file_extension,
+            token,
+            type: "sheet",
+            sub_id: payload.sheet_id,
+          },
+        },
+        opts,
+      ),
+    { as: "user" },
+  );
+  assertLarkOk(exportCreate);
+  const ticket = (exportCreate.data as { ticket?: string } | undefined)?.ticket;
+  if (!ticket) {
+    return json({ error: "导出任务创建失败，未返回 ticket。" });
+  }
+  for (let i = 0; i < 30; i += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const exportStatus = await client.invoke(
+      "feishu_sheet.export",
+      (sdk, opts) => sdk.drive.exportTask.get({ path: { ticket }, params: { token } }, opts),
+      { as: "user" },
+    );
+    assertLarkOk(exportStatus);
+    const result = (exportStatus.data as {
+      result?: {
+        job_status?: number;
+        file_token?: string;
+        file_name?: string;
+        file_size?: number;
+        job_error_msg?: string;
+      };
+    } | undefined)?.result;
+    if (result?.job_status === 0) {
+      return json({
+        file_token: result.file_token,
+        file_name: result.file_name,
+        file_size: result.file_size,
+        file_extension: payload.file_extension,
+      });
+    }
+    if ((result?.job_status ?? 0) >= 3) {
+      return json({ error: result?.job_error_msg ?? `导出失败 (status=${result?.job_status})` });
+    }
+  }
+  return json({ error: "导出任务超时，请稍后重试。" });
+}