claude-code-runrate 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-runrate",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Claude Code run-rate — subscription burn-rate & economy for your Claude Code sessions.",
   "license": "MIT",
   "author": "Bing Ho <reps-attic-riot@duck.com>",

package/src/account-limits.js

@@ -0,0 +1,165 @@
+// @ts-check
+'use strict';
+// src/account-limits.js — reconcile the ACCOUNT-WIDE rate-limit meters across the
+// live ccr profiles (cq/cw/ce/cr, …) so their sidecars agree.
+//
+// THE PROBLEM. The 5h and weekly walls are one shared account resource, but each
+// ccr profile only captures them when ITS OWN Claude session renders the status
+// line. Claude Code re-emits the status line per turn, not on a clock, so an idle
+// profile keeps showing the numbers from its last turn. Two sidecars open
+// side-by-side therefore disagree purely by capture time — the busy one is ahead,
+// the idle one lags. (The model in use is irrelevant: 5h/weekly are not
+// model-scoped.) We fix this by raising each meter the LOCAL profile already knows
+// to the freshest value seen across sibling profiles.
+//
+// THE GUARD — never mix accounts. The snapshot carries no account/org id, so we
+// cannot ask "same account?" directly. Instead we trust bucket IDENTITY: the
+// account-wide windows (5h, weekly — the buckets with no model scope) reset on a
+// per-account schedule, so at any instant every session on one account reports the
+// same resets_at for them. We build an "account fingerprint" from exactly those
+// buckets (key + reset instant) and merge a sibling ONLY when its fingerprint is
+// byte-for-byte the local one. A different account would have to collide on every
+// one of those independent reset timestamps at once (5h AND weekly) — negligible.
+// A sibling from an already-rolled window has a different reset instant, so it is
+// distrusted too (its used% is stale, not fresher). We never import a bucket the
+// local snapshot lacks and never adopt a sibling's resets_at — we only ever raise
+// the used% of a bucket the local profile is already showing. So a profile logged
+// into its own account is never contaminated by another.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { parseResetsAt } = require('./burn');
+const { modelScope } = require('./rate-limits');
+
+const MAX_SNAPSHOT_BYTES = 1_000_000; // a status JSON is a few KB; bound parse/disk
+const MAX_PROFILES = 32;              // sanity cap on how many siblings we scan
+
+/**
+ * Canonical reset instant for fingerprinting/matching — tolerant of CC reporting
+ * resets_at as epoch seconds or an ISO string. `null` when absent/unparseable.
+ * @param {any} bucket
+ * @returns {number | null}
+ */
+function resetInstant(bucket) {
+  return bucket && bucket.resets_at != null ? parseResetsAt(bucket.resets_at) : null;
+}
+
+/**
+ * The same-account signal: a stable string built from the ACCOUNT-WIDE buckets
+ * only (no model scope), each as `key@reset`. Buckets missing a used% or a reset
+ * are excluded — they can't anchor trust. Returns `null` when there is nothing to
+ * anchor on (no usable account-wide bucket), which callers treat as "don't merge".
+ * @param {any} rateLimits
+ * @returns {string | null}
+ */
+function accountFingerprint(rateLimits) {
+  if (!rateLimits || typeof rateLimits !== 'object') return null;
+  const parts = [];
+  for (const key of Object.keys(rateLimits)) {
+    if (modelScope(key)) continue;                 // model-scoped ≠ account-wide anchor
+    const r = rateLimits[key];
+    if (!r || typeof r !== 'object' || r.used_percentage == null) continue;
+    const at = resetInstant(r);
+    if (at == null) continue;
+    parts.push(`${key}@${at}`);
+  }
+  return parts.length ? parts.sort().join('|') : null;
+}
+
+/**
+ * Raise each of the local profile's meters to the freshest value seen across
+ * sibling profiles ON THE SAME ACCOUNT. Pure: no I/O. Returns the local rate_limits
+ * unchanged (same reference) when there is nothing trustworthy to merge.
+ *
+ * @param {any} localRl the local snapshot's `rate_limits`
+ * @param {any[]} siblingRls other profiles' `rate_limits` objects (account-untrusted)
+ * @returns {any} a shallow clone with used_percentage bumped where warranted, or `localRl`
+ */
+function mergeAccountLimits(localRl, siblingRls) {
+  const fp = accountFingerprint(localRl);
+  if (!fp) return localRl;                         // nothing to anchor trust on
+  const trusted = (siblingRls || []).filter((rl) => accountFingerprint(rl) === fp);
+  if (!trusted.length) return localRl;
+
+  let changed = false;
+  /** @type {any} */
+  const out = {};
+  for (const key of Object.keys(localRl)) {
+    const local = localRl[key];
+    out[key] = local;
+    if (!local || typeof local !== 'object' || local.used_percentage == null) continue;
+    let best = Number(local.used_percentage);
+    if (!Number.isFinite(best)) continue;
+    const at = resetInstant(local);
+    for (const rl of trusted) {
+      const s = rl[key];
+      if (!s || typeof s !== 'object') continue;
+      // Same window only — a sibling whose bucket reset at a different instant is
+      // from a rolled (or foreign) window; its used% does not describe this one.
+      if (resetInstant(s) !== at) continue;
+      const v = Number(s.used_percentage);
+      if (Number.isFinite(v) && v > best) best = v;
+    }
+    if (best !== local.used_percentage) { out[key] = { ...local, used_percentage: best }; changed = true; }
+  }
+  return changed ? out : localRl;
+}
+
+/**
+ * Read a sibling snapshot's `rate_limits`, best-effort. Bounded read; any error
+ * (missing, oversized, unparseable) yields `null` so a bad sibling is simply
+ * skipped rather than breaking the panel.
+ * @param {string} file
+ * @returns {any | null}
+ */
+function readSiblingRateLimits(file) {
+  try {
+    const st = fs.statSync(file);
+    if (!st.isFile() || st.size > MAX_SNAPSHOT_BYTES) return null;
+    const j = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return (j && j.rate_limits) || null;
+  } catch { return null; }
+}
+
+/**
+ * Disk wrapper: gather sibling profiles' rate limits from the ccr profile root and
+ * reconcile the local meters against them. Best-effort — returns `localRl` on any
+ * problem so it can wrap the render path without a guard at the call site.
+ *
+ * Engages ONLY for the launcher's profile layout (`~/.ccr/<profile>`): the state
+ * dir's parent must be `~/.ccr`. For ad-hoc `~/.ccr` or a custom CCR_STATE_DIR we
+ * have no sibling set to trust, so we behave exactly as before (no merge).
+ *
+ * @param {any} localRl the local snapshot's `rate_limits`
+ * @param {string} stateDir the local profile's state dir (CCR_STATE_DIR)
+ * @param {{ home?: string }} [opts]
+ * @returns {any}
+ */
+function freshenAccountLimits(localRl, stateDir, opts = {}) {
+  try {
+    if (!localRl || typeof localRl !== 'object') return localRl;
+    const home = opts.home || os.homedir();
+    const root = path.dirname(path.resolve(stateDir));
+    if (root !== path.resolve(path.join(home, '.ccr'))) return localRl; // not a profile layout
+    const selfFile = path.resolve(path.join(stateDir, 'last-status.json'));
+
+    /** @type {any[]} */
+    const siblings = [];
+    for (const name of fs.readdirSync(root)) {
+      if (siblings.length >= MAX_PROFILES) break;
+      const p = path.join(root, name);
+      let st; try { st = fs.statSync(p); } catch { continue; }
+      // A sibling profile dir (~/.ccr/<name>/last-status.json) or the ad-hoc
+      // ~/.ccr/last-status.json file itself.
+      const file = st.isDirectory() ? path.join(p, 'last-status.json')
+        : (name === 'last-status.json' ? p : null);
+      if (!file || path.resolve(file) === selfFile) continue;
+      const rl = readSiblingRateLimits(file);
+      if (rl) siblings.push(rl);
+    }
+    return mergeAccountLimits(localRl, siblings);
+  } catch { return localRl; }
+}
+
+module.exports = { accountFingerprint, mergeAccountLimits, freshenAccountLimits };

package/src/render/shared.js

@@ -59,7 +59,17 @@ function tok(/** @type {number|null} */ n) {
 function fmtMins(/** @type {number|null} */ m) {
   if (m == null || !isFinite(m)) return '?';
   m = Math.max(0, Math.round(m));
-  if (m >= 1440) { const d = Math.floor(m / 1440), hh = Math.floor((m % 1440) / 60); return hh ? `${d}d${hh}h` : `${d}d`; }
+  if (m >= 1440) {
+    const d = Math.floor(m / 1440), hh = Math.floor((m % 1440) / 60);
+    // A 100+ day horizon is a near-zero-burn artifact (100−used%)/rate with a
+    // tiny rate). Its hours are noise, and a wide value like "1000d5h" would
+    // overflow the sidebar's fixed 7-col time column and shove the meter bar out
+    // of vertical line with the sibling row (the 5h/weekly bars must align). Cap
+    // it so the string never exceeds 6 visible columns — compact and honest.
+    if (d >= 1000) return '>999d';
+    if (d >= 100) return `${d}d`;
+    return hh ? `${d}d${hh}h` : `${d}d`;
+  }
   const h = Math.floor(m / 60), r = m % 60;
   if (h >= 1) return r ? `${h}h${String(r).padStart(2, '0')}m` : `${h}h`;
   return `${m}m`;

package/src/sidecar.js

@@ -9,9 +9,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const { normalizeStatus } = require('./normalize');
+const { freshenAccountLimits } = require('./account-limits');
 const { renderEconomy } = require('./render/economy');
 const { renderFeed } = require('./render/feed');
 const { clampVisible } = require('./render/shared');
+const { liveness } = require('./liveness');
 const { currentTranscriptPath, readNewLines, parseEvents } = require('./transcripts');
 
 const STATE_DIR = process.env.CCR_STATE_DIR || path.join(os.homedir(), '.ccr');
@@ -87,7 +89,12 @@ function composeFrame(stateDir, opts = {}) {
   try { state = JSON.parse(raw); } catch { return clamp(dim('ccr · status unreadable') + '\n'); }
   let out;
   try {
-    out = renderEconomy(normalizeStatus(state), { tick: Math.floor(now / 1000) % 2 === 0 });
+    // 5h/weekly are ACCOUNT-WIDE but captured per-profile, so an idle sibling's
+    // panel lags a busy one. Reconcile the meters against sibling profiles on the
+    // SAME account (see src/account-limits.js) before rendering — best-effort, and
+    // strictly guarded so a different account is never mixed in.
+    const reconciled = { ...state, rate_limits: freshenAccountLimits(state.rate_limits, stateDir) };
+    out = renderEconomy(normalizeStatus(reconciled), { tick: Math.floor(now / 1000) % 2 === 0 });
   } catch (e) {
     out = dim('ccr render error: ' + (e && e instanceof Error ? e.message : String(e)));
   }
@@ -102,6 +109,16 @@ function composeFrame(stateDir, opts = {}) {
       if (feedStr) out += '\n\n' + feedStr;
     }
   } catch { /* feed is optional */ }
+  // Staleness annotation (never a wipe): Claude Code does not emit the status line
+  // during a single long operation, so the snapshot legitimately ages. Surface a
+  // quiet "updated Nm ago" so a stale panel reads as stale rather than broken —
+  // otherwise a long agent run (or a CC statusLine that stopped firing) looks like
+  // the sidecar just froze. See src/liveness.js + features/liveness.feature.
+  try {
+    const ageMs = now - fs.statSync(snapshot).mtimeMs;
+    const mark = liveness({ exited: false, ageMs }).marker;
+    if (mark) out += (out.endsWith('\n') ? '' : '\n') + '  ' + dim('· ' + mark);
+  } catch { /* snapshot mtime unknown → no marker */ }
   return clamp(out.endsWith('\n') ? out : out + '\n');
 }