chatccc 0.2.178 → 0.2.180

package/src/cursor-usage.ts

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const require = createRequire(import.meta.url);
+
+const CURSOR_USAGE_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
+
+export type CursorUsageSummary = {
+  billingCycleStart?: string;
+  billingCycleEnd?: string;
+  planUsage?: {
+    totalSpend?: number;
+    includedSpend?: number;
+    bonusSpend?: number;
+    limit?: number;
+    remainingBonus?: boolean;
+    bonusTooltip?: string;
+    autoPercentUsed?: number;
+    apiPercentUsed?: number;
+    totalPercentUsed?: number;
+  };
+  spendLimitUsage?: {
+    totalSpend?: number;
+    pooledLimit?: number;
+    pooledUsed?: number;
+    pooledRemaining?: number;
+    individualUsed?: number;
+    limitType?: string;
+  };
+  displayThreshold?: number;
+  enabled?: boolean;
+  displayMessage?: string;
+  autoModelSelectedDisplayMessage?: string;
+  namedModelSelectedDisplayMessage?: string;
+  autoBucketModels?: string[];
+};
+
+type SqliteStatement = {
+  get(value?: unknown): unknown;
+  all(value?: unknown): unknown[];
+};
+
+type SqliteDatabase = {
+  prepare(sql: string): SqliteStatement;
+  close(): void;
+};
+
+function getCursorDbPath(): string {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || "", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+
+  return join(homedir(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+}
+
+function openSqliteDatabase(dbPath: string): SqliteDatabase {
+  try {
+    const { DatabaseSync } = require("node:sqlite") as {
+      DatabaseSync?: new (path: string, opts: { readOnly: boolean }) => SqliteDatabase;
+    };
+    if (DatabaseSync) return new DatabaseSync(dbPath, { readOnly: true });
+  } catch (error) {
+    const code = (error as { code?: string }).code;
+    if (code !== "ERR_UNKNOWN_BUILTIN_MODULE" && code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+
+  try {
+    const Database = require("better-sqlite3") as new (path: string, opts: { readonly: boolean }) => SqliteDatabase;
+    return new Database(dbPath, { readonly: true });
+  } catch {
+    throw new Error("node:sqlite is unavailable and better-sqlite3 is not installed");
+  }
+}
+
+function parseStorageValue(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function getCursorAccessToken(dbPath = getCursorDbPath()): string {
+  if (!existsSync(dbPath)) {
+    throw new Error(`Cursor database not found: ${dbPath}`);
+  }
+
+  const db = openSqliteDatabase(dbPath);
+
+  try {
+    const row = db.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/accessToken") as
+      | { value?: unknown }
+      | undefined;
+    const token = parseStorageValue(row?.value);
+    if (typeof token === "string" && token.length > 0) return token;
+    throw new Error("Cursor access token not found");
+  } finally {
+    db.close();
+  }
+}
+
+export async function getCursorUsageSummary(): Promise<CursorUsageSummary> {
+  const token = getCursorAccessToken();
+  const response = await fetch(CURSOR_USAGE_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Connect-Protocol-Version": "1",
+    },
+    body: "{}",
+  });
+
+  if (!response.ok) {
+    throw new Error(`Cursor usage API returned ${response.status} ${response.statusText}`);
+  }
+
+  return (await response.json()) as CursorUsageSummary;
+}

package/src/feishu-api.ts

@@ -17,7 +17,9 @@ import {
   ts,
   resolveDefaultAgentTool,
   toolDisplayName,
+  config,
 } from "./config.ts";
+import { getCursorUsageSummary, type CursorUsageSummary } from "./cursor-usage.ts";
 import { applyPrivacy } from "./privacy.ts";
 
 // ---------------------------------------------------------------------------
@@ -316,6 +318,7 @@ const AVATAR_SIZE = 256;
 const AVATAR_BADGE_SIZE = 92;
 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;
@@ -344,7 +347,12 @@ function avatarCombinationPath(tool: string, status: string): string {
   return resolvePath(AVATAR_COMBINATIONS_DIR, `avatar_${normalizeAvatarTool(tool)}_${normalizeAvatarStatus(status)}.png`);
 }
 
-function avatarCacheKey(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): string {
+function avatarCacheKey(
+  tool: string,
+  status: string,
+  codexUsage: CodexUsageSummary | null = null,
+  cursorBatteryPercent: number | null = null,
+): string {
   const normalizedTool = normalizeAvatarTool(tool);
   const normalizedStatus = normalizeAvatarStatus(status);
   if (normalizedTool === "codex") {
@@ -352,6 +360,11 @@ function avatarCacheKey(tool: string, status: string, codexUsage: CodexUsageSumm
       ? `${normalizedTool}:${normalizedStatus}:${CODEX_AVATAR_USAGE_STYLE_VERSION}:week-battery:${codexUsage.weekly?.remainingPercent}:5h-ring:${codexUsage.fiveHour.remainingPercent}`
       : `${normalizedTool}:${normalizedStatus}:plain`;
   }
+  if (normalizedTool === "cursor") {
+    return cursorBatteryPercent !== null
+      ? `${normalizedTool}:${normalizedStatus}:${CURSOR_AVATAR_USAGE_STYLE_VERSION}:battery:${cursorBatteryPercent}`
+      : `${normalizedTool}:${normalizedStatus}:plain`;
+  }
   return `${normalizedTool}:${normalizedStatus}`;
 }
 
@@ -460,6 +473,28 @@ async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
   }
 }
 
+function cursorAvatarBatteryPercentFromUsage(summary: CursorUsageSummary): number {
+  if (config.cursor.avatarBatteryMode === "onDemandUse") {
+    const usedCents = Number(summary.spendLimitUsage?.individualUsed);
+    if (!Number.isFinite(usedCents)) throw new Error("missing spendLimitUsage.individualUsed");
+    const budget = config.cursor.onDemandMonthlyBudget > 0 ? config.cursor.onDemandMonthlyBudget : 1000;
+    return clampPercent(100 - ((usedCents / 100) / budget) * 100);
+  }
+
+  const apiPercentUsed = Number(summary.planUsage?.apiPercentUsed);
+  if (!Number.isFinite(apiPercentUsed)) throw new Error("missing planUsage.apiPercentUsed");
+  return clampPercent(100 - apiPercentUsed);
+}
+
+async function fetchCursorAvatarBatteryPercent(): Promise<number | null> {
+  try {
+    return cursorAvatarBatteryPercentFromUsage(await getCursorUsageSummary());
+  } catch (err) {
+    console.warn(`[${ts()}] [AVATAR] Cursor usage unavailable, using plain avatar: ${(err as Error).message}`);
+    return null;
+  }
+}
+
 function codexUsagePalette(remainingPercent: number): { start: string; end: string; glow: string } {
   if (remainingPercent <= 25) return { start: "#ef4444", end: "#fb923c", glow: "#fed7aa" };
   if (remainingPercent <= 60) return { start: "#eab308", end: "#facc15", glow: "#fef3c7" };
@@ -573,20 +608,32 @@ async function buildAgentBadgeOverlay(tool: string): Promise<sharp.OverlayOption
   };
 }
 
-async function renderAvatar(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
+async function renderAvatar(
+  tool: string,
+  status: string,
+  codexUsage: CodexUsageSummary | null = null,
+  cursorBatteryPercent: number | null = null,
+): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
   const normalizedTool = normalizeAvatarTool(tool);
   const normalizedStatus = normalizeAvatarStatus(status);
   const composites: sharp.OverlayOptions[] = [];
 
-  const useDynamicCodexAvatar = normalizedTool === "codex" && codexUsage?.weekly;
-  const basePath = useDynamicCodexAvatar
+  const codexWeeklyUsage = normalizedTool === "codex" ? codexUsage?.weekly : null;
+  const useDynamicCodexAvatar = codexUsage && codexWeeklyUsage;
+  const useDynamicCursorAvatar = normalizedTool === "cursor" && cursorBatteryPercent !== null;
+  const basePath = useDynamicCodexAvatar || useDynamicCursorAvatar
     ? AVATAR_SOURCES[normalizedStatus]
     : avatarCombinationPath(normalizedTool, normalizedStatus);
 
   if (useDynamicCodexAvatar) {
     composites.push(
       { input: buildCodexUsageRingSvg(codexUsage.fiveHour.remainingPercent), left: 0, top: 0 },
-      { input: buildCodexUsageBatterySvg(codexUsage.weekly.remainingPercent), left: 0, top: 0 },
+      { input: buildCodexUsageBatterySvg(codexWeeklyUsage.remainingPercent), left: 0, top: 0 },
+      await buildAgentBadgeOverlay(normalizedTool),
+    );
+  } else if (useDynamicCursorAvatar) {
+    composites.push(
+      { input: buildCodexUsageBatterySvg(cursorBatteryPercent), left: 0, top: 0 },
       await buildAgentBadgeOverlay(normalizedTool),
     );
   }
@@ -608,12 +655,20 @@ async function renderAvatar(tool: string, status: string, codexUsage: CodexUsage
     contentType: "image/jpeg",
     filename: codexUsage?.weekly
       ? `avatar_${normalizedTool}_${normalizedStatus}_week_${codexUsage.weekly.remainingPercent}_5h_${codexUsage.fiveHour.remainingPercent}.jpg`
+      : cursorBatteryPercent !== null
+        ? `avatar_${normalizedTool}_${normalizedStatus}_battery_${cursorBatteryPercent}.jpg`
       : `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
   };
 }
 
-async function uploadImage(token: string, tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<string> {
-  const image = await renderAvatar(tool, status, codexUsage);
+async function uploadImage(
+  token: string,
+  tool: string,
+  status: string,
+  codexUsage: CodexUsageSummary | null = null,
+  cursorBatteryPercent: number | null = null,
+): Promise<string> {
+  const image = await renderAvatar(tool, status, codexUsage, cursorBatteryPercent);
   const blob = new Blob([new Uint8Array(image.buffer)], { type: image.contentType });
   const form = new FormData();
   form.append("image_type", "avatar");
@@ -639,10 +694,11 @@ async function getOrUploadAvatarKey(token: string, tool: string, status: string)
   const normalizedTool = normalizeAvatarTool(tool);
   const normalizedStatus = normalizeAvatarStatus(status);
   const codexUsage = normalizedTool === "codex" ? await fetchCodexAvatarUsage() : null;
-  const keyName = avatarCacheKey(normalizedTool, normalizedStatus, codexUsage);
+  const cursorBatteryPercent = normalizedTool === "cursor" ? await fetchCursorAvatarBatteryPercent() : null;
+  const keyName = avatarCacheKey(normalizedTool, normalizedStatus, codexUsage, cursorBatteryPercent);
   const cached = avatarKeyCache.get(keyName);
   if (cached) return cached;
-  const key = await uploadImage(token, normalizedTool, normalizedStatus, codexUsage);
+  const key = await uploadImage(token, normalizedTool, normalizedStatus, codexUsage, cursorBatteryPercent);
   avatarKeyCache.set(keyName, key);
   await persistAvatarKeyCache().catch((err) => {
     console.error(`[${ts()}] [AVATAR] persist cache FAIL: ${(err as Error).message}`);

package/src/index.ts

@@ -213,7 +213,7 @@ function parseCardAction(data: unknown): CardActionResult | null {
   }
   if (!cmd) return null;
 
-  const CMD_MAP: Record<string, string> = { stop: "/stop", cancel: "/cancel", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", updateg: "/updateg", state: "/state", cd: "/cd", sessions: "/sessions", newh: "/newh" };
+  const CMD_MAP: Record<string, string> = { stop: "/stop", cancel: "/cancel", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", update: "/update", state: "/state", cd: "/cd", sessions: "/sessions", newh: "/newh" };
   let text = CMD_MAP[cmd] ?? "";
   if (cmd === "cd" && typeof action.value === "object" && action.value !== null) {
     const path = (action.value as Record<string, string>).path;