usage-cli 0.29.32__py3-none-any.whl

panels/base.py

@@ -0,0 +1,83 @@
+# 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
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Protocol
+
+if sys.platform == "darwin":
+    from Foundation import NSBundle, NSUserDefaults
+else:
+    NSBundle = None
+    NSUserDefaults = None
+
+if TYPE_CHECKING:
+    from menubar import PopoverState
+
+ACTIVE_PANEL_DEFAULTS_KEY = "usage.activePanelId"
+
+
+def next_panel_eviction_id(
+    panel_ids: list[str], active_panel_id: str, pending_evictions: set[str]
+) -> str | None:
+    return next(
+        (
+            panel_id
+            for panel_id in panel_ids
+            if panel_id != active_panel_id and panel_id not in pending_evictions
+        ),
+        None,
+    )
+
+
+class Panel(Protocol):
+    id: str
+    i18n_key: str
+    claude_card_height: float
+    codex_card_height: float
+    agy_card_height: float
+    service_alert_height: float
+
+    def build_view(self, delegate: Any) -> Any: ...
+    def apply_state(self, view: Any, state: PopoverState) -> None: ...
+    def preferred_size(self) -> tuple[float, float]: ...
+
+
+def load_active_panel_id(defaults: Any | None = None) -> str:
+    if defaults is None and sys.platform == "win32":
+        from prefs import _load_preferences
+
+        value = _load_preferences().get(ACTIVE_PANEL_DEFAULTS_KEY)
+        return str(value) if isinstance(value, str) and value else "classic"
+    assert NSUserDefaults is not None
+    store = defaults if defaults is not None else NSUserDefaults.standardUserDefaults()
+    value = store.stringForKey_(ACTIVE_PANEL_DEFAULTS_KEY)
+    return str(value) if value else "classic"
+
+
+def save_active_panel_id(panel_id: str, defaults: Any | None = None) -> None:
+    if defaults is None and sys.platform == "win32":
+        from prefs import _load_preferences, _save_preferences
+
+        preferences = _load_preferences()
+        preferences[ACTIVE_PANEL_DEFAULTS_KEY] = panel_id
+        _save_preferences(preferences)
+        return
+    assert NSUserDefaults is not None
+    store = defaults if defaults is not None else NSUserDefaults.standardUserDefaults()
+    store.setObject_forKey_(panel_id, ACTIVE_PANEL_DEFAULTS_KEY)
+
+
+def resolve_resource(name: str) -> str:
+    bundle = NSBundle.mainBundle() if NSBundle is not None else None
+    if bundle is not None:
+        stem, _, ext = name.rpartition(".")
+        path = bundle.pathForResource_ofType_(stem, ext)
+        if path:
+            return str(path)
+    return str(Path(__file__).resolve().parent.parent / "assets" / name)

panels/dynamic_height.py

@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+
+from __future__ import annotations
+
+import math
+
+MIN_PANEL_HEIGHT = 240.0
+
+CONTENT_HEIGHT_SCRIPT = """
+<script>
+(function() {
+  var applyState = window.usageApplyState;
+  if (typeof applyState !== "function") return;
+  var scheduled = false;
+  var lastPostedHeight = null;
+  function naturalContentHeight() {
+    var wrap = document.querySelector(".wrap");
+    if (!wrap) return null;
+    // A panel can explicitly mark a flexible region whose current laid-out
+    // height is part of the design (for example, world_cup's empty pitch).
+    // Preserve only those declared floors while releasing the viewport height
+    // chain; ordinary content can still contract when a quota row disappears.
+    var floors = Array.from(
+      wrap.querySelectorAll("[data-usage-height-floor]"),
+      function(element) {
+        return {
+          element: element,
+          height: element.getBoundingClientRect().height,
+          minHeight: element.style.minHeight
+        };
+      }
+    );
+    // Panels nest .wrap differently: most put it straight in <body>, but the
+    // viewport-based ones (world_cup, aquarium, black_hole, ...) insert a
+    // padded .viewport in between. Walk the real ancestor chain instead of
+    // assuming a fixed depth, so every 100%-height link is released and every
+    // layer's spacing is counted.
+    var chain = [];
+    for (var element = wrap; element; element = element.parentElement) {
+      chain.push(element);
+    }
+    var properties = ["height", "minHeight", "maxHeight"];
+    var saved = chain.map(function(element) {
+      return properties.map(function(property) { return element.style[property]; });
+    });
+    try {
+      chain.forEach(function(element) {
+        element.style.height = "auto";
+        element.style.minHeight = "0";
+        element.style.maxHeight = "none";
+      });
+      floors.forEach(function(floor) {
+        floor.element.style.minHeight = floor.height + "px";
+      });
+      // Force reflow with viewport constraints disabled. Restoration remains
+      // in this synchronous task, so the temporary styles are never painted.
+      var total = wrap.getBoundingClientRect().height;
+      chain.forEach(function(element, index) {
+        var style = window.getComputedStyle(element);
+        total += (parseFloat(style.marginTop) || 0) + (parseFloat(style.marginBottom) || 0);
+        // wrap's own rect already covers its padding and border; every
+        // ancestor wraps additional spacing around the measured box.
+        if (index === 0) return;
+        total +=
+          (parseFloat(style.paddingTop) || 0) + (parseFloat(style.paddingBottom) || 0) +
+          (parseFloat(style.borderTopWidth) || 0) + (parseFloat(style.borderBottomWidth) || 0);
+      });
+      return Math.ceil(total);
+    } finally {
+      chain.forEach(function(element, elementIndex) {
+        properties.forEach(function(property, propertyIndex) {
+          element.style[property] = saved[elementIndex][propertyIndex];
+        });
+      });
+      floors.forEach(function(floor) {
+        floor.element.style.minHeight = floor.minHeight;
+      });
+    }
+  }
+  function reportContentHeight() {
+    scheduled = false;
+    var height = naturalContentHeight();
+    var bridge = window.webkit && window.webkit.messageHandlers
+      && window.webkit.messageHandlers.usage;
+    if (Number.isFinite(height) && height > 0 && height !== lastPostedHeight && bridge
+        && typeof bridge.postMessage === "function") {
+      lastPostedHeight = height;
+      bridge.postMessage(JSON.stringify({ action: "content_height", height: height }));
+    }
+  }
+  function requestContentHeight() {
+    if (scheduled) return;
+    scheduled = true;
+    // Measure after the browser has committed DOM, font, and layout changes.
+    // A second frame catches WebView2's first visible layout without relying
+    // on a user clicking another control.
+    requestAnimationFrame(function() {
+      requestAnimationFrame(reportContentHeight);
+    });
+  }
+  window.usageRequestContentHeight = requestContentHeight;
+  window.usageApplyState = function usageApplyStateWithDynamicHeight(state) {
+    var result = applyState.apply(this, arguments);
+    requestContentHeight();
+    return result;
+  };
+  var wrap = document.querySelector(".wrap");
+  if (wrap && typeof MutationObserver === "function") {
+    new MutationObserver(requestContentHeight).observe(wrap, {
+      childList: true,
+      characterData: true,
+      subtree: true
+    });
+  }
+  if (wrap && typeof ResizeObserver === "function") {
+    new ResizeObserver(requestContentHeight).observe(wrap);
+  }
+  if (document.fonts && document.fonts.ready) {
+    document.fonts.ready.then(requestContentHeight);
+  }
+  requestContentHeight();
+})();
+</script>
+""".strip()
+
+
+def inject_content_height_script(html: str) -> str:
+    """Install the wrapper after the panel has defined usageApplyState."""
+    return html.replace("</body>", f"{CONTENT_HEIGHT_SCRIPT}\n</body>", 1)
+
+
+def clamp_content_height(height: object, maximum: float) -> float | None:
+    """Validate an untrusted JS measurement and clamp it to the usable screen."""
+    if isinstance(height, bool) or not isinstance(height, (int, float)):
+        return None
+    value = float(height)
+    if not math.isfinite(value) or value <= 0 or maximum < MIN_PANEL_HEIGHT:
+        return None
+    return min(max(value, MIN_PANEL_HEIGHT), maximum)

panels/payload.py

@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import sys
+from functools import cache, lru_cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from menubar_state import PopoverState, QuotaRowState
+
+CORE_SCRIPT_FILENAME = "panels/panel_core.js"
+
+
+def resolve_resource(name: str) -> str:
+    resource_root = os.environ.get("RESOURCEPATH")
+    if resource_root:
+        bundled = Path(resource_root) / name
+        if bundled.exists():
+            return str(bundled)
+    frozen_root = getattr(sys, "_MEIPASS", None)
+    if frozen_root:
+        bundled = Path(frozen_root) / "assets" / name
+        if bundled.exists():
+            return str(bundled)
+    return str(Path(__file__).resolve().parent.parent / "assets" / name)
+
+
+def _i18n_path() -> Path:
+    resource_root = os.environ.get("RESOURCEPATH")
+    if resource_root:
+        bundled = Path(resource_root) / "i18n.json"
+        if bundled.exists():
+            return bundled
+    frozen_root = getattr(sys, "_MEIPASS", None)
+    if frozen_root:
+        bundled = Path(frozen_root) / "i18n.json"
+        if bundled.exists():
+            return bundled
+    return Path(__file__).resolve().parent.parent / "i18n.json"
+
+
+def _new_state_payload(view: Any, payload: dict[str, object]) -> str | None:
+    if payload == getattr(view, "_last_injected_state", None):
+        return None
+    encoded = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+    view._last_injected_state = payload
+    if encoded == view._last_injected_payload:
+        return None
+    view._last_injected_payload = encoded
+    return encoded
+
+
+@cache
+def _load_panel_html(filename: str) -> str:
+    html = Path(resolve_resource(f"panels/{filename}")).read_text(encoding="utf-8")
+    return (
+        html.replace("{{CLAUDE_ICON}}", _data_uri("claude.webp"))
+        .replace("{{CODEX_ICON}}", _data_uri("codex.webp"))
+        .replace("{{CORE_SCRIPT}}", _load_core_script())
+        .replace("{{I18N_BUNDLE}}", json.dumps(_load_i18n_bundle(), ensure_ascii=False))
+    )
+
+
+@lru_cache(maxsize=1)
+def _load_core_script() -> str:
+    return Path(resolve_resource(CORE_SCRIPT_FILENAME)).read_text(encoding="utf-8")
+
+
+@lru_cache(maxsize=1)
+def _load_i18n_bundle() -> dict[str, dict[str, str]]:
+    data = json.loads(_i18n_path().read_text(encoding="utf-8"))
+    return {
+        str(lang): {str(key): str(value) for key, value in values.items()}
+        for lang, values in data.items()
+    }
+
+
+@lru_cache(maxsize=4)
+def _data_uri(asset_name: str) -> str:
+    path = Path(resolve_resource(asset_name))
+    mime = "image/png" if path.suffix.lower() == ".png" else "image/webp"
+    data = base64.b64encode(path.read_bytes()).decode("ascii")
+    return f"data:{mime};base64,{data}"
+
+
+def _row_payload(row: QuotaRowState) -> dict[str, object]:
+    return {
+        "percent": row.percent,
+        "percentText": row.percent_text,
+        "resetText": row.reset_text,
+        "warning": row.warning,
+        "available": row.available,
+        "title": row.title,
+    }
+
+
+def _state_payload(
+    state: PopoverState, *, system_accent_color: str | None = None
+) -> dict[str, object]:
+    codex_rows = {
+        key: _row_payload(row)
+        for key, row in (("session", state.codex_session), ("weekly", state.codex_weekly))
+        if row.title
+    }
+    project_payloads = []
+    for rows in (
+        state.projects,
+        state.projects_yesterday,
+        state.projects_7d,
+        state.projects_30d,
+        state.projects_all,
+    ):
+        project_payloads.append(
+            [
+                {
+                    "name": name,
+                    "tokens": tokens,
+                    "tokensText": _fmt_tokens(tokens),
+                    "costText": _fmt_cost(cost),
+                }
+                for name, tokens, cost in rows
+            ]
+        )
+    payload: dict[str, object] = {
+        "language": state.language,
+        "claude": {
+            "session": _row_payload(state.claude_session),
+            "weekly": _row_payload(state.claude_weekly),
+        },
+        "codex": {
+            **codex_rows,
+            "stale": state.codex_stale,
+            "credits": state.codex_credits,
+        },
+        "agy": {
+            "session": _row_payload(state.agy_session),
+            "weekly": _row_payload(state.agy_weekly),
+            "groupName": state.agy_group_name,
+            "stale": state.agy_stale,
+        },
+        "projects": project_payloads[0],
+        "projectsYesterday": project_payloads[1],
+        "projects7d": project_payloads[2],
+        "projects30d": project_payloads[3],
+        "projectsAll": project_payloads[4],
+        "hideClaude": state.hide_claude,
+        "hideCodex": state.hide_codex,
+        "hideAgy": state.hide_agy,
+        "cardOrder": list(state.card_order),
+        "historyError": state.history_error,
+        "statusline": state.statusline,
+        "talent": state.talent,
+        "footer": {
+            "rate": state.rate_text,
+            "status": state.status_text,
+            "today": state.today_text,
+            "yesterday": state.yesterday_text,
+            "serviceAlerts": list(state.service_alerts),
+            "showInstall": state.show_install_button,
+        },
+    }
+    if system_accent_color is not None:
+        payload["system_accent_color"] = system_accent_color
+    return payload
+
+
+def _fmt_tokens(tokens: int) -> str:
+    return f"{tokens:,}"
+
+
+def _fmt_cost(cost: float | None) -> str:
+    return "--" if cost is None else f"${cost:.2f}"