ctxline-claude 0.0.5 → 0.0.6

package/README.md

@@ -105,14 +105,15 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 | **Weekly** | Weekly usage allowance + time until the weekly reset (subscription users) |
 | **Task** | The in-progress todo, when there is one |
 
-> \[!NOTE\] Usage bars change color automatically as you approach your
-> limits.
+> [!NOTE]
+> Usage bars change color automatically as you approach your limits.
 
 ## How it works
 
-- **Source** — context comes from Claude Code's session data; both usage bars are fetched from `https://api.anthropic.com/api/oauth/usage` (the `/usage` data — 5-hour and weekly limits). API-key users skip the usage fetch.
-- **Adaptive timing** — 1.5s timeout on the first prompt (cold start), 1.2s after (connection reused).
-- **Caching** — usage is cached at `~/.claude/cache/usage-cache.json`, shared across sessions. Within 30s the cache renders directly (the API call is skipped); if a live call fails, the last value (up to 10 min old) is shown so the bar never vanishes. The reset countdown recomputes every render.
+- **Source** — context comes from Claude Code's session data. Usage bars are read straight from the `rate_limits` field Claude Code pipes in (no network), falling back to `https://api.anthropic.com/api/oauth/usage` (the same `/usage` data — 5-hour and weekly limits) when that field isn't present yet. API-key users skip usage entirely.
+- **No network on the fast path** — when `rate_limits` is in the session data, there's no API call at all. The fetch below only runs as a fallback (e.g. the first render of a session, before the field appears).
+- **Adaptive timing** — for the fallback fetch: 1.5s timeout on the first prompt (cold start), 1.2s after (connection reused).
+- **Caching** — the fallback fetch is cached at `~/.claude/cache/usage-cache.json`, shared across sessions. Within 30s the cache renders directly (the API call is skipped); if a live call fails, the last value (up to 10 min old) is shown so the bar never vanishes. The reset countdown recomputes every render.
 - **Never breaks** — every failure path falls back silently; the statusline always prints.
 
 ## FAQ
@@ -120,7 +121,7 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 <details>
 <summary>Does this use the same data as /usage?</summary>
 
-Yes. Usage information comes directly from Anthropic's usage API.
+Yes — the same 5-hour and weekly limits. It reads them from the session data Claude Code provides when available, and falls back to Anthropic's usage API (the endpoint `/usage` uses) otherwise.
 
 </details>
 
@@ -141,7 +142,7 @@ No. All failures are handled silently and the statusline always renders.
 <details>
 <summary>Does it expose my API keys / auth tokens?</summary>
 
-No. Your credentials never leave your machine. The OAuth token is read locally (from `~/.claude/.credentials.json` or the macOS keychain) only to authenticate the request to Anthropic's own usage API — the same endpoint `/usage` uses. Nothing is sent to any third party, logged, or cached; only the resulting usage percentages are stored locally.
+No. Your credentials never leave your machine. On the fast path no token is read at all — usage comes straight from the session data. Only on the fallback fetch is the OAuth token read locally (from `~/.claude/.credentials.json` or the macOS keychain), used solely to authenticate the request to Anthropic's own usage API — the same endpoint `/usage` uses. Nothing is sent to any third party, logged, or cached; only the resulting usage percentages are stored locally.
 
 </details>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxline-claude",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
   "bin": {
     "ctxline-claude": "bin/install.js"

package/statusline.js

@@ -163,6 +163,37 @@ function normalizePercentage(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
 
+// Build usage bars from stdin `rate_limits` (Claude.ai Pro/Max, present only after the
+// first API response of a session). Same data as the OAuth usage API, so reading it here
+// skips the network/credentials/cache path entirely. `resets_at` is a Unix epoch in
+// SECONDS (not ISO) — ×1000 before Date. Returns { current, weekly } bars, or null when
+// rate_limits is absent or the required five_hour segment is unusable (caller falls back).
+function buildUsageFromStdin(data) {
+  const rl = data?.rate_limits;
+  if (!rl) return null;
+
+  const toEntry = (seg) => {
+    if (!seg) return null;
+    const pct = normalizePercentage(seg.used_percentage);
+    if (pct == null) return null;
+    // resets_at is a Unix epoch in SECONDS. Coerce + validate defensively: a non-numeric
+    // or out-of-range value would make new Date(...).toISOString() throw, and this path
+    // runs outside outputStatus's try/catch. Fall back to resetsAt: null on anything bad.
+    let resetsAt = null;
+    const epoch = Number(seg.resets_at);
+    if (Number.isFinite(epoch) && epoch > 0) {
+      const d = new Date(epoch * 1000);
+      if (!Number.isNaN(d.getTime())) resetsAt = d.toISOString();
+    }
+    return { percentage: pct, resetsAt };
+  };
+
+  const fiveHour = toEntry(rl.five_hour);
+  if (!fiveHour) return null;          // five_hour is the required bar
+  const weekly = toEntry(rl.seven_day);
+  return buildUsageBars(fiveHour, weekly);
+}
+
 // Validate a single usage entry ({ percentage, resetsAt }). Returns true only for a
 // finite 0-100 percentage and a parseable (or absent) resetsAt.
 function isValidUsageEntry(entry) {
@@ -393,21 +424,45 @@ function outputFallback(usage) {
   process.stdout.write(parts.join(' \u2502 '));
 }
 
-// Wrapper that skips usage fetch for API key users
-function getUsage(callback) {
+// Resolve usage bars for a (possibly null) parsed stdin payload.
+// Order: API-key users get none; otherwise prefer stdin `rate_limits` (no network),
+// then fall back to the cache+API flow when stdin lacks it (cold start / non-Pro/Max).
+function resolveUsage(data, callback) {
   if (IS_API_KEY) {
-    callback(null);
-  } else {
-    getUsageWithCache(callback);
+    return callback(null);
   }
+  const fromStdin = buildUsageFromStdin(data);
+  if (fromStdin) {
+    return callback(fromStdin);
+  }
+  getUsageWithCache(callback);
 }
 
 // Process with timeout
-if (process.stdin.isTTY) {
-  getUsage((usage) => {
-    outputFallback(usage);
+// Parse the accumulated stdin into a payload object, or null if empty/unparseable.
+function parseInput(input) {
+  if (!input || input.length === 0) return null;
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return null;
+  }
+}
+
+// Resolve usage for `data` (preferring stdin rate_limits), then render and exit.
+function emit(data) {
+  resolveUsage(data, (usage) => {
+    if (data) {
+      outputStatus(data, usage);
+    } else {
+      outputFallback(usage);
+    }
     process.exit(0);
   });
+}
+
+if (process.stdin.isTTY) {
+  emit(null);
 } else {
   let input = '';
   let timeoutReached = false;
@@ -416,19 +471,7 @@ if (process.stdin.isTTY) {
 
   const timeout = setTimeout(() => {
     timeoutReached = true;
-    getUsage((usage) => {
-      if (input.length > 0) {
-        try {
-          const data = JSON.parse(input);
-          outputStatus(data, usage);
-        } catch (e) {
-          outputFallback(usage);
-        }
-      } else {
-        outputFallback(usage);
-      }
-      process.exit(0);
-    });
+    emit(parseInput(input));
   }, overallTimeout);
 
   process.stdin.setEncoding('utf8');
@@ -436,15 +479,6 @@ if (process.stdin.isTTY) {
   process.stdin.on('end', () => {
     if (timeoutReached) return;
     clearTimeout(timeout);
-
-    getUsage((usage) => {
-      try {
-        const data = JSON.parse(input);
-        outputStatus(data, usage);
-      } catch (e) {
-        outputFallback(usage);
-      }
-      process.exit(0);
-    });
+    emit(parseInput(input));
   });
 }