clauddy 1.21.1 → 1.22.0

package/README.md

@@ -46,7 +46,7 @@ Knowing you're at **82%** with **1h 12m** left on the window still leaves you do
 - **`~35m left at this pace`** (in coral) — you'd run out before the window resets. Ease off, or wrap up.
 - **`resets before you run out`** — the reset gets there first. Carry on.
 
-The slope is fitted over your **session tokens** rather than the account %. The % is the number you care about, but it arrives as a whole number every ~5 minutes — over a short window the whole signal is a single `16 → 17` step, which throws the fitted pace off by multiples. Local-log tokens step too — one jump per assistant turn — but in increments some 10–20× finer, so the slope is far steadier; the account % then anchors it, converting tokens into % and re-calibrating on every poll.
+The slope is fitted over your **session tokens** rather than the account %. The % is the number you care about, but it arrives as a whole number every few minutes — over a short window the whole signal is a single `16 → 17` step, which throws the fitted pace off by multiples. Local-log tokens step too — one jump per assistant turn — but in increments some 10–20× finer, so the slope is far steadier; the account % then anchors it, converting tokens into % and re-calibrating on every poll.
 
 It reads your **recent** pace, not the session average: go quiet for a few minutes and the projection eases off, which is the point.
 

package/auth.js

@@ -35,12 +35,25 @@ function setDataDir(dir) {
   tokens = null
   profile = null
   pending = null
+  unreadable = false
 }
 
+// Set when the file itself could not be read for a reason other than "it is not
+// there" — a disk still waking up, say. That must not read as a logout, or the
+// widget asks for a login it doesn't need and every account looks gone. A file
+// we did read but cannot parse is a different matter: that one really is dead.
+let unreadable = false
 function load() {
   if (tokens) return tokens
+  let raw = null
   try {
-    tokens = JSON.parse(fs.readFileSync(tokenPath, 'utf8'))
+    raw = fs.readFileSync(tokenPath, 'utf8')
+    unreadable = false
+  } catch (e) {
+    unreadable = e?.code !== 'ENOENT'
+  }
+  try {
+    tokens = raw == null ? null : JSON.parse(raw)
   } catch {
     tokens = null
   }
@@ -56,12 +69,15 @@ function save(t) {
 function clear() {
   tokens = null
   profile = null
+  unreadable = false
   try {
     fs.unlinkSync(tokenPath)
   } catch {}
 }
 function isConnected() {
-  return !!load()
+  // a token we merely failed to read still counts: the account is connected,
+  // we just couldn't see it this instant
+  return !!load() || unreadable
 }
 
 // Step 1: build the authorize URL (opens in the browser)
@@ -152,7 +168,13 @@ async function refresh() {
 
 async function validToken() {
   const t = load()
-  if (!t) throw Object.assign(new Error('not connected'), { status: 401 })
+  // status 0 is "try again later", not "log in again": only a token that is
+  // genuinely absent should send the user back through the browser
+  if (!t) {
+    throw Object.assign(new Error(unreadable ? 'token unreadable' : 'not connected'), {
+      status: unreadable ? 0 : 401,
+    })
+  }
   if (!t.expires_at || t.expires_at - Date.now() < 60000) await refresh()
   return load().access_token
 }
@@ -189,6 +211,24 @@ function scopedWeeks(j) {
   return out
 }
 
+// What the endpoint says its own budget is. Undocumented, so we only ever read
+// it — nothing depends on it yet. Knowing the real numbers is what tells us how
+// close the activity poll's floor can get.
+let rateLimit = null
+function readRateLimit(res) {
+  const out = {}
+  try {
+    for (const [k, v] of res.headers) {
+      if (k.startsWith('anthropic-ratelimit-')) out[k.slice(20)] = v
+    }
+  } catch {
+    return // no headers to read — nothing here is worth failing a fetch over
+  }
+  if (!Object.keys(out).length) return
+  if (JSON.stringify(out) !== JSON.stringify(rateLimit)) console.log('usage rate limit', out)
+  rateLimit = out
+}
+
 // Step 3: fetch the authoritative usage
 async function fetchUsage() {
   const token = await validToken()
@@ -206,6 +246,7 @@ async function fetchUsage() {
       status: res.status,
     })
   }
+  readRateLimit(res)
   const j = await res.json()
   return {
     session: win(j.five_hour) || { pct: 0, resetMs: null },
@@ -239,4 +280,13 @@ async function fetchProfile() {
   return profile
 }
 
-module.exports = { begin, complete, fetchUsage, fetchProfile, clear, isConnected, setDataDir }
+module.exports = {
+  rateLimit: () => rateLimit,
+  begin,
+  complete,
+  fetchUsage,
+  fetchProfile,
+  clear,
+  isConnected,
+  setDataDir,
+}

package/main.js

@@ -8,6 +8,7 @@ const {
   Tray,
   Menu,
   nativeImage,
+  powerMonitor,
 } = require('electron')
 const path = require('node:path')
 const fs = require('node:fs')
@@ -233,6 +234,7 @@ function applyAccount(acc) {
   usage.setClaudeDir(acc.claudeDir)
   armed = new Set()
   lastSessionPct = null
+  lastSeenTokens = null // the new account's first read is a baseline, not a spend
   loadAlertState()
 }
 
@@ -336,6 +338,7 @@ function createWindow() {
   for (const a of accounts.list()) pruneEmpty(a.id)
   accounts.pruneOrphans() // folders those slots left behind
   applyAccount(accounts.active())
+  powerMonitor?.on?.('resume', onResume)
   const { workAreaSize } = screen.getPrimaryDisplay()
   const H = 480
 
@@ -400,6 +403,7 @@ function createWindow() {
       const data = getUsage(config)
       win.webContents.send('usage', data)
       checkAlerts(config, data)
+      onLocalActivity(data)
     } catch (err) {
       win.webContents.send('usage-error', String(err))
     }
@@ -648,19 +652,51 @@ function watchDebug() {
 // ---- real usage via OAuth (authoritative %), polled slowly with 429 backoff ----
 let usageTimer = null
 let usageBackoff = 5 * 60 * 1000
+let authFails = 0 // consecutive 401s — see pollUsage
+let lastPollAt = 0
+
+// The authoritative % only moves when tokens are actually spent, and the local
+// logs show that within a tick. Polling off that beats a faster clock: it
+// answers while the user is working and asks for nothing while they are not.
+// The floor is what bounds the cost — never more than one call per 90s, well
+// under what a fixed one-minute poll would spend.
+const POLL_FLOOR_MS = 90 * 1000
+let lastSeenTokens = null
+function onLocalActivity(data) {
+  const t = data?.session?.tokens
+  if (typeof t !== 'number') return
+  const grew = lastSeenTokens != null && t > lastSeenTokens
+  lastSeenTokens = t
+  if (!grew || !auth.isConnected()) return
+  if (Date.now() - lastPollAt < POLL_FLOOR_MS) return
+  clearTimeout(usageTimer) // pollUsage schedules the next heartbeat itself
+  pollUsage()
+}
+
 function scheduleUsagePoll() {
   clearTimeout(usageTimer)
   if (auth.isConnected()) usageTimer = setTimeout(pollUsage, usageBackoff)
 }
 async function pollUsage() {
+  lastPollAt = Date.now()
   try {
     const u = await auth.fetchUsage()
     usageBackoff = 5 * 60 * 1000
+    authFails = 0
     pushRealUsage(u)
   } catch (e) {
     if (e && e.status === 429) {
       usageBackoff = Math.min(usageBackoff * 2, 30 * 60 * 1000)
     } else if (e && e.status === 401) {
+      // Refreshing rotates the refresh token, so a request that raced the one
+      // that rotated it comes back rejected while the session is perfectly
+      // alive. Clearing on that first answer throws away a good login, so the
+      // second rejection in a row is what counts.
+      if (++authFails < 2) {
+        usageBackoff = 60 * 1000
+        scheduleUsagePoll()
+        return
+      }
       auth.clear()
       pushRealUsage(null)
       sendAccounts()
@@ -674,9 +710,23 @@ async function pollUsage() {
   scheduleUsagePoll()
 }
 function startUsagePoll() {
+  authFails = 0
   if (auth.isConnected()) pollUsage()
 }
 
+// Waking up: the poll timer was frozen through the sleep, so the numbers on
+// screen are as old as the nap. Re-state what we know — a read that failed on
+// the way down would otherwise leave a stale "log in" panel up — and poll
+// again, after a beat, since the network is rarely back the instant we are.
+function onResume() {
+  if (!auth.isConnected()) return
+  if (win && !win.isDestroyed()) win.webContents.send('auth-state', { connected: true })
+  clearTimeout(usageTimer)
+  usageBackoff = 5 * 60 * 1000
+  usageTimer = setTimeout(pollUsage, 5000)
+  sendProfile()
+}
+
 // push the logged-in account's identity (email + plan) to the renderer
 let profileTimer = null
 async function sendProfile(tries = 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.21.1",
+  "version": "1.22.0",
   "description": "A cute desktop pet that tracks your Claude Code usage",
   "main": "main.js",
   "bin": {