chatccc 0.2.186 → 0.2.188

package/src/feishu-api.ts

@@ -20,6 +20,7 @@ import {
   config,
 } from "./config.ts";
 import { getCursorUsageSummary, type CursorUsageSummary } from "./cursor-usage.ts";
+import type { ChatAvatarUsageHints } from "./platform-adapter.ts";
 import { applyPrivacy } from "./privacy.ts";
 
 // ---------------------------------------------------------------------------
@@ -302,10 +303,10 @@ const AVATAR_DIR = resolvePath(PROJECT_ROOT, "images", "avatars");
 const AVATAR_BADGE_DIR = resolvePath(AVATAR_DIR, "badges");
 const AVATAR_COMBINATIONS_DIR = resolvePath(AVATAR_DIR, "combinations");
 const AVATAR_KEY_CACHE_FILE = resolvePath(USER_DATA_DIR, "state", "avatar-image-keys.json");
-const CODEX_AUTH_FILE = resolvePath(homedir(), ".codex", "auth.json");
-const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
-const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
-const CODEX_RESET_CONSUME_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
+const CODEX_AUTH_FILE = resolvePath(homedir(), ".codex", "auth.json");
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+const CODEX_RESET_CONSUME_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
 const AVATAR_SOURCES: Record<string, string> = {
   new: resolvePath(AVATAR_DIR, "status_new.png"),
   busy: resolvePath(AVATAR_DIR, "status_busy.png"),
@@ -322,31 +323,31 @@ const AVATAR_BADGE_MARGIN = 10;
 const CODEX_AVATAR_USAGE_STYLE_VERSION = "usage-ring-gray-consumed-v13";
 const CURSOR_AVATAR_USAGE_STYLE_VERSION = "usage-battery-v1";
 
-export interface CodexUsageBalance {
-  usedPercent: number;
-  remainingPercent: number;
-  resetAtEpochSeconds: number | null;
-  resetAfterSeconds: number | null;
-}
-
-export interface CodexRateLimitResetCredit {
-  grantedAt: string | null;
-  expiresAt: string;
-}
-
-export interface CodexUsageSummary {
-  fiveHour: CodexUsageBalance;
-  weekly: CodexUsageBalance | null;
-  rateLimitResetCreditsAvailable: number | null;
-  rateLimitResetCredits: CodexRateLimitResetCredit[] | null;
-}
-
-export type CodexResetConsumeCode = "reset" | "nothing_to_reset" | "no_credit" | "already_redeemed";
-
-export interface CodexResetConsumeResult {
-  code: CodexResetConsumeCode;
-  windowsReset: number;
-}
+export interface CodexUsageBalance {
+  usedPercent: number;
+  remainingPercent: number;
+  resetAtEpochSeconds: number | null;
+  resetAfterSeconds: number | null;
+}
+
+export interface CodexRateLimitResetCredit {
+  grantedAt: string | null;
+  expiresAt: string;
+}
+
+export interface CodexUsageSummary {
+  fiveHour: CodexUsageBalance;
+  weekly: CodexUsageBalance | null;
+  rateLimitResetCreditsAvailable: number | null;
+  rateLimitResetCredits: CodexRateLimitResetCredit[] | null;
+}
+
+export type CodexResetConsumeCode = "reset" | "nothing_to_reset" | "no_credit" | "already_redeemed";
+
+export interface CodexResetConsumeResult {
+  code: CodexResetConsumeCode;
+  windowsReset: number;
+}
 
 const avatarKeyCache = new Map<string, string>();
 let avatarKeyCacheLoaded = false;
@@ -427,167 +428,172 @@ function usageBalanceFromWindow(raw: Record<string, unknown>, fieldName: string)
   };
 }
 
-function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
+function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
   for (const key of keys) {
     const raw = rateLimit[key];
     if (!raw || typeof raw !== "object") continue;
     if ((raw as { used_percent?: unknown }).used_percent === undefined) continue;
     return usageBalanceFromWindow(raw as Record<string, unknown>, `rate_limit.${key}`);
   }
-  return null;
-}
-
-function parseRateLimitResetCredits(data: Record<string, unknown>): number | null {
-  const raw = data.rate_limit_reset_credits;
-  if (!raw || typeof raw !== "object") return null;
-  const availableCount = Number((raw as { available_count?: unknown }).available_count);
-  if (!Number.isFinite(availableCount)) return null;
-  return Math.max(0, Math.trunc(availableCount));
-}
-
-interface CodexAuth {
-  accessToken: string;
-  accountId?: string;
-}
-
-async function getCodexAuth(): Promise<CodexAuth | null> {
-  try {
-    const raw = await readFile(CODEX_AUTH_FILE, "utf-8");
-    const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown } };
-    const token = parsed.tokens?.access_token;
-    if (typeof token !== "string" || !token.trim()) return null;
-    const accountId = parsed.tokens?.account_id;
-    return {
-      accessToken: token,
-      accountId: typeof accountId === "string" && accountId.trim() ? accountId : undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-async function getCodexAccessToken(): Promise<string | null> {
-  return (await getCodexAuth())?.accessToken ?? null;
-}
-
-function codexAuthHeaders(auth: CodexAuth): Record<string, string> {
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${auth.accessToken}`,
-    "OpenAI-Beta": "codex-1",
-    originator: "Codex Desktop",
-  };
-  if (auth.accountId) headers["ChatGPT-Account-ID"] = auth.accountId;
-  return headers;
-}
-
-function parseCodexResetCreditDetails(data: Record<string, unknown>): {
-  availableCount: number | null;
-  availableCredits: CodexRateLimitResetCredit[];
-} {
-  const availableCount = Number(data.available_count);
-  const credits = Array.isArray(data.credits) ? data.credits : [];
-  return {
-    availableCount: Number.isFinite(availableCount) ? Math.max(0, Math.trunc(availableCount)) : null,
-    availableCredits: credits.flatMap((raw) => {
-      if (!raw || typeof raw !== "object") return [];
-      const credit = raw as { status?: unknown; granted_at?: unknown; expires_at?: unknown };
-      if (credit.status !== "available") return [];
-      if (typeof credit.expires_at !== "string" || !credit.expires_at.trim()) return [];
-      return [{
-        grantedAt: typeof credit.granted_at === "string" && credit.granted_at.trim() ? credit.granted_at : null,
-        expiresAt: credit.expires_at,
-      }];
-    }),
-  };
-}
-
-async function fetchCodexRateLimitResetCredits(auth: CodexAuth): Promise<{
-  availableCount: number | null;
-  availableCredits: CodexRateLimitResetCredit[];
-} | null> {
-  try {
-    const resp = await fetch(CODEX_RESET_CREDITS_URL, {
-      headers: codexAuthHeaders(auth),
-    });
-    const text = await resp.text();
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-    return parseCodexResetCreditDetails(JSON.parse(text) as Record<string, unknown>);
-  } catch (err) {
-    console.warn(`[Codex] reset credits lookup failed: ${(err as Error).message}`);
-    return null;
-  }
-}
-
-export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
-  const auth = await getCodexAuth();
-  if (!auth) throw new Error("missing ~/.codex/auth.json access token");
-
-  const resetCreditsPromise = fetchCodexRateLimitResetCredits(auth);
-
-  const resp = await fetch(CODEX_USAGE_URL, {
-    headers: { Authorization: `Bearer ${auth.accessToken}` },
-  });
-  const text = await resp.text();
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-
-  const data = JSON.parse(text) as {
-    rate_limit?: Record<string, unknown>;
-    rate_limit_reset_credits?: unknown;
-  };
-  const rateLimit = data.rate_limit;
-  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
-
-  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
-  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
-  const resetCredits = await resetCreditsPromise;
-
-  return {
-    fiveHour,
-    weekly: parseOptionalUsageWindow(rateLimit, [
-      "secondary_window",
-      "weekly_window",
-      "week_window",
-      "long_window",
-    ]),
-    rateLimitResetCreditsAvailable: resetCredits?.availableCount ?? parseRateLimitResetCredits(data),
-    rateLimitResetCredits: resetCredits?.availableCredits ?? null,
-  };
-}
-
-export async function consumeCodexRateLimitResetCredit(redeemRequestId: string): Promise<CodexResetConsumeResult> {
-  if (!redeemRequestId.trim()) throw new Error("missing redeem_request_id");
-  const token = await getCodexAccessToken();
-  if (!token) throw new Error("missing ~/.codex/auth.json access token");
-
-  const resp = await fetch(CODEX_RESET_CONSUME_URL, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ redeem_request_id: redeemRequestId }),
-  });
-  const text = await resp.text();
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-
-  const data = JSON.parse(text) as { code?: unknown; windows_reset?: unknown };
-  const code = data.code;
-  if (
-    code !== "reset"
-    && code !== "nothing_to_reset"
-    && code !== "no_credit"
-    && code !== "already_redeemed"
-  ) {
-    throw new Error("missing or unknown reset result code");
-  }
-  const windowsReset = Number(data.windows_reset);
-  return {
-    code,
-    windowsReset: Number.isFinite(windowsReset) ? Math.max(0, Math.trunc(windowsReset)) : 0,
-  };
-}
-
-async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
+  return null;
+}
+
+function parseRateLimitResetCredits(data: Record<string, unknown>): number | null {
+  const raw = data.rate_limit_reset_credits;
+  if (!raw || typeof raw !== "object") return null;
+  const availableCount = Number((raw as { available_count?: unknown }).available_count);
+  if (!Number.isFinite(availableCount)) return null;
+  return Math.max(0, Math.trunc(availableCount));
+}
+
+interface CodexAuth {
+  accessToken: string;
+  accountId?: string;
+}
+
+async function getCodexAuth(): Promise<CodexAuth | null> {
+  try {
+    const raw = await readFile(CODEX_AUTH_FILE, "utf-8");
+    const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown } };
+    const token = parsed.tokens?.access_token;
+    if (typeof token !== "string" || !token.trim()) return null;
+    const accountId = parsed.tokens?.account_id;
+    return {
+      accessToken: token,
+      accountId: typeof accountId === "string" && accountId.trim() ? accountId : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getCodexAccessToken(): Promise<string | null> {
+  return (await getCodexAuth())?.accessToken ?? null;
+}
+
+function codexAuthHeaders(auth: CodexAuth): Record<string, string> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${auth.accessToken}`,
+    "OpenAI-Beta": "codex-1",
+    originator: "Codex Desktop",
+  };
+  if (auth.accountId) headers["ChatGPT-Account-ID"] = auth.accountId;
+  return headers;
+}
+
+function parseCodexResetCreditDetails(data: Record<string, unknown>): {
+  availableCount: number | null;
+  availableCredits: CodexRateLimitResetCredit[];
+} {
+  const availableCount = Number(data.available_count);
+  const credits = Array.isArray(data.credits) ? data.credits : [];
+  return {
+    availableCount: Number.isFinite(availableCount) ? Math.max(0, Math.trunc(availableCount)) : null,
+    availableCredits: credits.flatMap((raw) => {
+      if (!raw || typeof raw !== "object") return [];
+      const credit = raw as { status?: unknown; granted_at?: unknown; expires_at?: unknown };
+      if (credit.status !== "available") return [];
+      if (typeof credit.expires_at !== "string" || !credit.expires_at.trim()) return [];
+      return [{
+        grantedAt: typeof credit.granted_at === "string" && credit.granted_at.trim() ? credit.granted_at : null,
+        expiresAt: credit.expires_at,
+      }];
+    }),
+  };
+}
+
+async function fetchCodexRateLimitResetCredits(auth: CodexAuth): Promise<{
+  availableCount: number | null;
+  availableCredits: CodexRateLimitResetCredit[];
+} | null> {
+  try {
+    const resp = await fetch(CODEX_RESET_CREDITS_URL, {
+      headers: codexAuthHeaders(auth),
+    });
+    const text = await resp.text();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+    return parseCodexResetCreditDetails(JSON.parse(text) as Record<string, unknown>);
+  } catch (err) {
+    console.warn(`[Codex] reset credits lookup failed: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
+  const auth = await getCodexAuth();
+  if (!auth) throw new Error("missing ~/.codex/auth.json access token");
+
+  const resetCreditsPromise = fetchCodexRateLimitResetCredits(auth);
+
+  const resp = await fetch(CODEX_USAGE_URL, {
+    headers: { Authorization: `Bearer ${auth.accessToken}` },
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+
+  const data = JSON.parse(text) as {
+    rate_limit?: Record<string, unknown>;
+    rate_limit_reset_credits?: unknown;
+  };
+  const rateLimit = data.rate_limit;
+  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
+
+  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
+  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
+  const resetCredits = await resetCreditsPromise;
+
+  return {
+    fiveHour,
+    weekly: parseOptionalUsageWindow(rateLimit, [
+      "secondary_window",
+      "weekly_window",
+      "week_window",
+      "long_window",
+    ]),
+    rateLimitResetCreditsAvailable: resetCredits?.availableCount ?? parseRateLimitResetCredits(data),
+    rateLimitResetCredits: resetCredits?.availableCredits ?? null,
+  };
+}
+
+export async function consumeCodexRateLimitResetCredit(redeemRequestId: string): Promise<CodexResetConsumeResult> {
+  if (!redeemRequestId.trim()) throw new Error("missing redeem_request_id");
+  const token = await getCodexAccessToken();
+  if (!token) throw new Error("missing ~/.codex/auth.json access token");
+
+  const resp = await fetch(CODEX_RESET_CONSUME_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ redeem_request_id: redeemRequestId }),
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+
+  const data = JSON.parse(text) as { code?: unknown; windows_reset?: unknown };
+  const code = data.code;
+  if (
+    code !== "reset"
+    && code !== "nothing_to_reset"
+    && code !== "no_credit"
+    && code !== "already_redeemed"
+  ) {
+    throw new Error("missing or unknown reset result code");
+  }
+  const windowsReset = Number(data.windows_reset);
+  return {
+    code,
+    windowsReset: Number.isFinite(windowsReset) ? Math.max(0, Math.trunc(windowsReset)) : 0,
+  };
+}
+
+async function resolveCodexAvatarUsage(usageHint?: CodexUsageSummary | null): Promise<CodexUsageSummary | null> {
+  if (usageHint !== undefined) {
+    if (!usageHint?.weekly) return null;
+    return usageHint;
+  }
+
   try {
     const summary = await getCodexUsageSummary();
     if (!summary.weekly) throw new Error("missing weekly usage window");
@@ -611,7 +617,17 @@ function cursorAvatarBatteryPercentFromUsage(summary: CursorUsageSummary): numbe
   return clampPercent(100 - apiPercentUsed);
 }
 
-async function fetchCursorAvatarBatteryPercent(): Promise<number | null> {
+async function resolveCursorAvatarBatteryPercent(usageHint?: CursorUsageSummary | null): Promise<number | null> {
+  if (usageHint !== undefined) {
+    if (!usageHint) return null;
+    try {
+      return cursorAvatarBatteryPercentFromUsage(usageHint);
+    } catch (err) {
+      console.warn(`[${ts()}] [AVATAR] Cursor usage unavailable, using plain avatar: ${(err as Error).message}`);
+      return null;
+    }
+  }
+
   try {
     return cursorAvatarBatteryPercentFromUsage(await getCursorUsageSummary());
   } catch (err) {
@@ -814,12 +830,19 @@ async function uploadImage(
   return data.data!.image_key!;
 }
 
-async function getOrUploadAvatarKey(token: string, tool: string, status: string): Promise<string> {
+async function getOrUploadAvatarKey(
+  token: string,
+  tool: string,
+  status: string,
+  usageHints: ChatAvatarUsageHints = {},
+): Promise<string> {
   await loadAvatarKeyCache();
   const normalizedTool = normalizeAvatarTool(tool);
   const normalizedStatus = normalizeAvatarStatus(status);
-  const codexUsage = normalizedTool === "codex" ? await fetchCodexAvatarUsage() : null;
-  const cursorBatteryPercent = normalizedTool === "cursor" ? await fetchCursorAvatarBatteryPercent() : null;
+  const codexUsage = normalizedTool === "codex" ? await resolveCodexAvatarUsage(usageHints.codexUsage) : null;
+  const cursorBatteryPercent = normalizedTool === "cursor"
+    ? await resolveCursorAvatarBatteryPercent(usageHints.cursorUsage)
+    : null;
   const keyName = avatarCacheKey(normalizedTool, normalizedStatus, codexUsage, cursorBatteryPercent);
   const cached = avatarKeyCache.get(keyName);
   if (cached) return cached;
@@ -832,9 +855,15 @@ async function getOrUploadAvatarKey(token: string, tool: string, status: string)
   return key;
 }
 
-export async function setChatAvatar(token: string, chatId: string, tool: string, status: string): Promise<void> {
+export async function setChatAvatar(
+  token: string,
+  chatId: string,
+  tool: string,
+  status: string,
+  usageHints: ChatAvatarUsageHints = {},
+): Promise<void> {
   try {
-    const avatarKey = await getOrUploadAvatarKey(token, tool, status);
+    const avatarKey = await getOrUploadAvatarKey(token, tool, status, usageHints);
     const resp = await fetch(`${BASE_URL}/im/v1/chats/${chatId}`, {
       method: "PUT",
       headers: {

package/src/index.ts

@@ -142,8 +142,8 @@ function createFeishuAdapter(): PlatformAdapter {
     async disbandChat(chatId) {
       return disbandChat(await auth(), chatId);
     },
-    async setChatAvatar(chatId, tool, status) {
-      return setChatAvatar(await auth(), chatId, tool, status);
+    async setChatAvatar(chatId, tool, status, usageHints) {
+      return setChatAvatar(await auth(), chatId, tool, status, usageHints);
     },
 
     extractSessionInfo(description) {