usage-cli 0.34.13__tar.gz → 0.34.15__tar.gz

{usage_cli-0.34.13/usage_cli.egg-info → usage_cli-0.34.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.13
+Version: 0.34.15
 Summary: usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）
 License-Expression: AGPL-3.0-only
 Requires-Python: >=3.13

usage_cli-0.34.15/analyzer/ledger_legacy_backfill.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+"""Restore dimensions of total-only ledger days from read-only Codex state."""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from contextlib import closing
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from loaders import codex_loader
+
+from .ledger_backfill import _allocate
+
+if TYPE_CHECKING:
+    from .reporter import _YearDay
+
+logger = logging.getLogger(__name__)
+
+
+def backfill_days(days: dict[str, _YearDay]) -> bool:
+    """Mutate eligible days only after a successful source read; report changes."""
+    eligible = {
+        key: day
+        for key, day in days.items()
+        if day["total_tokens"] > 0 and all(tokens == 0 for tokens in day["agent_tokens"].values())
+    }
+    if not eligible:
+        return False
+    try:
+        with closing(
+            sqlite3.connect(codex_loader._readonly_sqlite_uri(codex_loader.STATE_DB), uri=True)
+        ) as connection:
+            rows = connection.execute(
+                "SELECT created_at, tokens_used, model, cwd FROM threads WHERE tokens_used > 0"
+            ).fetchall()
+    except (OSError, sqlite3.Error) as exc:
+        logger.warning("Legacy ledger backfill could not read %s: %s", codex_loader.STATE_DB, exc)
+        return False
+
+    models: dict[str, dict[str, int]] = {key: {} for key in eligible}
+    projects: dict[str, dict[str, int]] = {key: {} for key in eligible}
+    for created_at, tokens, model, cwd in rows:
+        if not isinstance(created_at, int | float) or not isinstance(tokens, int) or tokens <= 0:
+            logger.warning("Legacy ledger backfill skipped invalid thread counts or timestamp")
+            continue
+        try:
+            day_key = datetime.fromtimestamp(created_at).date().isoformat()
+        except (OSError, OverflowError, ValueError):
+            logger.warning("Legacy ledger backfill skipped invalid thread timestamp %r", created_at)
+            continue
+        if day_key not in eligible:
+            continue
+        model = model if isinstance(model, str) and model else "unknown"
+        project = codex_loader._project_from_cwd(cwd) if isinstance(cwd, str) and cwd else "unknown"
+        models[day_key][model] = models[day_key].get(model, 0) + tokens
+        projects[day_key][project] = projects[day_key].get(project, 0) + tokens
+
+    for day_key, day in eligible.items():
+        source_total = sum(models[day_key].values())
+        codex_tokens = min(source_total, day["total_tokens"])
+        unknown_tokens = day["total_tokens"] - codex_tokens
+        day["agent_tokens"] = {"codex": codex_tokens} if codex_tokens else {}
+        day["model_tokens"] = (
+            dict(_allocate(models[day_key], {}, codex_tokens)) if codex_tokens else {}
+        )
+        day["project_tokens"] = (
+            dict(_allocate(projects[day_key], {}, codex_tokens)) if codex_tokens else {}
+        )
+        if unknown_tokens:
+            for dimension in (day["agent_tokens"], day["model_tokens"], day["project_tokens"]):
+                dimension["unknown"] = dimension.get("unknown", 0) + unknown_tokens
+    return True

{usage_cli-0.34.13 → usage_cli-0.34.15}/analyzer/reporter.py

@@ -29,7 +29,7 @@ from adapters.types import AgentInfo, UsageEntry
 from usage_common.pricing import calculate_cost, is_model_priced
 
 from .aggregator import aggregate_sessions
-from . import diagnoser, dispatch_ledger, ledger_backfill, usage_snapshot
+from . import diagnoser, dispatch_ledger, ledger_backfill, ledger_legacy_backfill, usage_snapshot
 
 logger = logging.getLogger(__name__)
 
@@ -45,9 +45,9 @@ _YEAR_WEEKS = 53
 YEAR_CACHE_PATH = Path(os.path.expanduser("~/.usage/year_cache.json"))
 YEAR_LEDGER_PATH = YEAR_CACHE_PATH.with_name("year_ledger.json")
 YEAR_CACHE_TTL_SECONDS = 6 * 3600
-_YEAR_CACHE_SCHEMA = 6
+_YEAR_CACHE_SCHEMA = 7
 _YEAR_LEDGER_SCHEMA = 1
-_year_ledger_lock = threading.Lock()
+_year_ledger_lock = threading.RLock()
 _YEAR_LEDGER_TRIM_BUFFER_DAYS = 60
 
 
@@ -572,6 +572,14 @@ def _year_day_from_json(value: object) -> _YearDay | None:
 
 
 def _read_year_ledger() -> _YearLedger:
+    with _year_ledger_lock:
+        ledger = _read_year_ledger_unlocked()
+        if ledger_legacy_backfill.backfill_days(ledger["days"]):
+            _write_year_ledger(ledger)
+        return ledger
+
+
+def _read_year_ledger_unlocked() -> _YearLedger:
     try:
         with YEAR_LEDGER_PATH.open(encoding="utf-8") as file:
             ledger = json.load(file)

{usage_cli-0.34.13 → usage_cli-0.34.15}/i18n.json

@@ -44,6 +44,7 @@
     "quota_label_menu": "顯示工作列額度",
     "quota_label_format": "{provider}: {value}%",
     "quota_label_unknown": "{provider}: --",
+    "quota_label_countdown": "{provider}: {value}",
     "quota_notifications_menu": "用量提醒通知",
     "quota_notifications_toggle": "開啟通知",
     "quota_notifications_permission_denied": "系統已關閉 usage 的通知 — 打開系統設定…",
@@ -261,12 +262,12 @@
     "report_wrapped_books_hint": "含重複的快取讀取，不等於實際產出的文字量。",
     "report_kpi_active_value": "{active} / {total} 天",
     "report_kpi_cost": "API 等值",
-    "report_kpi_cost_unpriced": "其中 {tokens} tokens 無公開價格，未計入",
+    "report_kpi_cost_unpriced": "其中 {tokens} tokens 沒有價格資料，未計入",
     "report_pricing_section": "API 價格覆蓋率（依 token 數）",
     "report_pricing_priced": "可換算 API 等值",
-    "report_pricing_unpriced": "無公開價格",
+    "report_pricing_unpriced": "沒有價格資料",
     "report_pricing_all_priced": "全部用量都有公開價格。",
-    "report_pricing_hint": "API 等值是用公開 API 價目表換算的等值金額，不是你的訂閱帳單；無公開價格的用量不計入 API 等值。 沒有公開價格不代表免費，只是無法換算。",
+    "report_pricing_hint": "API 等值是用公開 API 價目表換算的等值金額，不是你的訂閱帳單；沒有價格資料的用量不計入 API 等值，包括沒有公開價格的模型，以及只存了總量的舊紀錄。沒有價格資料不代表免費，只是無法換算。",
     "report_kpi_peak_day": "燒最兇的一天",
     "report_kpi_tokens": "燒掉 Tokens",
     "report_kpi_vs_prev_period": "較前期",
@@ -623,6 +624,7 @@
     "quota_label_menu": "Show Taskbar Quota",
     "quota_label_format": "{provider}: {value}%",
     "quota_label_unknown": "{provider}: --",
+    "quota_label_countdown": "{provider}: {value}",
     "quota_notifications_menu": "Usage Alert Notifications",
     "quota_notifications_toggle": "Enable notifications",
     "quota_notifications_permission_denied": "System notifications for usage are off — Open System Settings…",
@@ -840,12 +842,12 @@
     "report_wrapped_books_hint": "Includes repeated cache reads; this is not the amount of text actually generated.",
     "report_kpi_active_value": "{active} / {total} days",
     "report_kpi_cost": "API equivalent",
-    "report_kpi_cost_unpriced": "Includes {tokens} tokens without public pricing, excluded from the API equivalent",
+    "report_kpi_cost_unpriced": "Includes {tokens} tokens without pricing data, excluded from the API equivalent",
     "report_pricing_section": "API pricing coverage (by token count)",
     "report_pricing_priced": "Convertible to API equivalent",
-    "report_pricing_unpriced": "No public price",
+    "report_pricing_unpriced": "No pricing data",
     "report_pricing_all_priced": "All usage has a public price.",
-    "report_pricing_hint": "API equivalent is the API-equivalent value from public price lists, not your subscription bill. Usage without a public price is left out of API equivalent. No public price does not mean free; the API equivalent cannot be calculated.",
+    "report_pricing_hint": "API equivalent is the API-equivalent value from public price lists, not your subscription bill. Usage without pricing data is left out of API equivalent: models with no public price, and older records that kept only totals. Missing pricing data does not mean free; the API equivalent cannot be calculated.",
     "report_kpi_peak_day": "Peak Day",
     "report_kpi_tokens": "Burned Tokens",
     "report_kpi_vs_prev_period": "vs previous period",
@@ -1202,6 +1204,7 @@
     "quota_label_menu": "显示任务栏额度",
     "quota_label_format": "{provider}: {value}%",
     "quota_label_unknown": "{provider}: --",
+    "quota_label_countdown": "{provider}: {value}",
     "quota_notifications_menu": "用量提醒通知",
     "quota_notifications_toggle": "开启通知",
     "quota_notifications_permission_denied": "系统已关闭 usage 的通知 — 打开系统设置…",
@@ -1419,12 +1422,12 @@
     "report_wrapped_books_hint": "含重复的缓存读取，不等于实际生成的文字量。",
     "report_kpi_active_value": "{active} / {total} 天",
     "report_kpi_cost": "API 等值",
-    "report_kpi_cost_unpriced": "其中 {tokens} tokens 无公开价格，未计入",
+    "report_kpi_cost_unpriced": "其中 {tokens} tokens 没有价格数据，未计入",
     "report_pricing_section": "API 价格覆盖率（按 token 数）",
     "report_pricing_priced": "可换算 API 等值",
-    "report_pricing_unpriced": "无公开价格",
+    "report_pricing_unpriced": "没有价格数据",
     "report_pricing_all_priced": "全部用量都有公开价格。",
-    "report_pricing_hint": "API 等值是用公开 API 价目表换算的等值金额，不是你的订阅账单；无公开价格的用量不计入 API 等值。 没有公开价格不代表免费，只是无法换算。",
+    "report_pricing_hint": "API 等值是用公开 API 价目表换算的等值金额，不是你的订阅账单；没有价格数据的用量不计入 API 等值，包括没有公开价格的模型，以及只存了总量的旧记录。没有价格数据不代表免费，只是无法换算。",
     "report_kpi_peak_day": "烧最猛的一天",
     "report_kpi_tokens": "烧掉 Tokens",
     "report_kpi_vs_prev_period": "较前期",
@@ -1781,6 +1784,7 @@
     "quota_label_menu": "タスクバーにクォータを表示",
     "quota_label_format": "{provider}: {value}%",
     "quota_label_unknown": "{provider}: --",
+    "quota_label_countdown": "{provider}: {value}",
     "quota_notifications_menu": "使用量アラート通知",
     "quota_notifications_toggle": "通知を有効にする",
     "quota_notifications_permission_denied": "usage の通知はシステムで無効です — システム設定を開く…",
@@ -1998,12 +2002,12 @@
     "report_wrapped_books_hint": "繰り返しのキャッシュ読み込みを含むため、実際に生成した文章量とは異なります。",
     "report_kpi_active_value": "{active} / {total} 日",
     "report_kpi_cost": "API 換算",
-    "report_kpi_cost_unpriced": "うち {tokens} tokens は公開価格がなく、API 換算に含みません",
+    "report_kpi_cost_unpriced": "うち {tokens} tokens は価格データがなく、API 換算に含みません",
     "report_pricing_section": "API 価格カバー率（トークン数ベース）",
     "report_pricing_priced": "API 相当額に換算可能",
-    "report_pricing_unpriced": "公開価格なし",
+    "report_pricing_unpriced": "価格データなし",
     "report_pricing_all_priced": "すべての使用量に公開価格があります。",
-    "report_pricing_hint": "API 換算は公開 API 価格表で換算した相当額で、サブスクリプションの請求額ではありません。公開価格のない使用量はAPI 換算に含まれません。 公開価格がないことは無料を意味しません。API 相当額に換算できないだけです。",
+    "report_pricing_hint": "API 換算は公開 API 価格表で換算した相当額で、サブスクリプションの請求額ではありません。価格データのない使用量（公開価格のないモデルや、合計だけが残っている古い記録）は API 換算に含まれません。価格データがないことは無料を意味しません。API 相当額に換算できないだけです。",
     "report_kpi_peak_day": "最も使った日",
     "report_kpi_tokens": "使った Tokens",
     "report_kpi_vs_prev_period": "前期比",
@@ -2360,6 +2364,7 @@
     "quota_label_menu": "작업 표시줄 할당량 표시",
     "quota_label_format": "{provider}: {value}%",
     "quota_label_unknown": "{provider}: --",
+    "quota_label_countdown": "{provider}: {value}",
     "quota_notifications_menu": "사용량 알림",
     "quota_notifications_toggle": "알림 켜기",
     "quota_notifications_permission_denied": "시스템에서 usage 알림이 꺼져 있습니다 — 시스템 설정 열기…",
@@ -2577,12 +2582,12 @@
     "report_wrapped_books_hint": "반복된 캐시 읽기를 포함하므로 실제로 생성한 글의 양과는 다릅니다.",
     "report_kpi_active_value": "{active} / {total}일",
     "report_kpi_cost": "API 환산",
-    "report_kpi_cost_unpriced": "이 중 {tokens} tokens는 공개 가격이 없어 API 환산에서 제외됨",
+    "report_kpi_cost_unpriced": "이 중 {tokens} tokens는 가격 데이터가 없어 API 환산에서 제외됨",
     "report_pricing_section": "API 가격 적용률 (토큰 수 기준)",
     "report_pricing_priced": "API 환산액 계산 가능",
-    "report_pricing_unpriced": "공개 가격 없음",
+    "report_pricing_unpriced": "가격 데이터 없음",
     "report_pricing_all_priced": "모든 사용량에 공개 가격이 있습니다.",
-    "report_pricing_hint": "API 환산은 공개 API 가격표로 환산한 금액이며 구독 청구액이 아닙니다. 공개 가격이 없는 사용량은 API 환산에서 제외됩니다. 공개 가격이 없다고 무료인 것은 아닙니다. API 환산액을 계산할 수 없다는 뜻입니다.",
+    "report_pricing_hint": "API 환산은 공개 API 가격표로 환산한 금액이며 구독 청구액이 아닙니다. 가격 데이터가 없는 사용량(공개 가격이 없는 모델, 합계만 남은 이전 기록)은 API 환산에서 제외됩니다. 가격 데이터가 없다고 무료인 것은 아닙니다. API 환산액을 계산할 수 없다는 뜻입니다.",
     "report_kpi_peak_day": "가장 많이 쓴 날",
     "report_kpi_tokens": "쓴 Tokens",
     "report_kpi_vs_prev_period": "이전 기간 대비",

{usage_cli-0.34.13 → usage_cli-0.34.15}/loaders/agy_quota_probe.py

@@ -34,7 +34,9 @@ from typing import Any
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
+from loaders.cache_quarantine import quarantine
 from usage_common.cli_lookup import cli_env, resolve_cli
+from usage_common.network import google_auth_reachable
 from usage_common.subprocess_utils import hidden_console_kwargs
 
 CACHE_PATH = Path(os.path.expanduser("~/.usage/agy_quota_cache.json"))
@@ -79,9 +81,15 @@ _CLIENT_SECRET = "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"
 _DEFAULT_RETRY_AFTER_SECONDS = 60.0
 _MAX_RETRY_AFTER_SECONDS = 3600.0
 _rate_limit_until_monotonic = 0.0
+# A failed launch may open a browser sign-in page; don't repeat it every refresh.
+_CLI_FAILURE_COOLDOWN_SECONDS = 1800.0
+_cli_retry_after_monotonic = 0.0
 # When each group last appeared in a real API response; in memory only, reset on restart.
 _group_seen_at: dict[str, datetime] = {}
 _MISSING_GROUP_GRACE_MINUTES = 30
+# Models omit the period; keep known weekly resets weekly near expiry.
+# In memory only: after restart, unseen resets use the time heuristic again.
+_weekly_reset_times: set[str] = set()
 
 
 def _user_agent() -> str:
@@ -157,9 +165,23 @@ def _probe_via_cli(timeout: float) -> AgyQuotaResult | None:
     The slash command makes no model call. ``--log-file`` reuses one file instead of
     leaving a new log in the CLI's log directory on every probe.
     """
+    global _cli_retry_after_monotonic
     agy = find_agy()
     if agy is None:
         return None
+    if time.monotonic() < _cli_retry_after_monotonic:
+        return None
+    # Offline (e.g. just after a sleep wake) the CLI would open a browser sign-in page.
+    if not google_auth_reachable():
+        return None
+    result = _run_usage_command(agy, timeout)
+    _cli_retry_after_monotonic = (
+        0.0 if result is not None else time.monotonic() + _CLI_FAILURE_COOLDOWN_SECONDS
+    )
+    return result
+
+
+def _run_usage_command(agy: str, timeout: float) -> AgyQuotaResult | None:
     command = [agy, "-p", "/usage", "--output-format", "json", "--log-file", str(_CLI_LOG_PATH)]
     try:
         completed = subprocess.run(
@@ -509,6 +531,7 @@ def _post_json(url: str, access_token: str, body: dict[str, object], timeout: fl
     except HTTPError as exc:
         _handle_http_error(exc)
         if exc.code == 401:
+            _token_cache.clear()
             _mark_auth_expired()
         return None
     except (URLError, OSError, ValueError):
@@ -619,7 +642,13 @@ def _gemini_group_from_models(raw: object) -> AgyQuotaGroup | None:
     window = _bucket_to_window(bucket)
     reset = _bucket_reset_time(bucket)
     assert reset is not None
-    session = _seconds_until(reset) <= 5 * 3600 + 5 * 60
+    _weekly_reset_times.difference_update(
+        [seen for seen in _weekly_reset_times if _seconds_until(seen) <= 0]
+    )
+    session = reset not in _weekly_reset_times and _seconds_until(reset) <= 5 * 3600 + 5 * 60
+    # A full bucket's reset time slides with every response, so only a spent one is remembered.
+    if not session and window is not None and window.remaining_percent < 100.0:
+        _weekly_reset_times.add(reset)
     template = _assemble_groups({"gemini": {}})[0]
     return AgyQuotaGroup(
         name=template.name,
@@ -807,7 +836,14 @@ def _read_cache() -> AgyQuotaResult | None:
     try:
         with CACHE_PATH.open(encoding="utf-8") as cache_file:
             payload: object = json.load(cache_file)
-    except (OSError, json.JSONDecodeError):
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        quarantine(
+            CACHE_PATH, "decode-error" if isinstance(exc, UnicodeDecodeError) else "json-error"
+        )
+        with suppress(OSError):
+            CACHE_PATH.unlink()
+        return None
+    except OSError:
         return None
     return _result_from_payload(payload)
 

{usage_cli-0.34.13 → usage_cli-0.34.15}/menubar/agy.py

@@ -59,6 +59,7 @@ class AgyQuotaProjection:
     five_hour: AgyQuotaWindow | None
     group_switchable: bool = False
     weekly_only: bool = False
+    gemini_five_hour: AgyQuotaWindow | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -162,6 +163,10 @@ def project_quota(
         weekly=weekly,
         stale=stale,
         five_hour=selected.five_hour,
+        gemini_five_hour=next(
+            (group.five_hour for group in quota.groups if _matches_group(group.name, "gemini")),
+            None,
+        ),
     )
 
 

{usage_cli-0.34.13 → usage_cli-0.34.15}/menubar/app.py

@@ -843,7 +843,10 @@ class AppDelegate(NSObject):
 
     def _process_quota_notifications(self, state: PopoverState) -> None:
         try:
-            events = self._quota_notifier.update(menubar_notify.notification_channels(state))
+            events = self._quota_notifier.update(
+                menubar_notify.notification_channels(state),
+                menubar_notify.notification_scopes(state),
+            )
             for event in events:
                 if _quota_notifications_enabled() and not self.mock:
                     self._send_quota_notification(event, state)

{usage_cli-0.34.13 → usage_cli-0.34.15}/menubar/notify.py

@@ -170,6 +170,11 @@ def notification_channels(state: PopoverState) -> dict[str, tuple[float | None,
     }
 
 
+def notification_scopes(state: PopoverState) -> dict[str, str]:
+    """Antigravity rows follow the selected model group; track each group apart."""
+    return {"agy_session": state.agy_group_name, "agy_weekly": state.agy_group_name}
+
+
 # Keep the instance alive: UNUserNotificationCenter holds its delegate weakly.
 _notification_delegate: Any = None
 

usage_cli-0.34.15/menubar/quota_countdown.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+"""Shared quota recovery countdown formatting, without platform UI imports."""
+
+from __future__ import annotations
+
+import math
+
+from menubar.state import QuotaRowState
+
+
+def _format_countdown(seconds: float) -> str:
+    minutes = math.ceil(seconds / 60)
+    if minutes >= 1440:
+        return f"{minutes // 1440}d{minutes % 1440 // 60}h"
+    if minutes >= 60:
+        return f"{minutes // 60}h{minutes % 60}m"
+    return f"{minutes}m"
+
+
+def _quota_countdown(rows: tuple[QuotaRowState, ...], now: float) -> str | None:
+    full = [row for row in rows if row.display_percent is not None and row.display_percent >= 100]
+    if not full:
+        return None
+    resets = []
+    for row in full:
+        if row.resets_at is None or row.resets_at <= now:
+            return None
+        resets.append(row.resets_at)
+    return _format_countdown(max(resets) - now)

{usage_cli-0.34.13 → usage_cli-0.34.15}/menubar/title.py

@@ -8,7 +8,6 @@
 
 from __future__ import annotations
 
-import math
 import time
 from collections.abc import Callable
 from typing import Any, Protocol
@@ -29,7 +28,9 @@ from menubar.chrome import (
     _menubar_icon_attachment_string,
     _muse_menubar_icon,
 )
-from menubar.state import PopoverState, QuotaRowState, _format_percent
+from menubar.quota_countdown import _format_countdown as _format_countdown
+from menubar.quota_countdown import _quota_countdown
+from menubar.state import PopoverState, _format_percent
 
 
 class _TitleApp(Protocol):
@@ -75,27 +76,6 @@ _MENUBAR_MAX_ITEMS = 3
 SLOW_POLL_INTERVAL_S = 300.0
 
 
-def _format_countdown(seconds: float) -> str:
-    minutes = math.ceil(seconds / 60)
-    if minutes >= 1440:
-        return f"{minutes // 1440}d{minutes % 1440 // 60}h"
-    if minutes >= 60:
-        return f"{minutes // 60}h{minutes % 60}m"
-    return f"{minutes}m"
-
-
-def _quota_countdown(rows: tuple[QuotaRowState, ...], now: float) -> str | None:
-    full = [row for row in rows if row.display_percent is not None and row.display_percent >= 100]
-    if not full:
-        return None
-    resets = []
-    for row in full:
-        if row.resets_at is None or row.resets_at <= now:
-            return None
-        resets.append(row.resets_at)
-    return _format_countdown(max(resets) - now)
-
-
 def menubar_poll_interval(app: _TitleApp, state: PopoverState) -> float:
     if app._panel_window_is_visible() or any(
         text != "--" and not text.endswith("%") for _icon, text in _menubar_items(app, state)

{usage_cli-0.34.13 → usage_cli-0.34.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usage-cli"
-version = "0.34.13"
+version = "0.34.15"
 description = "usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）"
 readme = "README.md"
 requires-python = ">=3.13"

{usage_cli-0.34.13 → usage_cli-0.34.15}/quota/agy_window_keeper.py

@@ -19,6 +19,7 @@ from menubar.agy import AgyRefreshResult
 from menubar.prefs import _agy_window_keeper_enabled
 from quota import keeper_outcome
 from usage_common.cli_lookup import cli_env, resolve_cli
+from usage_common.network import google_auth_reachable
 from usage_common.subprocess_utils import hidden_console_kwargs
 
 logger = logging.getLogger(__name__)
@@ -117,7 +118,7 @@ def maybe_ping(result: AgyRefreshResult, mock: bool) -> None:
     if not enabled:
         return
     projection = result.projection
-    five_hour = projection.five_hour if projection is not None else None
+    five_hour = projection.gemini_five_hour if projection is not None else None
     now = time.time()
     last_ping_at = _load_last_ping()
     state = keeper_outcome.read_state(AGY_WINDOW_KEEPER_STATE_PATH)
@@ -137,6 +138,10 @@ def maybe_ping(result: AgyRefreshResult, mock: bool) -> None:
     retry = not fresh and keeper_outcome.should_retry(state, now, None, gate(None))
     if not (fresh or retry):
         return
+    # Offline (e.g. just after a sleep wake) the CLI would open a browser sign-in page;
+    # leave the state untouched so the next refresh tries again.
+    if not google_auth_reachable():
+        return
     if not _try_acquire():
         return
     keeper_outcome.update_state(

{usage_cli-0.34.13 → usage_cli-0.34.15}/quota/notifications.py

@@ -45,7 +45,10 @@ class QuotaNotifier:
     def __init__(self, thresholds: list[float] | None = None) -> None:
         values = [90.0] if thresholds is None else thresholds
         self.set_thresholds(values)
-        self._channels = {channel: _ChannelState() for channel in VALID_CHANNELS}
+        # Keyed by (channel, scope): one channel can show different quota pools,
+        # e.g. Antigravity's Gemini and Argon groups. Switching the shown pool
+        # must not read as a reset of the other one.
+        self._channels: dict[tuple[str, str], _ChannelState] = {}
 
     def set_thresholds(self, values: list[float]) -> None:
         """Replace thresholds without resetting channel observations or warning latches."""
@@ -54,21 +57,24 @@ class QuotaNotifier:
     def update(
         self,
         channels: dict[str, tuple[float | None, bool]],
+        scopes: dict[str, str] | None = None,
     ) -> list[NotificationEvent]:
         events: list[NotificationEvent] = []
         for channel, (percent, available) in channels.items():
             if channel not in VALID_CHANNELS:
                 continue
-            events.extend(self._update_channel(channel, percent, available))
+            scope = (scopes or {}).get(channel, "")
+            events.extend(self._update_channel(channel, scope, percent, available))
         return events
 
     def _update_channel(
         self,
         channel: str,
+        scope: str,
         percent: float | None,
         available: bool,
     ) -> list[NotificationEvent]:
-        state = self._channels[channel]
+        state = self._channels.setdefault((channel, scope), _ChannelState())
         events: list[NotificationEvent] = []
         if not available:
             return events