usage-cli 0.29.32__py3-none-any.whl

menubar_menu.py

@@ -0,0 +1,169 @@
+# 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.
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+from AppKit import NSMakePoint, NSMenu, NSMenuItem
+
+import login_item
+from i18n import _t
+from menubar_prefs import (
+    _hide_agy_enabled,
+    _hide_claude_enabled,
+    _hide_codex_enabled,
+    _quota_notifications_enabled,
+    _window_keeper_enabled,
+)
+
+
+class _SwitchMenuApp(Protocol):
+    language: str
+    active_panel: Any
+    _switch_menu_action_taken: bool
+
+    def _resync_popover_after_menu(self) -> None: ...
+
+
+def build_menu_item(
+    language: str,
+    title_key: str,
+    selector: str,
+    *,
+    target: Any,
+    represented: Any | None = None,
+    state: bool | None = None,
+    tooltip_key: str | None = None,
+) -> Any:
+    item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
+        _t(language, title_key), selector, ""
+    )
+    item.setTarget_(target)
+    if represented is not None:
+        item.setRepresentedObject_(represented)
+    if state is not None:
+        item.setState_(1 if state else 0)
+    if tooltip_key is not None:
+        item.setToolTip_(_t(language, tooltip_key))
+    return item
+
+
+def build_switch_menu(app: _SwitchMenuApp, sender: Any) -> None:
+    import panels
+    from menubar import _session_resume_enabled, _terse_mode_enabled
+
+    menu = NSMenu.alloc().initWithTitle_(_t(app.language, "switch_panel"))
+    # AI 人才市場 is a feature panel, not a cosmetic skin — it gets its own
+    # top-level row instead of hiding inside "面板主題 ▸" next to Matrix/Win95.
+    menu.addItem_(
+        build_menu_item(
+            app.language, "panel_talent_market", "toggleTalentMarket:", target=app,
+            represented="talent_market",
+            state=app.active_panel.id == "talent_market",
+        )
+    )
+    menu.addItem_(
+        build_menu_item(
+            app.language, "discussion_window_title", "toggleDiscussion:", target=app
+        )
+    )
+    menu.addItem_(
+        build_menu_item(app.language, "panel_ai_daily", "toggleAiDaily:", target=app)
+    )
+    menu.addItem_(NSMenuItem.separatorItem())
+    # Panel themes live in a submenu so the menu stays short — one "面板主題 ▸"
+    # row that expands on demand instead of nine inline rows. talent_market is
+    # excluded here since it already has its own top-level row above.
+    panel_submenu = NSMenu.alloc().initWithTitle_(_t(app.language, "switch_panel"))
+    for panel in panels.all_panels():
+        if panel.id == "talent_market":
+            continue
+        panel_submenu.addItem_(
+            build_menu_item(
+                app.language, panel.i18n_key, "selectPanel:", target=app,
+                represented=panel.id,
+                state=panel.id == app.active_panel.id,
+            )
+        )
+    panel_parent = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
+        _t(app.language, "switch_panel"), "", ""
+    )
+    panel_parent.setSubmenu_(panel_submenu)
+    menu.addItem_(panel_parent)
+    # Provider visibility lives in one "Hide Sections ▸" submenu row, grouped
+    # with the panel-themes submenu: both are drill-in rows that shape what
+    # the popover shows.
+    hide_submenu = NSMenu.alloc().initWithTitle_(_t(app.language, "hide_sections_menu"))
+    hide_submenu.addItem_(
+        build_menu_item(
+            app.language, "claude_name", "toggleHideClaude:", target=app,
+            state=_hide_claude_enabled(),
+        )
+    )
+    hide_submenu.addItem_(
+        build_menu_item(
+            app.language, "codex_name", "toggleHideCodex:", target=app,
+            state=_hide_codex_enabled(),
+        )
+    )
+    hide_submenu.addItem_(
+        build_menu_item(
+            app.language, "agy_name", "toggleHideAgy:", target=app,
+            state=_hide_agy_enabled(),
+        )
+    )
+    hide_parent = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
+        _t(app.language, "hide_sections_menu"), "", ""
+    )
+    hide_parent.setSubmenu_(hide_submenu)
+    menu.addItem_(hide_parent)
+    # Plain on/off switches sit together in the second group.
+    menu.addItem_(NSMenuItem.separatorItem())
+    menu.addItem_(
+        build_menu_item(
+            app.language, "launch_at_login", "toggleLaunchAtLogin:", target=app,
+            state=login_item.is_enabled(),
+        )
+    )
+    menu.addItem_(
+        build_menu_item(
+            app.language, "quota_notifications_menu", "toggleQuotaNotifications:", target=app,
+            state=_quota_notifications_enabled(),
+        )
+    )
+    menu.addItem_(
+        build_menu_item(
+            app.language, "window_keeper_menu", "toggleWindowKeeper:", target=app,
+            state=_window_keeper_enabled(),
+            tooltip_key="window_keeper_tooltip",
+        )
+    )
+    # Project Butler: one toggle that hands last session's progress to the next
+    # one. Tooltip carries the full explanation so the menu line stays short.
+    # Grouped with the plain switches above it — a separate section here just
+    # added a divider with no real category difference.
+    menu.addItem_(
+        build_menu_item(
+            app.language, "project_butler", "toggleSessionResume:", target=app,
+            state=_session_resume_enabled(),
+            tooltip_key="project_butler_tooltip",
+        )
+    )
+    menu.addItem_(
+        build_menu_item(
+            app.language, "terse_mode_menu", "toggleTerseMode:", target=app,
+            state=_terse_mode_enabled(),
+            tooltip_key="terse_mode_tooltip",
+        )
+    )
+    app._switch_menu_action_taken = False
+    menu.popUpMenuPositioningItem_atLocation_inView_(None, NSMakePoint(0, 0), sender)
+    # Dismissing the menu without picking anything used to close the panel:
+    # a transient popover was already gone by then, so closing it was just
+    # cleanup. The floating window survives the menu, so the same call would
+    # read as "cancelling the menu threw my panel away".
+    app._resync_popover_after_menu()

menubar_notify.py

@@ -0,0 +1,102 @@
+# 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.
+
+from __future__ import annotations
+
+from typing import Any
+
+import objc
+
+from i18n import _t
+from menubar_state import PopoverState, QuotaRowState
+
+
+def user_notification_center() -> tuple[Any, dict[str, int]]:
+    from UserNotifications import (
+        UNAuthorizationOptionAlert,
+        UNAuthorizationOptionBadge,
+        UNAuthorizationOptionSound,
+        UNUserNotificationCenter,
+    )
+    register_user_notification_block_metadata()
+
+    return (
+        UNUserNotificationCenter.currentNotificationCenter(),
+        {
+            "alert": int(UNAuthorizationOptionAlert),
+            "badge": int(UNAuthorizationOptionBadge),
+            "sound": int(UNAuthorizationOptionSound),
+        },
+    )
+
+
+def user_notification_classes() -> tuple[Any, Any, Any]:
+    register_user_notification_block_metadata()
+    from UserNotifications import (
+        UNMutableNotificationContent,
+        UNNotificationRequest,
+        UNNotificationSound,
+    )
+
+    return UNMutableNotificationContent, UNNotificationRequest, UNNotificationSound
+
+
+def register_user_notification_block_metadata() -> None:
+    objc.registerMetaDataForSelector(
+        b"UNUserNotificationCenter",
+        b"requestAuthorizationWithOptions:completionHandler:",
+        {
+            "arguments": {
+                3: {
+                    "callable": {
+                        "retval": {"type": b"v"},
+                        "arguments": {
+                            0: {"type": b"^v"},
+                            1: {"type": b"Z"},
+                            2: {"type": b"@"},
+                        },
+                    },
+                },
+            },
+        },
+    )
+    objc.registerMetaDataForSelector(
+        b"UNUserNotificationCenter",
+        b"addNotificationRequest:withCompletionHandler:",
+        {
+            "arguments": {
+                3: {
+                    "callable": {
+                        "retval": {"type": b"v"},
+                        "arguments": {
+                            0: {"type": b"^v"},
+                            1: {"type": b"@"},
+                        },
+                    },
+                },
+            },
+        },
+    )
+
+
+def notification_tool(channel: str) -> str:
+    return "Claude" if channel.startswith("claude_") else "Codex"
+
+
+def notification_scope(language: str, channel: str) -> str:
+    if channel.endswith("_session"):
+        return _t(language, "session_label")
+    return _t(language, "weekly_label")
+
+
+def notification_row(state: PopoverState, channel: str) -> QuotaRowState:
+    rows = {
+        "claude_session": state.claude_session,
+        "claude_weekly": state.claude_weekly,
+        "codex_session": state.codex_session,
+        "codex_weekly": state.codex_weekly,
+    }
+    return rows[channel]

menubar_popover.py

@@ -0,0 +1,233 @@
+# 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.
+
+# mypy: disable-error-code="import-untyped,misc"
+# PyObjC modules do not ship type stubs, and their base classes resolve to Any in mypy.
+from __future__ import annotations
+
+from typing import Any
+
+import objc
+from AppKit import (
+    NSAnimationContext,
+    NSMakeSize,
+    NSView,
+    NSViewController,
+    NSViewHeightSizable,
+    NSViewWidthSizable,
+)
+from Quartz import CGColorCreateGenericRGB
+
+import panel_window_state
+from menubar_state import PopoverState
+from panels.base import Panel as UsagePanel
+from panels.base import next_panel_eviction_id
+
+MAX_CACHED_PANEL_VIEWS = 6
+PANEL_TRANSITION_TIMEOUT_SECONDS = 1.5
+PANEL_TRANSITION_FADE_SECONDS = 0.18
+
+
+class PopoverViewController(NSViewController):
+    content_view = objc.ivar()
+    panel = objc.ivar()
+    delegate = objc.ivar()
+    panel_views = objc.ivar()
+    panel_lru = objc.ivar()
+    transition_overlays = objc.ivar()
+    latest_state = objc.ivar()
+    pending_panel_evictions = objc.ivar()
+
+    def initWithPanel_delegate_(self, panel: UsagePanel, delegate: Any) -> PopoverViewController:
+        self = objc.super(PopoverViewController, self).init()
+        if self is None:
+            return None
+        self.panel = panel
+        self.delegate = delegate
+        self.panel_views = {}
+        self.panel_lru = []
+        self.transition_overlays = {}
+        self.pending_panel_evictions = set()
+        self.latest_state = None
+        self.content_view = panel.build_view(delegate)
+        container = NSView.alloc().initWithFrame_(self.content_view.frame())
+        container.setWantsLayer_(True)
+        self.setView_(container)
+        self.preparePanelView_(self.content_view)
+        container.addSubview_(self.content_view)
+        # Only cache a real web view; a failed build (ErrorPanelView, no JS
+        # bridge) is shown but left uncached so a later switch rebuilds it.
+        if hasattr(self.content_view, "evaluateJavaScript_completionHandler_"):
+            self.panel_views[panel.id] = self.content_view
+            self.panel_lru.append(panel.id)
+        return self
+
+    def setState_(self, state: PopoverState) -> None:
+        self.latest_state = state
+        self.view().setFrameSize_(_popover_size(state, self.panel))
+        self.syncPanelFrames()
+        self.panel.apply_state(self.content_view, state)
+
+    def switchToPanel_(self, panel: UsagePanel) -> None:
+        previous = self.content_view
+        self.panel = panel
+        content_view = self.panel_views.get(panel.id)
+        if content_view is None:
+            content_view = panel.build_view(self.delegate)
+            content_view.setHidden_(True)
+            self.preparePanelView_(content_view)
+            self.view().addSubview_(content_view)
+            # Only cache a real web view. A failed build returns ErrorPanelView
+            # (no JS bridge); caching it would pin the error even after the file
+            # recovers, so leave it uncached and rebuild on the next switch.
+            if hasattr(content_view, "evaluateJavaScript_completionHandler_"):
+                self.panel_views[panel.id] = content_view
+                self.beginPanelTransitionForPanelId_view_(panel.id, content_view)
+        # Drop the previously shown view if it was an uncached error fallback,
+        # so it doesn't linger stacked in the container behind the new panel.
+        if (
+            previous is not None
+            and previous is not content_view
+            and previous not in self.panel_views.values()
+        ):
+            if hasattr(previous, "teardown"):
+                previous.teardown()
+            previous.removeFromSuperview()
+        self.content_view = content_view
+        if panel.id in self.panel_views:
+            self.markPanelUsed_(panel.id)
+        for panel_id, view in list(self.panel_views.items()):
+            view.setHidden_(panel_id != panel.id)
+        content_view.setHidden_(False)
+        if self.latest_state is not None:
+            self.setState_(self.latest_state)
+        self.evictPanelViewsIfNeeded()
+
+    def currentContentView(self) -> Any:
+        return self.content_view
+
+    def panelDidFirstPaint_(self, view: Any) -> None:
+        if view is self.content_view:
+            self.endPanelTransitionForPanelView_(view)
+
+    def beginPanelTransitionForPanelId_view_(self, panel_id: str, view: Any) -> None:
+        self.removeTransitionOverlay_(panel_id)
+        overlay = NSView.alloc().initWithFrame_(view.bounds())
+        overlay.setWantsLayer_(True)
+        overlay.setAlphaValue_(1.0)
+        overlay.setAutoresizingMask_(int(NSViewWidthSizable) | int(NSViewHeightSizable))
+        layer = overlay.layer()
+        if layer is not None:
+            layer.setBackgroundColor_(
+                CGColorCreateGenericRGB(10 / 255, 15 / 255, 20 / 255, 1.0)
+            )
+        view.addSubview_(overlay)
+        self.transition_overlays[panel_id] = overlay
+        self.performSelector_withObject_afterDelay_(
+            "transitionTimeoutElapsed:",
+            overlay,
+            PANEL_TRANSITION_TIMEOUT_SECONDS,
+        )
+
+    def transitionTimeoutElapsed_(self, overlay: Any) -> None:
+        # Match by the overlay object itself, not the panel id: if this panel was
+        # evicted and rebuilt, a stale timer must not fade the new overlay. A timer
+        # whose overlay is already gone from the map simply finds nothing and stops.
+        for panel_id, current_overlay in list(self.transition_overlays.items()):
+            if current_overlay is overlay:
+                self.endPanelTransitionForPanelId_(panel_id)
+                return
+
+    def endPanelTransitionForPanelView_(self, view: Any) -> None:
+        for panel_id, panel_view in list(self.panel_views.items()):
+            if panel_view is view:
+                self.endPanelTransitionForPanelId_(panel_id)
+                return
+
+    def endPanelTransitionForPanelId_(self, panel_id: str) -> None:
+        overlay = self.transition_overlays.pop(panel_id, None)
+        if overlay is None:
+            return
+
+        def _fade(context: Any) -> None:
+            context.setDuration_(PANEL_TRANSITION_FADE_SECONDS)
+            overlay.animator().setAlphaValue_(0.0)
+
+        def _remove() -> None:
+            overlay.removeFromSuperview()
+
+        NSAnimationContext.runAnimationGroup_completionHandler_(_fade, _remove)
+
+    def teardown(self) -> None:
+        for panel_id, view in list(self.panel_views.items()):
+            self.removeTransitionOverlay_(panel_id)
+            if hasattr(view, "teardown"):
+                view.teardown()
+            view.removeFromSuperview()
+        self.panel_views.clear()
+        self.panel_lru.clear()
+        self.content_view = None
+
+    def preparePanelView_(self, view: Any) -> None:
+        view.setFrame_(self.view().bounds() if self.view() is not None else view.frame())
+        view.setAutoresizingMask_(int(NSViewWidthSizable) | int(NSViewHeightSizable))
+        view.setWantsLayer_(True)
+        layer = view.layer()
+        if layer is not None:
+            layer.setMasksToBounds_(True)
+
+    def syncPanelFrames(self) -> None:
+        bounds = self.view().bounds()
+        for view in self.panel_views.values():
+            view.setFrame_(bounds)
+
+    def markPanelUsed_(self, panel_id: str) -> None:
+        self.panel_lru = [cached_id for cached_id in self.panel_lru if cached_id != panel_id]
+        self.panel_lru.append(panel_id)
+
+    def evictPanelViewsIfNeeded(self) -> None:
+        self._schedulePanelEvictionIfNeeded()
+
+    def _schedulePanelEvictionIfNeeded(self) -> None:
+        if self.panel is None or len(self.panel_views) <= MAX_CACHED_PANEL_VIEWS:
+            return
+        evict_id = next_panel_eviction_id(
+            self.panel_lru,
+            self.panel.id,
+            self.pending_panel_evictions,
+        )
+        if evict_id is None:
+            return
+        self.pending_panel_evictions.add(evict_id)
+        self.performSelector_withObject_afterDelay_("evictPanelViewForId:", evict_id, 0.0)
+
+    def evictPanelViewForId_(self, panel_id: str) -> None:
+        self.pending_panel_evictions.discard(panel_id)
+        # A user can return to this panel before the next run-loop turn. In
+        # that case it remains live; schedule another LRU candidate instead.
+        if self.panel is None or panel_id == self.panel.id:
+            self._schedulePanelEvictionIfNeeded()
+            return
+        view = self.panel_views.get(panel_id)
+        if view is None:
+            self._schedulePanelEvictionIfNeeded()
+            return
+        self.panel_lru = [cached_id for cached_id in self.panel_lru if cached_id != panel_id]
+        self.panel_views.pop(panel_id, None)
+        self.removeTransitionOverlay_(panel_id)
+        if hasattr(view, "teardown"):
+            view.teardown()
+        view.removeFromSuperview()
+        self._schedulePanelEvictionIfNeeded()
+
+    def removeTransitionOverlay_(self, panel_id: str) -> None:
+        overlay = self.transition_overlays.pop(panel_id, None)
+        if overlay is not None:
+            overlay.removeFromSuperview()
+
+
+def _popover_size(state: PopoverState, panel: UsagePanel | None = None) -> Any:
+    return NSMakeSize(*panel_window_state.resolve_panel_size(state, panel))

menubar_prefs.py

@@ -0,0 +1,118 @@
+# 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.
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from prefs import _load_preferences, _save_preferences
+
+DEFAULT_QUOTA_CARD_ORDER = ("claude", "codex", "agy")
+DEFAULT_PANEL_FLAVOR = "mocha"
+PANEL_FLAVORS = ("latte", "frappe", "macchiato", "mocha")
+
+
+def _resolved_preferences(prefs: Mapping[str, object] | None = None) -> Mapping[str, object]:
+    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
+
+
+def _hide_codex_enabled(prefs: Mapping[str, object] | None = None) -> bool:
+    data = _resolved_preferences(prefs)
+    return data.get("hide_codex_section") is True
+
+
+def _hide_agy_enabled(prefs: Mapping[str, object] | None = None) -> bool:
+    data = _resolved_preferences(prefs)
+    return data.get("hide_agy_section") is True
+
+
+def _panel_flavor(prefs: Mapping[str, object] | None = None) -> str:
+    data = _resolved_preferences(prefs)
+    flavor = _valid_panel_flavor(data.get("panel_flavor"))
+    return DEFAULT_PANEL_FLAVOR if flavor is None else flavor
+
+
+def _save_panel_flavor(flavor: object) -> bool:
+    valid_flavor = _valid_panel_flavor(flavor)
+    if valid_flavor is None:
+        return False
+    prefs = _load_preferences()
+    prefs["panel_flavor"] = valid_flavor
+    _save_preferences(prefs)
+    return True
+
+
+def _valid_panel_flavor(value: object) -> str | None:
+    if not isinstance(value, str) or value not in PANEL_FLAVORS:
+        return None
+    return value
+
+
+def _quota_card_order(prefs: Mapping[str, object] | None = None) -> tuple[str, ...]:
+    data = _resolved_preferences(prefs)
+    order = _valid_quota_card_order(data.get("quota_card_order"))
+    return DEFAULT_QUOTA_CARD_ORDER if order is None else order
+
+
+def _save_quota_card_order(order: object) -> bool:
+    valid_order = _valid_quota_card_order(order)
+    if valid_order is None:
+        return False
+    prefs = _load_preferences()
+    prefs["quota_card_order"] = list(valid_order)
+    _save_preferences(prefs)
+    return True
+
+
+def _valid_quota_card_order(value: object) -> tuple[str, ...] | None:
+    if not isinstance(value, list) or any(not isinstance(card, str) for card in value):
+        return None
+    order = tuple(value)
+    if len(order) != len(set(order)) or not set(order) <= set(DEFAULT_QUOTA_CARD_ORDER):
+        return None
+    # A saved order shorter than the current default means a source was added
+    # since it was written (e.g. a 4th quota card) — append the newcomers
+    # instead of discarding the user's whole preference.
+    missing = (card for card in DEFAULT_QUOTA_CARD_ORDER if card not in order)
+    return order + tuple(missing)
+
+
+def _quota_notifications_enabled(prefs: Mapping[str, object] | None = None) -> bool:
+    data = _resolved_preferences(prefs)
+    return data.get("quota_notifications") is not False
+
+
+def _window_keeper_enabled(prefs: Mapping[str, object] | None = None) -> bool:
+    # Defaults OFF (opt-in) — opposite polarity from quota_notifications, which
+    # is why this is `is True` rather than `is not False`.
+    data = _resolved_preferences(prefs)
+    return data.get("window_keeper") is True or data.get("agy_window_keeper") is True
+
+
+def _agy_window_keeper_enabled(prefs: Mapping[str, object] | None = None) -> bool:
+    return _window_keeper_enabled(prefs)
+
+
+def _quota_notification_thresholds(prefs: Mapping[str, object] | None = None) -> list[float]:
+    data = _resolved_preferences(prefs)
+    raw = data.get("quota_notification_thresholds")
+    if not isinstance(raw, list):
+        return [90.0]
+    thresholds: list[float] = []
+    for value in raw:
+        if isinstance(value, int | float) and 0 < float(value) <= 100:
+            thresholds.append(float(value))
+    return thresholds or [90.0]