tokenmaxxing 0.2.0__tar.gz → 0.2.1__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tokenmaxxing"
-version = "0.2.0"
+version = "0.2.1"
 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.1}/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.1"
 
 from tokenmaxxing.app import main
 

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

@@ -74,7 +74,12 @@ 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.
+SUSTAINED_429_THRESHOLD = 3  # after this many consecutive 429s, fall back to /v1/messages
+                             # headers (which cost ~10 tokens/poll) until /usage recovers
 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 +485,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 +570,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
@@ -760,7 +800,14 @@ class ClaudeMonitorApp(rumps.App):
                     continue
 
                 oauth_data = _get_oauth_data()
-                payload, err, is_rate_limited, retry_after = fetch_usage(oauth_data)
+                # After SUSTAINED_429_THRESHOLD consecutive /api/oauth/usage 429s,
+                # unstick the menu by falling back to the paid /v1/messages
+                # header path. We don't enable the fallback by default because it
+                # costs ~10 tokens/poll — we only pay that when the free endpoint
+                # is genuinely stuck in a multi-hour cooldown.
+                allow_fallback = consecutive_failures >= SUSTAINED_429_THRESHOLD
+                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.