cctally 1.77.0 → 1.78.0

package/bin/_cctally_statusline.py

@@ -275,13 +275,22 @@ def cmd_statusline(args: argparse.Namespace) -> int:
     # side effect that runs AFTER the line is printed and is FULLY guarded:
     # persistence must NEVER break or slow rendering, so the whole call is
     # wrapped here (the feeder itself forks detached + swallows its own
-    # errors, but this is belt-and-suspenders). Absence of rate_limits, a
-    # lost persist lock, or the throttle window all degrade to a clean
-    # no-op; the OAuth backfill covers the "no statusline feeding" case.
+    # errors, but this is belt-and-suspenders). Absence of rate_limits or a
+    # lost persist lock degrades to a clean no-op; the authoritative OAuth
+    # confirmation below covers the missing/stale-payload case.
     try:
         _statusline_persist(inp)
     except Exception:
         pass
+    # Claude Code may replay an unchanged rate_limits object across timer
+    # renders even after the provider counters have advanced. Confirm against
+    # the authoritative OAuth surface once per account-wide timer cycle. The
+    # helper is fully detached, shares hook-tick's throttle lock/marker, and
+    # honors the existing selected-freshness and 429-backoff gates.
+    try:
+        c._statusline_oauth_tick()
+    except Exception:
+        pass
     return 0
 
 
@@ -1229,6 +1238,122 @@ def _statusline_persist(parsed, *, sync_for_test: bool = False) -> None:
         c._release_persist_lock(lock_fd)
 
 
+def _try_acquire_statusline_oauth_lock() -> "int | None":
+    """Take hook-tick's account-wide OAuth throttle lock without blocking."""
+    try:
+        _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
+        fd = os.open(
+            _cctally_core.HOOK_TICK_THROTTLE_LOCK_PATH,
+            os.O_WRONLY | os.O_CREAT,
+            0o644,
+        )
+    except OSError:
+        return None
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+        return None
+    return fd
+
+
+def _release_statusline_oauth_lock(fd: int) -> None:
+    try:
+        fcntl.flock(fd, fcntl.LOCK_UN)
+    except OSError:
+        pass
+    try:
+        os.close(fd)
+    except OSError:
+        pass
+
+
+def _run_statusline_oauth_refresh() -> None:
+    """Run one already-throttled automatic OAuth confirmation."""
+    c = _cctally()
+    status, _ = c._hook_tick_oauth_refresh(
+        throttle_seconds=float(_cctally_core.STATUSLINE_OAUTH_POLL_SECONDS)
+    )
+    if status.startswith("ok("):
+        c._hook_tick_throttle_touch()
+
+
+def _fork_statusline_oauth_refresh(lock_fd: int) -> bool:
+    """Detach one OAuth confirmation while keeping ``lock_fd`` in the child."""
+    try:
+        pid = os.fork()
+    except OSError:
+        return False
+    if pid > 0:
+        # Do not explicitly unlock: the child inherited the same open file
+        # description and owns the account-wide lock until its refresh ends.
+        try:
+            os.close(lock_fd)
+        except OSError:
+            pass
+        return True
+
+    try:
+        try:
+            os.setsid()
+        except OSError:
+            pass
+        try:
+            devnull = os.open(os.devnull, os.O_RDWR)
+            os.dup2(devnull, 0)
+            os.dup2(devnull, 1)
+            os.dup2(devnull, 2)
+            if devnull > 2:
+                os.close(devnull)
+        except OSError:
+            pass
+        _run_statusline_oauth_refresh()
+    except BaseException:
+        pass
+    finally:
+        _release_statusline_oauth_lock(lock_fd)
+        os._exit(0)
+
+
+def _statusline_oauth_tick(*, sync_for_test: bool = False) -> None:
+    """Schedule one bounded authoritative refresh from a statusline timer.
+
+    Fast prechecks avoid forks while selected data is fresh, a shared 429
+    deadline is active, or another session/hook owns the account-wide poll.
+    Every condition is rechecked under hook-tick's throttle lock before the
+    detached child starts.
+    """
+    c = _cctally()
+    interval = float(_cctally_core.STATUSLINE_OAUTH_POLL_SECONDS)
+    if c._statusline_observe_age_seconds() < interval:
+        return
+    if c._oauth_backoff_remaining_seconds() > 0:
+        return
+    if c._hook_tick_throttle_age_seconds() < interval:
+        return
+    lock_fd = _try_acquire_statusline_oauth_lock()
+    if lock_fd is None:
+        return
+    try:
+        if c._statusline_observe_age_seconds() < interval:
+            return
+        if c._oauth_backoff_remaining_seconds() > 0:
+            return
+        if c._hook_tick_throttle_age_seconds() < interval:
+            return
+        if sync_for_test:
+            _run_statusline_oauth_refresh()
+            return
+        if _fork_statusline_oauth_refresh(lock_fd):
+            lock_fd = -1
+    finally:
+        if lock_fd >= 0:
+            _release_statusline_oauth_lock(lock_fd)
+
+
 def _resolve_context_window(model_id, warn_once) -> "int | None":
     """Look up ``model_id`` in ``CLAUDE_MODEL_CONTEXT_WINDOWS``; fall back
     to a family-substring match against

package/bin/_lib_dashboard_json.py

@@ -0,0 +1,43 @@
+"""Strict outbound JSON contract shared by dashboard HTTP/SSE and Doctor.
+
+Python's ``json.dumps`` defaults to emitting JavaScript-only ``NaN`` and
+``Infinity`` tokens. Browsers reject those tokens in ``JSON.parse`` and
+``Response.json``. Normalize supported JSON containers recursively, then keep
+``allow_nan=False`` as the final fail-loud guard. Unsupported objects and
+non-finite mapping keys are deliberately not coerced.
+"""
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def normalize_dashboard_json(value: Any) -> Any:
+    """Return a non-mutating JSON value with non-finite floats mapped to null."""
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    if isinstance(value, dict):
+        return {
+            key: normalize_dashboard_json(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [normalize_dashboard_json(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(normalize_dashboard_json(item) for item in value)
+    return value
+
+
+def encode_dashboard_json(value: Any, **kwargs: Any) -> str:
+    """Serialize one outbound payload with browser-strict JSON semantics."""
+    return json.dumps(
+        normalize_dashboard_json(value),
+        allow_nan=False,
+        **kwargs,
+    )
+
+
+def encode_dashboard_json_bytes(value: Any, **kwargs: Any) -> bytes:
+    """UTF-8 bytes companion for HTTP response bodies."""
+    return encode_dashboard_json(value, **kwargs).encode("utf-8")

package/bin/_lib_source_analytics.py

@@ -83,9 +83,26 @@ def assign_collision_safe_project_labels(
     selection the exact string that terminal, JSON, and share emit.
     """
     values = tuple(entries)
+    assigned = collision_safe_project_label_map(
+        (entry.project_key, entry.project_label) for entry in values
+    )
+    return tuple(
+        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
+        for entry in values
+    )
+
+
+def collision_safe_project_label_map(
+    identities_and_labels: Iterable[tuple[str, str]],
+) -> dict[str, str]:
+    """Allocate the shared deterministic privacy-safe label contract.
+
+    Callers supply opaque internal identities. Only the returned labels are
+    presentation data; the identity keys must remain inside the adapter.
+    """
     keys_by_label: dict[str, set[str]] = defaultdict(set)
-    for entry in values:
-        keys_by_label[entry.project_label].add(entry.project_key)
+    for identity, label in identities_and_labels:
+        keys_by_label[label].add(identity)
     # Never let an allocator-owned ``label (N)`` shadow a literal project
     # label.  Reserving every raw label also makes a later presentation pass
     # unnecessary, which avoids producing ``label (N) (N)``.
@@ -107,10 +124,7 @@ def assign_collision_safe_project_labels(
             assigned[key] = candidate
             used_labels.add(candidate)
             ordinal += 1
-    return tuple(
-        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
-        for entry in values
-    )
+    return assigned
 
 
 def opaque_project_key(source: str, root_key: str, resolved_key: str) -> str:

package/bin/cctally

@@ -558,6 +558,10 @@ _lib_log = _load_sibling("_lib_log")
 _lib_json_envelope = _load_sibling("_lib_json_envelope")
 stamp_schema_version = _lib_json_envelope.stamp_schema_version
 
+# Strict outbound dashboard/Doctor JSON: recursive non-finite normalization
+# followed by allow_nan=False serialization.
+_lib_dashboard_json = _load_sibling("_lib_dashboard_json")
+
 _lib_changelog = _load_sibling("_lib_changelog")
 # Backward-compat re-export: callers and tests reach the helper through
 # ``cctally._release_read_latest_release_version`` (incl. monkeypatch
@@ -1336,6 +1340,7 @@ _build_statusline_injections = _cctally_statusline._build_statusline_injections
 # `cctally._statusline_persist` (test surface) + the `_cctally()` accessor
 # resolve them.
 _statusline_persist = _cctally_statusline._statusline_persist
+_statusline_oauth_tick = _cctally_statusline._statusline_oauth_tick
 _fork_persist = _cctally_statusline._fork_persist
 _record_args = _cctally_statusline._record_args
 _try_acquire_persist_lock = _cctally_statusline._try_acquire_persist_lock