usage-cli 0.34.2__tar.gz → 0.34.4__tar.gz

{usage_cli-0.34.2/usage_cli.egg-info → usage_cli-0.34.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.2
+Version: 0.34.4
 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.2 → usage_cli-0.34.4}/loaders/muse_quota_probe.py

@@ -76,7 +76,8 @@ def validate_muse_cache(payload: object) -> MuseQuotaResult | None:
         if not isinstance(window, dict):
             return None
         used, reset = window.get("used_percent"), window.get("resets_at")
-        if not _number(used) or not _number(reset) or not 0 <= used <= 100:
+        # An exhausted window reports past 100 (e.g. 104); the row clamps it for display.
+        if not _number(used) or not _number(reset) or used < 0:
             return None
         windows.append(MuseQuotaWindow(used_percent=float(used), resets_at=float(reset)))
     return MuseQuotaResult(

{usage_cli-0.34.2 → usage_cli-0.34.4}/pyproject.toml

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

{usage_cli-0.34.2 → usage_cli-0.34.4}/quota/codex_window_keeper.py

@@ -171,6 +171,8 @@ def _run_codex_ping(codex_bin: str) -> subprocess.CompletedProcess[str]:
             "-m",
             "gpt-5.6-luna",
             "--skip-git-repo-check",
+            # Keep the ping out of the user's `codex resume` list.
+            "--ephemeral",
             "-c",
             "features.hooks=false",
             "-c",

{usage_cli-0.34.2 → usage_cli-0.34.4}/quota/window_keeper.py

@@ -172,6 +172,12 @@ def _run_claude_ping(claude_bin: str) -> subprocess.CompletedProcess[str]:
             "haiku",
             "--settings",
             str(KEEPER_CLAUDE_SETTINGS_PATH),
+            # No tools or MCP servers keeps the ping small; no persistence keeps
+            # it out of the user's /resume list.
+            "--tools",
+            "",
+            "--strict-mcp-config",
+            "--no-session-persistence",
         ],
         stdin=subprocess.DEVNULL,
         capture_output=True,

{usage_cli-0.34.2 → usage_cli-0.34.4}/tests/test_codex_window_keeper.py

@@ -635,6 +635,7 @@ def test_run_codex_ping_uses_verified_noninteractive_command(
         "-m",
         "gpt-5.6-luna",
         "--skip-git-repo-check",
+        "--ephemeral",
         "-c",
         "features.hooks=false",
         "-c",

{usage_cli-0.34.2 → usage_cli-0.34.4}/tests/test_muse_quota_probe.py

@@ -60,13 +60,21 @@ def test_read_missing_corrupt_and_good_cache() -> None:
     assert probe.read_cache() == quota()
 
 
-@pytest.mark.parametrize("value", [True, None, "25", -1, 101, float("nan"), float("inf"), 10**400])
+@pytest.mark.parametrize("value", [True, None, "25", -1, float("nan"), float("inf"), 10**400])
 def test_invalid_percent_rejected(value: object) -> None:
     raw = event()
     raw["payload"]["allowance"]["window"]["used_percent"] = value
     assert probe.parse_muse_allowance(json.dumps(raw), 1000) is None
 
 
+@pytest.mark.parametrize("value", [100, 104, 105, 250])
+def test_exhausted_window_past_100_is_kept(value: int) -> None:
+    raw = event()
+    raw["payload"]["allowance"]["window"]["used_percent"] = value
+    result = probe.parse_muse_allowance(json.dumps(raw), 1000)
+    assert result is not None and result["window"]["used_percent"] == value
+
+
 def test_missing_weekly_is_rejected() -> None:
     raw = event()
     del raw["payload"]["allowance"]["weekly"]

usage_cli-0.34.4/tests/test_taskbar_obstacles.py

@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+
+from __future__ import annotations
+
+import ctypes as C
+import importlib
+from collections.abc import Iterator
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+
+from wintray import taskbar_obstacles as obstacles
+
+
+@pytest.fixture(autouse=True)
+def clear_wts_api_cache() -> Iterator[None]:
+    obstacles._wts_api.cache_clear()
+    yield
+    obstacles._wts_api.cache_clear()
+
+
+def test_session_flags_offset() -> None:
+    assert (
+        obstacles._WTSINFOEXW.Data.offset + obstacles._WTSINFOEX_LEVEL1_W.SessionFlags.offset == 16
+    )
+    assert C.sizeof(obstacles._WTSINFOEXW) == 232
+
+
+@pytest.mark.parametrize("flags, locked", [(0, True), (1, False), (-1, False)])
+def test_session_locked_reads_buffer(
+    monkeypatch: pytest.MonkeyPatch, flags: int, locked: bool
+) -> None:
+    info = obstacles._WTSINFOEXW(Level=1)
+    info.Data.WTSInfoExLevel1.SessionFlags = flags
+
+    def query(server: object, session: int, kind: int, buffer: Any, size: Any) -> int:
+        assert (server, session, kind) == (None, 0xFFFFFFFF, 25)
+        C.cast(buffer, C.POINTER(C.c_void_p))[0] = C.addressof(info)
+        C.cast(size, C.POINTER(C.c_uint32))[0] = C.sizeof(info)
+        return 1
+
+    wts = SimpleNamespace(WTSQuerySessionInformationW=Mock(side_effect=query), WTSFreeMemory=Mock())
+    load = Mock(return_value=wts)
+    monkeypatch.setattr(C, "WinDLL", load, raising=False)
+
+    assert obstacles._session_locked() is locked
+    load.assert_called_once_with("wtsapi32", use_last_error=True)
+    assert wts.WTSQuerySessionInformationW.restype is C.c_int
+    assert len(wts.WTSQuerySessionInformationW.argtypes) == 5
+    wts.WTSFreeMemory.assert_called_once()
+    assert wts.WTSFreeMemory.call_args.args[0].value == C.addressof(info)
+
+
+def test_session_locked_api_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    wts = SimpleNamespace(WTSQuerySessionInformationW=Mock(return_value=0), WTSFreeMemory=Mock())
+    monkeypatch.setattr(C, "WinDLL", Mock(return_value=wts), raising=False)
+    assert obstacles._session_locked() is False
+    wts.WTSFreeMemory.assert_not_called()
+
+
+@pytest.mark.parametrize("error", [OSError("unavailable"), AttributeError("WinDLL")])
+def test_session_locked_unavailable(monkeypatch: pytest.MonkeyPatch, error: Exception) -> None:
+    monkeypatch.setattr(C, "WinDLL", Mock(side_effect=error), raising=False)
+    assert obstacles._session_locked() is False
+
+
+def test_watch_preserves_snapshot_while_locked_then_refreshes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    bounds = SimpleNamespace(Left=1.2, Top=2.3, Right=30.4, Bottom=40.5, IsEmpty=False)
+    button = SimpleNamespace(Current=SimpleNamespace(BoundingRectangle=bounds, IsOffscreen=False))
+    find_all = Mock(return_value=[button])
+    element = SimpleNamespace(
+        ControlTypeProperty="control",
+        FromHandle=Mock(return_value=SimpleNamespace(FindAll=find_all)),
+    )
+    modules = {
+        "clr": SimpleNamespace(AddReference=Mock()),
+        "System.Runtime.InteropServices": SimpleNamespace(
+            RuntimeEnvironment=SimpleNamespace(GetRuntimeDirectory=lambda: "/framework")
+        ),
+        "System.Windows.Automation": SimpleNamespace(
+            AutomationElement=element,
+            OrCondition=Mock(),
+            PropertyCondition=Mock(),
+            ControlType=SimpleNamespace(Button="button", ListItem="item"),
+            TreeScope=SimpleNamespace(Descendants="descendants"),
+        ),
+        "System": SimpleNamespace(IntPtr=lambda hwnd: hwnd),
+    }
+    monkeypatch.setattr(importlib, "import_module", lambda name: modules[name])
+    monkeypatch.setattr(obstacles, "_session_locked", Mock(side_effect=[True, False]))
+    worker = obstacles.TaskbarObstacles.__new__(obstacles.TaskbarObstacles)
+    worker.hwnd = 123
+    worker.snapshot = (123, ((5, 6, 7, 8),))
+    stop = Mock()
+    stop.is_set.side_effect = [False, False, True]
+    worker._stop = stop
+
+    def wait(seconds: int) -> None:
+        assert seconds == 2
+        if stop.wait.call_count == 1:
+            find_all.assert_not_called()
+            element.FromHandle.assert_not_called()
+            assert worker.snapshot == (123, ((5, 6, 7, 8),))
+        else:
+            find_all.assert_called_once_with(
+                "descendants", modules["System.Windows.Automation"].OrCondition.return_value
+            )
+            assert worker.snapshot == (123, ((1, 2, 30, 40),))
+
+    stop.wait.side_effect = wait
+    worker._watch()
+    assert stop.wait.call_count == 2
+    assert worker.snapshot == (123, ((1, 2, 30, 40),))

{usage_cli-0.34.2 → usage_cli-0.34.4}/tests/test_window_keeper.py

@@ -38,6 +38,10 @@ def test_run_claude_ping_skips_user_hooks(monkeypatch: pytest.MonkeyPatch, tmp_p
         "haiku",
         "--settings",
         str(settings_path),
+        "--tools",
+        "",
+        "--strict-mcp-config",
+        "--no-session-persistence",
     ]
     assert settings_path.is_file()
     assert json.loads(settings_path.read_text(encoding="utf-8")) == {"disableAllHooks": True}

{usage_cli-0.34.2 → usage_cli-0.34.4/usage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.2
+Version: 0.34.4
 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.2 → usage_cli-0.34.4}/usage_cli.egg-info/SOURCES.txt

@@ -188,6 +188,7 @@ tests/test_setup_hook_terse.py
 tests/test_subprocess_utils.py
 tests/test_subscription.py
 tests/test_taskbar_menu.py
+tests/test_taskbar_obstacles.py
 tests/test_time_utils.py
 tests/test_tui.py
 tests/test_tui_sprite.py

{usage_cli-0.34.2 → usage_cli-0.34.4}/wintray/taskbar_obstacles.py

@@ -5,9 +5,11 @@
 
 from __future__ import annotations
 
+import ctypes as C
 import importlib
 import logging
 import threading
+from functools import cache
 from pathlib import Path
 
 from wintray.taskbar_overlay import Rect
@@ -15,6 +17,76 @@ from wintray.taskbar_overlay import Rect
 logger = logging.getLogger(__name__)
 
 
+class _WTSINFOEX_LEVEL1_W(C.Structure):
+    # Windows WCHAR and LONG stay 16/32 bits even on hosts with wider C types.
+    _fields_ = [
+        ("SessionId", C.c_uint32),
+        ("SessionState", C.c_int32),
+        ("SessionFlags", C.c_int32),
+        ("WinStationName", C.c_uint16 * 33),
+        ("UserName", C.c_uint16 * 21),
+        ("DomainName", C.c_uint16 * 18),
+        ("LogonTime", C.c_int64),
+        ("ConnectTime", C.c_int64),
+        ("DisconnectTime", C.c_int64),
+        ("LastInputTime", C.c_int64),
+        ("CurrentTime", C.c_int64),
+        ("IncomingBytes", C.c_uint32),
+        ("OutgoingBytes", C.c_uint32),
+        ("IncomingFrames", C.c_uint32),
+        ("OutgoingFrames", C.c_uint32),
+        ("IncomingCompressedBytes", C.c_uint32),
+        ("OutgoingCompressedBytes", C.c_uint32),
+    ]
+
+
+class _WTSINFOEX_LEVEL_W(C.Union):
+    _fields_ = [("WTSInfoExLevel1", _WTSINFOEX_LEVEL1_W)]
+
+
+class _WTSINFOEXW(C.Structure):
+    _fields_ = [("Level", C.c_uint32), ("Data", _WTSINFOEX_LEVEL_W)]
+
+
+@cache
+def _wts_api() -> C.CDLL:
+    # WinDLL is absent from ctypes and its stubs on non-Windows hosts.
+    loader = getattr(C, "WinDLL")  # noqa: B009
+    wts: C.CDLL = loader("wtsapi32", use_last_error=True)
+    wts.WTSQuerySessionInformationW.argtypes = [
+        C.c_void_p,
+        C.c_uint32,
+        C.c_int,
+        C.POINTER(C.c_void_p),
+        C.POINTER(C.c_uint32),
+    ]
+    wts.WTSQuerySessionInformationW.restype = C.c_int
+    wts.WTSFreeMemory.argtypes = [C.c_void_p]
+    wts.WTSFreeMemory.restype = None
+    return wts
+
+
+def _session_locked() -> bool:
+    try:
+        wts = _wts_api()
+        buffer = C.c_void_p()
+        size = C.c_uint32()
+        try:
+            if not wts.WTSQuerySessionInformationW(
+                None, 0xFFFFFFFF, 25, C.byref(buffer), C.byref(size)
+            ):
+                return False
+            if not buffer or size.value < C.sizeof(_WTSINFOEXW):
+                return False
+            info = C.cast(buffer, C.POINTER(_WTSINFOEXW)).contents
+            return bool(info.Level == 1 and info.Data.WTSInfoExLevel1.SessionFlags == 0)
+        finally:
+            if buffer:
+                wts.WTSFreeMemory(buffer)
+    except (OSError, AttributeError):
+        return False
+
+
 class TaskbarObstacles:
     def __init__(self) -> None:
         self.hwnd = 0
@@ -42,7 +114,7 @@ class TaskbarObstacles:
             )
             while not self._stop.is_set():
                 hwnd = self.hwnd
-                if hwnd:
+                if hwnd and not _session_locked():
                     try:
                         root = element.FromHandle(system.IntPtr(hwnd))
                         buttons = root.FindAll(automation.TreeScope.Descendants, condition)