aiuse 3.2.4__tar.gz → 3.2.6__tar.gz

{aiuse-3.2.4/src/aiuse.egg-info → aiuse-3.2.6}/PKG-INFO

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

{aiuse-3.2.4 → aiuse-3.2.6}/pyproject.toml

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

{aiuse-3.2.4 → aiuse-3.2.6}/src/aiuse/__init__.py

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

{aiuse-3.2.4 → aiuse-3.2.6}/src/aiuse/collectors/muse.py

@@ -6,8 +6,9 @@ There are two live transports with mutual failover:
   1. Bearer (AIUSE_MUSE_API_KEY / META_API_KEY / secretspec / ~/.config/muse/auth.json
      from `muse login`) → https://api.meta.ai/v1/*
   2. Cookie (AIUSE_MUSE_COOKIE / secretspec MUSE_COOKIE from `aiuse credential refresh muse --from chrome`)
-     → GET https://dev.meta.ai/usage (scrape LSD + fb_dtsg + team_id) → POST https://dev.meta.ai/api/graphql/
-       doc_id 9128374650192834 (MuseDevBillingBalanceQuery) → billing_info {balance, credit_limit, remaining_budget}
+     → GET https://dev.meta.ai/api/auth/me + /api/portal/teams/{id}/billing-banner and /usage.
+       The pre-2026-10 Relay page (LSD + fb_dtsg on /usage) is only a fallback when the portal
+       routes are absent. https://dev.meta.ai/usage now redirects to the public marketing page.
 
 If one transport is absent or fails, the other is tried. Absent both → [] . 401/403 with a
 credential present surfaces as AccountUsage(error=…) only after both transports fail.
@@ -26,8 +27,10 @@ import re
 import shutil
 import subprocess
 from collections.abc import Mapping
+from datetime import date
 from pathlib import Path
 from typing import Any
+from urllib.parse import quote, urlencode
 
 import requests
 
@@ -61,6 +64,17 @@ _TEAM_ENV = "AIUSE_MUSE_TEAM_ID"
 _DEV_HOME_URL = "https://dev.meta.ai/"
 _DEV_USAGE_URL = "https://dev.meta.ai/usage"
 _GRAPHQL_URL = "https://dev.meta.ai/api/graphql/"
+_PORTAL_ORIGIN = "https://dev.meta.ai"
+_SIGN_IN_URL = "https://dev.meta.ai/api/auth/login"
+# Shown when Chrome still holds a dead llm_sess. /usage is a marketing redirect and
+# no longer embeds fb_dtsg; muse.ai is the separate Muse chat app.
+_SESSION_REJECTED = (
+    "Muse cookie: dev.meta.ai rejected this Chrome session. "
+    f"Open {_SIGN_IN_URL} in this Chrome profile and wait until the Model API "
+    "dashboard loads, then re-run `aiuse credential refresh muse --from chrome`. "
+    "Signing in at https://muse.ai does not create this session, and "
+    "https://dev.meta.ai/usage no longer embeds fb_dtsg."
+)
 # Live Relay persisted query (LLMDCBillingBannerContainerQuery). Meta rotates these;
 # free_money_* amounts use PECurrency DEFAULT_AMOUNT_OFFSET=100 (cents for USD).
 _BILLING_DOC_ID = "28281552291474266"
@@ -229,18 +243,36 @@ def _soft_inventory_account(*, account: str | None) -> AccountUsage:
         billing_kind=BillingKind.PAYG_API,
         notes=[
             "Muse API key accepted (/models); Meta does not expose a billing endpoint on api.meta.ai yet.",
-            "For live balance: sign into https://dev.meta.ai in Chrome, then run "
+            "For live balance: sign into https://dev.meta.ai/api/auth/login in Chrome, then run "
             "`aiuse credential refresh muse --from chrome`.",
         ],
     )
 
 
+class _PortalUnavailable(Exception):
+    """Portal routes are missing, so the legacy HTML scrape may still work."""
+
+
 def _collect_via_cookie(
     cookie: str,
     env: Mapping[str, str],
     timeout: float,
     *,
     account: str | None = None,
+) -> list[AccountUsage]:
+    """Read Model API billing. Portal JSON first; Relay HTML only if those routes are gone."""
+    try:
+        return _collect_via_portal(cookie, env, timeout, account=account)
+    except _PortalUnavailable:
+        return _collect_via_legacy_cookie(cookie, env, timeout, account=account)
+
+
+def _collect_via_legacy_cookie(
+    cookie: str,
+    env: Mapping[str, str],
+    timeout: float,
+    *,
+    account: str | None = None,
 ) -> list[AccountUsage]:
     # Prefer explicit team_id (env / operator URL). Bare /usage without team_id redirects to auth.
     team_id = str(env.get(_TEAM_ENV) or "").strip()
@@ -306,6 +338,298 @@ def _collect_via_cookie(
     return accounts
 
 
+def _portal_headers(cookie: str) -> dict[str, str]:
+    return {
+        "Cookie": cookie,
+        "User-Agent": _USER_AGENT,
+        "Accept": "application/json",
+        "Referer": f"{_PORTAL_ORIGIN}/",
+    }
+
+
+def _portal_get(cookie: str, path: str, timeout: float, *, missing_ok: bool = False) -> Any | None:
+    """GET a Model API portal route.
+
+    401/403 and a login redirect are a dead Chrome session. 404 or a non-JSON
+    body means this deployment has no portal (legacy Relay scrape may apply),
+    unless ``missing_ok`` treats 404 as an absent optional route.
+    """
+    url = f"{_PORTAL_ORIGIN}{path}"
+    try:
+        resp = requests.get(
+            url,
+            timeout=timeout,
+            allow_redirects=True,
+            headers=_portal_headers(cookie),
+        )
+    except requests.RequestException as exc:
+        raise CollectorError(f"Muse cookie: failed to fetch {path}: {exc.__class__.__name__}") from exc
+    final = resp.url or ""
+    if resp.status_code in (401, 403) or "auth.meta.com" in final:
+        raise CollectorError(_SESSION_REJECTED)
+    if resp.status_code == 404:
+        if missing_ok:
+            return None
+        raise _PortalUnavailable()
+    try:
+        resp.raise_for_status()
+    except requests.HTTPError as exc:
+        raise CollectorError(f"Muse cookie: dev.meta.ai portal returned HTTP {resp.status_code} for {path}") from exc
+    try:
+        payload = resp.json()
+    except (ValueError, AttributeError) as exc:
+        if missing_ok:
+            return None
+        raise _PortalUnavailable() from exc
+    if not isinstance(payload, (dict, list)):
+        if missing_ok:
+            return None
+        raise _PortalUnavailable()
+    return payload
+
+
+def _team_id_of(team: Any) -> str | None:
+    if not isinstance(team, dict):
+        return None
+    for key in ("id", "team_id", "teamId"):
+        value = team.get(key)
+        if value is not None and str(value).strip():
+            return str(value).strip()
+    return None
+
+
+def _pick_team_id(teams: list[Any], wanted: str) -> str:
+    ids = [team_id for team in teams if (team_id := _team_id_of(team))]
+    if wanted:
+        return wanted
+    if not ids:
+        raise CollectorError(
+            "Muse cookie: Model API session has no team id. "
+            f"Open {_SIGN_IN_URL} and finish signing in, or set AIUSE_MUSE_TEAM_ID."
+        )
+    return ids[0]
+
+
+def _iana_timezone() -> str:
+    try:
+        parts = Path("/etc/localtime").resolve().parts
+    except OSError:
+        return "UTC"
+    if "zoneinfo" not in parts:
+        return "UTC"
+    name = "/".join(parts[parts.index("zoneinfo") + 1 :])
+    return name or "UTC"
+
+
+def _minor_to_usd(raw: Any, *, offset: float = 100.0) -> float | None:
+    if isinstance(raw, bool) or raw is None:
+        return None
+    if isinstance(raw, (int, float)):
+        return float(raw) / offset
+    if isinstance(raw, str):
+        try:
+            return float(raw) / offset
+        except ValueError:
+            return None
+    return None
+
+
+def _free_remaining_usd(banner: Any) -> float | None:
+    """Free-credit remaining from the portal billing banner, in dollars."""
+    if not isinstance(banner, dict):
+        return None
+    kind = banner.get("kind")
+    if kind == "free_untouched":
+        return _minor_to_usd(banner.get("grant_minor_units"))
+    if kind == "free_partial":
+        return _minor_to_usd(banner.get("remaining_minor_units"))
+    return None
+
+
+def _usage_point_usd(point: dict[str, Any], offset: float) -> float | None:
+    # Dashboard formula for USAGE_BILLABLE_COST: amount is minor units
+    # (currency.offset, default 100). Missing amount falls back to value/1e8.
+    if point.get("amount") is not None:
+        return _minor_to_usd(point.get("amount"), offset=offset)
+    if point.get("value") is not None:
+        scaled = _minor_to_usd(point.get("value"), offset=1e8)
+        if scaled is None:
+            return None
+        return scaled / offset
+    return None
+
+
+def _mtd_from_portal_usage(payload: Any) -> float | None:
+    """Sum TOTAL billable cost for the current calendar month, in dollars."""
+    if not isinstance(payload, dict):
+        return None
+    series = payload.get("series")
+    if not isinstance(series, list):
+        return None
+    currency = payload.get("currency") if isinstance(payload.get("currency"), dict) else {}
+    offset = currency.get("offset") if isinstance(currency, dict) else None
+    if not isinstance(offset, (int, float)) or isinstance(offset, bool) or offset < 1:
+        offset = 100.0
+    prefix = date.today().strftime("%Y-%m")
+    totals = [row for row in series if isinstance(row, dict) and row.get("type") == "TOTAL"]
+    rows = totals or [row for row in series if isinstance(row, dict)]
+    saw_point = False
+    found = False
+    mtd = 0.0
+    for row in rows:
+        points = row.get("data_points")
+        if not isinstance(points, list):
+            continue
+        for point in points:
+            if not isinstance(point, dict):
+                continue
+            saw_point = True
+            day = str(point.get("date") or "")
+            if not day.startswith(prefix):
+                continue
+            amount = _usage_point_usd(point, float(offset))
+            if amount is None:
+                continue
+            mtd += amount
+            found = True
+    if not saw_point:
+        return None
+    return mtd if found else 0.0
+
+
+def _account_label_from_me(me: Any, account: str | None) -> str | None:
+    if account:
+        return account
+    if not isinstance(me, dict):
+        return None
+    candidates: list[Any] = [me, me.get("user") if isinstance(me.get("user"), dict) else None]
+    for obj in candidates:
+        if not isinstance(obj, dict):
+            continue
+        for key in ("email", "user_email", "name"):
+            value = obj.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+    return None
+
+
+def _accounts_from_portal(
+    banner: Any,
+    spend_usd: float | None,
+    *,
+    team_id: str,
+    usage_raw: Any,
+) -> list[AccountUsage]:
+    free_remaining = _free_remaining_usd(banner)
+    notes = [
+        "Live data fetched directly from Muse (dev.meta.ai portal).",
+        f"Endpoint: {_PORTAL_ORIGIN}/api/portal/teams/{team_id}/usage",
+        "Muse dashboard balance is cumulative PAYG spend (counts up from $0), "
+        "not prepaid remaining (DeepSeek / oc-zen count down to $0).",
+    ]
+    raw: dict[str, Any] = {"team_id": team_id, "banner": banner}
+    if usage_raw is not None:
+        raw["usage"] = usage_raw
+    if isinstance(banner, dict) and banner.get("kind"):
+        notes.append(f"Muse billing banner: {banner.get('kind')}.")
+    if spend_usd is not None:
+        notes.append(f"Muse spend this month: ${spend_usd:.2f} (counts up).")
+        return [
+            AccountUsage(
+                source="muse",
+                provider="muse",
+                billing_kind=BillingKind.PAYG_API,
+                balance_usd=None,
+                usage_credits=UsageCredits(used=spend_usd, currency="USD"),
+                notes=notes,
+                raw=raw,
+            )
+        ]
+    if free_remaining is not None and free_remaining > 0:
+        notes.append(f"Muse free credits remaining: ${free_remaining:.2f} (counts down).")
+        return [
+            AccountUsage(
+                source="muse",
+                provider="muse",
+                billing_kind=BillingKind.PREPAID_BALANCE,
+                balance_usd=free_remaining,
+                notes=notes,
+                raw=raw,
+            )
+        ]
+    raise CollectorError(
+        "Muse cookie: could not read MTD spend and free credits are empty; "
+        "re-run `aiuse credential refresh muse --from chrome`"
+    )
+
+
+def _collect_via_portal(
+    cookie: str,
+    env: Mapping[str, str],
+    timeout: float,
+    *,
+    account: str | None = None,
+) -> list[AccountUsage]:
+    me = _portal_get(cookie, "/api/auth/me", timeout)
+    teams_payload = _portal_get(cookie, "/api/portal/teams", timeout)
+    if isinstance(teams_payload, dict):
+        teams = teams_payload.get("teams")
+    elif isinstance(teams_payload, list):
+        teams = teams_payload
+    else:
+        teams = None
+    if not isinstance(teams, list) or not teams:
+        raise CollectorError(
+            "Muse cookie: Model API session returned no teams. "
+            f"Open {_SIGN_IN_URL} until the dashboard loads, then re-run "
+            "`aiuse credential refresh muse --from chrome`."
+        )
+    wanted = str(env.get(_TEAM_ENV) or "").strip()
+    team_id = _pick_team_id(teams, wanted)
+    team_path = quote(team_id, safe="")
+    try:
+        banner = _portal_get(
+            cookie,
+            f"/api/portal/teams/{team_path}/billing-banner",
+            timeout,
+            missing_ok=True,
+        )
+    except CollectorError as exc:
+        if str(exc) == _SESSION_REJECTED:
+            raise
+        banner = None
+    today = date.today()
+    query = urlencode(
+        {
+            "metric": "USAGE_BILLABLE_COST",
+            "start_date": today.replace(day=1).isoformat(),
+            "end_date": today.isoformat(),
+            "timezone": _iana_timezone(),
+        }
+    )
+    usage_raw: Any = None
+    spend_usd: float | None = None
+    try:
+        usage_raw = _portal_get(
+            cookie,
+            f"/api/portal/teams/{team_path}/usage?{query}",
+            timeout,
+            missing_ok=True,
+        )
+        spend_usd = _mtd_from_portal_usage(usage_raw)
+    except CollectorError as exc:
+        if str(exc) == _SESSION_REJECTED:
+            raise
+        spend_usd = None
+    label = _account_label_from_me(me, account)
+    accounts = _accounts_from_portal(banner, spend_usd, team_id=team_id, usage_raw=usage_raw)
+    if label:
+        for row in accounts:
+            if not row.account:
+                row.account = label
+    return accounts
+
+
 def _fetch_dev_session_html(cookie: str, timeout: float, *, team_id: str | None = None) -> str:
     """Load a logged-in Model API HTML shell (LSD/DTSG + optional team_id scrape)."""
     urls: list[str] = []
@@ -327,33 +651,20 @@ def _fetch_dev_session_html(cookie: str, timeout: float, *, team_id: str | None
                 },
             )
             if resp.status_code in (401, 403):
-                raise CollectorError(
-                    f"Muse cookie rejected by dev.meta.ai (HTTP {resp.status_code}); "
-                    "re-run `aiuse credential refresh muse --from chrome`"
-                )
+                raise CollectorError(_SESSION_REJECTED)
             resp.raise_for_status()
             text = resp.text
             # auth.meta.com login waterfall is not usable
             if "auth.meta.com" in (resp.url or ""):
-                last_error = CollectorError(
-                    "Muse cookie: dev.meta.ai returned a login/error shell; open "
-                    "https://dev.meta.ai/usage in Chrome so llm_sess is present, then re-run "
-                    "`aiuse credential refresh muse --from chrome`"
-                )
+                last_error = CollectorError(_SESSION_REJECTED)
                 continue
             if _extract_dtsg(text) or _extract_lsd(text):
                 return text
             # Tiny Error shells without tokens are not usable
             if len(text) < 5000:
-                last_error = CollectorError(
-                    "Muse cookie: dev.meta.ai returned a login/error shell; open "
-                    "https://dev.meta.ai/usage in Chrome so llm_sess is present, then re-run "
-                    "`aiuse credential refresh muse --from chrome`"
-                )
+                last_error = CollectorError(_SESSION_REJECTED)
                 continue
-            last_error = CollectorError(
-                "Muse cookie: fetched HTML without fb_dtsg/LSD; re-run `aiuse credential refresh muse --from chrome`"
-            )
+            last_error = CollectorError(_SESSION_REJECTED)
         except CollectorError as exc:
             last_error = exc
         except requests.RequestException as exc:

{aiuse-3.2.4 → aiuse-3.2.6}/src/aiuse/credentials.py

@@ -34,6 +34,10 @@ _OPENCODE_COOKIE_SECRET = "OPENCODE_ZEN_COOKIE"
 _MUSE = "muse"
 _MUSE_HOSTS = ("dev.meta.ai", "meta.ai", "facebook.com", "auth.meta.com")
 _MUSE_COOKIE_SECRET = "MUSE_COOKIE"
+# llama_dev_sess is the current Model API dashboard cookie (host dev.meta.ai).
+# llm_sess and dh_sess are older names. Facebook c_user/xs and muse.ai hatch_sess
+# do not authorize https://dev.meta.ai.
+_MUSE_SESSION_COOKIES = frozenset({"llama_dev_sess", "llm_sess", "dh_sess"})
 _CHROME_ROOT = Path.home() / "Library/Application Support/Google/Chrome"
 _DEFAULT_TIMEOUT_S = 10.0
 
@@ -238,14 +242,19 @@ def _chrome_cookie_header_for_muse(profile: str) -> str:
                 pairs.append(f"{item.name}={value}")
     if not pairs:
         raise CredentialError("no Muse cookies were found; sign in to dev.meta.ai in the selected Chrome profile")
-    # Model API auth is llm_sess on .dev.meta.ai (not Facebook c_user/xs).
-    if "llm_sess" not in names:
+    _require_muse_session_cookie(names)
+    return "; ".join(pairs)
+
+
+def _require_muse_session_cookie(names: set[str]) -> None:
+    """Reject a Chrome jar that has no Model API session cookie."""
+    if _MUSE_SESSION_COOKIES.isdisjoint(names):
         raise CredentialError(
-            "Chrome is missing the Muse session cookie (llm_sess). "
-            "In this Chrome profile open https://dev.meta.ai/usage until the usage "
-            "dashboard loads, then re-run `aiuse credential refresh muse --from chrome`."
+            "Chrome is missing a Model API session cookie (llama_dev_sess, llm_sess, or dh_sess). "
+            "Open https://dev.meta.ai/api/auth/login in this Chrome profile and wait "
+            "until the dashboard loads, then re-run `aiuse credential refresh muse --from chrome`. "
+            "https://muse.ai is the Muse chat app and does not sign in the Model API."
         )
-    return "; ".join(pairs)
 
 
 def _validate_muse_cookie(cookie: str, *, timeout: float) -> None:

{aiuse-3.2.4 → aiuse-3.2.6}/src/aiuse/report.py

@@ -1398,6 +1398,25 @@ def _cell_color(s: _Style, used: float) -> Any:
     return s.green
 
 
+def _style_clock_percent(s: _Style, cell: _ClockCell, *, width: int) -> str:
+    """Right-align ``NNu/NNl`` into ``width`` and color only the left token.
+
+    The used side (``44u/``) stays the default color. The left side (``56l``
+    or ``56l+``) is one colored token, so the ``l`` does not drop out between
+    the number and the reset span. An inferred clock is dim end to end.
+    Visible width is always ``width``: a short pair is padded on the left,
+    and the color codes are not part of that width, so the next column starts
+    on the same character in every row.
+    """
+    padded = f"{_clock_percent_text(cell):>{width}}"
+    if cell.inferred:
+        return s.dim(padded)
+    slash = padded.rfind("/")
+    if slash < 0:
+        return _cell_color(s, cell.used_percent)(padded)
+    return padded[: slash + 1] + _cell_color(s, cell.used_percent)(padded[slash + 1 :])
+
+
 def render_clock_matrix(
     alerts: list[UseOrLoseAlert],
     *,
@@ -1511,33 +1530,12 @@ def render_clock_matrix(
                 continue
             any_inferred = any_inferred or cell.inferred
             any_folded = any_folded or bool(cell.folded)
-            percent = _clock_percent_text(cell)
             span = _format_reset_span(
                 cell.days_until_reset,
                 estimated=cell.reset_estimated,
                 compact=layout.compact_deadline,
             )
-            # Split percent into used part (before "/") and left part (after "/" but before "l")
-            # Format: "44u/56l" or "44u/56l+" if folded
-            # Keep used part and slash in normal text, color only the left part
-            if "/" in percent:
-                used_part, rest = percent.split("/", 1)
-                # rest is like "56l" or "56l+"
-                left_part = rest.rstrip("l+")
-                mark = "+" if "+" in rest else ""
-                if cell.inferred:
-                    colored_used = s.dim(used_part)
-                    colored_left = s.dim(left_part)
-                else:
-                    colored_used = used_part  # Normal text for used part
-                    colored_left = _cell_color(s, cell.used_percent)(left_part)
-                colored = f"{colored_used}/{colored_left}l{mark}"
-            else:
-                colored = (
-                    s.dim(f"{percent:>{w_pct}}")
-                    if cell.inferred
-                    else _cell_color(s, cell.used_percent)(f"{percent:>{w_pct}}")
-                )
+            colored = _style_clock_percent(s, cell, width=w_pct)
             if span is None:
                 tail.append(colored + (" " * (w_clock - w_pct)))
                 continue

{aiuse-3.2.4 → aiuse-3.2.6/src/aiuse.egg-info}/PKG-INFO

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

{aiuse-3.2.4 → aiuse-3.2.6}/tests/test_credentials.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 from aiuse import cli
 from aiuse.collectors.opencode_zen import _SESSION_COOKIE
-from aiuse.credentials import CredentialError, _cookie_header_for_opencode
+from aiuse.credentials import CredentialError, _cookie_header_for_opencode, _require_muse_session_cookie
 
 
 def _cookie(name: str, value: str, domain: str) -> Cookie:
@@ -63,6 +63,25 @@ def test_cookie_header_rejects_missing_opencode_cookie():
         raise AssertionError("unrelated browser cookies must never be accepted")
 
 
+def test_muse_session_accepts_the_current_dashboard_cookie():
+    _require_muse_session_cookie({"llama_dev_sess"})
+
+
+def test_muse_session_still_accepts_older_cookie_names():
+    _require_muse_session_cookie({"llm_sess"})
+    _require_muse_session_cookie({"dh_sess"})
+
+
+def test_muse_chat_and_facebook_cookies_are_not_a_model_api_session():
+    try:
+        _require_muse_session_cookie({"hatch_sess", "c_user", "xs"})
+    except CredentialError as exc:
+        assert "llama_dev_sess" in str(exc)
+        assert "https://muse.ai" in str(exc)
+    else:
+        raise AssertionError("muse.ai and Facebook cookies must not pass the Model API gate")
+
+
 def test_credential_refresh_dry_run_validates_without_writing(monkeypatch, capsys):
     validated: list[str] = []
     monkeypatch.setattr("aiuse.credentials._chrome_cookie_header", lambda _profile: "session=secret")

{aiuse-3.2.4 → aiuse-3.2.6}/tests/test_muse.py

@@ -463,6 +463,23 @@ def test_collect_via_cookie_uses_team_id_and_spend_query(monkeypatch):
     }
 
     def fake_get(url, timeout, allow_redirects=True, headers=None):
+        if "/api/" in url:
+            # Portal routes absent: collector falls back to the Relay HTML scrape.
+            class NoPortal:
+                status_code = 404
+                text = ""
+                headers = {"content-type": "text/html"}
+
+                def __init__(self, final_url: str):
+                    self.url = final_url
+
+                def raise_for_status(self):
+                    pass
+
+                def json(self):
+                    raise ValueError("no portal")
+
+            return NoPortal(url)
         assert "team_id=1483959756871752" in url
         return FakeGet()
 
@@ -487,3 +504,104 @@ def test_collect_via_cookie_uses_team_id_and_spend_query(monkeypatch):
         muse_mod._BILLING_DOC_ID,
         muse_mod._SPEND_DOC_ID,
     }
+
+
+def _json_response(payload, *, status_code=200, url="https://dev.meta.ai/api/auth/me"):
+    class Response:
+        headers = {"content-type": "application/json"}
+        text = json.dumps(payload)
+
+        def __init__(self):
+            self.status_code = status_code
+            self.url = url
+
+        def raise_for_status(self):
+            if self.status_code >= 400:
+                raise requests.HTTPError(response=self)
+
+        def json(self):
+            return payload
+
+    return Response()
+
+
+def test_collect_via_cookie_portal_spend_and_session_label(monkeypatch):
+    from datetime import date
+
+    from aiuse.collectors import muse as muse_mod
+
+    day = date.today().isoformat()
+    seen: list[str] = []
+
+    def fake_get(url, timeout, allow_redirects=True, headers=None):
+        seen.append(url)
+        if url.endswith("/api/auth/me"):
+            return _json_response({"email": "muse-user@example.com"}, url=url)
+        if url.endswith("/api/portal/teams"):
+            return _json_response({"teams": [{"id": "1483959756871752", "name": "personal"}]}, url=url)
+        if url.endswith("/billing-banner"):
+            return _json_response(
+                {"kind": "free_partial", "remaining_minor_units": 250, "currency": "USD"},
+                url=url,
+            )
+        if "/usage?" in url:
+            assert "metric=USAGE_BILLABLE_COST" in url
+            return _json_response(
+                {
+                    "currency": {"code": "USD", "symbol": "$", "format": "{symbol}{amount}", "offset": 100},
+                    "series": [
+                        {
+                            "type": "TOTAL",
+                            "data_points": [{"date": day, "amount": "30"}],
+                        }
+                    ],
+                },
+                url=url,
+            )
+        raise AssertionError(url)
+
+    monkeypatch.setattr(requests, "get", fake_get)
+    accounts = muse_mod._collect_via_cookie("llm_sess=abc", {}, 5.0)
+    assert accounts[0].account == "muse-user@example.com"
+    assert accounts[0].balance_usd is None
+    assert accounts[0].usage_credits is not None
+    assert accounts[0].usage_credits.used == 0.30
+    assert accounts[0].billing_kind == BillingKind.PAYG_API
+    assert any("/api/auth/me" in url for url in seen)
+    assert all("/api/graphql" not in url for url in seen)
+
+
+def test_collect_via_cookie_portal_free_credits_when_usage_empty(monkeypatch):
+    from aiuse.collectors import muse as muse_mod
+
+    def fake_get(url, timeout, allow_redirects=True, headers=None):
+        if url.endswith("/api/auth/me"):
+            return _json_response({"email": "muse-user@example.com"}, url=url)
+        if url.endswith("/api/portal/teams"):
+            return _json_response({"teams": [{"id": "99"}]}, url=url)
+        if url.endswith("/billing-banner"):
+            return _json_response({"kind": "free_untouched", "grant_minor_units": 500}, url=url)
+        if "/usage?" in url:
+            return _json_response({"series": []}, url=url)
+        raise AssertionError(url)
+
+    monkeypatch.setattr(requests, "get", fake_get)
+    accounts = muse_mod._collect_via_cookie("dh_sess=abc", {}, 5.0)
+    assert accounts[0].balance_usd == 5.0
+    assert accounts[0].usage_credits is None
+    assert accounts[0].billing_kind == BillingKind.PREPAID_BALANCE
+
+
+def test_collect_via_cookie_rejected_session_does_not_scrape_html(monkeypatch):
+    from aiuse.collectors import muse as muse_mod
+
+    seen: list[str] = []
+
+    def fake_get(url, timeout, allow_redirects=True, headers=None):
+        seen.append(url)
+        return _json_response({"error": "Not authenticated"}, status_code=401, url=url)
+
+    monkeypatch.setattr(requests, "get", fake_get)
+    with pytest.raises(CollectorError, match="api/auth/login"):
+        muse_mod._collect_via_cookie("llm_sess=stale", {}, 5.0)
+    assert seen == ["https://dev.meta.ai/api/auth/me"]

{aiuse-3.2.4 → aiuse-3.2.6}/tests/test_report.py

@@ -1916,6 +1916,88 @@ def test_clock_matrix_omits_slash_when_clock_has_no_timestamp():
     assert "0u/100l" in tokens
 
 
+def test_clock_matrix_pads_percents_and_colors_only_the_left_token():
+    """A short ``4u/96l`` must not slide the next clock left of a ``79u/21l``.
+
+    Color wraps the whole left token (``21l``), not just the digits, and the
+    used side stays plain. Stripping ANSI leaves the plain table unchanged.
+    """
+    now = utcnow()
+
+    def window(label: str, used: float, left: float, *, window_minutes: int, **when: float) -> QuotaWindow:
+        return QuotaWindow(
+            label=label,
+            used_percent=used,
+            remaining_percent=left,
+            resets_at=now + timedelta(**when),
+            window_minutes=window_minutes,
+        )
+
+    snap = Snapshot(
+        collected_at=now,
+        accounts=[
+            AccountUsage(
+                provider="claude",
+                source="cswap",
+                account="me@gmail.com",
+                billing_kind=BillingKind.SUBSCRIPTION_WINDOW,
+                windows=[
+                    window("5-hour", 79.0, 21.0, window_minutes=300, hours=1, minutes=52),
+                    window("weekly", 56.0, 44.0, window_minutes=10080, days=5, hours=8),
+                ],
+            ),
+            AccountUsage(
+                provider="cursor",
+                source="codexbar",
+                account="me@gmail.com",
+                billing_kind=BillingKind.SUBSCRIPTION_WINDOW,
+                windows=[
+                    window("5-hour", 4.0, 96.0, window_minutes=300, minutes=36),
+                    window("weekly", 29.0, 71.0, window_minutes=10080, days=3, hours=2),
+                ],
+            ),
+        ],
+    )
+    plain = render_clock_matrix([], snapshot=snap, color=False, width=160)
+    colored = render_clock_matrix([], snapshot=snap, color=True, width=160)
+    assert _strip_ansi(colored) == plain
+
+    rows = {line.split()[2]: line for line in plain.splitlines() if line[:5].strip() in _BAND_TAGS}
+    claude = rows["claude"]
+    cursor = rows["cursor"]
+    assert claude.index("56u/44l") == cursor.index("29u/71l")
+    assert claude.index("79u/21l") == cursor.index("4u/96l") - 1
+    header = plain.splitlines()[0]
+    assert header.index("5H") + 1 == claude.index("79u/21l") + len("79u/21l") - 1
+    assert header.index("WEEK") + 3 == claude.index("56u/44l") + len("56u/44l") - 1
+
+    # First data row has no zebra stripe, so the reset is a plain ``[0m``.
+    # The next row's stripe rewrites that reset; the open code is what matters.
+    assert "79u/\033[33m21l\033[0m" in colored
+    assert "\033[32m96l" in colored
+    assert "\033[33m79u" not in colored
+    assert "\033[32m4u" not in colored
+
+
+def test_style_clock_percent_pads_and_keeps_fold_mark_in_the_left_token():
+    from aiuse.report import _ClockCell, _style_clock_percent
+
+    on = _Style(True)
+    short = _style_clock_percent(on, _ClockCell(used_percent=4.0), width=8)
+    assert _strip_ansi(short) == "  4u/96l"
+    assert short == "  4u/\033[32m96l\033[0m"
+
+    folded = _style_clock_percent(on, _ClockCell(used_percent=56.0, folded=2), width=8)
+    assert _strip_ansi(folded) == "56u/44l+"
+    assert folded == "56u/\033[36m44l+\033[0m"
+
+    inferred = _style_clock_percent(on, _ClockCell(used_percent=4.0, inferred=True), width=8)
+    assert inferred == on.dim("  4u/96l")
+
+    off = _Style(False)
+    assert _style_clock_percent(off, _ClockCell(used_percent=4.0), width=8) == "  4u/96l"
+
+
 @pytest.mark.parametrize(
     ("provider", "display"),
     [