chatccc 0.2.230 → 0.2.231

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

@@ -1,60 +1,60 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { sendTextReply } from "../feishu-api.ts";
-
-function abortError(): Error {
-  const err = new Error("aborted");
-  err.name = "AbortError";
-  return err;
-}
-
-describe("sendTextReply timeout", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it("aborts a hung text send request", async () => {
-    vi.useFakeTimers();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
-      new Promise<Response>((_resolve, reject) => {
-        init?.signal?.addEventListener("abort", () => reject(abortError()));
-      })
-    ));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const send = expect(sendTextReply("token", "chat-1", "hello"))
-      .resolves.toBe(false);
-    await vi.advanceTimersByTimeAsync(15_000);
-
-    await send;
-    expect(fetchMock).toHaveBeenCalledWith(
-      expect.stringContaining("/im/v1/messages?receive_id_type=chat_id"),
-      expect.objectContaining({ signal: expect.any(AbortSignal) }),
-    );
-  });
-
-  it("also aborts when response body reading hangs", async () => {
-    vi.useFakeTimers();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
-      Promise.resolve({
-        status: 200,
-        text: () => new Promise<string>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(abortError()));
-        }),
-      } as Response)
-    ));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const send = expect(sendTextReply("token", "chat-2", "hello"))
-      .resolves.toBe(false);
-    await vi.advanceTimersByTimeAsync(15_000);
-
-    await send;
-  });
-});
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { sendTextReply } from "../feishu-api.ts";
+
+function abortError(): Error {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+
+describe("sendTextReply timeout", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("aborts a hung text send request", async () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
+      new Promise<Response>((_resolve, reject) => {
+        init?.signal?.addEventListener("abort", () => reject(abortError()));
+      })
+    ));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const send = expect(sendTextReply("token", "chat-1", "hello"))
+      .resolves.toBe(false);
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await send;
+    expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining("/im/v1/messages?receive_id_type=chat_id"),
+      expect.objectContaining({ signal: expect.any(AbortSignal) }),
+    );
+  });
+
+  it("also aborts when response body reading hangs", async () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
+      Promise.resolve({
+        status: 200,
+        text: () => new Promise<string>((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => reject(abortError()));
+        }),
+      } as Response)
+    ));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const send = expect(sendTextReply("token", "chat-2", "hello"))
+      .resolves.toBe(false);
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await send;
+  });
+});

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,44 +88,10 @@ function mockAvatarUploadOnlyFetch(
     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", () => {
+  return fetchMock;
+}
+
+describe("Plain avatar fallback", () => {
   afterEach(() => {
     vi.unstubAllGlobals();
     vi.doUnmock("node:os");
@@ -137,72 +103,106 @@ describe("Codex avatar usage battery", () => {
     mockConfig.cursor.onDemandMonthlyBudget = 1000;
   });
 
-  it("adds 7-day battery and 5h ring percentages to Codex avatar uploads when both windows exist", async () => {
+  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 },
-      },
+      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-"));