ccusage 0.1.11__tar.gz → 0.2.0__tar.gz

ccusage-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  validate:
+    uses: wakamex/release-actions/.github/workflows/python-validation.yml@stable
+
+  publish:
+    needs: validate
+    runs-on: ubuntu-24.04
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: wakamex/release-actions/pypi-publish@stable
+
+  github-release:
+    needs: publish
+    permissions:
+      contents: write
+    uses: wakamex/release-actions/.github/workflows/github-release.yml@stable

ccusage-0.2.0/.github/workflows/release-eligibility.yml

@@ -0,0 +1,12 @@
+name: Release eligibility
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  release-eligible:
+    uses: wakamex/release-actions/.github/workflows/python-validation.yml@stable

ccusage-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wakamex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ccusage-0.1.11/README.md → ccusage-0.2.0/PKG-INFO

@@ -1,3 +1,14 @@
+Metadata-Version: 2.5
+Name: ccusage
+Version: 0.2.0
+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
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
 # ccusage
 
 Claude Code usage monitor. Fetches your real rate limit data from Anthropic's API and displays it in the Claude Code statusline.
@@ -47,6 +58,11 @@ Configure the statusline in `~/.claude/settings.json`:
 }
 ```
 
+If Claude Code uses `CLAUDE_CONFIG_DIR`, ccusage reads credentials and writes
+`usage-limits.json` in that directory instead.
+
+Each refresh also saves a copy under `usage-limits/<account uuid>.json`, tagged with the logged-in account's UUID and email from Claude Code's `.claude.json`. If you switch between Claude accounts with `/login`, the account you logged out of keeps its last usage there. An idle account cannot use quota, so that snapshot stays accurate until its windows reset.
+
 ## Commands
 
 | Command | Description |
@@ -134,7 +150,8 @@ anthropic-beta: oauth-2025-04-20
 
 ### Authentication
 
-The OAuth token lives at `~/.claude/.credentials.json`:
+The OAuth token normally lives at `~/.claude/.credentials.json`, or under
+`CLAUDE_CONFIG_DIR` when that environment variable is set:
 
 ```json
 {
@@ -173,4 +190,5 @@ seven_day:  75% at 60%, 50% at 35%, 25% at 15%
 | `~/.claude/.credentials.json` | Claude Code | OAuth tokens, plan tier |
 | `~/.claude/stats-cache.json` | Claude Code | Local usage stats (message counts, token counts per model) |
 | `~/.claude/usage-limits.json` | ccusage daemon | Cached API usage data (this tool) |
+| `~/.claude/usage-limits/<account uuid>.json` | ccusage daemon | Last usage seen for each Claude account (this tool) |
 | `~/.claude/statsig/` | Claude Code | Feature flags, experiment assignments |

ccusage-0.1.11/PKG-INFO → ccusage-0.2.0/README.md

@@ -1,12 +1,3 @@
-Metadata-Version: 2.4
-Name: ccusage
-Version: 0.1.11
-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
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
 # ccusage
 
 Claude Code usage monitor. Fetches your real rate limit data from Anthropic's API and displays it in the Claude Code statusline.
@@ -56,6 +47,11 @@ Configure the statusline in `~/.claude/settings.json`:
 }
 ```
 
+If Claude Code uses `CLAUDE_CONFIG_DIR`, ccusage reads credentials and writes
+`usage-limits.json` in that directory instead.
+
+Each refresh also saves a copy under `usage-limits/<account uuid>.json`, tagged with the logged-in account's UUID and email from Claude Code's `.claude.json`. If you switch between Claude accounts with `/login`, the account you logged out of keeps its last usage there. An idle account cannot use quota, so that snapshot stays accurate until its windows reset.
+
 ## Commands
 
 | Command | Description |
@@ -143,7 +139,8 @@ anthropic-beta: oauth-2025-04-20
 
 ### Authentication
 
-The OAuth token lives at `~/.claude/.credentials.json`:
+The OAuth token normally lives at `~/.claude/.credentials.json`, or under
+`CLAUDE_CONFIG_DIR` when that environment variable is set:
 
 ```json
 {
@@ -182,4 +179,5 @@ seven_day:  75% at 60%, 50% at 35%, 25% at 15%
 | `~/.claude/.credentials.json` | Claude Code | OAuth tokens, plan tier |
 | `~/.claude/stats-cache.json` | Claude Code | Local usage stats (message counts, token counts per model) |
 | `~/.claude/usage-limits.json` | ccusage daemon | Cached API usage data (this tool) |
+| `~/.claude/usage-limits/<account uuid>.json` | ccusage daemon | Last usage seen for each Claude account (this tool) |
 | `~/.claude/statsig/` | Claude Code | Feature flags, experiment assignments |

{ccusage-0.1.11 → ccusage-0.2.0}/pyproject.toml

@@ -1,9 +1,11 @@
 [project]
 name = "ccusage"
-version = "0.1.11"
+version = "0.2.0"
 description = "Claude Code usage monitor — fetches rate limits from Anthropic's API"
 readme = "README.md"
 requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
 dependencies = []
 
 [tool.uv]

ccusage-0.2.0/release-notes/v0.2.0.md

@@ -0,0 +1,20 @@
+ccusage now remembers the usage of every Claude account you log into, so switching accounts with `/login` no longer loses the other account's numbers. The package is also licensed under MIT.
+
+## Highlights
+
+- Each refresh also saves a copy of the usage to `~/.claude/usage-limits/<account uuid>.json`, tagged with the logged-in account's UUID and email. The account you switched away from keeps its last usage there, and since an idle account can't use quota, that copy stays accurate until its windows reset. `usage-limits.json` also gains an `account` field and is otherwise unchanged. ([`e2ed247`](https://github.com/wakamex/ccusage/commit/e2ed247b0b677c7e36220cb5b83f916022e0d14b))
+- If you switch accounts in the middle of a refresh, ccusage skips the per-account copy for that refresh, so usage is never saved under the wrong account. Both cache files are now written atomically, so readers never see a half-written file. ([`e2ed247`](https://github.com/wakamex/ccusage/commit/e2ed247b0b677c7e36220cb5b83f916022e0d14b))
+- The wheel and sdist now include a LICENSE file and declare `License-Expression: MIT`. ([`adbcbdb`](https://github.com/wakamex/ccusage/commit/adbcbdb40450f0e231a46026ad00848b0d188ac1))
+
+## Changes
+
+- Create the GitHub Release from committed release notes ([`146bf16`](https://github.com/wakamex/ccusage/commit/146bf165297bdd16c7300bd0dfdac3240d568fbf))
+- Use the shared release actions ([`e623b1d`](https://github.com/wakamex/ccusage/commit/e623b1d0f5189e71b561f1fbb5fda1c92b788069))
+- Remove the Markdown fence from the release workflows ([`614db37`](https://github.com/wakamex/ccusage/commit/614db372050760ba84f34469acd2ade6e03b0206))
+- Pin runners and actions, and follow release-actions stable ([`1ef57c9`](https://github.com/wakamex/ccusage/commit/1ef57c9009a6604b2bd0804ba654f84064a5b090))
+- Keep the last usage of each Claude account ([`e2ed247`](https://github.com/wakamex/ccusage/commit/e2ed247b0b677c7e36220cb5b83f916022e0d14b))
+- License ccusage under MIT ([`adbcbdb`](https://github.com/wakamex/ccusage/commit/adbcbdb40450f0e231a46026ad00848b0d188ac1))
+
+## History
+
+[v0.1.12...v0.2.0](https://github.com/wakamex/ccusage/compare/v0.1.12...v0.2.0)

{ccusage-0.1.11 → ccusage-0.2.0}/src/ccusage/__init__.py

@@ -9,12 +9,14 @@ Usage:
     ccusage status       Same as above
     ccusage json         Print raw JSON
     ccusage daemon       Run in foreground, refresh every 5 min, write to ~/.claude/usage-limits.json
+                         and ~/.claude/usage-limits/<account uuid>.json
     ccusage statusline   Claude Code statusline command (reads stdin + cache)
     ccusage install      Print setup instructions
 """
 
 import argparse
 import json
+import math
 import os
 import signal
 import subprocess
@@ -29,18 +31,23 @@ from pathlib import Path
 _TTY = sys.stdout.isatty()
 
 
+def _claude_config_dir() -> Path:
+    override = os.environ.get("CLAUDE_CONFIG_DIR")
+    return Path(override) if override is not None else Path.home() / ".claude"
+
+
 def _resolve_claude_path(relative: str) -> Path:
-    """Return the first existing path for a file inside ~/.claude/.
+    """Return the first existing path for a file inside Claude's config directory.
 
     On Windows, if the native path doesn't exist, also checks WSL distros
     so the tool works from a Windows terminal against a WSL-based Claude Code
     installation.
 
     Args:
-        relative: path relative to the .claude directory, e.g. ".credentials.json"
+        relative: path relative to Claude's config directory, e.g. ".credentials.json"
     """
-    native = Path.home() / ".claude" / relative
-    if native.exists() or sys.platform != "win32":
+    native = _claude_config_dir() / relative
+    if "CLAUDE_CONFIG_DIR" in os.environ or native.exists() or sys.platform != "win32":
         return native
 
     # Windows: try WSL paths
@@ -68,9 +75,13 @@ def _resolve_claude_path(relative: str) -> Path:
     return native
 
 
-CLAUDE_DIR = Path.home() / ".claude"
+CLAUDE_DIR = _claude_config_dir()
 CREDENTIALS_FILE = _resolve_claude_path(".credentials.json")
 USAGE_FILE = _resolve_claude_path("usage-limits.json")
+# One snapshot per Claude account, keyed by account UUID, so an account that is
+# logged out keeps its last usage. Idle accounts cannot use quota, so the
+# snapshot stays accurate until its windows reset.
+ACCOUNTS_DIR = USAGE_FILE.parent / "usage-limits"
 DAEMON_INTERVAL = 300  # 5 minutes
 UNAVAILABLE_RETRY_INTERVAL = 3600  # 1 hour
 TOKEN_URL = "https://console.anthropic.com/v1/oauth/token"
@@ -237,7 +248,7 @@ def fetch_usage() -> dict:
     """
     creds = get_credentials()
     if not creds:
-        raise RuntimeError("No credentials at ~/.claude/.credentials.json — run `claude` first")
+        raise RuntimeError(f"No credentials at {CREDENTIALS_FILE} — run `claude` first")
 
     oauth = creds.get("claudeAiOauth", {})
     token = oauth.get("accessToken")
@@ -338,23 +349,50 @@ def _buckets_from_limits(limits) -> list:
     out = []
     for entry in limits:
         if not isinstance(entry, dict):
-            continue
+            raise ValueError("Invalid usage response: each limit must be an object")
         pct = entry.get("percent")
         if pct is None:
             continue
+        if (
+            isinstance(pct, bool)
+            or not isinstance(pct, int | float)
+            or not math.isfinite(pct)
+            or not 0 <= pct <= 100
+        ):
+            raise ValueError("Invalid usage response: limit percent must be between 0 and 100")
         kind = entry.get("kind")
+        if not isinstance(kind, str) or not kind:
+            raise ValueError("Invalid usage response: limit kind must be a non-empty string")
         if kind == "session":
             short_key, order = "session", 0
         elif kind == "weekly_all":
             short_key, order = "7d", 1
         elif kind == "weekly_scoped":
-            model = (entry.get("scope") or {}).get("model") or {}
-            name = (model.get("display_name") or model.get("id") or "scoped").strip()
+            scope = entry.get("scope")
+            model = scope.get("model") if isinstance(scope, dict) else None
+            if not isinstance(model, dict):
+                raise ValueError("Invalid usage response: scoped limit must identify a model")
+            name = model.get("display_name") or model.get("id")
+            if not isinstance(name, str) or not name.strip():
+                raise ValueError("Invalid usage response: scoped limit must identify a model")
+            name = name.strip()
             short_key = "7d_" + name.lower().replace(" ", "_")
             order = {"7d_opus": 2, "7d_sonnet": 3}.get(short_key, 4)
         else:
-            short_key, order = kind or "unknown", 5
-        out.append((order, short_key, {"pct": pct, "resets_at": entry.get("resets_at")}))
+            short_key, order = kind, 5
+        resets_at = entry.get("resets_at")
+        if resets_at is not None:
+            if not isinstance(resets_at, str):
+                raise ValueError("Invalid usage response: reset time must be an ISO timestamp")
+            try:
+                reset = datetime.fromisoformat(resets_at.replace("Z", "+00:00"))
+            except ValueError as exc:
+                raise ValueError(
+                    "Invalid usage response: reset time must be an ISO timestamp"
+                ) from exc
+            if reset.tzinfo is None:
+                raise ValueError("Invalid usage response: reset time must include a timezone")
+        out.append((order, short_key, {"pct": pct, "resets_at": resets_at}))
     return out
 
 
@@ -372,7 +410,9 @@ def build_usage_json(api_data: dict, plan: str) -> dict:
         "updated_at": datetime.now(timezone.utc).isoformat(),
     }
     limits = api_data.get("limits")
-    buckets = _buckets_from_limits(limits) if isinstance(limits, list) else []
+    if not isinstance(limits, list):
+        raise ValueError("Invalid usage response: limits must be an array")
+    buckets = _buckets_from_limits(limits)
     for _, short_key, bucket in sorted(buckets, key=lambda b: b[0]):
         result[short_key] = bucket
     extra = api_data.get("extra_usage")
@@ -412,15 +452,51 @@ def _unavailable_hint(data: dict) -> str | None:
     return unavailable.get("hint") or unavailable.get("message") or "usage unavailable"
 
 
-def _cache_unavailable(error: UsageUnavailableError) -> dict:
+def _cache_unavailable(error: UsageUnavailableError, account: dict | None = None) -> dict:
     data = build_unavailable_usage(error, get_plan(), _read_cache())
-    write_usage_file(data)
+    write_usage_file(data, account)
     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")
+def current_account() -> dict | None:
+    """Return the logged-in account's UUID and email from Claude Code's config."""
+    if "CLAUDE_CONFIG_DIR" in os.environ:
+        path = _claude_config_dir() / ".claude.json"
+    else:
+        path = Path.home() / ".claude.json"
+    try:
+        account = json.loads(path.read_text()).get("oauthAccount") or {}
+    except (OSError, ValueError, AttributeError):
+        return None
+    if not account.get("accountUuid"):
+        return None
+    return {"uuid": account["accountUuid"], "email": account.get("emailAddress")}
+
+
+def _write_json(path: Path, data: dict):
+    """Write JSON through a temporary file so readers never see a partial file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_name = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w") as file:
+            file.write(json.dumps(data, indent=2) + "\n")
+        os.replace(tmp_name, path)
+    except BaseException:
+        Path(tmp_name).unlink(missing_ok=True)
+        raise
+
+
+def write_usage_file(data: dict, account: dict | None = None):
+    """Write usage data to ~/.claude/usage-limits.json and the account's snapshot.
+
+    `account` is the logged-in account read before the usage was fetched. The
+    snapshot is skipped when a /login switched accounts during the fetch, since
+    the data could then belong to either account.
+    """
+    if account and current_account() == account:
+        data["account"] = account
+        _write_json(ACCOUNTS_DIR / f"{account['uuid']}.json", data)
+    _write_json(USAGE_FILE, data)
 
 
 def _read_cache() -> dict | None:
@@ -458,11 +534,12 @@ def cmd_status(raw_json=False):
     token) falls back to the last cached usage rather than crashing.
     """
     stale = False
+    account = current_account()
     try:
         api_data = fetch_usage()
         data = build_usage_json(api_data, get_plan())
     except UsageUnavailableError as e:
-        data = _cache_unavailable(e)
+        data = _cache_unavailable(e, account)
     except Exception as e:
         cached = _read_cache()
         if cached is None:
@@ -530,10 +607,11 @@ def cmd_refresh():
     A one-shot equivalent of a single daemon tick — use it to force
     ~/.claude/usage-limits.json up to date without running the daemon.
     """
+    account = current_account()
     try:
         api_data = fetch_usage()
     except UsageUnavailableError as e:
-        data = _cache_unavailable(e)
+        data = _cache_unavailable(e, account)
         print(f"Updated {USAGE_FILE}")
         print(f"  Usage unavailable: {_unavailable_hint(data)}")
         return
@@ -542,7 +620,7 @@ def cmd_refresh():
         print(f"Could not refresh usage: {reason}", file=sys.stderr)
         sys.exit(1)
     data = build_usage_json(api_data, get_plan())
-    write_usage_file(data)
+    write_usage_file(data, account)
     pcts = " ".join(f"{key}:{int(b['pct'])}%" for key, b in _quota_buckets(data))
     print(f"Updated {USAGE_FILE}")
     if pcts:
@@ -560,16 +638,17 @@ def cmd_daemon(interval: int = DAEMON_INTERVAL):
 
     backoff = 0
     while True:
+        account = current_account()
         try:
             api_data = fetch_usage()
             plan = get_plan()
             data = build_usage_json(api_data, plan)
-            write_usage_file(data)
+            write_usage_file(data, account)
             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)
+            data = _cache_unavailable(e, account)
             backoff = UNAVAILABLE_RETRY_INTERVAL
             print(
                 f"[{datetime.now().strftime('%H:%M:%S')}] "
@@ -599,13 +678,14 @@ def _get_cached_usage(max_age: int = DAEMON_INTERVAL) -> dict:
     except Exception:
         pass
     # Cache is stale or missing — try to refresh
+    account = current_account()
     try:
         api_data = fetch_usage()
         usage = build_usage_json(api_data, get_plan())
-        write_usage_file(usage)
+        write_usage_file(usage, account)
         return usage
     except UsageUnavailableError as e:
-        return _cache_unavailable(e)
+        return _cache_unavailable(e, account)
     except Exception:
         # Return whatever we had, even if stale
         try:

{ccusage-0.1.11 → ccusage-0.2.0}/tests/test_ccusage.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import io
 import json
+import os
 import tempfile
 import time
 import unittest
@@ -46,6 +47,33 @@ REFRESH_RESULT = {
 }
 
 
+class ClaudePathTests(unittest.TestCase):
+    def test_config_dir_override_matches_claude_code(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            config_dir = Path(tmp) / "claude-config"
+            with mock.patch.dict(
+                os.environ, {"CLAUDE_CONFIG_DIR": str(config_dir)}, clear=False
+            ):
+                path = ccusage._resolve_claude_path(".credentials.json")
+
+        self.assertEqual(path, config_dir / ".credentials.json")
+
+    def test_config_dir_override_does_not_fall_back_to_wsl(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            config_dir = Path(tmp) / "missing-config"
+            with (
+                mock.patch.dict(
+                    os.environ, {"CLAUDE_CONFIG_DIR": str(config_dir)}, clear=False
+                ),
+                mock.patch.object(ccusage.sys, "platform", "win32"),
+                mock.patch.object(ccusage.subprocess, "run") as run_mock,
+            ):
+                path = ccusage._resolve_claude_path(".credentials.json")
+
+        self.assertEqual(path, config_dir / ".credentials.json")
+        run_mock.assert_not_called()
+
+
 class FetchUsageTests(unittest.TestCase):
     def setUp(self):
         self._tmp = tempfile.TemporaryDirectory()
@@ -279,6 +307,7 @@ class BuildUsageJsonTests(unittest.TestCase):
         }
         with (
             mock.patch.object(ccusage, "_get_cached_usage", return_value=usage),
+            mock.patch.object(ccusage, "_TTY", False),
             mock.patch("sys.stdin", io.StringIO(json.dumps(status_input))),
             mock.patch("sys.stdout", new_callable=io.StringIO) as stdout,
         ):
@@ -296,6 +325,50 @@ 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_rejects_missing_or_ill_typed_limits(self):
+        for api_data in ({}, {"limits": None}, {"limits": {}}, {"limits": "bad"}):
+            with self.subTest(api_data=api_data):
+                with self.assertRaisesRegex(ValueError, "limits must be an array"):
+                    ccusage.build_usage_json(api_data, "max_20x")
+
+    def test_rejects_malformed_limit_entries(self):
+        malformed = [
+            "bad",
+            {"kind": None, "percent": 10},
+            {"kind": "weekly_scoped", "percent": 10, "scope": []},
+            {"kind": "weekly_scoped", "percent": 10, "scope": {"model": {}}},
+        ]
+        for entry in malformed:
+            with self.subTest(entry=entry):
+                with self.assertRaisesRegex(ValueError, "Invalid usage response"):
+                    ccusage.build_usage_json({"limits": [entry]}, "max_20x")
+
+    def test_rejects_non_finite_or_out_of_range_percentages(self):
+        for pct in (float("nan"), float("inf"), float("-inf"), -0.1, 100.1, True, "10"):
+            with self.subTest(pct=pct):
+                with self.assertRaisesRegex(ValueError, "percent must be between 0 and 100"):
+                    ccusage.build_usage_json(
+                        {"limits": [{"kind": "session", "percent": pct}]},
+                        "max_20x",
+                    )
+
+    def test_rejects_invalid_reset_times(self):
+        for resets_at in (42, "not-a-time", "2026-07-04T05:10:00"):
+            with self.subTest(resets_at=resets_at):
+                with self.assertRaisesRegex(ValueError, "reset time"):
+                    ccusage.build_usage_json(
+                        {
+                            "limits": [
+                                {
+                                    "kind": "session",
+                                    "percent": 10,
+                                    "resets_at": resets_at,
+                                }
+                            ]
+                        },
+                        "max_20x",
+                    )
+
     def test_unavailable_tombstone_preserves_success_time_not_quota_values(self):
         previous = {
             "plan": "max_20x",
@@ -391,5 +464,78 @@ class UnavailableCacheTests(unittest.TestCase):
         self.assertNotIn("sess:", output)
 
 
+class AccountSnapshotTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.root = Path(self._tmp.name)
+        self.usage_file = self.root / "usage-limits.json"
+        self.accounts_dir = self.root / "usage-limits"
+        for name, value in (("USAGE_FILE", self.usage_file), ("ACCOUNTS_DIR", self.accounts_dir)):
+            patcher = mock.patch.object(ccusage, name, value)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+        self.config_dir = self.root / "config"
+        self.config_dir.mkdir()
+        env = mock.patch.dict(os.environ, {"CLAUDE_CONFIG_DIR": str(self.config_dir)}, clear=False)
+        env.start()
+        self.addCleanup(env.stop)
+
+    def _login(self, uuid: str, email: str):
+        (self.config_dir / ".claude.json").write_text(json.dumps({
+            "oauthAccount": {"accountUuid": uuid, "emailAddress": email, "organizationName": "x"},
+        }))
+
+    def test_current_account_reads_uuid_and_email_from_config_dir(self):
+        self._login("uuid-a", "a@example.com")
+        self.assertEqual(ccusage.current_account(), {"uuid": "uuid-a", "email": "a@example.com"})
+
+    def test_current_account_is_none_without_login(self):
+        self.assertIsNone(ccusage.current_account())
+        (self.config_dir / ".claude.json").write_text(json.dumps({"oauthAccount": None}))
+        self.assertIsNone(ccusage.current_account())
+
+    def test_write_keeps_a_snapshot_per_account(self):
+        self._login("uuid-a", "a@example.com")
+        account_a = ccusage.current_account()
+        ccusage.write_usage_file({"7d": {"pct": 91}}, account_a)
+        self._login("uuid-b", "b@example.com")
+        account_b = ccusage.current_account()
+        ccusage.write_usage_file({"7d": {"pct": 5}}, account_b)
+
+        snapshot_a = json.loads((self.accounts_dir / "uuid-a.json").read_text())
+        snapshot_b = json.loads((self.accounts_dir / "uuid-b.json").read_text())
+        main = json.loads(self.usage_file.read_text())
+        self.assertEqual(snapshot_a["7d"]["pct"], 91)
+        self.assertEqual(snapshot_a["account"]["email"], "a@example.com")
+        self.assertEqual(snapshot_b["7d"]["pct"], 5)
+        self.assertEqual(main, snapshot_b)
+
+    def test_snapshot_skipped_when_login_changes_during_fetch(self):
+        self._login("uuid-a", "a@example.com")
+        account_before_fetch = ccusage.current_account()
+        self._login("uuid-b", "b@example.com")
+        ccusage.write_usage_file({"7d": {"pct": 40}}, account_before_fetch)
+
+        self.assertFalse(self.accounts_dir.exists())
+        main = json.loads(self.usage_file.read_text())
+        self.assertNotIn("account", main)
+        self.assertEqual(main["7d"]["pct"], 40)
+
+    def test_refresh_writes_snapshot_for_logged_in_account(self):
+        self._login("uuid-a", "a@example.com")
+        api = {"limits": [{"name": "seven_day", "utilization": 12.0, "resets_at": None}]}
+        with (
+            mock.patch.object(ccusage, "fetch_usage", return_value=api),
+            mock.patch.object(ccusage, "get_plan", return_value="max_20x"),
+            mock.patch("sys.stdout", new_callable=io.StringIO),
+        ):
+            ccusage.cmd_refresh()
+
+        snapshot = json.loads((self.accounts_dir / "uuid-a.json").read_text())
+        self.assertEqual(snapshot["account"]["uuid"], "uuid-a")
+        self.assertEqual(snapshot["plan"], "max_20x")
+
+
 if __name__ == "__main__":
     unittest.main()

{ccusage-0.1.11 → ccusage-0.2.0}/uv.lock

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

ccusage-0.1.11/.github/workflows/publish.yml

@@ -1,29 +0,0 @@
-name: Publish to PyPI
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7.0.1
-      - name: Install uv
-        uses: astral-sh/setup-uv@v9.0.0
-        with:
-          enable-cache: false
-      - name: Verify version tag
-        run: test "$GITHUB_REF_NAME" = "v$(uv version --short)"
-      - name: Test
-        run: uv run --locked python -m unittest discover -s tests
-      - name: Build
-        run: uv build --no-sources
-      - name: Publish
-        run: uv publish --trusted-publishing always