ccusage 0.1.8__tar.gz → 0.1.9__tar.gz

{ccusage-0.1.8 → ccusage-0.1.9}/.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.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccusage
-Version: 0.1.8
+Version: 0.1.9
 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.9}/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.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ccusage"
-version = "0.1.8"
+version = "0.1.9"
 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.9}/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
@@ -94,6 +95,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 +144,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 +168,10 @@ 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:
+        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 +182,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 +211,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,12 +231,21 @@ 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:
+            if e.code not in (401, 403):
                 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")
 
 
@@ -208,6 +260,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 +305,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":
@@ -511,18 +564,19 @@ 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}]"]
 
     # 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 +600,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.8 → ccusage-0.1.9}/tests/test_ccusage.py

@@ -107,6 +107,7 @@ class FetchUsageTests(unittest.TestCase):
         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)
@@ -139,6 +140,52 @@ class FetchUsageTests(unittest.TestCase):
             with self.assertRaises(urllib.error.HTTPError):
                 ccusage.fetch_usage()
 
+    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"]
@@ -177,14 +224,39 @@ class BuildUsageJsonTests(unittest.TestCase):
         }
         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["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, ["5h", "7d", "7d_fable"])
+        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": [

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

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