chatccc 0.2.252 → 0.2.253

package/src/__tests__/feishu-avatar.test.ts

@@ -1,504 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import sharp from "sharp";
-
-const mockConfig = {
-  cursor: {
-    avatarBatteryMode: "apiPercent",
-    onDemandMonthlyBudget: 1000,
-  },
-};
-const getCursorUsageSummaryMock = vi.fn();
-
-async function loadFeishuApiWithHome(homeDir: string, userDataDir: string) {
-  vi.resetModules();
-  vi.doMock("node:os", () => ({ homedir: () => homeDir }));
-  vi.doMock("../config.ts", () => ({
-    APP_ID: "app_id",
-    APP_SECRET: "app_secret",
-    BASE_URL: "https://open.feishu.test",
-    CHAT_LOGS_DIR: join(userDataDir, "logs"),
-    PROJECT_ROOT: process.cwd(),
-    USER_DATA_DIR: userDataDir,
-    CLAUDE_SESSION_PREFIX: "Claude Code Session:",
-    CURSOR_SESSION_PREFIX: "Cursor Session:",
-    CODEX_SESSION_PREFIX: "Codex Session:",
-    ts: () => "test-ts",
-    resolveDefaultAgentTool: () => "claude",
-    toolDisplayName: (tool: string) => tool,
-    config: mockConfig,
-  }));
-  vi.doMock("../cursor-usage.ts", () => ({
-    getCursorUsageSummary: getCursorUsageSummaryMock,
-  }));
-  return import("../feishu-api.ts");
-}
-
-async function writeCodexAuth(homeDir: string): Promise<void> {
-  const codexDir = join(homeDir, ".codex");
-  await mkdir(codexDir, { recursive: true });
-  await writeFile(
-    join(codexDir, "auth.json"),
-    JSON.stringify({ tokens: { access_token: "codex-access-token", account_id: "codex-account-id" } }),
-    "utf-8",
-  );
-}
-
-function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void {
-  vi.stubGlobal("fetch", vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
-    const urlText = String(url);
-    if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
-      return usageResponse.clone();
-    }
-    if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
-      return new Response(JSON.stringify({ credits: [] }), { status: 200 });
-    }
-    if (urlText === "https://open.feishu.test/im/v1/images") {
-      const form = init?.body as FormData;
-      const image = form.get("image") as File;
-      uploadedNames.push(image.name);
-      return new Response(JSON.stringify({ code: 0, data: { image_key: "img_test" } }), { status: 200 });
-    }
-    if (urlText === "https://open.feishu.test/im/v1/chats/chat_1") {
-      return new Response(JSON.stringify({ code: 0 }), { status: 200 });
-    }
-    throw new Error(`unexpected fetch: ${urlText}`);
-  }));
-}
-
-function mockAvatarUploadOnlyFetch(
-  uploadedNames: string[],
-  uploadedImages: Buffer[] = [],
-): ReturnType<typeof vi.fn> {
-  const fetchMock = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
-    const urlText = String(url);
-    if (urlText === "https://open.feishu.test/im/v1/images") {
-      const form = init?.body as FormData;
-      const image = form.get("image") as File;
-      uploadedNames.push(image.name);
-      uploadedImages.push(Buffer.from(await image.arrayBuffer()));
-      return new Response(JSON.stringify({ code: 0, data: { image_key: "img_test" } }), { status: 200 });
-    }
-    if (urlText === "https://open.feishu.test/im/v1/chats/chat_1") {
-      return new Response(JSON.stringify({ code: 0 }), { status: 200 });
-    }
-    throw new Error(`unexpected fetch: ${urlText}`);
-  });
-  vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-describe("Plain avatar fallback", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.doUnmock("node:os");
-    vi.doUnmock("../config.ts");
-    vi.doUnmock("../cursor-usage.ts");
-    vi.restoreAllMocks();
-    getCursorUsageSummaryMock.mockReset();
-    mockConfig.cursor.avatarBatteryMode = "apiPercent";
-    mockConfig.cursor.onDemandMonthlyBudget = 1000;
-  });
-
-  it("uses a status-only avatar for unknown tools instead of falling back to Claude", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    mockAvatarUploadOnlyFetch(uploadedNames);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "ccc", "new");
-
-      expect(uploadedNames).toEqual(["avatar_plain_new.jpg"]);
-      const cacheRaw = await readFile(join(userDataDir, "state", "avatar-image-keys.json"), "utf-8");
-      const cache = JSON.parse(cacheRaw) as Record<string, string>;
-      expect(cache["plain:new"]).toBe("img_test");
-      expect(cache["claude:new"]).toBeUndefined();
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("Codex avatar usage battery", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.doUnmock("node:os");
-    vi.doUnmock("../config.ts");
-    vi.doUnmock("../cursor-usage.ts");
-    vi.restoreAllMocks();
-    getCursorUsageSummaryMock.mockReset();
-    mockConfig.cursor.avatarBatteryMode = "apiPercent";
-    mockConfig.cursor.onDemandMonthlyBudget = 1000;
-  });
-
-  it("adds 7-day battery and 5h ring percentages to Codex avatar uploads when both windows exist", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    await writeCodexAuth(homeDir);
-    mockAvatarFetch(uploadedNames, new Response(JSON.stringify({
-      rate_limit: {
-        primary_window: { used_percent: 37, limit_window_seconds: 18000 },
-        secondary_window: { used_percent: 12, limit_window_seconds: 604800 },
-      },
-    }), { status: 200 }));
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "codex", "busy");
-
-      expect(uploadedNames).toEqual(["avatar_codex_busy_7d_88_5h_63.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("uses a 7-day battery without a 5h ring when the API only returns a 7-day window", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    await writeCodexAuth(homeDir);
-    mockAvatarFetch(uploadedNames, new Response(JSON.stringify({
-      rate_limit: {
-        primary_window: {
-          used_percent: 23,
-          limit_window_seconds: 604800,
-          reset_after_seconds: 500000,
-          reset_at: 1784510226,
-        },
-        secondary_window: null,
-      },
-    }), { status: 200 }));
-
-    try {
-      const { getCodexUsageSummary, setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-
-      await expect(getCodexUsageSummary()).resolves.toEqual({
-        fiveHour: null,
-        weekly: {
-          usedPercent: 23,
-          remainingPercent: 77,
-          resetAfterSeconds: 500000,
-          resetAtEpochSeconds: 1784510226,
-          limitWindowSeconds: 604800,
-        },
-        rateLimitResetCreditsAvailable: null,
-        rateLimitResetCredits: [],
-      });
-
-      await setChatAvatar("tenant-token", "chat_1", "codex", "busy");
-
-      expect(uploadedNames).toEqual(["avatar_codex_busy_7d_77.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("uses provided Codex usage without fetching usage again", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    const fetchMock = mockAvatarUploadOnlyFetch(uploadedNames);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "codex", "busy", {
-        codexUsage: {
-          fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: null, resetAfterSeconds: null },
-          weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: null, resetAfterSeconds: null },
-          rateLimitResetCreditsAvailable: null,
-          rateLimitResetCredits: null,
-        },
-      });
-
-      expect(uploadedNames).toEqual(["avatar_codex_busy_7d_88_5h_63.jpg"]);
-      expect(fetchMock).not.toHaveBeenCalledWith("https://chatgpt.com/backend-api/wham/usage", expect.anything());
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("isolates Fast and standard Codex avatars in the upload cache", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    mockAvatarUploadOnlyFetch(uploadedNames);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "codex", "idle", {
-        codexUsage: null,
-        fastMode: false,
-      });
-      await setChatAvatar("tenant-token", "chat_1", "codex", "idle", {
-        codexUsage: null,
-        fastMode: true,
-      });
-
-      expect(uploadedNames).toEqual([
-        "avatar_codex_idle.jpg",
-        "avatar_codex_idle_fast.jpg",
-      ]);
-      const cacheRaw = await readFile(join(userDataDir, "state", "avatar-image-keys.json"), "utf-8");
-      const cache = JSON.parse(cacheRaw) as Record<string, string>;
-      expect(cache["codex:idle:plain"]).toBe("img_test");
-      expect(cache["codex:idle:plain:fast-champagne-frame-v2"]).toBe("img_test");
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("renders an extra-thick champagne frame above the Codex badge in Fast mode", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    const uploadedImages: Buffer[] = [];
-    mockAvatarUploadOnlyFetch(uploadedNames, uploadedImages);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "codex", "idle", {
-        codexUsage: null,
-        fastMode: true,
-      });
-
-      expect(uploadedNames).toEqual(["avatar_codex_idle_fast.jpg"]);
-      const { data, info } = await sharp(uploadedImages[0]).raw().toBuffer({ resolveWithObject: true });
-      const pixelOffset = (144 * info.width + 200) * info.channels;
-      const [red, green, blue] = data.subarray(pixelOffset, pixelOffset + 3);
-      expect(red).toBeGreaterThan(220);
-      expect(green).toBeGreaterThan(150);
-      expect(blue).toBeLessThan(180);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("returns both usage windows and available reset credit expiries", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    await writeCodexAuth(homeDir);
-    const fetchMock = vi.fn(async (url: string | URL | Request) => {
-      const urlText = String(url);
-      if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
-        return new Response(JSON.stringify({
-          rate_limit: {
-            primary_window: { used_percent: 37, reset_after_seconds: 10349, reset_at: 1781528212 },
-            secondary_window: { used_percent: 12, reset_after_seconds: 325063, reset_at: 1781842926 },
-          },
-          rate_limit_reset_credits: { available_count: 1 },
-        }), { status: 200 });
-      }
-      if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
-        return new Response(JSON.stringify({
-          available_count: 2,
-          credits: [
-            {
-              status: "available",
-              granted_at: "2026-06-12T04:01:47.770016Z",
-              expires_at: "2026-07-12T04:01:47.770016Z",
-            },
-            {
-              status: "redeemed",
-              granted_at: "2026-06-13T04:01:47.770016Z",
-              expires_at: "2026-07-13T04:01:47.770016Z",
-            },
-            {
-              status: "available",
-              granted_at: "2026-06-18T00:44:23.904386Z",
-              expires_at: "2026-07-18T00:44:23.904386Z",
-            },
-          ],
-        }), { status: 200 });
-      }
-      throw new Error(`unexpected fetch: ${urlText}`);
-    });
-    vi.stubGlobal("fetch", fetchMock);
-
-    try {
-      const { getCodexUsageSummary } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await expect(getCodexUsageSummary()).resolves.toEqual({
-        fiveHour: { usedPercent: 37, remainingPercent: 63, resetAfterSeconds: 10349, resetAtEpochSeconds: 1781528212 },
-        weekly: { usedPercent: 12, remainingPercent: 88, resetAfterSeconds: 325063, resetAtEpochSeconds: 1781842926 },
-        rateLimitResetCreditsAvailable: 2,
-        rateLimitResetCredits: [
-          { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
-          { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
-        ],
-      });
-      expect(fetchMock).toHaveBeenCalledWith(
-        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits",
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: "Bearer codex-access-token",
-            "ChatGPT-Account-ID": "codex-account-id",
-            "OpenAI-Beta": "codex-1",
-            originator: "Codex Desktop",
-          }),
-        }),
-      );
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("consumes a Codex rate-limit reset credit through the WHAM endpoint", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    await writeCodexAuth(homeDir);
-    const fetchMock = vi.fn(async () => new Response(JSON.stringify({
-      code: "reset",
-      windows_reset: 2,
-    }), { status: 200 }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    try {
-      const { consumeCodexRateLimitResetCredit } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await expect(consumeCodexRateLimitResetCredit("request-1")).resolves.toEqual({
-        code: "reset",
-        windowsReset: 2,
-      });
-      expect(fetchMock).toHaveBeenCalledWith(
-        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume",
-        expect.objectContaining({
-          method: "POST",
-          headers: expect.objectContaining({
-            Authorization: "Bearer codex-access-token",
-            "Content-Type": "application/json",
-          }),
-          body: JSON.stringify({ redeem_request_id: "request-1" }),
-        }),
-      );
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("falls back to the pre-combined Codex avatar when usage lookup fails", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    await writeCodexAuth(homeDir);
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-    mockAvatarFetch(uploadedNames, new Response("fail", { status: 500 }));
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "codex", "idle");
-
-      expect(uploadedNames).toEqual(["avatar_codex_idle.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("Cursor avatar usage battery", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.doUnmock("node:os");
-    vi.doUnmock("../config.ts");
-    vi.doUnmock("../cursor-usage.ts");
-    vi.restoreAllMocks();
-    getCursorUsageSummaryMock.mockReset();
-    mockConfig.cursor.avatarBatteryMode = "apiPercent";
-    mockConfig.cursor.onDemandMonthlyBudget = 1000;
-  });
-
-  it("uses remaining API percentage for Cursor avatar battery", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    getCursorUsageSummaryMock.mockResolvedValue({
-      planUsage: { apiPercentUsed: 40 },
-    });
-    mockAvatarFetch(uploadedNames, new Response("unused", { status: 500 }));
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "cursor", "busy");
-
-      expect(uploadedNames).toEqual(["avatar_cursor_busy_battery_60.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("uses provided Cursor usage without fetching usage again", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    mockAvatarUploadOnlyFetch(uploadedNames);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "cursor", "idle", {
-        cursorUsage: {
-          planUsage: { apiPercentUsed: 30 },
-        },
-      });
-
-      expect(uploadedNames).toEqual(["avatar_cursor_idle_battery_70.jpg"]);
-      expect(getCursorUsageSummaryMock).not.toHaveBeenCalled();
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("uses On-Demand budget for Cursor avatar battery when configured", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    mockConfig.cursor.avatarBatteryMode = "onDemandUse";
-    mockConfig.cursor.onDemandMonthlyBudget = 1000;
-    getCursorUsageSummaryMock.mockResolvedValue({
-      spendLimitUsage: { individualUsed: 25000 },
-    });
-    mockAvatarFetch(uploadedNames, new Response("unused", { status: 500 }));
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "cursor", "idle");
-
-      expect(uploadedNames).toEqual(["avatar_cursor_idle_battery_75.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-
-  it("falls back to the pre-combined Cursor avatar when usage lookup fails", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-    getCursorUsageSummaryMock.mockRejectedValue(new Error("cursor unavailable"));
-    mockAvatarFetch(uploadedNames, new Response("unused", { status: 500 }));
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "cursor", "busy");
-
-      expect(uploadedNames).toEqual(["avatar_cursor_busy.jpg"]);
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-});

package/src/__tests__/feishu-message-ingress.test.ts

@@ -1,138 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import {
-  FeishuMessageLedger,
-  createAckFirstEventHandler,
-} from "../feishu-message-ingress.ts";
-
-const tempDirs: string[] = [];
-
-async function createLedger(maxEntries = 5): Promise<FeishuMessageLedger> {
-  const dir = await mkdtemp(join(tmpdir(), "chatccc-feishu-ingress-"));
-  tempDirs.push(dir);
-  return new FeishuMessageLedger(join(dir, "messages.json"), maxEntries);
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-describe("createAckFirstEventHandler", () => {
-  it("returns before starting the asynchronous event worker", async () => {
-    let scheduled: (() => void) | undefined;
-    const schedule = vi.fn((task: () => void) => {
-      scheduled = task;
-    });
-    const worker = vi.fn(async () => {});
-    const onError = vi.fn();
-    const handler = createAckFirstEventHandler(worker, onError, schedule);
-
-    await expect(handler({ message: "test" })).resolves.toBeUndefined();
-    expect(schedule).toHaveBeenCalledOnce();
-    expect(worker).not.toHaveBeenCalled();
-
-    scheduled?.();
-    await vi.waitFor(() => expect(worker).toHaveBeenCalledWith({ message: "test" }));
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("reports detached worker failures without rejecting the SDK callback", async () => {
-    const error = new Error("worker failed");
-    const onError = vi.fn();
-    const handler = createAckFirstEventHandler(
-      async () => {
-        throw error;
-      },
-      onError,
-      (task) => task(),
-    );
-
-    await expect(handler({})).resolves.toBeUndefined();
-    await vi.waitFor(() => expect(onError).toHaveBeenCalledWith(error));
-  });
-});
-
-describe("FeishuMessageLedger", () => {
-  it("rejects an already accepted message after a process restart", async () => {
-    const first = await createLedger();
-    await first.load();
-
-    expect(await first.accept({
-      messageId: "om_001",
-      chatId: "oc_chat",
-      createTime: 100,
-    })).toBe("accepted");
-
-    const restarted = new FeishuMessageLedger(first.filePath, 5);
-    await restarted.load();
-
-    expect(await restarted.accept({
-      messageId: "om_001",
-      chatId: "oc_chat",
-      createTime: 100,
-    })).toBe("duplicate");
-  });
-
-  it("rejects a unique old event after restoring the chat high-water mark", async () => {
-    const first = await createLedger();
-    await first.load();
-
-    expect(await first.accept({
-      messageId: "om_new",
-      chatId: "oc_chat",
-      createTime: 200,
-    })).toBe("accepted");
-
-    const restarted = new FeishuMessageLedger(first.filePath, 5);
-    await restarted.load();
-
-    expect(await restarted.accept({
-      messageId: "om_old",
-      chatId: "oc_chat",
-      createTime: 100,
-    })).toBe("stale");
-  });
-
-  it("accepts distinct messages with the same create timestamp", async () => {
-    const ledger = await createLedger();
-    await ledger.load();
-
-    expect(await ledger.accept({
-      messageId: "om_001",
-      chatId: "oc_chat",
-      createTime: 100,
-    })).toBe("accepted");
-    expect(await ledger.accept({
-      messageId: "om_002",
-      chatId: "oc_chat",
-      createTime: 100,
-    })).toBe("accepted");
-  });
-
-  it("keeps only the configured number of recent message IDs", async () => {
-    const ledger = await createLedger(2);
-    await ledger.load();
-
-    await ledger.accept({ messageId: "om_001", chatId: "oc_chat", createTime: 100 });
-    await ledger.accept({ messageId: "om_002", chatId: "oc_chat", createTime: 200 });
-    await ledger.accept({ messageId: "om_003", chatId: "oc_chat", createTime: 300 });
-
-    const restarted = new FeishuMessageLedger(ledger.filePath, 2);
-    await restarted.load();
-
-    expect(await restarted.accept({
-      messageId: "om_001",
-      chatId: "oc_other",
-      createTime: 100,
-    })).toBe("accepted");
-    expect(await restarted.accept({
-      messageId: "om_003",
-      chatId: "oc_chat",
-      createTime: 300,
-    })).toBe("duplicate");
-  });
-});