usage-cli 0.29.32__py3-none-any.whl

menubar_actions.py

@@ -0,0 +1,204 @@
+# 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.
+
+"""Background workers behind the menu's hook, statusline and report actions."""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import logging
+import os
+from typing import Any, Protocol
+
+import session_hooks
+import setup_hook
+from i18n import _t
+from menubar_chrome import _make_alert
+from statusline_settings import (
+    _disable_statusline_settings,
+    _enable_statusline_settings,
+    _set_forwarder_mode_prompt_dismissed,
+    _toggle_statusline_settings,
+)
+from usage_lang import detect_lang
+
+logger = logging.getLogger(__name__)
+
+
+class _ActionApp(Protocol):
+    language: str
+
+    def performSelectorOnMainThread_withObject_waitUntilDone_(
+        self, selector: str, obj: Any, wait: bool
+    ) -> None: ...
+
+
+def toggle_session_resume_in_background(app: _ActionApp) -> None:
+    import session_hooks
+
+    output = io.StringIO()
+    ok = True
+    enabled = False
+    try:
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
+            if session_hooks.is_resume_enabled():
+                session_hooks.disable_session_resume()
+            else:
+                ok = session_hooks.enable_session_resume() == 0
+                enabled = ok
+    except SystemExit as exc:
+        if exc.code:
+            ok = False
+            print(exc.code, file=output)
+    except Exception as exc:
+        ok = False
+        print(f"{type(exc).__name__}: {exc}", file=output)
+
+    app.performSelectorOnMainThread_withObject_waitUntilDone_(
+        "_finishSessionResume:",
+        {"ok": ok, "enabled": enabled, "output": output.getvalue().strip()},
+        False,
+    )
+
+
+def toggle_terse_mode_in_background(app: _ActionApp) -> None:
+    import session_hooks
+
+    output = io.StringIO()
+    ok = True
+    enabled = False
+    try:
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
+            if session_hooks.is_terse_mode_enabled():
+                session_hooks.disable_terse_mode()
+            else:
+                ok = session_hooks.enable_terse_mode() == 0
+                enabled = ok
+    except SystemExit as exc:
+        if exc.code:
+            ok = False
+            print(exc.code, file=output)
+    except Exception as exc:
+        ok = False
+        print(f"{type(exc).__name__}: {exc}", file=output)
+
+    app.performSelectorOnMainThread_withObject_waitUntilDone_(
+        "_finishTerseMode:",
+        {"ok": ok, "enabled": enabled, "output": output.getvalue().strip()},
+        False,
+    )
+
+
+def install_hook_in_background(app: _ActionApp) -> None:
+    output = io.StringIO()
+    exit_code = 1
+    try:
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
+            import session_hooks
+            import setup_hook
+
+            exit_code = setup_hook.setup()
+            if exit_code == 0:
+                session_hooks._migrate_bundled_python_commands_if_needed()
+    except SystemExit as exc:
+        exit_code = exc.code if isinstance(exc.code, int) else 1
+        if exc.code:
+            print(exc.code, file=output)
+    except Exception as exc:
+        print(f"{type(exc).__name__}: {exc}", file=output)
+
+    result = {
+        "success": exit_code == 0,
+        "message": output.getvalue().strip(),
+    }
+    app.performSelectorOnMainThread_withObject_waitUntilDone_(
+        "_finishHookInstall:",
+        result,
+        False,
+    )
+
+
+def statusline_action_in_background(app: _ActionApp, action: str) -> None:
+    output = io.StringIO()
+    ok = True
+    try:
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
+            if action == "toggle":
+                _toggle_statusline_settings()
+            elif action == "uninstall":
+                _disable_statusline_settings()
+            else:
+                _enable_statusline_settings()
+    except SystemExit as exc:
+        if exc.code:
+            ok = False
+            print(exc.code, file=output)
+    except Exception as exc:
+        ok = False
+        print(f"{type(exc).__name__}: {exc}", file=output)
+
+    app.performSelectorOnMainThread_withObject_waitUntilDone_(
+        "_finishStatuslineAction:",
+        {"ok": ok, "action": action, "output": output.getvalue().strip()},
+        False,
+    )
+
+
+def analyze_usage_in_background(app: _ActionApp, period: str) -> None:
+    from menubar import _generate_analysis_report
+
+    result: dict[str, str | bool]
+    try:
+        saved = _generate_analysis_report(period=period, language=app.language)
+        result = {"success": True, "message": saved}
+    except Exception as exc:
+        if os.environ.get("USAGE_DEBUG") == "1":
+            logger.warning("analysis report failed", exc_info=True)
+        result = {"success": False, "message": f"{type(exc).__name__}: {exc}"}
+    app.performSelectorOnMainThread_withObject_waitUntilDone_(
+        "_finishAnalyzeUsage:",
+        result,
+        False,
+    )
+
+
+def show_forwarder_mode_prompt_if_needed(language: str | None = None) -> None:
+    try:
+        settings = setup_hook._load_settings()
+        usage_settings = settings.get(setup_hook.BACKUP_KEY)
+        dismissed = (
+            isinstance(usage_settings, dict)
+            and usage_settings.get("forwarderModePromptDismissed") is True
+        )
+        if dismissed or setup_hook._detect_current_state(settings) != "external":
+            return
+    except Exception:
+        if os.environ.get("USAGE_DEBUG") == "1":
+            logger.warning("forwarder prompt check failed", exc_info=True)
+        return
+
+    lang = language or detect_lang()
+    alert = _make_alert()
+    alert.setMessageText_(_t(lang, "alert_forwarder_title"))
+    alert.setInformativeText_(_t(lang, "alert_forwarder_body"))
+    alert.addButtonWithTitle_(_t(lang, "alert_forwarder_enable"))
+    alert.addButtonWithTitle_(_t(lang, "alert_forwarder_keep"))
+    result = int(alert.runModal())
+
+    try:
+        if result == 1000:
+            setup_hook.setup(force_forwarder=True)
+            session_hooks._migrate_bundled_python_commands_if_needed()
+    except Exception:
+        if os.environ.get("USAGE_DEBUG") == "1":
+            logger.warning("forwarder setup failed", exc_info=True)
+    finally:
+        try:
+            _set_forwarder_mode_prompt_dismissed()
+        except Exception:
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("forwarder prompt dismissal failed", exc_info=True)

menubar_agy.py

@@ -0,0 +1,193 @@
+# 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.
+
+"""Background-safe Antigravity quota projection for the menu-bar panel."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import cast
+
+from agy_quota_probe import (
+    AgyQuotaGroup,
+    AgyQuotaResult,
+    AgyQuotaWindow,
+    load_quota,
+)
+from agy_quota_probe import (
+    find_agy as find_agy,
+)
+from i18n import _t
+from menubar_state import (
+    AGY_COLOR,
+    AgyStaleState,
+    QuotaRowState,
+    _bar_color,
+    _format_percent,
+    format_human_time,
+)
+from time_utils import parse_iso8601_utc_or_raise
+
+AGY_STALE_SECONDS = 20 * 60
+
+
+@dataclass(frozen=True, slots=True)
+class AgyQuotaProjection:
+    """Panel-ready data for Antigravity's Gemini group by default."""
+
+    group_name: str
+    session: QuotaRowState
+    weekly: QuotaRowState
+    stale: AgyStaleState | None
+    five_hour: AgyQuotaWindow | None
+
+
+@dataclass(frozen=True, slots=True)
+class AgyRefreshResult:
+    """One background probe/load outcome, including card visibility."""
+
+    projection: AgyQuotaProjection | None
+    hide_agy: bool
+
+
+def project_quota(
+    quota: AgyQuotaResult | None,
+    language: str,
+    now: float | None = None,
+) -> AgyQuotaProjection | None:
+    """Select and convert the Gemini quota group without I/O when available."""
+    if quota is None or not quota.groups:
+        return None
+    selected = next(
+        (group for group in quota.groups if "gemini" in group.name.lower()),
+        min(quota.groups, key=_group_remaining_percent),
+    )
+    current_time = time.time() if now is None else now
+    age_minutes = _cache_age_minutes(quota.fetched_at, current_time)
+    return AgyQuotaProjection(
+        group_name=selected.name,
+        session=_window_row(
+            _t(language, "session_label"),
+            selected.five_hour,
+            language,
+            age_minutes,
+        ),
+        weekly=_window_row(
+            _t(language, "weekly_label"),
+            selected.weekly,
+            language,
+            age_minutes,
+        ),
+        stale=_stale_state(quota.fetched_at, current_time, language),
+        five_hour=selected.five_hour,
+    )
+
+
+def load_refresh_result(language: str) -> AgyRefreshResult:
+    """Load/probe quota for a worker thread; never call this on the main thread."""
+    if find_agy() is None:
+        return AgyRefreshResult(projection=None, hide_agy=True)
+    try:
+        projection = project_quota(load_quota(), language)
+    except Exception:
+        projection = None
+    return AgyRefreshResult(projection=projection, hide_agy=projection is None)
+
+
+def fallback_projection(language: str) -> AgyQuotaProjection:
+    """Return inert rows while the card is hidden after an unavailable probe."""
+    return AgyQuotaProjection(
+        group_name="",
+        session=QuotaRowState(
+            title=_t(language, "session_label"),
+            percent=None,
+            percent_text="--",
+            reset_text=_t(language, "reset_placeholder"),
+            color=AGY_COLOR,
+            available=False,
+        ),
+        weekly=QuotaRowState(
+            title=_t(language, "weekly_label"),
+            percent=None,
+            percent_text="--",
+            reset_text=_t(language, "reset_placeholder"),
+            color=AGY_COLOR,
+            available=False,
+        ),
+        stale=None,
+        five_hour=None,
+    )
+
+
+def _group_remaining_percent(group: AgyQuotaGroup) -> float:
+    return min(
+        _remaining_percent(group.five_hour),
+        _remaining_percent(group.weekly),
+    )
+
+
+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)."""
+    try:
+        age_seconds = now - parse_iso8601_utc_or_raise(fetched_at).timestamp()
+    except (TypeError, ValueError):
+        return 0
+    return max(0, int(age_seconds // 60))
+
+
+def _window_row(
+    title: str, window: AgyQuotaWindow, language: str, age_minutes: int = 0
+) -> QuotaRowState:
+    remaining = _remaining_percent(window)
+    used = 100.0 - remaining
+    if remaining == 100.0:
+        reset_text = _t(language, "agy_quota_full")
+    elif window.resets_in_minutes is None:
+        reset_text = _t(language, "reset_placeholder")
+    else:
+        minutes_left = max(1, window.resets_in_minutes - max(0, age_minutes))
+        reset_text = _t(
+            language,
+            "reset_in",
+            time=format_human_time(minutes_left * 60, language),
+        )
+    return QuotaRowState(
+        title=title,
+        percent=used,
+        percent_text=_t(language, "percent_used", value=_format_percent(used)),
+        reset_text=reset_text,
+        color=_bar_color(used, AGY_COLOR),
+        available=True,
+    )
+
+
+def _stale_state(fetched_at: str, now: float, language: str) -> AgyStaleState | None:
+    try:
+        age_seconds = now - parse_iso8601_utc_or_raise(fetched_at).timestamp()
+    except (TypeError, ValueError):
+        return None
+    if age_seconds <= AGY_STALE_SECONDS:
+        return None
+    if age_seconds < 3600:
+        return cast(
+            AgyStaleState,
+            {
+                "ageText": _t(
+                    language,
+                    "agy_stale_minutes",
+                    minutes=max(1, int(age_seconds // 60)),
+                )
+            },
+        )
+    return cast(
+        AgyStaleState,
+        {"ageText": _t(language, "agy_stale_hours", hours=max(1, int(age_seconds // 3600)))}
+    )

menubar_chrome.py

@@ -0,0 +1,156 @@
+# mypy: disable-error-code="import-untyped,misc"
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+from AppKit import NSAlert, NSAttributedString, NSImage, NSMakeRect, NSMakeSize, NSTextAttachment
+
+from panels.base import resolve_resource
+
+logger = logging.getLogger(__name__)
+
+_ALERT_ICON: Any = None
+_ALERT_ICON_LOADED = False
+_CLAUDE_MENUBAR_ICON: Any = None
+_CLAUDE_MENUBAR_ICON_LOADED = False
+_CODEX_MENUBAR_ICON: Any = None
+_CODEX_MENUBAR_ICON_LOADED = False
+_AGY_MENUBAR_ICON: Any = None
+_AGY_MENUBAR_ICON_LOADED = False
+_CRITTER_IMAGE_CACHE: dict[str, Any] = {}
+_CRITTER_ATTACHMENT_STRING_CACHE: dict[str, Any] = {}
+
+
+class _NoopAlert:
+    def setIcon_(self, icon: Any) -> None:
+        return
+
+    def setMessageText_(self, text: str) -> None:
+        return
+
+    def setInformativeText_(self, text: str) -> None:
+        return
+
+    def addButtonWithTitle_(self, title: str) -> None:
+        return
+
+    def runModal(self) -> int:
+        return 0
+
+
+def _alert_icon() -> Any:
+    # NSAlert defaults to the application icon, which from source (and for an
+    # accessory app with no Dock presence) is py2app's / Python's rocket. Setting
+    # NSApp.applicationIconImage does not propagate to NSAlert, so each alert must
+    # set the branded icon explicitly. Loaded once and cached.
+    global _ALERT_ICON, _ALERT_ICON_LOADED
+    if not _ALERT_ICON_LOADED:
+        _ALERT_ICON_LOADED = True
+        try:
+            _ALERT_ICON = NSImage.alloc().initWithContentsOfFile_(resolve_resource("usage.icns"))
+        except Exception:
+            _ALERT_ICON = None
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("load alert icon failed", exc_info=True)
+    return _ALERT_ICON
+
+
+def _load_menubar_color_icon(filename: str) -> Any:
+    image = NSImage.alloc().initWithContentsOfFile_(resolve_resource(filename))
+    if image is not None:
+        image.setTemplate_(False)
+        image.setSize_(NSMakeSize(14, 14))
+    return image
+
+
+def _claude_menubar_icon() -> Any:
+    global _CLAUDE_MENUBAR_ICON, _CLAUDE_MENUBAR_ICON_LOADED
+    if not _CLAUDE_MENUBAR_ICON_LOADED:
+        _CLAUDE_MENUBAR_ICON_LOADED = True
+        try:
+            _CLAUDE_MENUBAR_ICON = _load_menubar_color_icon("claude_color_menubar.png")
+        except Exception:
+            _CLAUDE_MENUBAR_ICON = None
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("load Claude menubar icon failed", exc_info=True)
+    return _CLAUDE_MENUBAR_ICON
+
+
+def _codex_menubar_icon() -> Any:
+    global _CODEX_MENUBAR_ICON, _CODEX_MENUBAR_ICON_LOADED
+    if not _CODEX_MENUBAR_ICON_LOADED:
+        _CODEX_MENUBAR_ICON_LOADED = True
+        try:
+            _CODEX_MENUBAR_ICON = _load_menubar_color_icon("codex_color_menubar.png")
+        except Exception:
+            _CODEX_MENUBAR_ICON = None
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("load Codex menubar icon failed", exc_info=True)
+    return _CODEX_MENUBAR_ICON
+
+
+def _agy_menubar_icon() -> Any:
+    global _AGY_MENUBAR_ICON, _AGY_MENUBAR_ICON_LOADED
+    if not _AGY_MENUBAR_ICON_LOADED:
+        _AGY_MENUBAR_ICON_LOADED = True
+        try:
+            _AGY_MENUBAR_ICON = _load_menubar_color_icon("agy_color_menubar.png")
+        except Exception:
+            _AGY_MENUBAR_ICON = None
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("load Antigravity menubar icon failed", exc_info=True)
+    return _AGY_MENUBAR_ICON
+
+
+def _menubar_icon_attachment_string(image: Any) -> Any:
+    attachment = NSTextAttachment.alloc().init()
+    attachment.setImage_(image)
+    attachment.setBounds_(NSMakeRect(0, -2.5, 14, 14))
+    return NSAttributedString.attributedStringWithAttachment_(attachment)
+
+
+def _critter_icon_attachment_string(path: str, image: Any) -> Any:
+    cached = _CRITTER_ATTACHMENT_STRING_CACHE.get(path)
+    if cached is not None:
+        return cached
+    attachment = NSTextAttachment.alloc().init()
+    attachment.setImage_(image)
+    attachment.setBounds_(NSMakeRect(0, -4.0, 18, 18))
+    attributed = NSAttributedString.attributedStringWithAttachment_(attachment)
+    _CRITTER_ATTACHMENT_STRING_CACHE[path] = attributed
+    return attributed
+
+
+def _critter_frame_image(path: str) -> Any:
+    cached = _CRITTER_IMAGE_CACHE.get(path)
+    if cached is not None:
+        return cached
+    image = NSImage.alloc().initWithContentsOfFile_(resolve_resource(path))
+    if image is not None:
+        image.setTemplate_(True)
+        image.setSize_(NSMakeSize(18, 18))
+    _CRITTER_IMAGE_CACHE[path] = image
+    return image
+
+
+def _make_alert() -> Any:
+    try:
+        alert = NSAlert.alloc().init()
+    except Exception:
+        if os.environ.get("USAGE_DEBUG") == "1":
+            logger.warning("create alert failed", exc_info=True)
+        return _NoopAlert()
+    if alert is None:
+        if os.environ.get("USAGE_DEBUG") == "1":
+            logger.warning("create alert returned None")
+        return _NoopAlert()
+    icon = _alert_icon()
+    if icon is not None:
+        try:
+            alert.setIcon_(icon)
+        except Exception:
+            if os.environ.get("USAGE_DEBUG") == "1":
+                logger.warning("set alert icon failed", exc_info=True)
+    return alert