tokenmaxxing 0.1.5__tar.gz → 0.2.0__tar.gz

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

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

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

{tokenmaxxing-0.1.5 → 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:
@@ -619,6 +687,23 @@ class ClaudeMonitorApp(rumps.App):
         self._history_lock = threading.Lock()
         self._history = _load_history()
 
+        # Hydrate _latest from the last snapshot so the menu shows last-known
+        # values immediately after restart instead of going blank while the
+        # first poll is in flight (or during a rate-limit window where no fresh
+        # poll will land for many minutes). resets_at is unknown for a hydrated
+        # payload — the render path tolerates that and shows "—" for the time.
+        if self._history:
+            last = self._history[-1]
+            self._latest = {
+                "five_hour":         {"utilization": last.get("session_pct")},
+                "seven_day":         {"utilization": last.get("weekly_pct")},
+                "seven_day_sonnet":  {"utilization": last.get("weekly_sonnet_pct")},
+            }
+            try:
+                self._latest_at = datetime.fromtimestamp(last["ts"], tz=timezone.utc)
+            except (KeyError, TypeError, ValueError, OverflowError):
+                self._latest_at = None
+
         # Detail rows: one per known view (clickable to switch)
         self._detail_items = {}
         for label, key in VIEWS:
@@ -1003,8 +1088,13 @@ class ClaudeMonitorApp(rumps.App):
         # Either way, render markers/emoji on detail items so the user can see which view
         # is being tracked even before the first poll lands.
         if payload is None:
-            if err is not None:
-                self._set_title(MENU_ICON, "", err, None)
+            # Prefer the formatted status suffix when we have one — it carries
+            # the rate-limit countdown ("[rate limited 18m]") and is more useful
+            # than the raw error string. Falls back to err when no suffix
+            # applies (e.g. transient network blip with no cached data).
+            tail = status_suffix.lstrip() if status_suffix else err
+            if tail:
+                self._set_title(MENU_ICON, "", f" {tail}", None)
             for key, item in self._detail_items.items():
                 marker = MARKER_SELECTED if key == self.current_view else MARKER_UNSELECTED
                 item.title = f"{marker}{status_emoji(None)} {VIEW_LABEL[key]}: {UNAVAILABLE}"