@kodelyth/feishu 2026.5.42 → 2026.6.2

package/src/comment-dispatcher-runtime-api.ts

@@ -1,6 +0,0 @@
-export {
-  createReplyPrefixContext,
-  type ClawdbotConfig,
-  type ReplyPayload,
-  type RuntimeEnv,
-} from "../runtime-api.js";

package/src/comment-dispatcher.test.ts

@@ -1,185 +0,0 @@
-import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const resolveFeishuRuntimeAccountMock = vi.hoisted(() => vi.fn());
-const createFeishuClientMock = vi.hoisted(() => vi.fn());
-const createReplyPrefixContextMock = vi.hoisted(() => vi.fn());
-const createCommentTypingReactionLifecycleMock = vi.hoisted(() => vi.fn());
-const deliverCommentThreadTextMock = vi.hoisted(() => vi.fn());
-const createReplyDispatcherWithTypingMock = vi.hoisted(() => vi.fn());
-const getFeishuRuntimeMock = vi.hoisted(() => vi.fn());
-
-vi.mock("./accounts.js", () => ({
-  resolveFeishuRuntimeAccount: resolveFeishuRuntimeAccountMock,
-}));
-
-vi.mock("./client.js", () => ({
-  createFeishuClient: createFeishuClientMock,
-}));
-
-vi.mock("./comment-dispatcher-runtime-api.js", () => ({
-  createReplyPrefixContext: createReplyPrefixContextMock,
-}));
-
-vi.mock("./comment-reaction.js", () => ({
-  createCommentTypingReactionLifecycle: createCommentTypingReactionLifecycleMock,
-}));
-
-vi.mock("./drive.js", () => ({
-  deliverCommentThreadText: deliverCommentThreadTextMock,
-}));
-
-vi.mock("./runtime.js", () => ({
-  getFeishuRuntime: getFeishuRuntimeMock,
-}));
-
-import { createFeishuCommentReplyDispatcher } from "./comment-dispatcher.js";
-
-async function raceWithNextMacrotask<T>(promise: Promise<T>): Promise<T | "pending"> {
-  return await Promise.race([
-    promise,
-    new Promise<"pending">((resolve) => {
-      setImmediate(() => resolve("pending"));
-    }),
-  ]);
-}
-
-describe("createFeishuCommentReplyDispatcher", () => {
-  afterAll(() => {
-    vi.doUnmock("./accounts.js");
-    vi.doUnmock("./client.js");
-    vi.doUnmock("./comment-dispatcher-runtime-api.js");
-    vi.doUnmock("./comment-reaction.js");
-    vi.doUnmock("./drive.js");
-    vi.doUnmock("./runtime.js");
-    vi.resetModules();
-  });
-
-  function createTestCommentReplyDispatcher() {
-    createFeishuCommentReplyDispatcher({
-      cfg: {} as never,
-      agentId: "main",
-      runtime: { log: vi.fn(), error: vi.fn() } as never,
-      accountId: "main",
-      fileToken: "doc_token_1",
-      fileType: "docx",
-      commentId: "comment_1",
-      replyId: "reply_1",
-      isWholeComment: false,
-    });
-  }
-
-  function latestReplyDispatcherOptions() {
-    const options = createReplyDispatcherWithTypingMock.mock.calls.at(-1)?.[0];
-    if (!options) {
-      throw new Error("expected reply dispatcher options");
-    }
-    return options as {
-      deliver: (payload: { text: string }, phase: { kind: string }) => Promise<void> | void;
-      onCleanup?: () => Promise<void> | void;
-      onReplyStart?: () => Promise<void> | void;
-    };
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    resolveFeishuRuntimeAccountMock.mockReturnValue({
-      accountId: "main",
-      appId: "app_id",
-      appSecret: "app_secret",
-      domain: "feishu",
-      config: {},
-    });
-    createFeishuClientMock.mockReturnValue({});
-    createReplyPrefixContextMock.mockReturnValue({
-      responsePrefix: undefined,
-      responsePrefixContextProvider: undefined,
-    });
-    deliverCommentThreadTextMock.mockResolvedValue({
-      delivery_mode: "reply_comment",
-      reply_id: "reply_1",
-    });
-    createCommentTypingReactionLifecycleMock.mockReturnValue({
-      start: vi.fn(async () => {}),
-      cleanup: vi.fn(async () => {}),
-    });
-    createReplyDispatcherWithTypingMock.mockImplementation(() => ({
-      dispatcher: {
-        markComplete: vi.fn(),
-        waitForIdle: vi.fn(async () => {}),
-      },
-      replyOptions: {},
-      markDispatchIdle: vi.fn(),
-      markRunComplete: vi.fn(),
-    }));
-    getFeishuRuntimeMock.mockReturnValue({
-      channel: {
-        text: {
-          resolveTextChunkLimit: vi.fn(() => 4000),
-          resolveChunkMode: vi.fn(() => "line"),
-          chunkTextWithMode: vi.fn((text: string) => [text]),
-        },
-        reply: {
-          createReplyDispatcherWithTyping: createReplyDispatcherWithTypingMock,
-          resolveHumanDelayConfig: vi.fn(() => undefined),
-        },
-      },
-    });
-  });
-
-  it("sends final comment text without waiting for typing cleanup", async () => {
-    let resolveCleanup: (() => void) | undefined;
-    const cleanup = vi.fn(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveCleanup = resolve;
-        }),
-    );
-    createCommentTypingReactionLifecycleMock.mockReturnValue({
-      start: vi.fn(async () => {}),
-      cleanup,
-    });
-
-    createTestCommentReplyDispatcher();
-
-    const options = latestReplyDispatcherOptions();
-    const deliverPromise = Promise.resolve(
-      options.deliver({ text: "hello world" }, { kind: "final" }),
-    );
-    const status = await raceWithNextMacrotask(deliverPromise.then(() => "done"));
-
-    expect(status).toBe("done");
-    const client = createFeishuClientMock.mock.results[0]?.value;
-    if (!client) {
-      throw new Error("Expected Feishu client");
-    }
-    expect(deliverCommentThreadTextMock).toHaveBeenCalledWith(client, {
-      file_token: "doc_token_1",
-      file_type: "docx",
-      comment_id: "comment_1",
-      content: "hello world",
-      is_whole_comment: false,
-    });
-    expect(cleanup).not.toHaveBeenCalled();
-
-    void options.onCleanup?.();
-    expect(cleanup).toHaveBeenCalledTimes(1);
-
-    resolveCleanup?.();
-    await deliverPromise;
-  });
-
-  it("starts the typing reaction from dispatcher onReplyStart", async () => {
-    const start = vi.fn(async () => {});
-    createCommentTypingReactionLifecycleMock.mockReturnValue({
-      start,
-      cleanup: vi.fn(async () => {}),
-    });
-
-    createTestCommentReplyDispatcher();
-
-    const options = latestReplyDispatcherOptions();
-    await options.onReplyStart?.();
-
-    expect(start).toHaveBeenCalledTimes(1);
-  });
-});

package/src/comment-dispatcher.ts

@@ -1,107 +0,0 @@
-import { resolveSendableOutboundReplyParts } from "klaw/plugin-sdk/reply-payload";
-import { resolveFeishuRuntimeAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import {
-  createReplyPrefixContext,
-  type ClawdbotConfig,
-  type ReplyPayload,
-  type RuntimeEnv,
-} from "./comment-dispatcher-runtime-api.js";
-import { createCommentTypingReactionLifecycle } from "./comment-reaction.js";
-import type { CommentFileType } from "./comment-target.js";
-import { deliverCommentThreadText } from "./drive.js";
-import { getFeishuRuntime } from "./runtime.js";
-
-type CreateFeishuCommentReplyDispatcherParams = {
-  cfg: ClawdbotConfig;
-  agentId: string;
-  runtime: RuntimeEnv;
-  accountId?: string;
-  fileToken: string;
-  fileType: CommentFileType;
-  commentId: string;
-  replyId?: string;
-  isWholeComment?: boolean;
-};
-
-export function createFeishuCommentReplyDispatcher(
-  params: CreateFeishuCommentReplyDispatcherParams,
-) {
-  const core = getFeishuRuntime();
-  const prefixContext = createReplyPrefixContext({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "feishu",
-    accountId: params.accountId,
-  });
-  const account = resolveFeishuRuntimeAccount({ cfg: params.cfg, accountId: params.accountId });
-  const client = createFeishuClient(account);
-  const textChunkLimit = core.channel.text.resolveTextChunkLimit(
-    params.cfg,
-    "feishu",
-    params.accountId,
-    {
-      fallbackLimit: 4000,
-    },
-  );
-  const chunkMode = core.channel.text.resolveChunkMode(params.cfg, "feishu");
-  const typingReaction = createCommentTypingReactionLifecycle({
-    cfg: params.cfg,
-    fileToken: params.fileToken,
-    fileType: params.fileType,
-    replyId: params.replyId,
-    accountId: params.accountId,
-    runtime: params.runtime,
-  });
-
-  const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } =
-    core.channel.reply.createReplyDispatcherWithTyping({
-      responsePrefix: prefixContext.responsePrefix,
-      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-      humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
-      onReplyStart: async () => {
-        await typingReaction.start();
-      },
-      deliver: async (payload: ReplyPayload, info) => {
-        if (info.kind !== "final") {
-          return;
-        }
-        const reply = resolveSendableOutboundReplyParts(payload);
-        if (!reply.hasText) {
-          if (reply.hasMedia) {
-            params.runtime.log?.(
-              `feishu[${params.accountId ?? "default"}]: comment reply ignored media-only payload for comment=${params.commentId}`,
-            );
-          }
-          return;
-        }
-        const chunks = core.channel.text.chunkTextWithMode(reply.text, textChunkLimit, chunkMode);
-        for (const chunk of chunks) {
-          await deliverCommentThreadText(client, {
-            file_token: params.fileToken,
-            file_type: params.fileType,
-            comment_id: params.commentId,
-            content: chunk,
-            is_whole_comment: params.isWholeComment,
-          });
-        }
-      },
-      onError: (err, info) => {
-        params.runtime.error?.(
-          `feishu[${params.accountId ?? "default"}]: comment dispatcher failed kind=${info.kind} comment=${params.commentId}: ${String(err)}`,
-        );
-      },
-      onCleanup: () => {
-        void typingReaction.cleanup();
-      },
-    });
-
-  return {
-    dispatcher,
-    replyOptions,
-    markDispatchIdle,
-    markRunComplete,
-    startTypingReaction: typingReaction.start,
-    cleanupTypingReaction: typingReaction.cleanup,
-  };
-}

package/src/comment-handler-runtime-api.ts

@@ -1,3 +0,0 @@
-export type { KlawConfig as ClawdbotConfig } from "klaw/plugin-sdk/config-contracts";
-export type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-export { createChannelPairingController } from "klaw/plugin-sdk/channel-pairing";