tokenmaxxing 0.2.0__tar.gz → 0.2.2__tar.gz

{tokenmaxxing-0.2.0 → tokenmaxxing-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tokenmaxxing
-Version: 0.2.0
+Version: 0.2.2
 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.2.0 → tokenmaxxing-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tokenmaxxing"
-version = "0.2.0"
+version = "0.2.2"
 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.2.0 → tokenmaxxing-0.2.2}/src/tokenmaxxing/__init__.py

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

{tokenmaxxing-0.2.0 → tokenmaxxing-0.2.2}/src/tokenmaxxing/app.py

@@ -74,7 +74,10 @@ APP_NAME = "Claude"
 LOADING_TEXT = "loading…"
 TIMER_INTERVAL = 1
 
-REFRESH_SECONDS = 300  # 5 min: OAuth usage endpoint has aggressive undocumented rate limits
+REFRESH_SECONDS = 1800  # 30 min: /api/oauth/usage tolerates ~hourly polling but trips
+                        # at ~5 min cadence with a sticky multi-hour cooldown. 30 min keeps
+                        # us well below the throttle threshold; on-demand menu opens still
+                        # refresh instantly.
 STALE_AFTER_SECONDS = 600  # 10 min: only mark cached data "(stale)" past this age — one
                            # missed poll cycle (~5 min) shouldn't trigger the warning
 REFRESH_MAX_BACKOFF = 1800  # Max backoff: 30 minutes
@@ -480,22 +483,70 @@ def _epoch_to_iso(epoch: float) -> str:
     return datetime.fromtimestamp(epoch, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
-def fetch_usage(oauth_data: Optional[dict] = None):
+def fetch_usage(oauth_data: Optional[dict] = None, allow_messages_fallback: bool = False):
     """Returns (payload_dict, error_str, is_rate_limited, retry_after_seconds).
 
-    Strategy: a 1-token /v1/messages probe whose response headers carry
-    anthropic-ratelimit-unified-* — the same data the official Claude Code
-    client reads. This avoids the /api/oauth/usage IP-throttle entirely.
-
-    Pro/Max subscribers don't pay per-token, so the probe is effectively free.
-    The retry_after_seconds field stays for compatibility but should be None
-    in practice — /v1/messages doesn't 429 the way /api/oauth/usage does.
+    Primary path: /api/oauth/usage — token-free, same endpoint the official
+    Claude Code client uses (see claude-code submodule services/api/usage.ts).
+    Honors the server's Retry-After on 429 so we never poll inside the
+    cooldown window.
+
+    Fallback: if the caller passes allow_messages_fallback=True (the worker
+    flips this on after SUSTAINED_429_THRESHOLD consecutive 429s), we make
+    one 1-token /v1/messages probe and parse the anthropic-ratelimit-unified-*
+    response headers — same data, but costs ~10 tokens per call. Used only to
+    rescue the menu from a stuck cooldown; the primary path resumes as soon
+    as /usage stops 429ing.
     """
     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 (start a claude session)", False, None
+    payload, err, is_rate_limited, retry_after = _fetch_usage_oauth(token)
+    if payload is not None:
+        return payload, None, False, None
+    if is_rate_limited and allow_messages_fallback:
+        msg_payload, msg_err, msg_is_rate, msg_retry = _fetch_usage_messages(token)
+        if msg_payload is not None:
+            return msg_payload, None, False, None
+        # Fallback also failed — surface the /usage 429 since that's the path
+        # we want to recover, not the messages probe failure.
+    return None, err, is_rate_limited, retry_after
+
+
+def _fetch_usage_oauth(token: str):
+    """Hit /api/oauth/usage. Zero token cost. Throttled if polled too often."""
+    req = urllib.request.Request(
+        USAGE_URL,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "anthropic-beta": OAUTH_API_VERSION,
+            "User-Agent": "claude-limit-app/1.0",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT) as resp:
+            return json.loads(resp.read().decode("utf-8")), None, False, None
+    except urllib.error.HTTPError as e:
+        if e.code == HTTP_STATUS_RATE_LIMITED:
+            retry_after = None
+            try:
+                retry_after = int(e.headers.get("Retry-After") or 0) or None
+            except (TypeError, ValueError):
+                retry_after = None
+            return None, "rate limited — data is stale, retrying soon", True, retry_after
+        if e.code == HTTP_STATUS_UNAUTHORIZED:
+            return None, "auth expired (start a claude session)", False, None
+        return None, f"HTTP {e.code}", False, None
+    except urllib.error.URLError as e:
+        return None, f"net: {e.reason}", False, None
+    except Exception as e:  # noqa: BLE001
+        return None, str(e), False, None
+
+
+def _fetch_usage_messages(token: str):
+    """Paid fallback: 1-token /v1/messages probe; read rate-limit headers."""
     body = json.dumps({
         "model": PROBE_MODEL,
         "max_tokens": 1,
@@ -517,25 +568,12 @@ def fetch_usage(oauth_data: Optional[dict] = None):
         with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT) as resp:
             return _payload_from_ratelimit_headers(resp.headers), None, False, None
     except urllib.error.HTTPError as e:
-        # Even error responses (e.g. 529 overload) carry the ratelimit headers
-        # — extract them when we can so a brief upstream blip still updates
-        # the menu.
-        if e.code == HTTP_STATUS_RATE_LIMITED:
-            payload = _payload_from_ratelimit_headers(e.headers)
-            retry_after = None
-            try:
-                retry_after = int(e.headers.get("Retry-After") or 0) or None
-            except (TypeError, ValueError):
-                retry_after = None
-            if payload:
-                return payload, None, False, None
-            return None, "rate limited — data is stale, retrying soon", True, retry_after
-        if e.code == HTTP_STATUS_UNAUTHORIZED:
-            return None, "auth expired (start a claude session)", False, None
         payload = _payload_from_ratelimit_headers(e.headers)
         if payload:
             return payload, None, False, None
-        return None, f"HTTP {e.code}", False, None
+        if e.code == HTTP_STATUS_UNAUTHORIZED:
+            return None, "auth expired (start a claude session)", False, None
+        return None, f"HTTP {e.code} on /v1/messages fallback", False, None
     except urllib.error.URLError as e:
         return None, f"net: {e.reason}", False, None
     except Exception as e:  # noqa: BLE001
@@ -684,6 +722,7 @@ class ClaudeMonitorApp(rumps.App):
         self._pending_lock = threading.Lock()
         self._wake = threading.Event()
         self._backoff_until = 0     # unix timestamp; worker won't poll until after this
+        self._force_fallback_next = False  # set by "Force fresh" menu; consumed by next poll
         self._history_lock = threading.Lock()
         self._history = _load_history()
 
@@ -733,6 +772,8 @@ class ClaudeMonitorApp(rumps.App):
         self.stats_item = rumps.MenuItem(HISTORY_COLLECTING)
         self._dashboard_item = rumps.MenuItem("Open Claude dashboard…", callback=self._open_dashboard)
         self._refresh_item = rumps.MenuItem("Refresh now", callback=self._manual_refresh)
+        self._refresh_paid_item = rumps.MenuItem(
+            "Force fresh (uses ~10 tokens)", callback=self._manual_refresh_paid)
 
         self.menu = self._build_menu_items()
 
@@ -760,7 +801,16 @@ class ClaudeMonitorApp(rumps.App):
                     continue
 
                 oauth_data = _get_oauth_data()
-                payload, err, is_rate_limited, retry_after = fetch_usage(oauth_data)
+                # /v1/messages fallback is opt-in only — the user explicitly
+                # triggers it via the "Force fresh (uses ~10 tokens)" menu item,
+                # which sets _force_fallback_next for exactly one poll. The
+                # default path stays zero-token even when /api/oauth/usage is
+                # stuck — we'd rather show stale data than silently bill the
+                # user's quota.
+                allow_fallback = self._force_fallback_next
+                self._force_fallback_next = False
+                payload, err, is_rate_limited, retry_after = fetch_usage(
+                    oauth_data, allow_messages_fallback=allow_fallback)
                 # 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.
@@ -835,6 +885,17 @@ class ClaudeMonitorApp(rumps.App):
         # 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.
+        # Zero token cost: hits /api/oauth/usage only.
+        self._backoff_until = 0
+        self._wake.set()
+
+    def _manual_refresh_paid(self, _sender):
+        # Opt-in escape hatch when /api/oauth/usage is stuck in a long
+        # cooldown. Costs ~10 tokens for one /v1/messages probe whose
+        # response headers carry the current rate-limit values. Consumed
+        # exactly once by the next poll; subsequent polls revert to the
+        # free path.
+        self._force_fallback_next = True
         self._backoff_until = 0
         self._wake.set()
 
@@ -915,6 +976,7 @@ class ClaudeMonitorApp(rumps.App):
             None,
             self.last_update_item,
             self._refresh_item,
+            self._refresh_paid_item,
         ])
         return items