tokenmaxxing 0.1.6__tar.gz → 0.2.1__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tokenmaxxing"
-version = "0.1.6"
+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.1.6 → 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.1.6"
+__version__ = "0.2.1"
 
 from tokenmaxxing.app import main
 

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

@@ -50,6 +50,20 @@ except ImportError:  # pragma: no cover
 
 USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
 OAUTH_API_VERSION = "oauth-2025-04-20"
+
+# The /api/oauth/usage endpoint is aggressively rate-limited (per-IP cooldown of
+# ~1h that resets on every probe). It's also not how the official Claude Code
+# client reads its rate limits — it reads them from the
+# anthropic-ratelimit-unified-* response headers on regular inference calls.
+# Make a 1-token /v1/messages call and parse those headers — same data, no
+# /usage throttle.
+MESSAGES_URL = "https://api.anthropic.com/v1/messages"
+ANTHROPIC_VERSION = "2023-06-01"
+PROBE_MODEL = "claude-haiku-4-5-20251001"  # cheapest current model
+HEADER_5H_UTIL = "anthropic-ratelimit-unified-5h-utilization"
+HEADER_5H_RESET = "anthropic-ratelimit-unified-5h-reset"
+HEADER_7D_UTIL = "anthropic-ratelimit-unified-7d-utilization"
+HEADER_7D_RESET = "anthropic-ratelimit-unified-7d-reset"
 KEYCHAIN_SERVICE = "Claude Code-credentials"
 CREDENTIALS_FILE = Path.home() / ".claude" / ".credentials.json"
 DASHBOARD_URL = "https://claude.ai/settings/usage"
@@ -60,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
@@ -460,23 +479,46 @@ def get_access_token() -> Optional[str]:
     return oauth_data.get("accessToken") if oauth_data else None
 
 
-def fetch_usage(oauth_data: Optional[dict] = None):
+def _epoch_to_iso(epoch: float) -> str:
+    """Convert unix-epoch seconds to ISO-8601 with Z suffix (the format the
+    /api/oauth/usage payload uses)."""
+    return datetime.fromtimestamp(epoch, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def fetch_usage(oauth_data: Optional[dict] = None, allow_messages_fallback: bool = False):
     """Returns (payload_dict, error_str, is_rate_limited, retry_after_seconds).
 
-    `retry_after_seconds` is the int parsed from the server's Retry-After
-    header on 429s (or None if absent / non-429). Lets the worker schedule
-    the next poll exactly when the rate-limit window expires instead of
-    guessing via exponential backoff.
+    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.
     """
-    # 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 (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={
@@ -505,6 +547,72 @@ def fetch_usage(oauth_data: Optional[dict] = None):
         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,
+        "messages": [{"role": "user", "content": "."}],
+    }).encode("utf-8")
+    req = urllib.request.Request(
+        MESSAGES_URL,
+        data=body,
+        method="POST",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "anthropic-version": ANTHROPIC_VERSION,
+            "anthropic-beta": OAUTH_API_VERSION,
+            "content-type": "application/json",
+            "User-Agent": "claude-limit-app/1.0",
+        },
+    )
+    try:
+        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:
+        payload = _payload_from_ratelimit_headers(e.headers)
+        if payload:
+            return payload, None, 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
+        return None, str(e), False, None
+
+
+def _payload_from_ratelimit_headers(headers) -> Optional[dict]:
+    """Parse anthropic-ratelimit-unified-* response headers into the
+    /api/oauth/usage payload shape the rest of the app expects.
+
+    Returns None if neither five-hour nor seven-day data is present (e.g. on
+    a non-OAuth request or a free-tier user without subscription limits)."""
+    def _f(name):
+        v = headers.get(name)
+        try:
+            return float(v) if v is not None else None
+        except (TypeError, ValueError):
+            return None
+
+    out = {}
+    util_5h, reset_5h = _f(HEADER_5H_UTIL), _f(HEADER_5H_RESET)
+    if util_5h is not None:
+        view = {"utilization": util_5h * 100.0}  # headers are 0..1; payload is 0..100
+        if reset_5h is not None:
+            view["resets_at"] = _epoch_to_iso(reset_5h)
+        out["five_hour"] = view
+    util_7d, reset_7d = _f(HEADER_7D_UTIL), _f(HEADER_7D_RESET)
+    if util_7d is not None:
+        view = {"utilization": util_7d * 100.0}
+        if reset_7d is not None:
+            view["resets_at"] = _epoch_to_iso(reset_7d)
+        out["seven_day"] = view
+    # seven_day_sonnet has no equivalent header — leave absent so the menu
+    # row renders as "—" rather than misleading stale data.
+    return out or None
+
+
 def bar(pct: Optional[float], width: int = BAR_WIDTH) -> str:
     """Solid Unicode progress bar."""
     if pct is None:
@@ -692,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.