cc-dev-template 0.1.102 → 0.1.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.102",
+  "version": "0.1.104",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"

package/src/scripts/statusline.js

@@ -13,15 +13,18 @@
  * Output: Formatted status to stdout
  */
 
-const { readFileSync, writeFileSync, readdirSync, statSync } = require('fs');
+const { readFileSync, writeFileSync, readdirSync, statSync, unlinkSync } = require('fs');
 const { join, basename } = require('path');
 const { execSync, spawnSync, spawn } = require('child_process');
 const { homedir } = require('os');
 
 // Usage API cache
 const USAGE_CACHE_PATH = join(homedir(), '.claude', '.usage-cache.json');
-const USAGE_CACHE_TTL = 120000; // 2 minutes
-const USAGE_HISTORY_MAX = 20; // ~40 min of readings at 2min intervals
+const USAGE_LOCK_PATH = join(homedir(), '.claude', '.usage-cache.lock');
+const USAGE_CACHE_TTL = 30000; // 30s normal refresh interval
+const USAGE_ERROR_TTL = 300000; // 5 min backoff on errors (rate limit, network, etc.)
+const USAGE_LOCK_TTL = 15000; // 15s lock (curl timeout is 5s, 15s is generous)
+const USAGE_HISTORY_MAX = 20; // ~10 min of readings at 30s intervals
 
 // Background refresh mode: fetch usage data and write cache, then exit
 if (process.argv.includes('--refresh')) {
@@ -305,13 +308,33 @@ function getOAuthToken() {
   }
 }
 
+/**
+ * Write error backoff to cache — preserves existing data/history,
+ * but delays next refresh attempt by USAGE_ERROR_TTL.
+ */
+function writeErrorBackoff() {
+  const now = Date.now();
+  try {
+    const existing = JSON.parse(readFileSync(USAGE_CACHE_PATH, 'utf-8'));
+    existing.nextRefreshAfter = now + USAGE_ERROR_TTL;
+    writeFileSync(USAGE_CACHE_PATH, JSON.stringify(existing));
+  } catch {
+    writeFileSync(USAGE_CACHE_PATH, JSON.stringify({
+      timestamp: now,
+      nextRefreshAfter: now + USAGE_ERROR_TTL,
+      data: null,
+      history: [],
+    }));
+  }
+}
+
 /**
  * Fetch usage data from API and write to cache (runs in background)
  */
 function refreshUsageCache() {
   try {
     const token = getOAuthToken();
-    if (!token) return;
+    if (!token) { writeErrorBackoff(); return; }
 
     const result = spawnSync('curl', [
       '-s', '--max-time', '3',
@@ -321,72 +344,77 @@ function refreshUsageCache() {
       '-H', 'Content-Type: application/json',
     ], { encoding: 'utf-8', timeout: 5000 });
 
-    if (result.status === 0 && result.stdout) {
-      const data = JSON.parse(result.stdout.trim());
-      if (data.five_hour && data.seven_day) {
-        // Load existing history and append new reading
-        let history = [];
-        try {
-          const existing = JSON.parse(readFileSync(USAGE_CACHE_PATH, 'utf-8'));
-          if (Array.isArray(existing.history)) history = existing.history;
-        } catch {}
-
-        const now = Date.now();
-        history.push({
-          t: now,
-          five_hour: data.five_hour.utilization,
-          seven_day: data.seven_day.utilization,
-        });
+    if (result.status !== 0 || !result.stdout) { writeErrorBackoff(); return; }
 
-        // Keep only the last N readings
-        if (history.length > USAGE_HISTORY_MAX) {
-          history = history.slice(-USAGE_HISTORY_MAX);
-        }
+    let responseData;
+    try { responseData = JSON.parse(result.stdout.trim()); } catch { writeErrorBackoff(); return; }
 
-        writeFileSync(USAGE_CACHE_PATH, JSON.stringify({
-          timestamp: now,
-          data,
-          history,
-        }));
-      }
+    if (!responseData.five_hour || !responseData.seven_day) { writeErrorBackoff(); return; }
+
+    // --- Success path ---
+    let history = [];
+    try {
+      const existing = JSON.parse(readFileSync(USAGE_CACHE_PATH, 'utf-8'));
+      if (Array.isArray(existing.history)) history = existing.history;
+    } catch {}
+
+    const now = Date.now();
+    history.push({
+      t: now,
+      five_hour: responseData.five_hour.utilization,
+      seven_day: responseData.seven_day.utilization,
+    });
+
+    if (history.length > USAGE_HISTORY_MAX) {
+      history = history.slice(-USAGE_HISTORY_MAX);
     }
+
+    writeFileSync(USAGE_CACHE_PATH, JSON.stringify({
+      timestamp: now,
+      nextRefreshAfter: now + USAGE_CACHE_TTL,
+      data: responseData,
+      history,
+    }));
   } catch {
-    // Silently fail - stale cache will be used on next render
+    writeErrorBackoff();
+  } finally {
+    try { unlinkSync(USAGE_LOCK_PATH); } catch {}
   }
 }
 
 /**
- * Read cached usage data, trigger background refresh if stale
+ * Read cached usage data, trigger background refresh if scheduled time has passed.
+ * All instances share the same nextRefreshAfter timestamp — only one refresh per cycle.
  */
 function getUsageData() {
   let cacheData = null;
   let cacheHistory = null;
-  let cacheAge = Infinity;
+  let shouldRefresh = true; // refresh if no cache exists
 
   try {
     const raw = readFileSync(USAGE_CACHE_PATH, 'utf-8');
     const cache = JSON.parse(raw);
     cacheData = cache.data;
     cacheHistory = cache.history || null;
-    cacheAge = Date.now() - cache.timestamp;
+    shouldRefresh = Date.now() > (cache.nextRefreshAfter || 0);
   } catch {}
 
-  // Trigger background refresh if cache is stale
-  if (cacheAge > USAGE_CACHE_TTL) {
-    // Optimistic lock: claim the timestamp so other sessions see fresh cache
+  if (shouldRefresh) {
+    let lockHeld = false;
     try {
-      const raw = readFileSync(USAGE_CACHE_PATH, 'utf-8');
-      const cache = JSON.parse(raw);
-      cache.timestamp = Date.now();
-      writeFileSync(USAGE_CACHE_PATH, JSON.stringify(cache));
-    } catch {}
-    try {
-      const child = spawn(process.execPath, [__filename, '--refresh'], {
-        detached: true,
-        stdio: 'ignore',
-      });
-      child.unref();
+      const lockTime = parseInt(readFileSync(USAGE_LOCK_PATH, 'utf-8'), 10);
+      lockHeld = (Date.now() - lockTime) < USAGE_LOCK_TTL;
     } catch {}
+    if (!lockHeld) {
+      try { writeFileSync(USAGE_LOCK_PATH, String(Date.now())); } catch {}
+      try {
+        const child = spawn(process.execPath, [__filename, '--refresh'], {
+          detached: true,
+          stdio: 'ignore',
+        });
+        child.unref();
+      } catch {}
+    }
   }
 
   return { data: cacheData, history: cacheHistory };