ccusage 0.2.0__tar.gz → 0.3.0__tar.gz

{ccusage-0.2.0 → ccusage-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ccusage
-Version: 0.2.0
+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
@@ -63,13 +63,15 @@ If Claude Code uses `CLAUDE_CONFIG_DIR`, ccusage reads credentials and writes
 
 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 |
 

{ccusage-0.2.0 → ccusage-0.3.0}/README.md

@@ -52,13 +52,15 @@ If Claude Code uses `CLAUDE_CONFIG_DIR`, ccusage reads credentials and writes
 
 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 |
 

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

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

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.2.0 → ccusage-0.3.0}/src/ccusage/__init__.py

@@ -627,8 +627,31 @@ def cmd_refresh():
         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))
@@ -637,18 +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, 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, account)
+            own_stamp = data["updated_at"]
             backoff = UNAVAILABLE_RETRY_INTERVAL
             print(
                 f"[{datetime.now().strftime('%H:%M:%S')}] "
@@ -793,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()
@@ -805,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.2.0 → 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
 
@@ -537,5 +538,70 @@ class AccountSnapshotTests(unittest.TestCase):
         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.2.0 → ccusage-0.3.0}/uv.lock

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