chatccc 0.2.226 → 0.2.228

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

@@ -1,9 +1,9 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+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";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import sharp from "sharp";
 
 const mockConfig = {
   cursor: {
@@ -69,18 +69,18 @@ function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void
   }));
 }
 
-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 });
+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 });
@@ -88,10 +88,44 @@ function mockAvatarUploadOnlyFetch(
     throw new Error(`unexpected fetch: ${urlText}`);
   });
   vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-describe("Plain avatar fallback", () => {
+  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");
@@ -103,106 +137,72 @@ describe("Plain avatar fallback", () => {
     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 () => {
+  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 },
-      },
+      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"]);
+      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 () => {
+  });
+
+  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[] = [];
@@ -219,71 +219,71 @@ describe("Codex avatar usage battery", () => {
         },
       });
 
-      expect(uploadedNames).toEqual(["avatar_codex_busy_7d_88_5h_63.jpg"]);
+      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("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-"));

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

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