tokenmaxxing 0.1.2__tar.gz → 0.1.4__tar.gz

{tokenmaxxing-0.1.2 → tokenmaxxing-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tokenmaxxing
-Version: 0.1.2
+Version: 0.1.4
 Summary: Menu bar app showing your live Claude Code session and weekly usage as a colored progress bar.
 Project-URL: Homepage, https://github.com/alvations/tokenmaxxing
 Project-URL: Repository, https://github.com/alvations/tokenmaxxing

{tokenmaxxing-0.1.2 → tokenmaxxing-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tokenmaxxing"
-version = "0.1.2"
+version = "0.1.4"
 description = "Menu bar app showing your live Claude Code session and weekly usage as a colored progress bar."
 readme = "README.md"
 requires-python = ">=3.9"

{tokenmaxxing-0.1.2 → tokenmaxxing-0.1.4}/src/tokenmaxxing/__init__.py

@@ -1,6 +1,6 @@
 """tokenmaxxing — menu bar app for Claude Code session and weekly usage."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 from tokenmaxxing.app import main
 

{tokenmaxxing-0.1.2 → tokenmaxxing-0.1.4}/src/tokenmaxxing/app.py

@@ -387,6 +387,46 @@ def _compute_min_max_avg(snapshots: list, key: str, now_ts: int):
     return min(vals), sum(vals) / len(vals), max(vals)
 
 
+def _lift_claude_env_token() -> Optional[str]:
+    """Find a fresh CLAUDE_CODE_OAUTH_TOKEN from a running `claude` process.
+
+    Pro/Max users can't refresh the keychain token in-place (refreshToken is
+    empty). After expiry (~24 h), the keychain token returns 401 forever,
+    triggering sustained 429s on the OAuth usage endpoint — the menu bar
+    locks into "[rate limited]" with no recovery short of starting a new
+    `claude` session.
+
+    A running `claude` parent process has the fresh token in its env vars.
+    Lifting it lets tokenmaxxing keep polling indefinitely as long as any
+    claude session is alive.
+    """
+    env_tok = os.environ.get("CLAUDE_CODE_OAUTH_TOKEN")
+    if env_tok:
+        return env_tok
+    try:
+        out = subprocess.check_output(
+            ["pgrep", "-x", "claude"],
+            stderr=subprocess.DEVNULL,
+            timeout=KEYCHAIN_TIMEOUT,
+        ).decode()
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+        return None
+    pids = [p.strip() for p in out.splitlines() if p.strip()]
+    for pid in pids:
+        try:
+            env_out = subprocess.check_output(
+                ["ps", "-E", "-p", pid],
+                stderr=subprocess.DEVNULL,
+                timeout=KEYCHAIN_TIMEOUT,
+            ).decode()
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+            continue
+        for tok in env_out.split():
+            if tok.startswith("CLAUDE_CODE_OAUTH_TOKEN="):
+                return tok.split("=", 1)[1]
+    return None
+
+
 def _get_oauth_data() -> Optional[dict]:
     """Read Claude Code's OAuth credentials from keychain or file. Returns the full claudeAiOauth dict."""
     user = os.environ.get("USER", "")
@@ -422,9 +462,15 @@ def get_access_token() -> Optional[str]:
 
 def fetch_usage(oauth_data: Optional[dict] = None):
     """Returns (payload_dict, error_str, is_rate_limited). One of payload/error is always None."""
-    token = oauth_data.get("accessToken") if oauth_data else None
+    # Prefer a fresh token lifted from a running `claude` process — the
+    # keychain token can't refresh in-place for Pro/Max users and will 401
+    # once it expires. Fall back to the keychain only if no claude session
+    # is alive.
+    token = _lift_claude_env_token()
+    if not token and oauth_data:
+        token = oauth_data.get("accessToken")
     if not token:
-        return None, "no Claude Code token", False
+        return None, "no Claude Code token (start a claude session)", False
     req = urllib.request.Request(
         USAGE_URL,
         headers={
@@ -440,7 +486,7 @@ def fetch_usage(oauth_data: Optional[dict] = None):
         if e.code == HTTP_STATUS_RATE_LIMITED:
             return None, "rate limited — data is stale, retrying soon", True
         if e.code == HTTP_STATUS_UNAUTHORIZED:
-            return None, "auth expired (run `claude` to refresh)", False
+            return None, "auth expired (start a claude session)", False
         return None, f"HTTP {e.code}", False
     except urllib.error.URLError as e:
         return None, f"net: {e.reason}", False
@@ -604,42 +650,58 @@ class ClaudeMonitorApp(rumps.App):
     # ----- worker / dispatch -----
 
     def _worker_loop(self):
+        """Background poll loop. Must NEVER die — any uncaught exception
+        leaves the UI frozen on the last state forever, with no further
+        polls to recover."""
         consecutive_failures = 0
         while True:
-            now = time.time()
-            if now < self._backoff_until:
-                self._wake.wait(timeout=min(REFRESH_SECONDS, self._backoff_until - now))
+            try:
+                now = time.time()
+                if now < self._backoff_until:
+                    self._wake.wait(timeout=min(REFRESH_SECONDS, self._backoff_until - now))
+                    self._wake.clear()
+                    continue
+
+                oauth_data = _get_oauth_data()
+                payload, err, is_rate_limited = fetch_usage(oauth_data)
+                # Drop any Refresh-now clicks that arrived during the poll — the
+                # in-flight poll already satisfies them, and re-polling immediately
+                # can trip the OAuth endpoint's rate limit.
                 self._wake.clear()
-                continue
-
-            oauth_data = _get_oauth_data()
-            payload, err, is_rate_limited = fetch_usage(oauth_data)
-            # Drop any Refresh-now clicks that arrived during the poll — the
-            # in-flight poll already satisfies them, and re-polling immediately
-            # can trip the OAuth endpoint's rate limit.
-            self._wake.clear()
-            with self._pending_lock:
-                self._pending = (payload, err, is_rate_limited, oauth_data)
-
-            if payload is not None:
-                consecutive_failures = 0
-                self._backoff_until = 0
-                self._record_snapshot(payload)
-                sleep_for = REFRESH_SECONDS
-            elif is_rate_limited:
-                consecutive_failures += 1
-                backoff = _calc_backoff(consecutive_failures)
-                self._backoff_until = time.time() + backoff
-                # Retry as soon as the backoff window allows, instead of waiting
-                # the full REFRESH_SECONDS — otherwise the menu keeps showing
-                # "[rate limited]" for ~5 min after a single transient 429 even
-                # when the API recovered within seconds.
-                sleep_for = backoff
-            else:
-                sleep_for = REFRESH_SECONDS
-
-            self._wake.wait(timeout=sleep_for)
-            self._wake.clear()
+                with self._pending_lock:
+                    self._pending = (payload, err, is_rate_limited, oauth_data)
+
+                if payload is not None:
+                    consecutive_failures = 0
+                    self._backoff_until = 0
+                    self._record_snapshot(payload)
+                    sleep_for = REFRESH_SECONDS
+                elif is_rate_limited:
+                    consecutive_failures += 1
+                    backoff = _calc_backoff(consecutive_failures)
+                    self._backoff_until = time.time() + backoff
+                    # Retry as soon as the backoff window allows, instead of waiting
+                    # the full REFRESH_SECONDS — otherwise the menu keeps showing
+                    # "[rate limited]" for ~5 min after a single transient 429 even
+                    # when the API recovered within seconds.
+                    sleep_for = backoff
+                else:
+                    sleep_for = REFRESH_SECONDS
+
+                self._wake.wait(timeout=sleep_for)
+                self._wake.clear()
+            except Exception as e:  # noqa: BLE001
+                # Surface the failure to the UI as a transient error and keep
+                # looping. Without this, a single bad poll kills polling forever.
+                print(f"tokenmaxxing worker: {type(e).__name__}: {e}", file=sys.stderr)
+                with self._pending_lock:
+                    self._pending = (None, f"worker error: {type(e).__name__}", False, None)
+                # Avoid a tight loop if the exception happens immediately.
+                try:
+                    self._wake.wait(timeout=REFRESH_SECONDS)
+                    self._wake.clear()
+                except Exception:  # noqa: BLE001
+                    time.sleep(REFRESH_SECONDS)
 
     def _apply_pending(self, _sender):
         with self._pending_lock:
@@ -665,6 +727,11 @@ class ClaudeMonitorApp(rumps.App):
         self._render()
 
     def _manual_refresh(self, _sender):
+        # Force-clear any pending backoff so the click actually polls.
+        # Without this, when the worker is in backoff (e.g. after sustained
+        # 429s), the wake event fires but the loop top-checks _backoff_until
+        # and goes right back to waiting — the click is swallowed.
+        self._backoff_until = 0
         self._wake.set()
 
     def _record_snapshot(self, payload):