tokenmaxxing 0.1.6__tar.gz → 0.2.0__tar.gz

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

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

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

{tokenmaxxing-0.1.6 → tokenmaxxing-0.2.0}/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"
@@ -460,44 +474,67 @@ def get_access_token() -> Optional[str]:
     return oauth_data.get("accessToken") if oauth_data else 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):
     """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.
+    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.
     """
-    # 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
+    body = json.dumps({
+        "model": PROBE_MODEL,
+        "max_tokens": 1,
+        "messages": [{"role": "user", "content": "."}],
+    }).encode("utf-8")
     req = urllib.request.Request(
-        USAGE_URL,
+        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 json.loads(resp.read().decode("utf-8")), None, False, None
+            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
     except urllib.error.URLError as e:
         return None, f"net: {e.reason}", False, None
@@ -505,6 +542,37 @@ def fetch_usage(oauth_data: Optional[dict] = None):
         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: