ccusage 0.1.9__tar.gz → 0.1.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccusage
-Version: 0.1.9
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "ccusage"
-version = "0.1.9"
+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.9 → ccusage-0.1.10}/src/ccusage/__init__.py

@@ -72,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:
@@ -168,6 +198,9 @@ 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:
@@ -231,7 +264,10 @@ 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 not in (401, 403):
+            unavailable = _usage_unavailable_error(e)
+            if unavailable:
+                raise unavailable from e
+            if e.code != 401:
                 raise
 
             latest = get_credentials()
@@ -250,7 +286,10 @@ def fetch_usage() -> dict:
 
 
 # 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]:
@@ -342,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")
@@ -385,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:
@@ -425,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"]
@@ -450,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)
@@ -481,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)
@@ -509,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:
@@ -566,6 +663,9 @@ def cmd_statusline():
     plan = usage.get("plan", "?")
     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):

{ccusage-0.1.9 → ccusage-0.1.10}/tests/test_ccusage.py

@@ -140,6 +140,36 @@ class FetchUsageTests(unittest.TestCase):
             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)
@@ -266,6 +296,100 @@ class BuildUsageJsonTests(unittest.TestCase):
         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.9 → ccusage-0.1.10}/uv.lock

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