ccusage 0.1.8__tar.gz → 0.1.10__tar.gz

{ccusage-0.1.8 → ccusage-0.1.10}/.github/workflows/publish.yml

@@ -1,8 +1,10 @@
 name: Publish to PyPI
 
 on:
-  release:
-    types: [published]
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
 
 permissions:
   id-token: write

{ccusage-0.1.8 → ccusage-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccusage
-Version: 0.1.8
+Version: 0.1.10
 Summary: Claude Code usage monitor — fetches rate limits from Anthropic's API
 Project-URL: Homepage, https://github.com/wakamex/ccusage
 Project-URL: Source, https://github.com/wakamex/ccusage
@@ -17,7 +17,7 @@ Claude Code usage monitor. Fetches your real rate limit data from Anthropic's AP
 
 ```
 Plan: max_5x
-  Session (5h)         39%  resets 1h26m
+  Session              39%  resets 1h26m
   Week (all)           15%  resets 143h26m
   Week (Sonnet)        39%  resets 65h26m
   Extra usage          $0.00 / $1000.00
@@ -26,7 +26,7 @@ Plan: max_5x
 Claude Code statusline (self-caching — refreshes from API when stale, no daemon needed):
 
 ```
-~/projects/myapp [Opus 4.6] 5h:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
+~/projects/myapp [Opus 4.6] sess:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
 ```
 
 ## Install
@@ -98,6 +98,9 @@ The flat `seven_day_*` keys above are all `null` now — the live quota data
 lives in a structured `limits` array, which ccusage reads. Each entry is
 self-describing: `kind` (`session` / `weekly_all` / `weekly_scoped`),
 `percent`, `resets_at`, and for scoped limits a `scope.model.display_name`.
+Because the structured response does not include a session duration, ccusage
+labels that limit `Session` and caches it under `session` rather than assuming
+it is always five hours. Existing `5h` cache files remain readable.
 Model-scoped weekly windows (Opus, Sonnet, and a newly added **Fable**) are
 keyed by their model name, so any new one is auto-detected and displayed with
 no code change (e.g. `scope.model.display_name: "Fable"` → "Week (Fable)",

{ccusage-0.1.8 → ccusage-0.1.10}/README.md

@@ -8,7 +8,7 @@ Claude Code usage monitor. Fetches your real rate limit data from Anthropic's AP
 
 ```
 Plan: max_5x
-  Session (5h)         39%  resets 1h26m
+  Session              39%  resets 1h26m
   Week (all)           15%  resets 143h26m
   Week (Sonnet)        39%  resets 65h26m
   Extra usage          $0.00 / $1000.00
@@ -17,7 +17,7 @@ Plan: max_5x
 Claude Code statusline (self-caching — refreshes from API when stale, no daemon needed):
 
 ```
-~/projects/myapp [Opus 4.6] 5h:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
+~/projects/myapp [Opus 4.6] sess:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
 ```
 
 ## Install
@@ -89,6 +89,9 @@ The flat `seven_day_*` keys above are all `null` now — the live quota data
 lives in a structured `limits` array, which ccusage reads. Each entry is
 self-describing: `kind` (`session` / `weekly_all` / `weekly_scoped`),
 `percent`, `resets_at`, and for scoped limits a `scope.model.display_name`.
+Because the structured response does not include a session duration, ccusage
+labels that limit `Session` and caches it under `session` rather than assuming
+it is always five hours. Existing `5h` cache files remain readable.
 Model-scoped weekly windows (Opus, Sonnet, and a newly added **Fable**) are
 keyed by their model name, so any new one is auto-detected and displayed with
 no code change (e.g. `scope.model.display_name: "Fable"` → "Week (Fable)",

{ccusage-0.1.8 → ccusage-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ccusage"
-version = "0.1.8"
+version = "0.1.10"
 description = "Claude Code usage monitor — fetches rate limits from Anthropic's API"
 readme = "README.md"
 requires-python = ">=3.12"

{ccusage-0.1.8 → ccusage-0.1.10}/src/ccusage/__init__.py

@@ -19,6 +19,7 @@ import os
 import signal
 import subprocess
 import sys
+import tempfile
 import time
 import urllib.error
 import urllib.request
@@ -71,10 +72,40 @@ CLAUDE_DIR = Path.home() / ".claude"
 CREDENTIALS_FILE = _resolve_claude_path(".credentials.json")
 USAGE_FILE = _resolve_claude_path("usage-limits.json")
 DAEMON_INTERVAL = 300  # 5 minutes
+UNAVAILABLE_RETRY_INTERVAL = 3600  # 1 hour
 TOKEN_URL = "https://console.anthropic.com/v1/oauth/token"
 CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"  # Claude Code's public OAuth client
 
 
+class UsageUnavailableError(RuntimeError):
+    """The account is authenticated but its usage endpoint is unavailable."""
+
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+def _usage_unavailable_error(error: urllib.error.HTTPError) -> UsageUnavailableError | None:
+    """Translate known account-level authorization failures into a typed error."""
+    if error.code != 403:
+        return None
+    try:
+        payload = json.loads(error.read())
+        api_error = payload.get("error") or {}
+        details = api_error.get("details") or {}
+        code = details.get("error_code")
+        message = api_error.get("message")
+    except (AttributeError, json.JSONDecodeError, TypeError):
+        return None
+    if code != "oauth_not_allowed_for_organization":
+        return None
+    return UsageUnavailableError(
+        code,
+        message or "OAuth authentication is not allowed for this organization.",
+    )
+
+
 def get_credentials() -> dict | None:
     """Read OAuth credentials from Claude Code's credentials file."""
     try:
@@ -94,6 +125,48 @@ def get_plan(creds: dict | None = None) -> str:
     return tier.removeprefix("default_claude_")
 
 
+def _credential_identity(creds: dict | None) -> tuple[object, object]:
+    oauth = (creds or {}).get("claudeAiOauth", {})
+    return oauth.get("accessToken"), oauth.get("refreshToken")
+
+
+def _persist_credentials(updated: dict, expected_identity: tuple[object, object]) -> dict:
+    latest = get_credentials()
+    if latest and _credential_identity(latest) != expected_identity:
+        return latest
+    if latest:
+        latest_oauth = latest.get("claudeAiOauth", {})
+        updated_oauth = updated.get("claudeAiOauth", {})
+        updated = {
+            **latest,
+            **updated,
+            "claudeAiOauth": {**latest_oauth, **updated_oauth},
+        }
+
+    tmp: Path | None = None
+    try:
+        CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp_name = tempfile.mkstemp(
+            prefix=f".{CREDENTIALS_FILE.name}.", dir=CREDENTIALS_FILE.parent
+        )
+        tmp = Path(tmp_name)
+        os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w") as file:
+            file.write(json.dumps(updated))
+        os.replace(tmp, CREDENTIALS_FILE)
+    except OSError as exc:
+        if tmp:
+            try:
+                tmp.unlink()
+            except OSError:
+                pass
+        print(
+            f"Warning: refreshed token but could not write {CREDENTIALS_FILE}: {exc}",
+            file=sys.stderr,
+        )
+    return updated
+
+
 def refresh_credentials(creds: dict) -> dict:
     """Refresh the OAuth access token and persist updated credentials.
 
@@ -101,6 +174,11 @@ def refresh_credentials(creds: dict) -> dict:
     back to .credentials.json or Claude Code's stored one goes stale and the
     user gets logged out.
     """
+    expected_identity = _credential_identity(creds)
+    latest = get_credentials()
+    if latest and _credential_identity(latest) != expected_identity:
+        return latest
+
     oauth = creds.get("claudeAiOauth", {})
     refresh_token = oauth.get("refreshToken")
     if not refresh_token:
@@ -120,6 +198,13 @@ def refresh_credentials(creds: dict) -> dict:
         with urllib.request.urlopen(req, timeout=10) as resp:
             result = json.loads(resp.read())
     except urllib.error.HTTPError as e:
+        unavailable = _usage_unavailable_error(e)
+        if unavailable:
+            raise unavailable from e
+        latest = get_credentials()
+        if e.code in (400, 401) and latest:
+            if _credential_identity(latest) != expected_identity:
+                return latest
         raise RuntimeError(f"Token refresh failed ({e.code}) — open Claude Code to refresh it") from e
 
     oauth = dict(oauth)
@@ -130,16 +215,7 @@ def refresh_credentials(creds: dict) -> dict:
     updated = dict(creds)
     updated["claudeAiOauth"] = oauth
 
-    try:
-        tmp = CREDENTIALS_FILE.parent / (CREDENTIALS_FILE.name + ".tmp")
-        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-        with os.fdopen(fd, "w") as f:
-            f.write(json.dumps(updated))
-        os.replace(tmp, CREDENTIALS_FILE)
-    except OSError as e:
-        print(f"Warning: refreshed token but could not write {CREDENTIALS_FILE}: {e}", file=sys.stderr)
-
-    return updated
+    return _persist_credentials(updated, expected_identity)
 
 
 def fetch_usage() -> dict:
@@ -168,13 +244,13 @@ def fetch_usage() -> dict:
     if not token:
         raise RuntimeError("No OAuth access token in credentials")
 
-    # Refresh proactively if expired (or about to), then retry once on 401/403
-    # in case the token was revoked early.
+    # Refresh proactively if expired (or about to).
     if time.time() * 1000 > oauth.get("expiresAt", 0) - 60_000:
         creds = refresh_credentials(creds)
         token = creds["claudeAiOauth"]["accessToken"]
 
-    for attempt in range(2):
+    refreshed_after_rejection = False
+    for attempt in range(3):
         req = urllib.request.Request(
             "https://api.anthropic.com/api/oauth/usage",
             headers={
@@ -188,17 +264,32 @@ def fetch_usage() -> dict:
             with urllib.request.urlopen(req, timeout=10) as resp:
                 return json.loads(resp.read())
         except urllib.error.HTTPError as e:
-            if e.code in (401, 403) and attempt == 0:
-                creds = refresh_credentials(creds)
-                token = creds["claudeAiOauth"]["accessToken"]
-            else:
+            unavailable = _usage_unavailable_error(e)
+            if unavailable:
+                raise unavailable from e
+            if e.code != 401:
                 raise
 
+            latest = get_credentials()
+            latest_token = (latest or {}).get("claudeAiOauth", {}).get("accessToken")
+            if latest_token and latest_token != token:
+                creds, token = latest, latest_token
+                continue
+            if not refreshed_after_rejection:
+                creds = refresh_credentials(latest or creds)
+                token = creds["claudeAiOauth"]["accessToken"]
+                refreshed_after_rejection = True
+                continue
+            raise
+
     raise RuntimeError("Failed to fetch usage after token refresh")
 
 
 # Top-level keys in the cached usage dict that are NOT rate-limit buckets.
-_META_KEYS = {"plan", "source", "updated_at", "extra_usage"}
+_META_KEYS = {
+    "plan", "source", "updated_at", "last_success_at", "status",
+    "unavailable", "extra_usage",
+}
 
 
 def _bucket_display(short_key: str) -> tuple[str, str]:
@@ -208,6 +299,7 @@ def _bucket_display(short_key: str) -> tuple[str, str]:
     label automatically, e.g. "7d_fable" -> ("Week (Fable)", "fab").
     """
     known = {
+        "session": ("Session", "sess"),
         "5h": ("Session (5h)", "5h"),
         "7d": ("Week (all)", "7d"),
         "7d_opus": ("Week (Opus)", "opus"),
@@ -252,7 +344,7 @@ def _buckets_from_limits(limits) -> list:
             continue
         kind = entry.get("kind")
         if kind == "session":
-            short_key, order = "5h", 0
+            short_key, order = "session", 0
         elif kind == "weekly_all":
             short_key, order = "7d", 1
         elif kind == "weekly_scoped":
@@ -289,6 +381,43 @@ def build_usage_json(api_data: dict, plan: str) -> dict:
     return result
 
 
+def build_unavailable_usage(
+    error: UsageUnavailableError, plan: str, previous: dict | None = None
+) -> dict:
+    """Build a cache tombstone that replaces stale quota values."""
+    result = {
+        "plan": plan,
+        "source": "api",
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "status": "unavailable",
+        "unavailable": {
+            "code": error.code,
+            "message": error.message,
+            "hint": "no active subscription or organization OAuth disabled",
+        },
+    }
+    if previous:
+        last_success = previous.get("last_success_at")
+        if not last_success and previous.get("status") != "unavailable":
+            last_success = previous.get("updated_at")
+        if last_success:
+            result["last_success_at"] = last_success
+    return result
+
+
+def _unavailable_hint(data: dict) -> str | None:
+    unavailable = data.get("unavailable")
+    if data.get("status") != "unavailable" or not isinstance(unavailable, dict):
+        return None
+    return unavailable.get("hint") or unavailable.get("message") or "usage unavailable"
+
+
+def _cache_unavailable(error: UsageUnavailableError) -> dict:
+    data = build_unavailable_usage(error, get_plan(), _read_cache())
+    write_usage_file(data)
+    return data
+
+
 def write_usage_file(data: dict):
     """Write usage data to ~/.claude/usage-limits.json."""
     USAGE_FILE.write_text(json.dumps(data, indent=2) + "\n")
@@ -332,6 +461,8 @@ def cmd_status(raw_json=False):
     try:
         api_data = fetch_usage()
         data = build_usage_json(api_data, get_plan())
+    except UsageUnavailableError as e:
+        data = _cache_unavailable(e)
     except Exception as e:
         cached = _read_cache()
         if cached is None:
@@ -372,6 +503,10 @@ def cmd_status(raw_json=False):
             return ""
 
     print(f"Plan: {data.get('plan', '?')}")
+    unavailable = _unavailable_hint(data)
+    if unavailable:
+        print(f"  Usage unavailable: {unavailable}")
+        return
     for key, bucket in _quota_buckets(data):
         label = _bucket_display(key)[0]
         pct = bucket["pct"]
@@ -397,6 +532,11 @@ def cmd_refresh():
     """
     try:
         api_data = fetch_usage()
+    except UsageUnavailableError as e:
+        data = _cache_unavailable(e)
+        print(f"Updated {USAGE_FILE}")
+        print(f"  Usage unavailable: {_unavailable_hint(data)}")
+        return
     except Exception as e:
         reason = "rate limited (HTTP 429) — try again shortly" if _is_429(e) else str(e)
         print(f"Could not refresh usage: {reason}", file=sys.stderr)
@@ -428,6 +568,14 @@ def cmd_daemon(interval: int = DAEMON_INTERVAL):
             backoff = 0
             pcts = [f"{key}:{int(b['pct'])}%" for key, b in _quota_buckets(data)]
             print(f"[{datetime.now().strftime('%H:%M:%S')}] {' '.join(pcts)}")
+        except UsageUnavailableError as e:
+            data = _cache_unavailable(e)
+            backoff = UNAVAILABLE_RETRY_INTERVAL
+            print(
+                f"[{datetime.now().strftime('%H:%M:%S')}] "
+                f"Usage unavailable: {_unavailable_hint(data)}; retrying in {backoff}s",
+                file=sys.stderr,
+            )
         except urllib.error.HTTPError as e:
             if e.code == 429:
                 backoff = min((backoff or interval) * 2, 3600)
@@ -456,6 +604,8 @@ def _get_cached_usage(max_age: int = DAEMON_INTERVAL) -> dict:
         usage = build_usage_json(api_data, get_plan())
         write_usage_file(usage)
         return usage
+    except UsageUnavailableError as e:
+        return _cache_unavailable(e)
     except Exception:
         # Return whatever we had, even if stale
         try:
@@ -511,18 +661,22 @@ def cmd_statusline():
     usage = _get_cached_usage()
 
     plan = usage.get("plan", "?")
-    five_h = usage.get("5h", {})
-
     parts = [f"{D}{pwd}{RST}", f"[{C}{model}{RST}]"]
 
+    if _unavailable_hint(usage):
+        parts.append("usage:unavailable")
+
     # Auto-include every quota bucket present (a newly added one just appears).
+    session_bucket = {}
     for key, bucket in _quota_buckets(usage):
         abbrev = _bucket_display(key)[1]
         parts.append(f"{abbrev}:{color_pct(int(bucket.get('pct', 0)))}")
+        if key in {"session", "5h"}:
+            session_bucket = bucket
 
     parts.append(f"| {cost_fmt} | {D}{plan}{RST}")
 
-    reset = fmt_reset(five_h.get("resets_at"))
+    reset = fmt_reset(session_bucket.get("resets_at"))
     if reset:
         parts.append(f"| {D}reset:{reset}{RST}")
 
@@ -546,7 +700,7 @@ def cmd_install():
    }
 
 3. The statusline reads ~/.claude/usage-limits.json (written by the daemon)
-   and shows: 5h session, 7d all-models, 7d Sonnet-specific limits.
+   and shows: session, weekly all-models, and weekly scoped limits.
 """)
 
 

ccusage-0.1.10/tests/test_ccusage.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+import io
+import json
+import tempfile
+import time
+import unittest
+import urllib.error
+from pathlib import Path
+from unittest import mock
+
+import ccusage
+
+USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+
+
+def _creds(expires_at: int) -> dict:
+    return {
+        "claudeAiOauth": {
+            "accessToken": "old-token",
+            "refreshToken": "old-refresh",
+            "expiresAt": expires_at,
+            "scopes": ["user:inference"],
+            "subscriptionType": "max",
+        },
+        "otherTopLevel": "keep-me",
+    }
+
+
+class _FakeResponse(io.BytesIO):
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
+def _json_response(payload: dict) -> _FakeResponse:
+    return _FakeResponse(json.dumps(payload).encode())
+
+
+REFRESH_RESULT = {
+    "access_token": "new-token",
+    "refresh_token": "new-refresh",
+    "expires_in": 28800,
+}
+
+
+class FetchUsageTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.credfile = Path(self._tmp.name) / ".credentials.json"
+        patcher = mock.patch.object(ccusage, "CREDENTIALS_FILE", self.credfile)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def _write_creds(self, expires_at: int):
+        self.credfile.write_text(json.dumps(_creds(expires_at)))
+
+    def test_valid_token_skips_refresh(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+        calls = []
+
+        def fake_urlopen(req, timeout=None):
+            calls.append(req.full_url)
+            self.assertEqual(req.headers["Authorization"], "Bearer old-token")
+            return _json_response({"five_hour": {"utilization": 4.0}})
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            data = ccusage.fetch_usage()
+
+        self.assertEqual(data, {"five_hour": {"utilization": 4.0}})
+        self.assertEqual(calls, [USAGE_URL])
+
+    def test_expired_token_refreshes_and_persists_rotated_credentials(self):
+        self._write_creds(0)
+        calls = []
+
+        def fake_urlopen(req, timeout=None):
+            calls.append(req.full_url)
+            if req.full_url == ccusage.TOKEN_URL:
+                self.assertEqual(
+                    json.loads(req.data),
+                    {
+                        "grant_type": "refresh_token",
+                        "refresh_token": "old-refresh",
+                        "client_id": ccusage.CLIENT_ID,
+                    },
+                )
+                return _json_response(REFRESH_RESULT)
+            self.assertEqual(req.headers["Authorization"], "Bearer new-token")
+            return _json_response({"five_hour": {"utilization": 4.0}})
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            ccusage.fetch_usage()
+
+        self.assertEqual(calls, [ccusage.TOKEN_URL, USAGE_URL])
+
+        on_disk = json.loads(self.credfile.read_text())
+        oauth = on_disk["claudeAiOauth"]
+        self.assertEqual(oauth["accessToken"], "new-token")
+        self.assertEqual(oauth["refreshToken"], "new-refresh")
+        self.assertGreater(oauth["expiresAt"], time.time() * 1000)
+        # Fields not returned by the token endpoint must survive the rewrite
+        self.assertEqual(oauth["scopes"], ["user:inference"])
+        self.assertEqual(oauth["subscriptionType"], "max")
+        self.assertEqual(on_disk["otherTopLevel"], "keep-me")
+        self.assertEqual(self.credfile.stat().st_mode & 0o777, 0o600)
+        self.assertEqual(list(self.credfile.parent.glob("..credentials.json.*")), [])
+
+    def test_rejected_token_retries_once_after_refresh(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+        state = {"rejected": False}
+
+        def fake_urlopen(req, timeout=None):
+            if req.full_url == ccusage.TOKEN_URL:
+                return _json_response(REFRESH_RESULT)
+            if not state["rejected"]:
+                state["rejected"] = True
+                raise urllib.error.HTTPError(req.full_url, 401, "Unauthorized", {}, io.BytesIO(b""))
+            self.assertEqual(req.headers["Authorization"], "Bearer new-token")
+            return _json_response({"ok": True})
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            self.assertEqual(ccusage.fetch_usage(), {"ok": True})
+
+        on_disk = json.loads(self.credfile.read_text())
+        self.assertEqual(on_disk["claudeAiOauth"]["accessToken"], "new-token")
+
+    def test_persistent_rejection_raises(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+
+        def fake_urlopen(req, timeout=None):
+            if req.full_url == ccusage.TOKEN_URL:
+                return _json_response(REFRESH_RESULT)
+            raise urllib.error.HTTPError(req.full_url, 401, "Unauthorized", {}, io.BytesIO(b""))
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            with self.assertRaises(urllib.error.HTTPError):
+                ccusage.fetch_usage()
+
+    def test_organization_oauth_denial_is_not_treated_as_token_rejection(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+        calls = []
+        denial = {
+            "type": "error",
+            "error": {
+                "type": "permission_error",
+                "message": "OAuth authentication is currently not allowed for this organization.",
+                "details": {
+                    "error_code": "oauth_not_allowed_for_organization",
+                },
+            },
+        }
+
+        def fake_urlopen(req, timeout=None):
+            calls.append(req.full_url)
+            raise urllib.error.HTTPError(
+                req.full_url, 403, "Forbidden", {},
+                io.BytesIO(json.dumps(denial).encode()),
+            )
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            with self.assertRaises(ccusage.UsageUnavailableError) as raised:
+                ccusage.fetch_usage()
+
+        self.assertEqual(
+            raised.exception.code, "oauth_not_allowed_for_organization"
+        )
+        self.assertEqual(calls, [USAGE_URL])
+
+    def test_rejected_token_reloads_concurrently_updated_credentials(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+        replacement = _creds(int(time.time() * 1000) + 3_600_000)
+        replacement["claudeAiOauth"]["accessToken"] = "replacement-token"
+        replacement["claudeAiOauth"]["refreshToken"] = "replacement-refresh"
+        calls = []
+
+        def fake_urlopen(req, timeout=None):
+            calls.append(req.full_url)
+            if len(calls) == 1:
+                self.credfile.write_text(json.dumps(replacement))
+                raise urllib.error.HTTPError(
+                    req.full_url, 401, "Unauthorized", {}, io.BytesIO(b"")
+                )
+            self.assertEqual(
+                req.headers["Authorization"], "Bearer replacement-token"
+            )
+            return _json_response({"ok": True})
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            self.assertEqual(ccusage.fetch_usage(), {"ok": True})
+
+        self.assertEqual(calls, [USAGE_URL, USAGE_URL])
+
+    def test_refresh_does_not_overwrite_concurrently_rotated_credentials(self):
+        self._write_creds(0)
+        original = json.loads(self.credfile.read_text())
+        replacement = _creds(int(time.time() * 1000) + 3_600_000)
+        replacement["claudeAiOauth"]["accessToken"] = "replacement-token"
+        replacement["claudeAiOauth"]["refreshToken"] = "replacement-refresh"
+
+        class RotatingResponse(_FakeResponse):
+            def read(inner_self, *args):
+                self.credfile.write_text(json.dumps(replacement))
+                return super().read(*args)
+
+        with mock.patch.object(
+            ccusage.urllib.request,
+            "urlopen",
+            return_value=RotatingResponse(json.dumps(REFRESH_RESULT).encode()),
+        ):
+            result = ccusage.refresh_credentials(original)
+
+        self.assertEqual(result, replacement)
+        self.assertEqual(json.loads(self.credfile.read_text()), replacement)
+
+    def test_expired_token_without_refresh_token_raises(self):
+        creds = _creds(0)
+        del creds["claudeAiOauth"]["refreshToken"]
+        self.credfile.write_text(json.dumps(creds))
+
+        with self.assertRaisesRegex(RuntimeError, "no refresh token"):
+            ccusage.fetch_usage()
+
+    def test_refresh_endpoint_error_raises_runtime_error(self):
+        self._write_creds(0)
+
+        def fake_urlopen(req, timeout=None):
+            raise urllib.error.HTTPError(req.full_url, 429, "Too Many Requests", {}, io.BytesIO(b""))
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            with self.assertRaisesRegex(RuntimeError, "Token refresh failed \\(429\\)"):
+                ccusage.fetch_usage()
+
+
+class BuildUsageJsonTests(unittest.TestCase):
+    def test_reads_structured_limits_array(self):
+        # Current API shape: session/weekly totals and the model-scoped Fable
+        # quota all live in `limits`; the flat seven_day_* keys are ignored.
+        api_data = {
+            "seven_day_opus": None,
+            "seven_day_sonnet": None,
+            "iguana_necktie": None,
+            "limits": [
+                {"kind": "session", "percent": 3, "resets_at": "2026-07-04T05:10:00+00:00"},
+                {"kind": "weekly_all", "percent": 33, "resets_at": "2026-07-07T13:00:00+00:00"},
+                {"kind": "weekly_scoped", "percent": 58,
+                 "resets_at": "2026-07-07T13:00:00+00:00",
+                 "scope": {"model": {"id": None, "display_name": "Fable"}}},
+            ],
+            "extra_usage": {"is_enabled": True, "monthly_limit": 100000},
+        }
+        result = ccusage.build_usage_json(api_data, "max_20x")
+        self.assertEqual(result["plan"], "max_20x")
+        self.assertEqual(result["session"], {"pct": 3, "resets_at": "2026-07-04T05:10:00+00:00"})
+        self.assertNotIn("5h", result)
+        self.assertEqual(result["7d"], {"pct": 33, "resets_at": "2026-07-07T13:00:00+00:00"})
+        self.assertEqual(result["7d_fable"], {"pct": 58, "resets_at": "2026-07-07T13:00:00+00:00"})
+        self.assertEqual(result["extra_usage"], {"is_enabled": True, "monthly_limit": 100000})
+        self.assertEqual(ccusage._bucket_display("7d_fable"), ("Week (Fable)", "fab"))
+        # Buckets appear in a stable, sensible order.
+        keys = [k for k, _ in ccusage._quota_buckets(result)]
+        self.assertEqual(keys, ["session", "7d", "7d_fable"])
+
+    def test_statusline_uses_semantic_session_bucket_for_reset(self):
+        usage = {
+            "plan": "max_20x",
+            "session": {
+                "pct": 3,
+                "resets_at": "2099-01-01T00:00:00+00:00",
+            },
+            "7d": {"pct": 13, "resets_at": None},
+        }
+        status_input = {
+            "model": {"display_name": "Test"},
+            "workspace": {"current_dir": "/code/test"},
+        }
+        with (
+            mock.patch.object(ccusage, "_get_cached_usage", return_value=usage),
+            mock.patch("sys.stdin", io.StringIO(json.dumps(status_input))),
+            mock.patch("sys.stdout", new_callable=io.StringIO) as stdout,
+        ):
+            ccusage.cmd_statusline()
+
+        output = stdout.getvalue()
+        self.assertIn("sess:3%", output)
+        self.assertIn("reset:", output)
+
+    def test_scoped_limit_without_percent_is_skipped(self):
+        api_data = {"limits": [
+            {"kind": "weekly_scoped", "percent": None,
+             "scope": {"model": {"display_name": "Opus"}}},
+        ]}
+        result = ccusage.build_usage_json(api_data, "max_20x")
+        self.assertEqual([k for k, _ in ccusage._quota_buckets(result)], [])
+
+    def test_unavailable_tombstone_preserves_success_time_not_quota_values(self):
+        previous = {
+            "plan": "max_20x",
+            "updated_at": "2026-07-27T12:00:00+00:00",
+            "session": {"pct": 3, "resets_at": None},
+            "7d": {"pct": 13, "resets_at": None},
+        }
+        error = ccusage.UsageUnavailableError(
+            "oauth_not_allowed_for_organization",
+            "OAuth authentication is currently not allowed for this organization.",
+        )
+
+        result = ccusage.build_unavailable_usage(error, "max_20x", previous)
+
+        self.assertEqual(result["status"], "unavailable")
+        self.assertEqual(result["last_success_at"], previous["updated_at"])
+        self.assertEqual(
+            result["unavailable"]["code"],
+            "oauth_not_allowed_for_organization",
+        )
+        self.assertNotIn("session", result)
+        self.assertNotIn("7d", result)
+        self.assertEqual(list(ccusage._quota_buckets(result)), [])
+
+
+class UnavailableCacheTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.usage_file = Path(self._tmp.name) / "usage-limits.json"
+        patcher = mock.patch.object(ccusage, "USAGE_FILE", self.usage_file)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.error = ccusage.UsageUnavailableError(
+            "oauth_not_allowed_for_organization",
+            "OAuth authentication is currently not allowed for this organization.",
+        )
+
+    def test_stale_cache_is_replaced_when_refresh_is_unavailable(self):
+        self.usage_file.write_text(json.dumps({
+            "plan": "max_20x",
+            "updated_at": "2026-07-27T12:00:00+00:00",
+            "session": {"pct": 3, "resets_at": None},
+        }))
+
+        with (
+            mock.patch.object(ccusage, "fetch_usage", side_effect=self.error),
+            mock.patch.object(ccusage, "get_plan", return_value="max_20x"),
+        ):
+            result = ccusage._get_cached_usage(max_age=0)
+
+        self.assertEqual(result["status"], "unavailable")
+        self.assertNotIn("session", result)
+        self.assertEqual(json.loads(self.usage_file.read_text()), result)
+
+    def test_daemon_uses_hourly_retry_for_unavailable_usage(self):
+        sleeps = []
+
+        def stop_after_sleep(seconds):
+            sleeps.append(seconds)
+            raise KeyboardInterrupt
+
+        with (
+            mock.patch.object(ccusage, "fetch_usage", side_effect=self.error),
+            mock.patch.object(ccusage, "get_plan", return_value="max_20x"),
+            mock.patch.object(ccusage.signal, "signal"),
+            mock.patch.object(ccusage.time, "sleep", side_effect=stop_after_sleep),
+            mock.patch("sys.stdout", new_callable=io.StringIO),
+            mock.patch("sys.stderr", new_callable=io.StringIO),
+            self.assertRaises(KeyboardInterrupt),
+        ):
+            ccusage.cmd_daemon(interval=300)
+
+        self.assertEqual(sleeps, [ccusage.UNAVAILABLE_RETRY_INTERVAL])
+        cached = json.loads(self.usage_file.read_text())
+        self.assertEqual(cached["status"], "unavailable")
+
+    def test_statusline_reports_unavailable_without_quota_values(self):
+        usage = ccusage.build_unavailable_usage(self.error, "max_20x")
+        status_input = {
+            "model": {"display_name": "Test"},
+            "workspace": {"current_dir": "/code/test"},
+        }
+        with (
+            mock.patch.object(ccusage, "_get_cached_usage", return_value=usage),
+            mock.patch("sys.stdin", io.StringIO(json.dumps(status_input))),
+            mock.patch("sys.stdout", new_callable=io.StringIO) as stdout,
+        ):
+            ccusage.cmd_statusline()
+
+        output = stdout.getvalue()
+        self.assertIn("usage:unavailable", output)
+        self.assertNotIn("sess:", output)
+
+
+if __name__ == "__main__":
+    unittest.main()

{ccusage-0.1.8 → ccusage-0.1.10}/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.12"
 
 [[package]]
 name = "ccusage"
-version = "0.1.8"
+version = "0.1.10"
 source = { editable = "." }

ccusage-0.1.8/tests/test_ccusage.py

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-import io
-import json
-import tempfile
-import time
-import unittest
-import urllib.error
-from pathlib import Path
-from unittest import mock
-
-import ccusage
-
-USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
-
-
-def _creds(expires_at: int) -> dict:
-    return {
-        "claudeAiOauth": {
-            "accessToken": "old-token",
-            "refreshToken": "old-refresh",
-            "expiresAt": expires_at,
-            "scopes": ["user:inference"],
-            "subscriptionType": "max",
-        },
-        "otherTopLevel": "keep-me",
-    }
-
-
-class _FakeResponse(io.BytesIO):
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        pass
-
-
-def _json_response(payload: dict) -> _FakeResponse:
-    return _FakeResponse(json.dumps(payload).encode())
-
-
-REFRESH_RESULT = {
-    "access_token": "new-token",
-    "refresh_token": "new-refresh",
-    "expires_in": 28800,
-}
-
-
-class FetchUsageTests(unittest.TestCase):
-    def setUp(self):
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.credfile = Path(self._tmp.name) / ".credentials.json"
-        patcher = mock.patch.object(ccusage, "CREDENTIALS_FILE", self.credfile)
-        patcher.start()
-        self.addCleanup(patcher.stop)
-
-    def _write_creds(self, expires_at: int):
-        self.credfile.write_text(json.dumps(_creds(expires_at)))
-
-    def test_valid_token_skips_refresh(self):
-        self._write_creds(int(time.time() * 1000) + 3_600_000)
-        calls = []
-
-        def fake_urlopen(req, timeout=None):
-            calls.append(req.full_url)
-            self.assertEqual(req.headers["Authorization"], "Bearer old-token")
-            return _json_response({"five_hour": {"utilization": 4.0}})
-
-        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
-            data = ccusage.fetch_usage()
-
-        self.assertEqual(data, {"five_hour": {"utilization": 4.0}})
-        self.assertEqual(calls, [USAGE_URL])
-
-    def test_expired_token_refreshes_and_persists_rotated_credentials(self):
-        self._write_creds(0)
-        calls = []
-
-        def fake_urlopen(req, timeout=None):
-            calls.append(req.full_url)
-            if req.full_url == ccusage.TOKEN_URL:
-                self.assertEqual(
-                    json.loads(req.data),
-                    {
-                        "grant_type": "refresh_token",
-                        "refresh_token": "old-refresh",
-                        "client_id": ccusage.CLIENT_ID,
-                    },
-                )
-                return _json_response(REFRESH_RESULT)
-            self.assertEqual(req.headers["Authorization"], "Bearer new-token")
-            return _json_response({"five_hour": {"utilization": 4.0}})
-
-        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
-            ccusage.fetch_usage()
-
-        self.assertEqual(calls, [ccusage.TOKEN_URL, USAGE_URL])
-
-        on_disk = json.loads(self.credfile.read_text())
-        oauth = on_disk["claudeAiOauth"]
-        self.assertEqual(oauth["accessToken"], "new-token")
-        self.assertEqual(oauth["refreshToken"], "new-refresh")
-        self.assertGreater(oauth["expiresAt"], time.time() * 1000)
-        # Fields not returned by the token endpoint must survive the rewrite
-        self.assertEqual(oauth["scopes"], ["user:inference"])
-        self.assertEqual(oauth["subscriptionType"], "max")
-        self.assertEqual(on_disk["otherTopLevel"], "keep-me")
-        self.assertEqual(self.credfile.stat().st_mode & 0o777, 0o600)
-
-    def test_rejected_token_retries_once_after_refresh(self):
-        self._write_creds(int(time.time() * 1000) + 3_600_000)
-        state = {"rejected": False}
-
-        def fake_urlopen(req, timeout=None):
-            if req.full_url == ccusage.TOKEN_URL:
-                return _json_response(REFRESH_RESULT)
-            if not state["rejected"]:
-                state["rejected"] = True
-                raise urllib.error.HTTPError(req.full_url, 401, "Unauthorized", {}, io.BytesIO(b""))
-            self.assertEqual(req.headers["Authorization"], "Bearer new-token")
-            return _json_response({"ok": True})
-
-        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
-            self.assertEqual(ccusage.fetch_usage(), {"ok": True})
-
-        on_disk = json.loads(self.credfile.read_text())
-        self.assertEqual(on_disk["claudeAiOauth"]["accessToken"], "new-token")
-
-    def test_persistent_rejection_raises(self):
-        self._write_creds(int(time.time() * 1000) + 3_600_000)
-
-        def fake_urlopen(req, timeout=None):
-            if req.full_url == ccusage.TOKEN_URL:
-                return _json_response(REFRESH_RESULT)
-            raise urllib.error.HTTPError(req.full_url, 401, "Unauthorized", {}, io.BytesIO(b""))
-
-        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
-            with self.assertRaises(urllib.error.HTTPError):
-                ccusage.fetch_usage()
-
-    def test_expired_token_without_refresh_token_raises(self):
-        creds = _creds(0)
-        del creds["claudeAiOauth"]["refreshToken"]
-        self.credfile.write_text(json.dumps(creds))
-
-        with self.assertRaisesRegex(RuntimeError, "no refresh token"):
-            ccusage.fetch_usage()
-
-    def test_refresh_endpoint_error_raises_runtime_error(self):
-        self._write_creds(0)
-
-        def fake_urlopen(req, timeout=None):
-            raise urllib.error.HTTPError(req.full_url, 429, "Too Many Requests", {}, io.BytesIO(b""))
-
-        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
-            with self.assertRaisesRegex(RuntimeError, "Token refresh failed \\(429\\)"):
-                ccusage.fetch_usage()
-
-
-class BuildUsageJsonTests(unittest.TestCase):
-    def test_reads_structured_limits_array(self):
-        # Current API shape: session/weekly totals and the model-scoped Fable
-        # quota all live in `limits`; the flat seven_day_* keys are ignored.
-        api_data = {
-            "seven_day_opus": None,
-            "seven_day_sonnet": None,
-            "iguana_necktie": None,
-            "limits": [
-                {"kind": "session", "percent": 3, "resets_at": "2026-07-04T05:10:00+00:00"},
-                {"kind": "weekly_all", "percent": 33, "resets_at": "2026-07-07T13:00:00+00:00"},
-                {"kind": "weekly_scoped", "percent": 58,
-                 "resets_at": "2026-07-07T13:00:00+00:00",
-                 "scope": {"model": {"id": None, "display_name": "Fable"}}},
-            ],
-            "extra_usage": {"is_enabled": True, "monthly_limit": 100000},
-        }
-        result = ccusage.build_usage_json(api_data, "max_20x")
-        self.assertEqual(result["plan"], "max_20x")
-        self.assertEqual(result["5h"], {"pct": 3, "resets_at": "2026-07-04T05:10:00+00:00"})
-        self.assertEqual(result["7d"], {"pct": 33, "resets_at": "2026-07-07T13:00:00+00:00"})
-        self.assertEqual(result["7d_fable"], {"pct": 58, "resets_at": "2026-07-07T13:00:00+00:00"})
-        self.assertEqual(result["extra_usage"], {"is_enabled": True, "monthly_limit": 100000})
-        self.assertEqual(ccusage._bucket_display("7d_fable"), ("Week (Fable)", "fab"))
-        # Buckets appear in a stable, sensible order.
-        keys = [k for k, _ in ccusage._quota_buckets(result)]
-        self.assertEqual(keys, ["5h", "7d", "7d_fable"])
-
-    def test_scoped_limit_without_percent_is_skipped(self):
-        api_data = {"limits": [
-            {"kind": "weekly_scoped", "percent": None,
-             "scope": {"model": {"display_name": "Opus"}}},
-        ]}
-        result = ccusage.build_usage_json(api_data, "max_20x")
-        self.assertEqual([k for k, _ in ccusage._quota_buckets(result)], [])
-
-
-if __name__ == "__main__":
-    unittest.main()