aiuse 3.3.0__tar.gz → 3.3.2__tar.gz

{aiuse-3.3.0/src/aiuse.egg-info → aiuse-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.3.0
+Version: 3.3.2
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT

{aiuse-3.3.0 → aiuse-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiuse"
-version = "3.3.0"
+version = "3.3.2"
 description = "Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments"
 readme = "README.md"
 requires-python = ">=3.11"

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse/__init__.py

@@ -1,3 +1,3 @@
 """Aggregate provider quotas and flag use-it-or-lose-it allotments."""
 
-__version__ = "3.3.0"
+__version__ = "3.3.2"

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse/cli.py

@@ -878,6 +878,19 @@ def diagnose(
     for collector_key, cmd, version_argv in _EXTERNAL_TOOLS:
         enabled = _collector_enabled(config, collector_key)
         path = lookup(cmd)
+        if collector_key == "openusage_ai" and which_fn is None and probe:
+            # Two products ship an ``openusage`` binary; only OpenUsage.app's
+            # prints JSON. Report the one the collector will actually run and
+            # warn about any same-named binary it had to skip.
+            from aiuse.collectors.openusage import resolve_app_cli
+
+            path, foreign = resolve_app_cli()
+            if foreign:
+                used = f"using {path}" if path else "no OpenUsage.app CLI found, loopback HTTP only"
+                lines.append(
+                    f"  warning  {', '.join(foreign)} is not OpenUsage.app's CLI "
+                    f"(openusage.sh's terminal dashboard?) — {used}"
+                )
         if path:
             status = "ok"
             detail = path

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse/collectors/base.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import json
+import os
 import shutil
 import subprocess
+from collections.abc import Callable
 from typing import Any
 
 
@@ -21,6 +23,70 @@ def which(cmd: str) -> str | None:
     return shutil.which(cmd)
 
 
+def which_all(cmd: str, *, extra_paths: tuple[str, ...] = ()) -> list[str]:
+    """Every executable named ``cmd`` on PATH, in PATH order, then ``extra_paths``.
+
+    Duplicates (the same file reached through different symlinks or PATH
+    entries) are dropped, keeping the first. Unlike :func:`which` this lets a
+    collector look past a same-named binary from an unrelated product that
+    happens to sit earlier on PATH.
+    """
+    seen: set[str] = set()
+    found: list[str] = []
+    search = [os.path.join(d, cmd) for d in os.environ.get("PATH", "").split(os.pathsep) if d]
+    search.extend(os.path.expanduser(p) for p in extra_paths)
+    for path in search:
+        if not (os.path.isfile(path) and os.access(path, os.X_OK)):
+            continue
+        real = os.path.realpath(path)
+        if real in seen:
+            continue
+        seen.add(real)
+        found.append(path)
+    return found
+
+
+def first_tool(
+    cmd: str,
+    accept: Callable[[str], bool],
+    *,
+    extra_paths: tuple[str, ...] = (),
+) -> tuple[str | None, list[str]]:
+    """The first ``cmd`` candidate that ``accept`` approves, plus the rejected ones.
+
+    ``accept`` is called with each candidate path in :func:`which_all` order
+    until one passes; the rejected candidates are returned for diagnostics.
+    """
+    rejected: list[str] = []
+    for path in which_all(cmd, extra_paths=extra_paths):
+        if accept(path):
+            return path, rejected
+        rejected.append(path)
+    return None, rejected
+
+
+def probe_output(argv: list[str], *, timeout: float = 5.0) -> str:
+    """stdout+stderr of a short, detached, non-interactive probe ("" on failure).
+
+    Same isolation as :func:`run_json` (no stdin, new session) so a binary
+    that would open a TUI on /dev/tty fails fast instead of taking over the
+    user's terminal.
+    """
+    try:
+        proc = subprocess.run(
+            argv,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+            start_new_session=True,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    return (proc.stdout or "") + (proc.stderr or "")
+
+
 def run_json(
     argv: list[str],
     *,
@@ -32,6 +98,14 @@ def run_json(
         # Never inherit the caller's TTY on stdin. Tools like ``caut usage``
         # put stdin into raw mode; on timeout/kill that leaves the shell with
         # echo off until the user runs ``reset``.
+        #
+        # ``start_new_session`` also detaches the child from the controlling
+        # terminal, so a tool that opens /dev/tty directly (a Go/bubbletea TUI
+        # such as openusage.sh's ``openusage`` does this when stdin is not a
+        # terminal) cannot switch the user's terminal into raw mode at all:
+        # its open() fails and it exits instead of hanging until the timeout.
+        # Collector children are non-interactive by contract, so nothing
+        # legitimate needs the terminal.
         proc = subprocess.run(
             argv,
             stdin=subprocess.DEVNULL,
@@ -39,6 +113,7 @@ def run_json(
             text=True,
             timeout=timeout,
             check=False,
+            start_new_session=True,
         )
     except FileNotFoundError as exc:
         raise CollectorError(f"command not found: {argv[0]}") from exc

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse/collectors/openusage.py

@@ -11,6 +11,7 @@ Schema: ``openusage.limits.v1`` — providers keyed by id with ``resources``.
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 import urllib.error
 import urllib.parse
@@ -30,9 +31,80 @@ from aiuse.models import (
     coerce_float as _f,
 )
 
-from .base import CollectorError, run_json, which
+from .base import CollectorError, first_tool, probe_output, run_json
 from .throttle import QueryGate
 
+# Two unrelated products ship a binary called ``openusage``. OpenUsage.app's
+# CLI (a symlink to the bundled helper below, installed from Settings →
+# Command Line) prints JSON and exits; openusage.sh's Go binary opens a
+# full-screen terminal dashboard on /dev/tty when run without a subcommand,
+# hangs until the collector timeout, and when killed leaves the terminal in
+# raw mode. So the collector never trusts the first ``openusage`` on PATH: it
+# walks every candidate (PATH order, then the usual install locations) and
+# runs the first one that proves to be the app CLI — by resolving into
+# OpenUsage.app, or failing that by answering ``--help`` with the app CLI's
+# usage text. Verdicts are cached per path for the life of the process.
+_APP_HELPER_SUFFIX = os.path.join("OpenUsage.app", "Contents", "Helpers", "openusage")
+_KNOWN_APP_CLI_PATHS: tuple[str, ...] = (
+    "/usr/local/bin/openusage",
+    "/Applications/OpenUsage.app/Contents/Helpers/openusage",
+    "~/Applications/OpenUsage.app/Contents/Helpers/openusage",
+)
+# Fragments of OpenUsage.app's ``openusage --help`` banner ("Read limits
+# through OpenUsage's shared five-minute cache and exit. Output is always
+# JSON.") — any one of them identifies it; openusage.sh's help says
+# "terminal dashboard" and lists subcommands instead.
+_APP_HELP_MARKERS: tuple[str, ...] = ("Read limits through OpenUsage", "Output is always JSON")
+_PROBE_TIMEOUT_S = 5.0
+_cli_verdicts: dict[str, bool] = {}
+
+
+def _is_app_bundle_path(path: str) -> bool:
+    try:
+        real = os.path.realpath(os.path.expanduser(path))
+    except (OSError, ValueError):
+        return False
+    return real.endswith(_APP_HELPER_SUFFIX)
+
+
+def is_app_cli(path: str, *, probe: bool = True) -> bool:
+    """True when ``path`` is OpenUsage.app's CLI.
+
+    Cheap structural check first (resolves into OpenUsage.app); otherwise, with
+    ``probe``, a detached ``--help`` run that must print the app CLI's usage
+    text. Verdicts are cached per path.
+    """
+    cached = _cli_verdicts.get(path)
+    if cached is not None:
+        return cached
+    verdict = _is_app_bundle_path(path)
+    if not verdict and probe:
+        banner = probe_output([path, "--help"], timeout=_PROBE_TIMEOUT_S)
+        verdict = any(marker in banner for marker in _APP_HELP_MARKERS)
+    _cli_verdicts[path] = verdict
+    return verdict
+
+
+def clear_cli_verdicts() -> None:
+    """Forget cached ``is_app_cli`` verdicts (tests; after an install)."""
+    _cli_verdicts.clear()
+
+
+def resolve_app_cli() -> tuple[str | None, list[str]]:
+    """(path of OpenUsage.app's CLI or None, same-named binaries rejected on the way)."""
+    return first_tool("openusage", is_app_cli, extra_paths=_KNOWN_APP_CLI_PATHS)
+
+
+def app_cli_path() -> str | None:
+    """Path of OpenUsage.app's CLI, or None when only loopback HTTP is available."""
+    return resolve_app_cli()[0]
+
+
+def foreign_openusage_binaries() -> list[str]:
+    """``openusage`` binaries found that are not OpenUsage.app's CLI (doctor warning)."""
+    return resolve_app_cli()[1]
+
+
 DEFAULT_OPENUSAGE_BASE = "http://127.0.0.1:6736"
 DEFAULT_HTTP_TIMEOUT = 30.0
 
@@ -168,7 +240,7 @@ def _fetch_limits_gated(
     payload. Without ``--force`` OpenUsage serves its own cached reading.
     """
     gated = sorted(_gated_providers(min_intervals))
-    if not force_refresh or not gated or not which("openusage"):
+    if not force_refresh or not gated or not app_cli_path():
         payload, via = _fetch_limits(
             timeout=timeout, base_url=base_url, force_refresh=force_refresh, try_launch_app=try_launch_app
         )
@@ -201,7 +273,7 @@ def _fetch_limits(
     force_refresh: bool,
     try_launch_app: bool,
 ) -> tuple[dict[str, Any], str]:
-    cli = which("openusage")
+    cli = app_cli_path()
     if cli:
         argv = [cli]
         if force_refresh:

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse/collectors/runner.py

@@ -19,6 +19,7 @@ from aiuse.models import (
     provider_display_name,
     utcnow,
 )
+from aiuse.tty import restore_stdin_tty, save_stdin_tty
 
 from .bailian import collect_bailian
 from .base import which
@@ -32,6 +33,7 @@ from .muse import collect_muse
 from .opencode_go import collect_opencode_go
 from .opencode_zen import collect_opencode_zen
 from .openrouter import collect_openrouter
+from .openusage import app_cli_path as openusage_app_cli_path
 from .openusage import collect_openusage_ai
 from .openusage_sh import collect_openusage_sh
 from .qwencloud import collect_qwencloud
@@ -113,6 +115,21 @@ _PROVIDER_ALIASES = PROVIDER_ID_ALIASES
 
 
 def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
+    """Collect from every enabled source, leaving the terminal as it was found.
+
+    A collector child that grabs the terminal (a TUI opened on /dev/tty, a tool
+    killed at its timeout in raw mode) must not corrupt the report printed right
+    after collection, so termios is restored here, before any rendering, as well
+    as at process exit (cli.main).
+    """
+    saved_tty = save_stdin_tty()
+    try:
+        return _run_collectors(config)
+    finally:
+        restore_stdin_tty(saved_tty)
+
+
+def _run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
     config = config or {}
     collectors_cfg = config.get("collectors") or {}
     snapshot = Snapshot(collected_at=utcnow())
@@ -988,7 +1005,7 @@ def collector_tools_present() -> dict[str, bool]:
         "cswap": which("cswap") is not None,
         "codexbar": which("codexbar") is not None,
         "caut": which("caut") is not None,
-        "openusage_ai": which("openusage") is not None,
+        "openusage_ai": openusage_app_cli_path() is not None,
         "openusage_sh": which("openusage-sh") is not None,
         "tokscale": which("tokscale") is not None,
         "hermes": True,

aiuse-3.3.2/src/aiuse/tty.py

@@ -0,0 +1,88 @@
+"""Terminal attribute save/restore helpers.
+
+Some external CLIs put the terminal into raw/cbreak mode: ``caut usage`` on an
+inherited stdin, and openusage.sh's ``openusage`` on /dev/tty directly when it
+is started without a subcommand. If they are killed mid-run (collector
+timeout) or fail to restore, the terminal is left without echo and without
+output post-processing (every line of the report then starts where the
+previous one ended) until the shell or ``reset`` fixes it. Collectors pass
+``stdin=DEVNULL`` and run in a new session (see ``run_json``); this module is
+belt-and-suspenders for any path that still reaches the terminal.
+
+The snapshot covers whichever of stdin, stdout and stderr is the terminal (all
+three are normally the same device), so ``aiuse </dev/null`` is protected too.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+
+def _terminal_fd() -> int | None:
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        try:
+            if stream is not None and stream.isatty():
+                return stream.fileno()
+        except (AttributeError, OSError, ValueError):
+            continue
+    return None
+
+
+def save_stdin_tty() -> Any | None:
+    """Snapshot termios attrs of the terminal (stdin, else stdout, else stderr).
+
+    Returns an opaque token for ``restore_stdin_tty``; None when there is no
+    terminal.
+    """
+    fd = _terminal_fd()
+    if fd is None:
+        return None
+    try:
+        import termios
+    except ImportError:
+        return None
+    try:
+        return (fd, termios.tcgetattr(fd))
+    except (termios.error, OSError, ValueError):
+        return None
+
+
+def _owns_terminal(fd: int) -> bool:
+    """True when this process may write terminal attributes without SIGTTOU.
+
+    ``tcsetattr`` from a process that is not in the terminal's foreground
+    process group raises SIGTTOU, which *stops* the process (``aiuse &``,
+    ``brew test``, any job-control runner): a hang, not an error. Such a
+    process has no business resetting someone else's terminal anyway; the
+    foreground shell restores it at its next prompt.
+    """
+    try:
+        return os.tcgetpgrp(fd) == os.getpgrp()
+    except (OSError, AttributeError):
+        return False
+
+
+def restore_stdin_tty(saved: Any | None) -> None:
+    """Restore termios attrs previously returned by ``save_stdin_tty``.
+
+    A no-op when the attributes are unchanged (the common case) and when this
+    process is not the terminal's foreground job (see ``_owns_terminal``).
+    """
+    if saved is None:
+        return
+    try:
+        import termios
+    except ImportError:
+        return
+    try:
+        fd, attrs = saved
+        fd = int(fd)
+        if termios.tcgetattr(fd) == attrs:
+            return
+        if not _owns_terminal(fd):
+            return
+        termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+    except (termios.error, OSError, ValueError, TypeError):
+        return

{aiuse-3.3.0 → aiuse-3.3.2/src/aiuse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.3.0
+Version: 3.3.2
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT

{aiuse-3.3.0 → aiuse-3.3.2}/src/aiuse.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ tests/test_muse.py
 tests/test_opencode_go.py
 tests/test_opencode_zen.py
 tests/test_openrouter.py
+tests/test_openusage_cli_resolution.py
 tests/test_openusage_parse.py
 tests/test_pace.py
 tests/test_query_throttle.py

{aiuse-3.3.0 → aiuse-3.3.2}/tests/test_base_run_json.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import json
+import subprocess
 from types import SimpleNamespace
 
 import pytest
 
-from aiuse.collectors.base import CollectorError, run_json
+from aiuse.collectors.base import CollectorError, probe_output, run_json
 
 
 def _fake_run(stdout: str, *, returncode: int = 0):
@@ -93,3 +94,36 @@ def test_run_json_passes_stdin_devnull(monkeypatch):
     monkeypatch.setattr("aiuse.collectors.base.subprocess.run", _run)
     assert run_json(["tool"]) == {"ok": True}
     assert seen.get("stdin") is subprocess.DEVNULL
+
+
+def test_run_json_detaches_children_from_the_terminal(monkeypatch):
+    """No stdin and a new session: a child cannot open /dev/tty and leave it raw."""
+    seen: dict[str, object] = {}
+
+    def _run(argv, **kwargs):  # noqa: ARG001
+        seen.update(kwargs)
+        return SimpleNamespace(stdout="{}", stderr="", returncode=0)
+
+    monkeypatch.setattr("aiuse.collectors.base.subprocess.run", _run)
+    assert run_json(["tool"]) == {}
+    assert seen["stdin"] == subprocess.DEVNULL
+    assert seen["start_new_session"] is True
+
+
+def test_probe_output_is_detached_and_swallows_failure(monkeypatch):
+    seen: dict[str, object] = {}
+
+    def _run(argv, **kwargs):  # noqa: ARG001
+        seen.update(kwargs)
+        return SimpleNamespace(stdout="out ", stderr="err", returncode=1)
+
+    monkeypatch.setattr("aiuse.collectors.base.subprocess.run", _run)
+    assert probe_output(["tool", "--help"]) == "out err"
+    assert seen["stdin"] == subprocess.DEVNULL
+    assert seen["start_new_session"] is True
+
+    def _boom(argv, **kwargs):  # noqa: ARG001
+        raise subprocess.TimeoutExpired(argv, 1)
+
+    monkeypatch.setattr("aiuse.collectors.base.subprocess.run", _boom)
+    assert probe_output(["tool", "--help"]) == ""

aiuse-3.3.2/tests/test_openusage_cli_resolution.py

@@ -0,0 +1,162 @@
+"""The OpenUsage.ai collector must run OpenUsage.app's CLI, never a same-named binary.
+
+Two products ship an ``openusage`` binary: OpenUsage.app's helper prints JSON
+and exits; openusage.sh's Go dashboard opens a TUI on /dev/tty, hangs until the
+collector timeout and leaves the terminal in raw mode when killed.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+
+import pytest
+
+from aiuse.collectors import base, openusage
+
+APP_HELP = "Usage: openusage [provider] [--force]\n\nRead limits through OpenUsage's shared five-minute cache and exit. Output is always JSON.\n"
+SH_HELP = (
+    "OpenUsage is a terminal dashboard for monitoring AI coding tool usage and spend.\n\nUsage:\n  openusage [flags]\n"
+)
+
+
+def _executable(path: Path) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("#!/bin/sh\nexit 0\n")
+    path.chmod(path.stat().st_mode | stat.S_IXUSR)
+    return path
+
+
+@pytest.fixture(autouse=True)
+def _fresh_verdicts():
+    openusage.clear_cli_verdicts()
+    yield
+    openusage.clear_cli_verdicts()
+
+
+def _bundle_cli(tmp_path: Path) -> Path:
+    return _executable(tmp_path / "OpenUsage.app" / "Contents" / "Helpers" / "openusage")
+
+
+def test_which_all_walks_every_path_entry_in_order_and_dedupes(tmp_path, monkeypatch):
+    first = _executable(tmp_path / "a" / "tool")
+    second = _executable(tmp_path / "b" / "tool")
+    link_dir = tmp_path / "c"
+    link_dir.mkdir()
+    (link_dir / "tool").symlink_to(first)  # same file again via a symlink
+    _executable(tmp_path / "d" / "other")  # different name, ignored
+    monkeypatch.setenv(
+        "PATH", os.pathsep.join(str(d) for d in (tmp_path / "a", tmp_path / "b", link_dir, tmp_path / "d"))
+    )
+
+    assert base.which_all("tool") == [str(first), str(second)]
+    assert base.which_all("tool", extra_paths=(str(second), str(tmp_path / "missing"))) == [str(first), str(second)]
+
+
+def test_first_tool_returns_first_accepted_and_the_rejected_before_it(tmp_path, monkeypatch):
+    bad = _executable(tmp_path / "a" / "tool")
+    good = _executable(tmp_path / "b" / "tool")
+    monkeypatch.setenv("PATH", os.pathsep.join([str(tmp_path / "a"), str(tmp_path / "b")]))
+
+    chosen, rejected = base.first_tool("tool", lambda p: p == str(good))
+    assert chosen == str(good)
+    assert rejected == [str(bad)]
+
+    chosen, rejected = base.first_tool("tool", lambda _p: False)
+    assert chosen is None
+    assert rejected == [str(bad), str(good)]
+
+
+def test_bundle_symlink_is_accepted_without_a_probe(tmp_path, monkeypatch):
+    helper = _bundle_cli(tmp_path)
+    link = tmp_path / "bin" / "openusage"
+    link.parent.mkdir()
+    link.symlink_to(helper)
+    monkeypatch.setattr(openusage, "probe_output", lambda *_a, **_k: pytest.fail("probed a bundle path"))
+
+    assert openusage.is_app_cli(str(link))
+
+
+def test_foreign_binary_is_rejected_by_its_help_banner(tmp_path, monkeypatch):
+    foreign = _executable(tmp_path / "homebrew" / "openusage")
+    probes: list[list[str]] = []
+
+    def fake_probe(argv, *, timeout):
+        probes.append(argv)
+        return SH_HELP
+
+    monkeypatch.setattr(openusage, "probe_output", fake_probe)
+    assert not openusage.is_app_cli(str(foreign))
+    assert not openusage.is_app_cli(str(foreign))  # cached: no second probe
+    assert probes == [[str(foreign), "--help"]]
+
+
+def test_app_cli_anywhere_is_accepted_by_its_help_banner(tmp_path, monkeypatch):
+    relocated = _executable(tmp_path / "elsewhere" / "openusage")
+    monkeypatch.setattr(openusage, "probe_output", lambda *_a, **_k: APP_HELP)
+    assert openusage.is_app_cli(str(relocated))
+
+
+def test_resolver_skips_the_shadowing_binary_and_uses_the_app_cli_later_on_path(tmp_path, monkeypatch):
+    foreign = _executable(tmp_path / "homebrew" / "openusage")
+    helper = _bundle_cli(tmp_path)
+    link = tmp_path / "usr-local" / "openusage"
+    link.parent.mkdir()
+    link.symlink_to(helper)
+    monkeypatch.setenv("PATH", os.pathsep.join([str(tmp_path / "homebrew"), str(link.parent)]))
+    monkeypatch.setattr(openusage, "_KNOWN_APP_CLI_PATHS", ())
+    monkeypatch.setattr(openusage, "probe_output", lambda *_a, **_k: SH_HELP)
+
+    assert openusage.resolve_app_cli() == (str(link), [str(foreign)])
+    assert openusage.app_cli_path() == str(link)
+    assert openusage.foreign_openusage_binaries() == [str(foreign)]
+
+
+def test_resolver_falls_back_to_known_install_locations(tmp_path, monkeypatch):
+    foreign = _executable(tmp_path / "homebrew" / "openusage")
+    helper = _bundle_cli(tmp_path)
+    monkeypatch.setenv("PATH", str(tmp_path / "homebrew"))
+    monkeypatch.setattr(openusage, "_KNOWN_APP_CLI_PATHS", (str(helper),))
+    monkeypatch.setattr(openusage, "probe_output", lambda *_a, **_k: SH_HELP)
+
+    assert openusage.resolve_app_cli() == (str(helper), [str(foreign)])
+
+
+def test_resolver_reports_no_cli_when_only_foreign_binaries_exist(tmp_path, monkeypatch):
+    foreign = _executable(tmp_path / "homebrew" / "openusage")
+    monkeypatch.setenv("PATH", str(tmp_path / "homebrew"))
+    monkeypatch.setattr(openusage, "_KNOWN_APP_CLI_PATHS", ())
+    monkeypatch.setattr(openusage, "probe_output", lambda *_a, **_k: SH_HELP)
+
+    assert openusage.resolve_app_cli() == (None, [str(foreign)])
+
+
+def test_fetch_limits_never_runs_a_foreign_binary(monkeypatch):
+    monkeypatch.setattr(openusage, "app_cli_path", lambda: None)
+    monkeypatch.setattr(openusage, "run_json", lambda *_a, **_k: pytest.fail("ran a CLI that is not OpenUsage.app's"))
+    payload = {"providers": {}}
+    monkeypatch.setattr(openusage, "_http_limits", lambda *, base_url, timeout: payload)
+
+    got, via = openusage._fetch_limits(
+        timeout=5.0, base_url="http://127.0.0.1:6736", force_refresh=True, try_launch_app=False
+    )
+    assert (got, via) == (payload, "http")
+
+
+def test_fetch_limits_runs_the_verified_app_cli(monkeypatch):
+    calls: list[list[str]] = []
+    payload = {"providers": {}}
+
+    def fake_run_json(argv, *, timeout):
+        calls.append(argv)
+        return payload
+
+    monkeypatch.setattr(openusage, "app_cli_path", lambda: "/Applications/OpenUsage.app/Contents/Helpers/openusage")
+    monkeypatch.setattr(openusage, "run_json", fake_run_json)
+
+    got, via = openusage._fetch_limits(
+        timeout=5.0, base_url="http://127.0.0.1:6736", force_refresh=True, try_launch_app=False
+    )
+    assert (got, via) == (payload, "cli")
+    assert calls == [["/Applications/OpenUsage.app/Contents/Helpers/openusage", "--force"]]

{aiuse-3.3.0 → aiuse-3.3.2}/tests/test_query_throttle.py

@@ -151,7 +151,7 @@ def test_openusage_withholds_force_while_antigravity_is_throttled(monkeypatch):
         forced.append(force_refresh)
         return payload, "cli"
 
-    monkeypatch.setattr(openusage, "which", lambda _cmd: "/usr/local/bin/openusage")
+    monkeypatch.setattr(openusage, "app_cli_path", lambda: "/usr/local/bin/openusage")
     monkeypatch.setattr(openusage, "_fetch_limits", fake_fetch)
     limits = {"antigravity": 900.0}
 
@@ -173,7 +173,7 @@ def test_openusage_force_without_antigravity_does_not_spend_the_slot(monkeypatch
             }
         }
     }
-    monkeypatch.setattr(openusage, "which", lambda _cmd: "/usr/local/bin/openusage")
+    monkeypatch.setattr(openusage, "app_cli_path", lambda: "/usr/local/bin/openusage")
     monkeypatch.setattr(openusage, "_fetch_limits", lambda **_kw: (payload, "cli"))
     openusage.collect_openusage_ai(min_intervals={"antigravity": 900.0})
 

aiuse-3.3.2/tests/test_tty.py

@@ -0,0 +1,117 @@
+"""Tests for terminal attribute save/restore helpers."""
+
+from __future__ import annotations
+
+import pytest
+
+from aiuse import tty
+from aiuse.collectors import runner
+from aiuse.tty import restore_stdin_tty, save_stdin_tty
+
+
+class _Stream:
+    def __init__(self, *, is_tty: bool, fd: int) -> None:
+        self._is_tty = is_tty
+        self._fd = fd
+
+    def isatty(self) -> bool:
+        return self._is_tty
+
+    def fileno(self) -> int:
+        return self._fd
+
+
+def _streams(monkeypatch, *, stdin: bool, stdout: bool, stderr: bool) -> None:
+    monkeypatch.setattr(tty.sys, "stdin", _Stream(is_tty=stdin, fd=0))
+    monkeypatch.setattr(tty.sys, "stdout", _Stream(is_tty=stdout, fd=1))
+    monkeypatch.setattr(tty.sys, "stderr", _Stream(is_tty=stderr, fd=2))
+
+
+def test_save_restore_noop_when_not_tty(monkeypatch):
+    _streams(monkeypatch, stdin=False, stdout=False, stderr=False)
+    assert save_stdin_tty() is None
+    restore_stdin_tty(None)  # must not raise
+
+
+def test_restore_ignores_corrupt_saved(monkeypatch):
+    # Passing an invalid snapshot must not raise.
+    restore_stdin_tty(["not", "real", "termios"])
+    restore_stdin_tty((999999, ["nope"]))
+
+
+def test_save_uses_stdout_when_stdin_is_redirected(monkeypatch):
+    """``aiuse </dev/null`` still has a terminal to protect on stdout."""
+    import termios
+
+    _streams(monkeypatch, stdin=False, stdout=True, stderr=True)
+    monkeypatch.setattr(termios, "tcgetattr", lambda fd: ["attrs", fd])
+    assert save_stdin_tty() == (1, ["attrs", 1])
+
+
+def test_restore_targets_the_saved_fd(monkeypatch):
+    import termios
+
+    calls: list[tuple[int, int, object]] = []
+    monkeypatch.setattr(termios, "tcgetattr", lambda fd: ["raw"])
+    monkeypatch.setattr(termios, "tcsetattr", lambda fd, when, attrs: calls.append((fd, when, attrs)))
+    monkeypatch.setattr(tty, "_owns_terminal", lambda fd: True)
+    restore_stdin_tty((2, ["attrs"]))
+    assert calls == [(2, termios.TCSADRAIN, ["attrs"])]
+
+
+def test_restore_is_a_noop_when_nothing_changed(monkeypatch):
+    """No tcsetattr at all in the common case (no SIGTTOU risk, no drain)."""
+    import termios
+
+    monkeypatch.setattr(termios, "tcgetattr", lambda fd: ["attrs"])
+    monkeypatch.setattr(termios, "tcsetattr", lambda *_a: pytest.fail("tcsetattr on unchanged attrs"))
+    monkeypatch.setattr(tty, "_owns_terminal", lambda fd: pytest.fail("checked pgrp on unchanged attrs"))
+    restore_stdin_tty((2, ["attrs"]))
+
+
+def test_restore_never_writes_from_a_background_job(monkeypatch):
+    """``aiuse --version &`` with stderr on the tty: tcsetattr would SIGTTOU-stop us.
+
+    Regression: 3.3.1's ``brew test`` hung for five minutes in state T.
+    """
+    import termios
+
+    monkeypatch.setattr(termios, "tcgetattr", lambda fd: ["raw"])
+    monkeypatch.setattr(termios, "tcsetattr", lambda *_a: pytest.fail("tcsetattr from a background process group"))
+    monkeypatch.setattr(tty.os, "tcgetpgrp", lambda fd: 4242)
+    monkeypatch.setattr(tty.os, "getpgrp", lambda: 1)
+    restore_stdin_tty((2, ["attrs"]))
+
+
+def test_owns_terminal_matches_foreground_pgrp(monkeypatch):
+    monkeypatch.setattr(tty.os, "tcgetpgrp", lambda fd: 7)
+    monkeypatch.setattr(tty.os, "getpgrp", lambda: 7)
+    assert tty._owns_terminal(2)
+    monkeypatch.setattr(tty.os, "tcgetpgrp", lambda fd: (_ for _ in ()).throw(OSError("not a tty")))
+    assert not tty._owns_terminal(2)
+
+
+def test_run_collectors_restores_the_terminal_before_returning(monkeypatch):
+    """A child that leaves the terminal raw must not corrupt the report printed next."""
+    events: list[str] = []
+    monkeypatch.setattr(runner, "save_stdin_tty", lambda: events.append("save") or "token")
+    monkeypatch.setattr(runner, "restore_stdin_tty", lambda saved: events.append(f"restore:{saved}"))
+
+    def fake_inner(config):
+        events.append("collect")
+        return "snapshot"
+
+    monkeypatch.setattr(runner, "_run_collectors", fake_inner)
+    assert runner.run_collectors({}) == "snapshot"
+    assert events == ["save", "collect", "restore:token"]
+
+    def failing_inner(config):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(runner, "_run_collectors", failing_inner)
+    events.clear()
+    try:
+        runner.run_collectors({})
+    except RuntimeError:
+        pass
+    assert events == ["save", "restore:token"]

aiuse-3.3.0/src/aiuse/tty.py

@@ -1,41 +0,0 @@
-"""Terminal attribute save/restore helpers.
-
-Some external CLIs (notably ``caut usage``) put the inherited stdin TTY into
-raw/cbreak mode. If they are killed mid-run (collector timeout) or fail to
-restore, the parent shell loses echo until the user runs ``reset``. Collectors
-should pass ``stdin=DEVNULL``; this module is belt-and-suspenders for any path
-that still inherits a TTY.
-"""
-
-from __future__ import annotations
-
-import sys
-from typing import Any
-
-
-def save_stdin_tty() -> Any | None:
-    """Snapshot stdin termios attrs when stdin is a TTY; else None."""
-    if not getattr(sys.stdin, "isatty", lambda: False)():
-        return None
-    try:
-        import termios
-    except ImportError:
-        return None
-    try:
-        return termios.tcgetattr(sys.stdin.fileno())
-    except (termios.error, OSError, ValueError):
-        return None
-
-
-def restore_stdin_tty(saved: Any | None) -> None:
-    """Restore stdin termios attrs previously returned by ``save_stdin_tty``."""
-    if saved is None:
-        return
-    try:
-        import termios
-    except ImportError:
-        return
-    try:
-        termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, saved)
-    except (termios.error, OSError, ValueError):
-        return

aiuse-3.3.0/tests/test_tty.py

@@ -1,20 +0,0 @@
-"""Tests for stdin TTY save/restore helpers."""
-
-from __future__ import annotations
-
-from aiuse.tty import restore_stdin_tty, save_stdin_tty
-
-
-def test_save_restore_noop_when_not_tty(monkeypatch):
-    class _Fake:
-        def isatty(self) -> bool:
-            return False
-
-    monkeypatch.setattr("aiuse.tty.sys.stdin", _Fake())
-    assert save_stdin_tty() is None
-    restore_stdin_tty(None)  # must not raise
-
-
-def test_restore_ignores_corrupt_saved(monkeypatch):
-    # Passing an invalid snapshot must not raise.
-    restore_stdin_tty(["not", "real", "termios"])