cc-costline 0.4.0 → 0.4.2

package/dist/statusline.d.ts

@@ -1,6 +1,8 @@
+import type { CacheData } from "./cache.js";
 export declare function formatTokens(t: number): string;
 export declare function formatCost(n: number): string;
 export declare function ctxColor(pct: number): string;
 export declare function formatCountdown(resetsAtMs: number): string;
+export declare function shouldRefreshLocalCostCache(cache: CacheData | null, transcriptPath?: string, now?: number): boolean;
 export declare function rankColor(rank: number): string;
 export declare function render(input: string): string;

package/dist/statusline.js

@@ -1,11 +1,13 @@
-import { readFileSync, existsSync, writeFileSync, unlinkSync } from "node:fs";
+import { readFileSync, existsSync, statSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
 import { readCache, writeCache, readConfig } from "./cache.js";
 import { collectCosts } from "./collector.js";
-// Unified TTL for all cached data (2 minutes)
+// TTL for local cost cache (2 minutes)
 const CACHE_TTL_MS = 120_000;
+// TTL for external API retry throttle (5 minutes) — usage API has strict per-token rate limits (~5 req/token)
+const API_RETRY_TTL_MS = 300_000;
 // ANSI colors (matching original statusline.sh)
 const FG_GRAY = "\x1b[38;5;245m";
 const FG_GRAY_DIM = "\x1b[38;5;102m";
@@ -49,23 +51,45 @@ export function formatCountdown(resetsAtMs) {
     const minutes = totalMinutes % 60;
     return `-${hours}:${String(minutes).padStart(2, "0")}`;
 }
-// ccclub rank fetcher — TTL-based cache (stale fallback on failure)
+export function shouldRefreshLocalCostCache(cache, transcriptPath = "", now = Date.now()) {
+    if (!cache)
+        return true;
+    const cacheUpdatedAt = new Date(cache.updatedAt).getTime();
+    if (isNaN(cacheUpdatedAt))
+        return true;
+    if (transcriptPath) {
+        try {
+            const transcriptMtime = statSync(transcriptPath).mtimeMs;
+            if (transcriptMtime > cacheUpdatedAt)
+                return true;
+        }
+        catch { }
+    }
+    return now - cacheUpdatedAt >= CACHE_TTL_MS;
+}
+// ccclub rank fetcher — split cache: data persists, retry throttled
 function getCcclubRank() {
     const configPath = join(homedir(), ".ccclub", "config.json");
     if (!existsSync(configPath))
         return null;
     const cacheFile = "/tmp/sl-ccclub-rank";
+    const now = Date.now();
     let staleData = null;
+    let lastAttempt = 0;
     if (existsSync(cacheFile)) {
         try {
             const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
             staleData = cached.data ?? null;
-            const cacheAge = Date.now() - (cached.timestamp || 0);
-            if (cacheAge < CACHE_TTL_MS)
+            lastAttempt = cached.lastAttempt || cached.timestamp || 0;
+            if (now - lastAttempt < API_RETRY_TTL_MS)
                 return staleData;
         }
         catch { }
     }
+    try {
+        writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: staleData ? (lastAttempt || now) : 0, lastAttempt: now }), "utf-8");
+    }
+    catch { }
     try {
         const config = JSON.parse(readFileSync(configPath, "utf-8"));
         const code = config.groups?.[0];
@@ -83,14 +107,10 @@ function getCcclubRank() {
         if (!me)
             return staleData;
         const result = { rank: me.rank, total: rankings.length, cost: me.costUSD };
-        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: Date.now() }), "utf-8");
+        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: now, lastAttempt: now }), "utf-8");
         return result;
     }
     catch {
-        try {
-            writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: Date.now() }), "utf-8");
-        }
-        catch { }
         return staleData;
     }
 }
@@ -103,44 +123,65 @@ export function rankColor(rank) {
         return FG_ORANGE;
     return FG_CYAN;
 }
-// Claude usage fetcher — TTL-based cache (stale fallback on failure)
+// Claude usage fetcher — token-aware cache: detects token rotation to retry immediately
 function getClaudeUsage() {
     const cacheFile = "/tmp/sl-claude-usage";
     const hitFile = "/tmp/sl-claude-usage-hit";
     const now = Date.now();
+    // Cache format: { data, lastAttempt, tokenPrefix (first 20 chars of token) }
     let staleData = null;
+    let lastAttempt = 0;
+    let cachedTokenPrefix = "";
     if (existsSync(cacheFile)) {
         try {
             const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
             staleData = cached.data ?? null;
-            const cacheAge = now - (cached.timestamp || 0);
-            if (cacheAge < CACHE_TTL_MS)
-                return staleData;
+            lastAttempt = cached.lastAttempt || 0;
+            cachedTokenPrefix = cached.tokenPrefix || "";
         }
         catch { }
     }
+    // Get current token
+    let accessToken = "";
     try {
         const username = process.env.USER || process.env.USERNAME;
         const keychainCmd = `security find-generic-password -s "Claude Code-credentials" -a "${username}" -w 2>/dev/null`;
         const credentialsJSON = execSync(keychainCmd, { encoding: "utf-8", timeout: 2000 }).trim();
         if (!credentialsJSON)
-            return null;
+            return staleData;
         const credentials = JSON.parse(credentialsJSON);
-        const accessToken = credentials.claudeAiOauth?.accessToken;
+        accessToken = credentials.claudeAiOauth?.accessToken || "";
         if (!accessToken)
-            return null;
+            return staleData;
         const expiresAt = credentials.claudeAiOauth?.expiresAt;
-        if (expiresAt && Date.now() / 1000 > expiresAt)
-            return null;
+        if (expiresAt && now > expiresAt)
+            return staleData;
+    }
+    catch {
+        return staleData;
+    }
+    const currentTokenPrefix = accessToken.slice(-20);
+    const tokenChanged = cachedTokenPrefix && currentTokenPrefix !== cachedTokenPrefix;
+    // Throttle: skip API call unless token rotated or TTL expired
+    if (!tokenChanged && lastAttempt && now - lastAttempt < API_RETRY_TTL_MS)
+        return staleData;
+    // Mark attempt and store token prefix
+    try {
+        writeFileSync(cacheFile, JSON.stringify({ data: staleData, lastAttempt: now, tokenPrefix: currentTokenPrefix }), "utf-8");
+    }
+    catch { }
+    try {
         const apiUrl = "https://api.anthropic.com/api/oauth/usage";
         const curlCmd = `curl -sf "${apiUrl}" -H "Authorization: Bearer ${accessToken}" -H "anthropic-beta: oauth-2025-04-20"`;
         const response = execSync(curlCmd, { encoding: "utf-8", timeout: 5000 });
-        if (!response) {
-            // API failed — write cache with null data to prevent retry flood
-            writeFileSync(cacheFile, JSON.stringify({ data: null, timestamp: now }), "utf-8");
+        if (!response)
             return staleData;
-        }
         const data = JSON.parse(response);
+        // Debug: save raw API response for diagnosis
+        try {
+            writeFileSync("/tmp/sl-claude-usage-raw", JSON.stringify(data, null, 2), "utf-8");
+        }
+        catch { }
         const parseUtil = (val) => {
             if (typeof val === "number")
                 return Math.round(val);
@@ -184,15 +225,10 @@ function getClaudeUsage() {
         const result = { fiveHour, sevenDay };
         if (fiveHourResetsAt)
             result.fiveHourResetsAt = fiveHourResetsAt;
-        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: now }), "utf-8");
+        writeFileSync(cacheFile, JSON.stringify({ data: result, lastAttempt: now, tokenPrefix: currentTokenPrefix }), "utf-8");
         return result;
     }
     catch {
-        // Write cache with stale/null data to prevent retry flood on persistent failures
-        try {
-            writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: now }), "utf-8");
-        }
-        catch { }
         return staleData;
     }
 }
@@ -206,7 +242,7 @@ export function render(input) {
     }
     // Session data from Claude Code stdin
     const cost = data.cost?.total_cost_usd ?? 0;
-    const model = data.model?.display_name ?? "—";
+    const model = (data.model?.display_name ?? "—").replace(/\s*\((\d+[KMB])\s+context\)/i, " ($1)");
     const contextPct = Math.floor(data.context_window?.used_percentage ?? 0);
     const transcriptPath = data.transcript_path ?? "";
     // Token stats from transcript
@@ -231,8 +267,7 @@ export function render(input) {
     }
     // Refresh local cost cache if stale
     let cache = readCache();
-    const cacheAge = cache ? Date.now() - new Date(cache.updatedAt).getTime() : Infinity;
-    if (cacheAge >= CACHE_TTL_MS) {
+    if (shouldRefreshLocalCostCache(cache, transcriptPath)) {
         try {
             const result = collectCosts();
             // Don't overwrite valid cache with zeros (directory read failure)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-costline",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Enhanced statusline for Claude Code with cost tracking, usage limits, and leaderboard",
   "type": "module",
   "bin": {