usage-cli 0.32.2__py3-none-any.whl → 0.32.4__py3-none-any.whl

doctor.py

@@ -20,6 +20,7 @@ from typing import Final
 
 from i18n import packaged_resource_path
 from installer import setup_hook
+from installer.codex_hook_trust import codex_terse_hook_trust
 
 SEPARATOR = "-" * 29
 RATE_LIMIT_FRESH_SECONDS: Final = 15 * 60
@@ -54,6 +55,7 @@ CHECK_LABELS: Final = {
     CODEX_RATE_LIMITS: "codex rate limits",
     CODEX_HISTORY: "codex history",
     CLAUDE_COST: "claude cost",
+    "codex_terse_hook_trust": "codex terse hook trust",
 }
 
 
@@ -87,6 +89,7 @@ def collect() -> DoctorReport:
         ("optional", _field(CODEX_LOGS, _codex_logs)),
         ("optional", _field(CODEX_RATE_LIMITS, _codex_rate_limits)),
         ("optional", _field(CLAUDE_COST, _claude_cost)),
+        ("optional", _field("codex_terse_hook_trust", _codex_terse_trust)),
     ]
     return DoctorReport(
         version=_text_field(_current_version),
@@ -514,3 +517,8 @@ def _ago(mtime: float) -> str:
         return f"{hours}h"
     days = hours // 24
     return f"{days}d"
+
+
+def _codex_terse_trust() -> CheckResult:
+    trust = codex_terse_hook_trust()
+    return CheckResult("codex_terse_hook_trust", "ok" if trust == "trusted" else "warn", trust)

installer/codex_hook_trust.py

@@ -0,0 +1,66 @@
+"""Read Codex's approval record without granting hook trust."""
+
+from __future__ import annotations
+
+import json
+import os
+import tomllib
+
+from installer import session_hooks
+from loaders.codex_paths import codex_home
+
+
+def codex_terse_hook_trust() -> str:
+    """Return the usage SessionStart hook's trust state.
+
+    A trusted_hash alone cannot detect Modified (a hook edited after approval).
+    Codex remains responsible for verifying the hash and asking for approval.
+    """
+    path = session_hooks.CODEX_HOOKS_JSON
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return "unknown"
+        groups = session_hooks._codex_session_start_list(data)
+        if groups is None:
+            return "not_installed"
+        index = None
+        for group_index, group in enumerate(groups):
+            handlers = group.get("hooks") if isinstance(group, dict) else None
+            if not isinstance(handlers, list):
+                continue
+            for handler_index, handler in enumerate(handlers):
+                command = handler.get("command") if isinstance(handler, dict) else None
+                if isinstance(command, str) and session_hooks._TERSE_MARKER in command:
+                    index = (group_index, handler_index)
+                    break
+            if index is not None:
+                break
+        if index is None:
+            return "not_installed"
+        with (codex_home() / "config.toml").open("rb") as handle:
+            config = tomllib.load(handle)
+        hooks = config.get("hooks", {})
+        states = hooks.get("state", {}) if isinstance(hooks, dict) else {}
+        if not isinstance(states, dict):
+            return "unknown"
+        suffix = f":session_start:{index[0]}:{index[1]}"
+        entry = states.get(f"{path}{suffix}")
+        if entry is None:
+            entry = next(
+                (
+                    value
+                    for key, value in states.items()
+                    if key.endswith(suffix)
+                    and os.path.realpath(key[: -len(suffix)]) == os.path.realpath(path)
+                ),
+                {},
+            )
+        if not isinstance(entry, dict):
+            return "untrusted"
+        if entry.get("enabled") is False:
+            return "disabled"
+        trusted_hash = entry.get("trusted_hash")
+        return "trusted" if isinstance(trusted_hash, str) and trusted_hash else "untrusted"
+    except (OSError, UnicodeError, ValueError):
+        return "unknown"

loaders/agy_quota_probe.py

@@ -37,6 +37,19 @@ from urllib.request import Request, urlopen
 from usage_common.subprocess_utils import hidden_console_kwargs
 
 CACHE_PATH = Path(os.path.expanduser("~/.usage/agy_quota_cache.json"))
+AUTH_EXPIRED_PATH = CACHE_PATH.parent / "agy_auth_expired"
+
+
+def auth_expired() -> bool:
+    return AUTH_EXPIRED_PATH.exists()
+
+
+def _mark_auth_expired() -> None:
+    with suppress(OSError):
+        AUTH_EXPIRED_PATH.parent.mkdir(parents=True, exist_ok=True)
+        AUTH_EXPIRED_PATH.touch()
+
+
 # Legacy OAuth token written by older Antigravity CLI versions. Read-only: we
 # never write back here (that is the CLI's home and could corrupt its login).
 _TOKEN_PATH = Path(os.path.expanduser("~/.gemini/antigravity-cli/antigravity-oauth-token"))
@@ -117,7 +130,11 @@ def probe_quota(timeout_seconds: float = 15) -> AgyQuotaResult | None:
     groups_raw = _extract_groups(raw)
     if not groups_raw:
         return None
-    return _build_result(groups_raw)
+    result = _build_result(groups_raw)
+    if result is not None:
+        with suppress(OSError):
+            AUTH_EXPIRED_PATH.unlink(missing_ok=True)
+    return result
 
 
 def find_agy() -> str | None:
@@ -353,6 +370,20 @@ def _refresh_token(refresh_token: str, timeout: float) -> tuple[str, int] | None
         payload = json.loads(raw)
     except HTTPError as exc:
         _handle_http_error(exc)
+        if exc.code == 401:
+            _mark_auth_expired()
+        elif exc.code == 400:
+            try:
+                raw_error = exc.read(_MAX_RESPONSE_BYTES + 1)
+                if len(raw_error) <= _MAX_RESPONSE_BYTES:
+                    error_payload = json.loads(raw_error)
+                    if (
+                        isinstance(error_payload, dict)
+                        and error_payload.get("error") == "invalid_grant"
+                    ):
+                        _mark_auth_expired()
+            except (OSError, ValueError):
+                pass
         return None
     except (URLError, OSError, ValueError):
         return None
@@ -387,6 +418,8 @@ def _post_json(url: str, access_token: str, body: dict[str, object], timeout: fl
         return json.loads(raw)
     except HTTPError as exc:
         _handle_http_error(exc)
+        if exc.code == 401:
+            _mark_auth_expired()
         return None
     except (URLError, OSError, ValueError):
         return None

menubar/agy.py

@@ -18,6 +18,7 @@ from loaders.agy_quota_probe import (
     AgyQuotaGroup,
     AgyQuotaResult,
     AgyQuotaWindow,
+    auth_expired,
     load_quota,
 )
 from loaders.agy_quota_probe import (
@@ -213,20 +214,20 @@ def _remaining_percent(window: AgyQuotaWindow) -> float:
     return max(0.0, min(100.0, float(window.remaining_percent)))
 
 
-def _cache_age_minutes(fetched_at: str, now: float) -> int:
-    """Whole minutes since the cached snapshot was taken (never negative)."""
+def _cache_age_minutes(fetched_at: str, now: float) -> float:
+    """Minutes since the cached snapshot was taken (never negative)."""
     try:
         age_seconds = now - parse_iso8601_utc_or_raise(fetched_at).timestamp()
     except (TypeError, ValueError):
         return 0
-    return max(0, int(age_seconds // 60))
+    return max(0.0, age_seconds / 60)
 
 
 def _window_row(
     title: str,
     window: AgyQuotaWindow,
     language: str,
-    age_minutes: int = 0,
+    age_minutes: float = 0,
     forecast_seconds: float | None = None,
     warning_max_seconds: float | None = None,
     *,
@@ -236,12 +237,20 @@ def _window_row(
     used = 100.0 - remaining
     warning = False
     warning_seconds: float | None = None
-    if remaining == 100.0:
+    reset_done = window.resets_in_minutes is not None and window.resets_in_minutes <= max(
+        0, age_minutes
+    )
+    if reset_done:
+        used = 0.0
+        reset_text = _t(language, "reset_done")
+    elif remaining == 100.0:
         reset_text = _t(language, "agy_quota_full")
     elif window.resets_in_minutes is None:
         reset_text = _t(language, "reset_placeholder")
+    elif window.resets_in_minutes - max(0, age_minutes) < 1:
+        reset_text = _t(language, "reset_imminent")
     else:
-        minutes_left = max(1, window.resets_in_minutes - max(0, age_minutes))
+        minutes_left = window.resets_in_minutes - int(max(0, age_minutes))
         time_to_reset = minutes_left * 60
         if window_seconds is None:
             if (
@@ -275,16 +284,22 @@ def _window_row(
             )
     return QuotaRowState(
         title=title,
-        percent=used,
+        percent=100.0 - remaining,
         percent_text=_t(language, "percent_used", value=_format_percent(used)),
         reset_text=reset_text,
         color=_bar_color(used, AGY_COLOR),
         warning=warning,
         available=True,
+        reset_done=reset_done,
     )
 
 
 def _stale_state(fetched_at: str, now: float, language: str) -> AgyStaleState | None:
+    if auth_expired():
+        return {
+            "ageText": _t(language, "agy_signin_expired"),
+            "tooltip": _t(language, "agy_signin_expired_tooltip"),
+        }
     try:
         age_seconds = now - parse_iso8601_utc_or_raise(fetched_at).timestamp()
     except (TypeError, ValueError):

menubar/app.py

@@ -70,6 +70,7 @@ from loaders.history_loader import (
     flush_caches_on_terminate as flush_history_cache,
 )
 from menubar import actions as menubar_actions
+from menubar import manual_refresh
 from menubar import menu as menubar_menu
 from menubar import notify as menubar_notify
 from menubar import refresh as menubar_refresh
@@ -84,7 +85,6 @@ from menubar.chrome import (
 )
 from menubar.popover import PopoverViewController, _popover_size
 from menubar.prefs import (
-    _auto_update_check_enabled,
     _hide_agy_enabled,
     _hide_claude_enabled,
     _hide_codex_enabled,
@@ -180,7 +180,6 @@ __all__ = [
     "_missing_row",
     "_quota_row",
     "format_human_time",
-    "_auto_update_check_enabled",
     "_hide_agy_enabled",
     "_hide_claude_enabled",
     "_hide_codex_enabled",
@@ -305,6 +304,7 @@ class AppDelegate(NSObject):
             "agy_session": BurnRateTracker(),
             "agy_weekly": BurnRateTracker(),
         }
+        self._auto_check_schedule = update_gate.AutoCheckSchedule()
         self._quota_notifier = QuotaNotifier(_quota_notification_thresholds())
         self._refresh_in_flight = False
         self._refresh_queued = False
@@ -382,7 +382,7 @@ class AppDelegate(NSObject):
 
     def timerFired_(self, timer: Any) -> None:
         self._refresh()
-        self._clear_stale_update_cache()
+        menubar_update.on_poll_tick(self)
 
     def _reschedule_poll_timer(self, interval: float) -> None:
         if self.timer is not None and self.timer_interval == interval:
@@ -419,7 +419,7 @@ class AppDelegate(NSObject):
             self._panel_window_did_hide()
 
     def refreshNow_(self, sender: Any) -> None:
-        self._refresh(queue_if_busy=True)
+        manual_refresh.start_mac(self)
 
     def installHook_(self, sender: Any) -> None:
         thread = threading.Thread(target=self._install_hook_in_background, daemon=True)
@@ -610,19 +610,8 @@ class AppDelegate(NSObject):
     def _maybe_check_update_in_background(self) -> None:
         menubar_update.maybe_check_update_in_background(self)
 
-    def _check_update_in_background(
-        self,
-        *,
-        manual: bool,
-        ignore_cooldown: bool,
-        ignore_skipped: bool,
-    ) -> None:
-        menubar_update.check_update_in_background(
-            self,
-            manual=manual,
-            ignore_cooldown=ignore_cooldown,
-            ignore_skipped=ignore_skipped,
-        )
+    def _check_update_in_background(self) -> bool:
+        return menubar_update.check_update_in_background(self)
 
     def _showUpdateAlert_(self, release: update_checker.ReleaseInfo) -> None:
         alert = _make_alert()
@@ -643,16 +632,6 @@ class AppDelegate(NSObject):
             prefs["update_dismissed_at"] = time.time()
         _save_preferences(prefs)
 
-    def _showNoUpdateAvailable_(self, result: Any) -> None:
-        alert = _make_alert()
-        alert.setMessageText_(_t(self.language, "update_no_new_version"))
-        alert.runModal()
-
-    def _showUpdateCheckFailed_(self, result: Any) -> None:
-        alert = _make_alert()
-        alert.setMessageText_(_t(self.language, "update_check_failed"))
-        alert.runModal()
-
     def _set_active_panel_id(self, panel_id: str) -> None:
         panel = panels.get_panel(panel_id)
         save_active_panel_id(panel.id)
@@ -822,7 +801,7 @@ class AppDelegate(NSObject):
             codex_model = result.get("codex_model", "unknown")
             self.codex_5h_pct = codex_5h_pct
             self.codex_model = codex_model
-            self.latest_state = state
+            self.latest_state = manual_refresh.finish_mac(self, state)
             self._process_quota_notifications(state)
             if self._panel_window_is_visible():
                 self.popover_controller.setState_(self.latest_state)
@@ -831,8 +810,7 @@ class AppDelegate(NSObject):
             menubar_title._set_button_title(self, state)
         finally:
             should_refresh_again = bool(self._refresh_queued)
-            self._refresh_queued = False
-            self._refresh_in_flight = False
+            self._refresh_queued = self._refresh_in_flight = False
         if should_refresh_again:
             self._refresh()
         if started_at:
@@ -842,7 +820,7 @@ class AppDelegate(NSObject):
             )
 
     def _clearRefreshInFlight_(self, _sender: Any) -> None:
-        self._refresh_in_flight = False
+        manual_refresh.fail_mac(self)
 
     def _load_codex_refresh_result(self) -> dict[str, Any]:
         history_scan = None if self.mock else self._history_source_scan()
@@ -905,16 +883,7 @@ class AppDelegate(NSObject):
     def _request_notification_authorization(self) -> None:
         if self.mock or not _quota_notifications_enabled():
             return
-        try:
-            center, constants = menubar_notify.user_notification_center()
-            options = constants["badge"] | constants["sound"] | constants["alert"]
-            center.requestAuthorizationWithOptions_completionHandler_(
-                options,
-                lambda granted, error: None,
-            )
-        except Exception:
-            if os.environ.get("USAGE_DEBUG") == "1":
-                logger.warning("notification authorization failed", exc_info=True)
+        menubar_notify.request_notification_authorization()
 
     def _process_quota_notifications(self, state: PopoverState) -> None:
         try:

menubar/grok.py

@@ -18,9 +18,7 @@ from menubar.state import (
     GROK_COLOR,
     GrokStaleState,
     QuotaRowState,
-    _bar_color,
-    _format_percent,
-    format_human_time,
+    _quota_row,
 )
 from usage_common.time_utils import parse_iso8601_utc_or_raise
 
@@ -56,22 +54,15 @@ def project_quota(
         period_end = parse_iso8601_utc_or_raise(quota.period_end).timestamp()
     except (TypeError, ValueError):
         return None
-    if period_end < current_time:
-        return None
     stale = _stale_state(quota.fetched_at, current_time, language)
-    used = max(0.0, min(100.0, quota.used_percent))
     return GrokQuotaProjection(
-        weekly=QuotaRowState(
-            title=_t(language, "weekly_label"),
-            percent=used,
-            percent_text=_t(language, "percent_used", value=_format_percent(used)),
-            reset_text=_t(
-                language,
-                "reset_in",
-                time=format_human_time(max(0.0, period_end - current_time), language),
-            ),
-            color=_bar_color(used, GROK_COLOR),
-            available=True,
+        weekly=_quota_row(
+            _t(language, "weekly_label"),
+            quota.used_percent,
+            period_end,
+            current_time,
+            GROK_COLOR,
+            language,
         ),
         stale=stale,
     )

menubar/manual_refresh.py

@@ -0,0 +1,51 @@
+"""Status-chip feedback for user-requested refreshes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from i18n import _t
+from menubar.state import PopoverState
+
+
+def begin(state: PopoverState, *, queued: bool = False) -> None:
+    if state.refresh_status is None:
+        state.refresh_status = (state.status_text, state.status_long)
+    state.refresh_queued = state.refresh_queued or queued
+    state.status_text = _t(
+        state.language, "status_text", value=_t(state.language, "status_refreshing")
+    )
+    state.status_long = False
+
+
+def finish(
+    previous: PopoverState | None, state: PopoverState, *, queued: bool = False
+) -> PopoverState:
+    if previous is not None and previous.refresh_status is not None:
+        keep = previous.refresh_queued and queued
+        previous.status_text, previous.status_long = previous.refresh_status
+        previous.refresh_status = None
+        previous.refresh_queued = False
+        if keep:
+            begin(state)
+    return state
+
+
+def finish_mac(app: Any, state: PopoverState) -> PopoverState:
+    return finish(app.latest_state, state, queued=bool(app._refresh_queued))
+
+
+def start_mac(app: Any) -> None:
+    begin(app.latest_state, queued=bool(app._refresh_in_flight))
+    app._refresh(queue_if_busy=True)
+    if app._panel_window_is_visible():
+        app.popover_controller.setState_(app.latest_state)
+
+
+def fail_mac(app: Any) -> None:
+    state = getattr(app, "latest_state", None)
+    if state is not None:
+        finish(state, state)
+    app._refresh_in_flight = False
+    if state is not None and app._panel_window_is_visible():
+        app.popover_controller.setState_(state)

menubar/menu.py

@@ -51,6 +51,20 @@ def build_menu_item(
         item.setState_(1 if state else 0)
     if tooltip_key is not None:
         item.setToolTip_(_t(language, tooltip_key))
+    if title_key == "window_keeper_menu" and state:
+        from quota.keeper_outcome import failure_tooltip
+
+        failures = failure_tooltip(language)
+        if failures:
+            item.setTitle_(_t(language, title_key) + " ⚠")
+            item.setToolTip_(failures + "\n" + _t(language, "window_keeper_tooltip"))
+    if title_key == "terse_mode_menu" and state:
+        from installer.codex_hook_trust import codex_terse_hook_trust
+
+        trust = codex_terse_hook_trust()
+        if trust in ("untrusted", "disabled"):
+            item.setTitle_(_t(language, title_key) + " ⚠")
+            item.setToolTip_(_t(language, f"terse_codex_hook_{trust}"))
     return item
 
 

menubar/notify.py

@@ -6,6 +6,8 @@
 
 from __future__ import annotations
 
+import logging
+import time
 from typing import Any
 
 import objc
@@ -45,6 +47,9 @@ def user_notification_classes() -> tuple[Any, Any, Any]:
     return UNMutableNotificationContent, UNNotificationRequest, UNNotificationSound
 
 
+logger = logging.getLogger(__name__)
+
+
 ALERT_SOUND = "usage_uhoh.wav"
 
 
@@ -56,6 +61,20 @@ def notification_sound(sound_cls: Any, kind: str) -> Any:
 
 
 def register_user_notification_block_metadata() -> None:
+    objc.registerMetaDataForSelector(
+        b"UNUserNotificationCenter",
+        b"getNotificationSettingsWithCompletionHandler:",
+        {
+            "arguments": {
+                2: {
+                    "callable": {
+                        "retval": {"type": b"v"},
+                        "arguments": {0: {"type": b"^v"}, 1: {"type": b"@"}},
+                    }
+                }
+            }
+        },
+    )
     objc.registerMetaDataForSelector(
         b"UNUserNotificationCenter",
         b"requestAuthorizationWithOptions:completionHandler:",
@@ -117,3 +136,84 @@ def notification_row(state: PopoverState, channel: str) -> QuotaRowState:
         "agy_weekly": state.agy_weekly,
     }
     return rows[channel]
+
+
+# Keep the instance alive: UNUserNotificationCenter holds its delegate weakly.
+_notification_delegate: Any = None
+
+
+def install_notification_delegate(center: Any) -> None:
+    global _notification_delegate
+    if _notification_delegate is None:
+        import UserNotifications  # noqa: F401 — load the delegate protocol lazily
+        from Foundation import NSObject
+
+        objc.registerMetaDataForSelector(
+            b"UsageNotificationDelegate",
+            b"userNotificationCenter:willPresentNotification:withCompletionHandler:",
+            {
+                "arguments": {
+                    4: {
+                        "callable": {
+                            "retval": {"type": b"v"},
+                            "arguments": {0: {"type": b"^v"}, 1: {"type": objc._C_NSUInteger}},
+                        }
+                    }
+                }
+            },
+        )
+
+        class UsageNotificationDelegate(  # type: ignore[call-arg]
+            NSObject,  # type: ignore[misc]
+            protocols=[objc.protocolNamed("UNUserNotificationCenterDelegate")],
+        ):
+            def userNotificationCenter_willPresentNotification_withCompletionHandler_(
+                self,
+                center: Any,
+                notification: Any,
+                completion: Any,
+            ) -> None:
+                completion((1 << 4) | (1 << 3) | (1 << 1))
+
+        _notification_delegate = UsageNotificationDelegate.alloc().init()
+    center.setDelegate_(_notification_delegate)
+
+
+def _authorization_result(granted: bool, error: Any) -> None:
+    # The file log keeps WARNING and up outside debug mode; a denial must reach it.
+    log = logger.info if granted else logger.warning
+    log("notification authorization granted=%s error=%s", granted, error)
+
+
+def request_notification_authorization() -> None:
+    try:
+        center, constants = user_notification_center()
+        try:
+            install_notification_delegate(center)
+        except Exception:
+            logger.warning("notification delegate setup failed", exc_info=True)
+        options = constants["badge"] | constants["sound"] | constants["alert"]
+        center.requestAuthorizationWithOptions_completionHandler_(options, _authorization_result)
+    except Exception:
+        logger.warning("notification authorization failed", exc_info=True)
+
+
+def send_simple_notification(title: str, body: str) -> None:
+    try:
+        center, _ = user_notification_center()
+        content_cls, request_cls, sound_cls = user_notification_classes()
+        content = content_cls.alloc().init()
+        content.setTitle_(title)
+        content.setBody_(body)
+        content.setSound_(sound_cls.defaultSound())
+        request = request_cls.requestWithIdentifier_content_trigger_(
+            f"usage.keeper.{time.time_ns()}", content, None
+        )
+
+        def completed(error: Any) -> None:
+            if error is not None:
+                logger.warning("keeper notification failed: %s", error)
+
+        center.addNotificationRequest_withCompletionHandler_(request, completed)
+    except Exception:
+        logger.warning("keeper notification failed", exc_info=True)

menubar/prefs.py

@@ -20,11 +20,6 @@ def _resolved_preferences(prefs: Mapping[str, object] | None = None) -> Mapping[
     return _load_preferences() if prefs is None else prefs
 
 
-def _auto_update_check_enabled(prefs: Mapping[str, object] | None = None) -> bool:
-    data = _resolved_preferences(prefs)
-    return data.get("auto_update_check") is not False
-
-
 def _hide_claude_enabled(prefs: Mapping[str, object] | None = None) -> bool:
     data = _resolved_preferences(prefs)
     return data.get("hide_claude_section") is True

menubar/refresh.py

@@ -228,6 +228,13 @@ def build_result(app: _RefreshApp, sources: RefreshSources) -> dict[str, Any]:
             )
         agy_window_keeper.maybe_ping(agy_result, app.mock)
         codex_window_keeper.maybe_ping(app.mock)
+        from menubar.notify import send_simple_notification
+        from menubar.prefs import _quota_notifications_enabled
+        from quota.keeper_outcome import notify_failures
+
+        notify_failures(
+            app.language, _quota_notifications_enabled(), app.mock, send_simple_notification
+        )
     except Exception as exc:
         if os.environ.get("USAGE_DEBUG") == "1":
             logger.warning("refresh failed", exc_info=True)