ccusage 0.1.12__tar.gz → 0.3.0__tar.gz

ccusage-0.3.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.3.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.3.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.12/README.md → ccusage-0.3.0/PKG-INFO

@@ -1,3 +1,14 @@
+Metadata-Version: 2.5
+Name: ccusage
+Version: 0.3.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.
@@ -50,13 +61,17 @@ 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.
+
+To keep a second account current while you are logged into another, give it its own config directory with a permanent login, run a second daemon there with `CLAUDE_CONFIG_DIR` set, and symlink that directory's `usage-limits` folder to the main one so both daemons share their snapshots. Start that daemon with `--defer`: it then skips a refresh whenever another daemon saved the same account's snapshot within the last one and a half intervals, so an account logged in under two config directories is polled once.
+
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `ccusage` | Show current usage (colored terminal output) |
 | `ccusage json` | Print raw JSON |
-| `ccusage daemon [-i SECS]` | Run in foreground, refresh every 5 min (customizable) |
+| `ccusage daemon [-i SECS] [--defer]` | Run in foreground, refresh every 5 min (customizable) |
 | `ccusage statusline` | Claude Code statusline (self-caching, no daemon needed) |
 | `ccusage install` | Print setup instructions |
 
@@ -177,4 +192,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.12/PKG-INFO → ccusage-0.3.0/README.md

@@ -1,12 +1,3 @@
-Metadata-Version: 2.5
-Name: ccusage
-Version: 0.1.12
-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.
@@ -59,13 +50,17 @@ 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.
+
+To keep a second account current while you are logged into another, give it its own config directory with a permanent login, run a second daemon there with `CLAUDE_CONFIG_DIR` set, and symlink that directory's `usage-limits` folder to the main one so both daemons share their snapshots. Start that daemon with `--defer`: it then skips a refresh whenever another daemon saved the same account's snapshot within the last one and a half intervals, so an account logged in under two config directories is polled once.
+
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `ccusage` | Show current usage (colored terminal output) |
 | `ccusage json` | Print raw JSON |
-| `ccusage daemon [-i SECS]` | Run in foreground, refresh every 5 min (customizable) |
+| `ccusage daemon [-i SECS] [--defer]` | Run in foreground, refresh every 5 min (customizable) |
 | `ccusage statusline` | Claude Code statusline (self-caching, no daemon needed) |
 | `ccusage install` | Print setup instructions |
 
@@ -186,4 +181,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.12 → ccusage-0.3.0}/pyproject.toml

@@ -1,9 +1,11 @@
 [project]
 name = "ccusage"
-version = "0.1.12"
+version = "0.3.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.3.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.3.0/release-notes/v0.3.0.md

@@ -0,0 +1,11 @@
+`ccusage daemon --defer` lets you keep several Claude accounts current without polling any of them twice.
+
+To track an account you are not logged into, give it its own config directory with a permanent login, run a second daemon there with `CLAUDE_CONFIG_DIR` set, and symlink that directory's `usage-limits` folder to the main one. If you then log your main directory into the same account, both daemons would poll it. A daemon started with `--defer` skips a refresh whenever another daemon saved the same account's snapshot within the last one and a half refresh intervals, and starts refreshing again once that other daemon moves to a different account. Daemons without the flag behave as before.
+
+## Changes
+
+- Add daemon --defer to poll an account once across config directories ([`97d96a2`](https://github.com/wakamex/ccusage/commit/97d96a2b70e3424cece8f32bc8cac440df93c68c))
+
+## History
+
+[v0.2.0...v0.3.0](https://github.com/wakamex/ccusage/compare/v0.2.0...v0.3.0)

{ccusage-0.1.12 → ccusage-0.3.0}/src/ccusage/__init__.py

@@ -9,6 +9,7 @@ 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
 """
@@ -77,6 +78,10 @@ def _resolve_claude_path(relative: str) -> Path:
 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"
@@ -447,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:
@@ -493,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:
@@ -565,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
@@ -577,15 +620,38 @@ 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:
         print(f"  {pcts}")
 
 
-def cmd_daemon(interval: int = DAEMON_INTERVAL):
-    """Run in foreground, refresh every `interval` seconds."""
+def _covered_by_another_daemon(account: dict | None, own_stamp: str | None, interval: int) -> bool:
+    """True when a different daemon recently saved this account's snapshot.
+
+    Daemons for several config directories can share one snapshot directory
+    through a symlink. A snapshot whose timestamp this daemon did not write,
+    and that is younger than one and a half intervals, means another daemon is
+    polling the same account.
+    """
+    if not account:
+        return False
+    try:
+        stamp = json.loads((ACCOUNTS_DIR / f"{account['uuid']}.json").read_text())["updated_at"]
+        age = (datetime.now(timezone.utc) - datetime.fromisoformat(stamp)).total_seconds()
+    except (OSError, ValueError, KeyError, TypeError):
+        return False
+    return stamp != own_stamp and age < 1.5 * interval
+
+
+def cmd_daemon(interval: int = DAEMON_INTERVAL, defer: bool = False):
+    """Run in foreground, refresh every `interval` seconds.
+
+    With `defer`, skip a refresh while another daemon keeps this account's
+    snapshot current, so an account logged in under two config directories is
+    polled once.
+    """
     signal.signal(signal.SIGINT, lambda *_: sys.exit(0))
     if hasattr(signal, "SIGTERM"):
         signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
@@ -594,17 +660,29 @@ def cmd_daemon(interval: int = DAEMON_INTERVAL):
     print(f"Writing to {USAGE_FILE}")
 
     backoff = 0
+    own_stamp = None
+    deferring = False
     while True:
+        account = current_account()
+        if defer and _covered_by_another_daemon(account, own_stamp, interval):
+            if not deferring:
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] deferring to another daemon for this account")
+            deferring = True
+            time.sleep(interval)
+            continue
+        deferring = False
         try:
             api_data = fetch_usage()
             plan = get_plan()
             data = build_usage_json(api_data, plan)
-            write_usage_file(data)
+            write_usage_file(data, account)
+            own_stamp = data["updated_at"]
             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)
+            own_stamp = data["updated_at"]
             backoff = UNAVAILABLE_RETRY_INTERVAL
             print(
                 f"[{datetime.now().strftime('%H:%M:%S')}] "
@@ -634,13 +712,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:
@@ -748,6 +827,8 @@ def main():
     daemon_parser = sub.add_parser("daemon", help="Run refresh daemon")
     daemon_parser.add_argument("-i", "--interval", type=int, default=DAEMON_INTERVAL,
                                help=f"Refresh interval in seconds (default: {DAEMON_INTERVAL})")
+    daemon_parser.add_argument("--defer", action="store_true",
+                               help="Skip a refresh while another daemon keeps this account's snapshot current")
     sub.add_parser("statusline", help="Claude Code statusline (reads stdin + cache)")
     sub.add_parser("install", help="Print setup instructions")
     args = parser.parse_args()
@@ -760,7 +841,7 @@ def main():
     elif cmd == "refresh":
         cmd_refresh()
     elif cmd == "daemon":
-        cmd_daemon(interval=args.interval)
+        cmd_daemon(interval=args.interval, defer=args.defer)
     elif cmd == "statusline":
         cmd_statusline()
     elif cmd == "install":

{ccusage-0.1.12 → ccusage-0.3.0}/tests/test_ccusage.py

@@ -7,6 +7,7 @@ import tempfile
 import time
 import unittest
 import urllib.error
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from unittest import mock
 
@@ -464,5 +465,143 @@ 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")
+
+
+
+class DeferTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.accounts_dir = Path(self._tmp.name) / "usage-limits"
+        self.accounts_dir.mkdir()
+        patcher = mock.patch.object(ccusage, "ACCOUNTS_DIR", self.accounts_dir)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.account = {"uuid": "uuid-a", "email": "a@example.com"}
+
+    def _snapshot(self, seconds_old: float) -> str:
+        stamp = (datetime.now(timezone.utc) - timedelta(seconds=seconds_old)).isoformat()
+        (self.accounts_dir / "uuid-a.json").write_text(json.dumps({"updated_at": stamp}))
+        return stamp
+
+    def test_fresh_snapshot_from_another_daemon_covers_the_account(self):
+        self._snapshot(100)
+        self.assertTrue(ccusage._covered_by_another_daemon(self.account, "own-earlier-stamp", 300))
+        self.assertTrue(ccusage._covered_by_another_daemon(self.account, None, 300))
+
+    def test_own_snapshot_does_not_cover_the_account(self):
+        stamp = self._snapshot(100)
+        self.assertFalse(ccusage._covered_by_another_daemon(self.account, stamp, 300))
+
+    def test_stale_snapshot_from_another_daemon_does_not_cover(self):
+        self._snapshot(451)
+        self.assertFalse(ccusage._covered_by_another_daemon(self.account, None, 300))
+
+    def test_missing_snapshot_or_account_does_not_cover(self):
+        self.assertFalse(ccusage._covered_by_another_daemon(self.account, None, 300))
+        self.assertFalse(ccusage._covered_by_another_daemon(None, None, 300))
+
+    def _run_daemon_once(self, defer: bool):
+        def stop(_seconds):
+            raise KeyboardInterrupt
+
+        api = {"limits": [{"name": "seven_day", "utilization": 12.0, "resets_at": None}]}
+        with (
+            mock.patch.object(ccusage, "current_account", return_value=self.account),
+            mock.patch.object(ccusage, "fetch_usage", return_value=api) as fetch,
+            mock.patch.object(ccusage, "get_plan", return_value="max_20x"),
+            mock.patch.object(ccusage, "write_usage_file"),
+            mock.patch.object(ccusage.signal, "signal"),
+            mock.patch.object(ccusage.time, "sleep", side_effect=stop),
+            mock.patch("sys.stdout", new_callable=io.StringIO),
+            self.assertRaises(KeyboardInterrupt),
+        ):
+            ccusage.cmd_daemon(interval=300, defer=defer)
+        return fetch
+
+    def test_deferring_daemon_skips_the_fetch_when_covered(self):
+        self._snapshot(100)
+        self._run_daemon_once(defer=True).assert_not_called()
+
+    def test_daemon_without_defer_always_fetches(self):
+        self._snapshot(100)
+        self._run_daemon_once(defer=False).assert_called_once()
+
+    def test_deferring_daemon_fetches_when_not_covered(self):
+        self._snapshot(451)
+        self._run_daemon_once(defer=True).assert_called_once()
+
+
 if __name__ == "__main__":
     unittest.main()

{ccusage-0.1.12 → ccusage-0.3.0}/uv.lock

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

ccusage-0.1.12/.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 --no-config version --short)"
-      - name: Test
-        run: uv --no-config run --locked python -m unittest discover -s tests
-      - name: Build
-        run: uv --no-config build --no-sources
-      - name: Publish
-        run: uv publish --trusted-publishing always