cdx-manager 0.9.16 → 0.11.0

package/src/cli_helpers.py

@@ -57,17 +57,16 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
-def _update_notice_warning(ctx):
-    notices = ctx.get("update_notices") or []
-    if not notices:
-        return None
-    warnings = _update_notice_warnings(ctx)
-    return warnings[0] if warnings else None
-
-
 def _update_notice_warnings(ctx):
     warnings = []
     for notice in ctx.get("update_notices") or []:
+        if notice.get("code") == "disk_cleanup_available":
+            warnings.append({
+                "code": "disk_cleanup_available",
+                "message": notice["message"],
+                **{key: value for key, value in notice.items() if key not in ("code", "message")},
+            })
+            continue
         tool = notice.get("tool") or "cdx-manager"
         current = notice.get("current_version") or ctx.get("version")
         command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)
@@ -111,7 +110,7 @@ def _format_bytes(value):
         amount /= 1024
     if unit == "B":
         return f"{int(amount)} B"
-    return f"{amount:.1f} {unit}"
+    return f"{int(amount)} {unit}" if amount.is_integer() else f"{amount:.1f} {unit}"
 
 
 def _format_export_report(result):
@@ -150,39 +149,16 @@ def _make_export_progress(ctx):
     return progress
 
 
-def _make_status_progress(ctx):
-    progress_state = {"checked": 0, "total": 0}
-
-    def progress(event):
-        kind = event.get("event")
-        if kind == "status_started":
-            progress_state["checked"] = 0
-            progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
-            message = f"Resolving status for {event.get('session_count', 0)} session(s)..."
-            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
-        elif kind == "session_started":
-            provider = event.get("provider") or "session"
-            message = f"Checking {event.get('session_name')} ({provider})..."
-            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
-        elif kind == "session_finished" and not event.get("cache_hit"):
-            progress_state["checked"] += 1
-            total = progress_state["total"] or progress_state["checked"]
-            message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
-            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
-        elif kind == "status_finished":
-            message = f"Resolved {event.get('row_count', 0)} status row(s)."
-            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
-    return progress
-
-
-def _make_notify_progress(ctx):
+def _make_session_progress(ctx, start_event, start_message):
     progress_state = {"checked": 0, "total": 0}
 
     def progress(event):
         kind = event.get("event")
-        if kind == "notify_check_started":
-            target = event.get("session_name") or "next ready session"
-            ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
+        if kind == start_event:
+            if kind == "status_started":
+                progress_state["checked"] = 0
+                progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
+            ctx["out"](f"{_info(start_message(event), ctx['use_color'])}\n")
         elif kind == "status_started":
             progress_state["checked"] = 0
             progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
@@ -197,12 +173,31 @@ def _make_notify_progress(ctx):
             total = progress_state["total"] or progress_state["checked"]
             message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "status_finished":
+            message = f"Resolved {event.get('row_count', 0)} status row(s)."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
         elif kind == "notify_waiting":
             message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
     return progress
 
 
+def _make_status_progress(ctx):
+    return _make_session_progress(
+        ctx,
+        "status_started",
+        lambda event: f"Resolving status for {event.get('session_count', 0)} session(s)...",
+    )
+
+
+def _make_notify_progress(ctx):
+    return _make_session_progress(
+        ctx,
+        "notify_check_started",
+        lambda event: f"Checking notification target: {event.get('session_name') or 'next ready session'}...",
+    )
+
+
 def _latest_launch_transcript_path(session):
     paths = _list_launch_transcript_paths(session)
     if not paths:

package/src/cli_view.py

@@ -1,4 +1,4 @@
-from .cli_helpers import _json_success, _write_json
+from .cli_helpers import _json_failure, _json_success, _update_notice_warnings, _write_json
 from .cli_render import _warn
 from .errors import CdxError
 from .logics_view import (
@@ -13,31 +13,6 @@ from .update_check import check_logics_manager_for_update
 VIEW_USAGE = "Usage: cdx view [--json] [--lan] [--lan-rw] [--focus <ref>] [--read] [--port <port>] [--host <host>] [--refresh-interval <s>] [--tls] [--open] [--no-open]"
 
 
-def _update_notice_warnings(notices):
-    warnings = []
-    for notice in notices or []:
-        if not notice:
-            continue
-        tool = notice.get("tool") or "logics-manager"
-        current = notice.get("current_version")
-        command = notice.get("update_command")
-        message = f"Update available: {tool} {notice['latest_version']}"
-        if current:
-            message = f"{message} (current {current})"
-        if command:
-            message = f"{message}. Run: {command}"
-        warnings.append({
-            "code": f"{tool.replace('-', '_')}_update_available",
-            "message": message,
-            "tool": tool,
-            "latest_version": notice["latest_version"],
-            "current_version": current,
-            "update_command": command,
-            "url": notice.get("url"),
-        })
-    return warnings
-
-
 def _logics_manager_update_notice(ctx, env):
     checker = ctx["options"].get("checkLogicsManagerForUpdate") or check_logics_manager_for_update
     return checker(
@@ -86,9 +61,12 @@ def handle_view(rest, ctx):
     update_notice = _logics_manager_update_notice(ctx, env) if executable else None
     failure = None if executable else missing_logics_manager_failure()
     diagnostics = build_viewer_diagnostics(executable, cwd, update_notice=update_notice, failure=failure, extra_args=viewer_args)
-    warnings = _update_notice_warnings([update_notice])
+    warnings = _update_notice_warnings({"update_notices": [update_notice] if update_notice else []})
 
     if json_flag:
+        if failure:
+            _write_json(ctx, _json_failure("view", "viewer_unavailable", failure["message"], warnings=warnings, viewer=diagnostics))
+            return 1
         _write_json(ctx, _json_success("view", "Collected Logics viewer diagnostics", warnings=warnings, viewer=diagnostics))
         return 0
 

package/src/codex_usage.py

@@ -4,6 +4,7 @@ import os
 import queue
 import subprocess
 import threading
+import time
 from datetime import datetime, timezone
 
 from .status_source import _is_zero_credit_balance
@@ -17,7 +18,7 @@ CODEX_AUTH_LOCK_NAME = ".cdx-auth.lock"
 
 
 @contextlib.contextmanager
-def codex_auth_lock(auth_home, blocking=False):
+def codex_auth_lock(auth_home, blocking=False, timeout_seconds=None, retry_interval_seconds=0.05):
     """Serialize codex token refreshes per CODEX_HOME.
 
     Codex rotates its OAuth refresh_token on refresh and invalidates the old
@@ -36,13 +37,18 @@ def codex_auth_lock(auth_home, blocking=False):
     except OSError:
         yield True
         return
-    flags = fcntl.LOCK_EX if blocking else fcntl.LOCK_EX | fcntl.LOCK_NB
-    try:
-        fcntl.flock(handle, flags)
-    except OSError:
-        handle.close()
-        yield False
-        return
+    deadline = None if timeout_seconds is None else time.monotonic() + timeout_seconds
+    while True:
+        flags = fcntl.LOCK_EX if blocking and timeout_seconds is None else fcntl.LOCK_EX | fcntl.LOCK_NB
+        try:
+            fcntl.flock(handle, flags)
+            break
+        except OSError:
+            if not blocking or (deadline is not None and time.monotonic() >= deadline):
+                handle.close()
+                yield False
+                return
+            time.sleep(retry_interval_seconds)
     try:
         yield True
     finally:
@@ -65,6 +71,15 @@ def _format_reset_date(unix_seconds):
     return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
 
 
+def _format_timestamp(unix_seconds):
+    if unix_seconds is None:
+        return None
+    try:
+        return datetime.fromtimestamp(int(unix_seconds), tz=timezone.utc).astimezone().isoformat()
+    except (TypeError, ValueError, OSError):
+        return None
+
+
 def _remaining_from_used_percent(value):
     if value is None:
         return None
@@ -84,7 +99,7 @@ def _get_window(snapshot, duration_mins):
     return {}
 
 
-def normalize_codex_rate_limit_snapshot(snapshot):
+def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
     if not snapshot:
         return None
 
@@ -101,6 +116,23 @@ def normalize_codex_rate_limit_snapshot(snapshot):
 
     reset_5h_at = _format_reset_date(five_hour.get("resetsAt") or five_hour.get("resets_at"))
     reset_week_at = _format_reset_date(weekly.get("resetsAt") or weekly.get("resets_at"))
+    reset_credits = reset_credits or {}
+    available_count = reset_credits.get("availableCount", reset_credits.get("available_count"))
+    try:
+        available_count = max(0, int(available_count)) if available_count is not None else None
+    except (TypeError, ValueError):
+        available_count = None
+    credit_rows = []
+    for credit in reset_credits.get("credits") or []:
+        if not isinstance(credit, dict) or credit.get("status") not in (None, "available"):
+            continue
+        credit_rows.append({
+            "id": credit.get("id"),
+            "title": credit.get("title"),
+            "description": credit.get("description"),
+            "granted_at": _format_timestamp(credit.get("grantedAt", credit.get("granted_at"))),
+            "expires_at": _format_timestamp(credit.get("expiresAt", credit.get("expires_at"))),
+        })
 
     raw_status_text = json.dumps(snapshot, sort_keys=True)
     return {
@@ -111,6 +143,8 @@ def normalize_codex_rate_limit_snapshot(snapshot):
             weekly.get("usedPercent", weekly.get("used_percent"))
         ),
         "credits": credit_balance,
+        "reset_credits_available": available_count,
+        "reset_credits": credit_rows,
         "reset_5h_at": reset_5h_at,
         "reset_week_at": reset_week_at,
         "reset_at": reset_week_at or reset_5h_at,
@@ -166,6 +200,32 @@ def fetch_codex_rate_limit_diagnostic(session, timeout=5, popen_factory=None):
 
 
 def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_factory=None):
+    diagnostic = _request_codex_app_server(
+        auth_home,
+        "account/rateLimits/read",
+        None,
+        "rate_limits_read_failed",
+        timeout=timeout,
+        popen_factory=popen_factory,
+    )
+    if not diagnostic["ok"]:
+        return diagnostic
+    response = diagnostic["response"]
+    result = response.get("result") or {}
+    by_limit = result.get("rateLimitsByLimitId") or {}
+    snapshot = by_limit.get("codex") or result.get("rateLimits")
+    status = normalize_codex_rate_limit_snapshot(snapshot, result.get("rateLimitResetCredits"))
+    if not status:
+        return {
+            "ok": False,
+            "reason": "missing_rate_limits",
+            "status": None,
+            "response": response,
+        }
+    return {"ok": True, "reason": None, "status": status, "response": response}
+
+
+def _request_codex_app_server(auth_home, method, params, failure_reason, timeout=5, popen_factory=None):
     env = os.environ.copy()
     env["CODEX_HOME"] = auth_home
     popen_factory = popen_factory or subprocess.Popen
@@ -204,29 +264,18 @@ def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_fact
         _write_json_line(process, {
             "jsonrpc": "2.0",
             "id": 2,
-            "method": "account/rateLimits/read",
-            "params": None,
+            "method": method,
+            "params": params,
         })
         response = _read_response(output, 2, timeout)
         if not response or response.get("error"):
             return {
                 "ok": False,
-                "reason": "rate_limits_read_failed",
-                "status": None,
-                "response": response,
-            }
-        result = response.get("result") or {}
-        by_limit = result.get("rateLimitsByLimitId") or {}
-        snapshot = by_limit.get("codex") or result.get("rateLimits")
-        status = normalize_codex_rate_limit_snapshot(snapshot)
-        if not status:
-            return {
-                "ok": False,
-                "reason": "missing_rate_limits",
+                "reason": failure_reason,
                 "status": None,
                 "response": response,
             }
-        return {"ok": True, "reason": None, "status": status, "response": response}
+        return {"ok": True, "reason": None, "status": None, "response": response}
     except FileNotFoundError as error:
         return {"ok": False, "reason": "codex_cli_not_found", "status": None, "error": str(error)}
     except (OSError, ValueError, BrokenPipeError) as error:
@@ -250,3 +299,25 @@ def fetch_codex_rate_limits(session, timeout=5, popen_factory=None):
         popen_factory=popen_factory,
     )
     return diagnostic.get("status") if diagnostic.get("ok") else None
+
+
+def consume_codex_rate_limit_reset_credit(session, idempotency_key, credit_id=None, timeout=5, popen_factory=None):
+    auth_home = session.get("authHome")
+    if not auth_home:
+        return {"ok": False, "reason": "missing_auth_home", "outcome": None}
+    with codex_auth_lock(auth_home) as acquired:
+        if not acquired:
+            return {"ok": False, "reason": "auth_locked", "outcome": None}
+        params = {"idempotencyKey": idempotency_key}
+        if credit_id:
+            params["creditId"] = credit_id
+        diagnostic = _request_codex_app_server(
+            auth_home,
+            "account/rateLimitResetCredit/consume",
+            params,
+            "reset_consume_failed",
+            timeout=timeout,
+            popen_factory=popen_factory,
+        )
+        result = (diagnostic.get("response") or {}).get("result") or {}
+        return {**diagnostic, "outcome": result.get("outcome")}

package/src/notify.py

@@ -1,6 +1,7 @@
 import json
 import os
 import shlex
+import shutil
 import subprocess
 import time
 from datetime import datetime, timedelta
@@ -165,14 +166,14 @@ def send_desktop_notification(title, message, spawn_sync=None, env=None):
     env = env or os.environ
     if sys.platform == "win32":
         _send_windows_notification(title, message, spawn_sync, env)
-    elif shutil_which("osascript", env):
+    elif shutil.which("osascript", path=env.get("PATH")):
         script = f'display notification "{_escape_applescript(message)}" with title "{_escape_applescript(title)}"'
         _run_notification_command(
             ["osascript", "-e", script],
             spawn_sync,
             env,
         )
-    elif shutil_which("notify-send", env):
+    elif shutil.which("notify-send", path=env.get("PATH")):
         _run_notification_command(
             ["notify-send", str(title), str(message)],
             spawn_sync,
@@ -209,11 +210,6 @@ def _escape_powershell(value):
     return str(value).replace("'", "''")
 
 
-def shutil_which(command, env):
-    import shutil
-    return shutil.which(command, path=env.get("PATH"))
-
-
 def _escape_applescript(value):
     return str(value).replace("\\", "\\\\").replace('"', '\\"')
 
@@ -247,7 +243,7 @@ def schedule_notification_event(base_dir, parsed, event, spawn_sync=None, env=No
 
 
 def _scheduled_notify_argv(parsed, env):
-    executable = env.get("CDX_BIN") or shutil_which("cdx", env) or "cdx"
+    executable = env.get("CDX_BIN") or shutil.which("cdx", path=env.get("PATH")) or "cdx"
     argv = [executable, "notify"]
     if parsed["mode"] == "at-reset":
         argv.append(parsed["name"])
@@ -331,7 +327,7 @@ def _launchd_plist(label, script_path, target):
 def _schedule_linux(parsed, event, argv, spawn_sync, env):
     unit = _schedule_id("cdx-manager-notify", parsed, event)
     target = _round_up_to_next_minute(datetime.fromtimestamp(event["target_timestamp"]).astimezone())
-    if shutil_which("systemd-run", env):
+    if shutil.which("systemd-run", path=env.get("PATH")):
         calendar = target.strftime("%Y-%m-%d %H:%M:%S")
         result = _run_scheduler_command(
             ["systemd-run", "--user", f"--unit={unit}", f"--on-calendar={calendar}", *argv],
@@ -343,7 +339,7 @@ def _schedule_linux(parsed, event, argv, spawn_sync, env):
         if _scheduler_error_means_exists(result["error"]):
             return {"scheduled": True, "existing": True, "backend": "systemd", "id": unit}
         raise CdxError(f"Failed to schedule notification with systemd-run: {result['error']}")
-    if shutil_which("at", env):
+    if shutil.which("at", path=env.get("PATH")):
         at_time = target.strftime("%Y%m%d%H%M.%S")
         command = " ".join(shlex.quote(str(part)) for part in argv)
         result = _run_scheduler_command(["at", "-t", at_time], spawn_sync, env, input_text=f"{command}\n")

package/src/provider_runtime.py

@@ -16,6 +16,11 @@ from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVI
 from .errors import CdxError
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
+AUTH_PROBE_TIMEOUT_SECONDS = 15
+CODEX_INTERACTIVE_AUTH_LOCK_TIMEOUT_SECONDS = 10
+AUTH_PROBE_AUTHENTICATED = "authenticated"
+AUTH_PROBE_LOGGED_OUT = "logged_out"
+AUTH_PROBE_DEGRADED = "degraded"
 REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 RTK_PROMPT = (
     "When running noisy shell commands, prefer RTK wrappers (`rtk <command>`) if `rtk` is available. "
@@ -173,12 +178,15 @@ def codex_auth_diagnostic(session, spawn_sync=None, env_override=None):
         "live_error": None,
     }
     try:
-        result["live_status"] = "authenticated" if _probe_provider_auth(
+        status = _probe_provider_auth_status(
             session,
             spawn_sync=spawn_sync,
             env_override=env_override,
             trust_local_credentials=False,
-        ) else "logged_out"
+        )
+        result["live_status"] = status
+        if status == AUTH_PROBE_DEGRADED:
+            result["live_error"] = _auth_probe_degraded_message(session)
     except CdxError as error:
         result["live_status"] = "error"
         result["live_error"] = str(error)
@@ -899,14 +907,21 @@ def _resolve_command(command, env=None):
     return shutil.which(command, path=env.get("PATH")) or command
 
 
-def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_local_credentials=True):
+def _auth_probe_degraded_message(session):
+    return (
+        f"Auth probe timed out after {AUTH_PROBE_TIMEOUT_SECONDS}s for session {session.get('name') or 'unknown'}; "
+        "authentication status is degraded."
+    )
+
+
+def _probe_provider_auth_status(session, spawn_sync=None, env_override=None, trust_local_credentials=True):
     spawn_sync = spawn_sync or subprocess.run
     spec = _build_login_status_spec(session, env_override)
     if trust_local_credentials:
         if session.get("provider") == PROVIDER_CLAUDE and _has_local_claude_auth(_get_auth_home(session)):
-            return True
+            return AUTH_PROBE_AUTHENTICATED
         if session.get("provider") == PROVIDER_CODEX and _has_local_codex_auth(_get_auth_home(session)):
-            return True
+            return AUTH_PROBE_AUTHENTICATED
     try:
         if spawn_sync is subprocess.run:
             command = _resolve_command(spec["command"], spec["env"])
@@ -914,19 +929,33 @@ def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_loca
                 [command] + spec["args"],
                 env=spec["env"],
                 capture_output=True, text=True,
+                timeout=AUTH_PROBE_TIMEOUT_SECONDS,
             )
             output = (result.stdout or "") + (result.stderr or "")
         else:
             result = spawn_sync(spec["command"], spec["args"], spec)
             error = result.get("error") if isinstance(result, dict) else getattr(result, "error", None)
             if error:
+                if isinstance(error, subprocess.TimeoutExpired):
+                    raise error
                 raise _format_probe_failure(session, spec, error)
             stdout = result.get("stdout") if isinstance(result, dict) else getattr(result, "stdout", "")
             stderr = result.get("stderr") if isinstance(result, dict) else getattr(result, "stderr", "")
             output = (stdout or "") + (stderr or "")
+    except subprocess.TimeoutExpired:
+        return AUTH_PROBE_DEGRADED
     except OSError as error:
         raise _format_probe_failure(session, spec, error) from error
-    return spec["parser"](output)
+    return AUTH_PROBE_AUTHENTICATED if spec["parser"](output) else AUTH_PROBE_LOGGED_OUT
+
+
+def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_local_credentials=True):
+    return _probe_provider_auth_status(
+        session,
+        spawn_sync=spawn_sync,
+        env_override=env_override,
+        trust_local_credentials=trust_local_credentials,
+    ) == AUTH_PROBE_AUTHENTICATED
 
 
 def _signal_exit_code(sig):
@@ -953,10 +982,15 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                   lifecycle_callback=lifecycle_callback)
     if session.get("provider") != PROVIDER_CODEX:
         return _run_interactive_provider_command_impl(session, action, **kwargs)
-    # Hold the per-CODEX_HOME lock for the whole session so a concurrent status
-    # probe backs off instead of rotating the refresh_token mid-run (which logs
-    # the session out). ponytail: non-blocking, so launch never waits on a probe.
-    with codex_auth_lock(_get_auth_home(session)):
+    # Hold the per-CODEX_HOME lock for the whole session so concurrent Codex
+    # processes cannot rotate the refresh_token under each other.
+    with codex_auth_lock(
+        _get_auth_home(session),
+        blocking=True,
+        timeout_seconds=CODEX_INTERACTIVE_AUTH_LOCK_TIMEOUT_SECONDS,
+    ) as acquired:
+        if not acquired:
+            raise CdxError(f"Timed out waiting for Codex auth lock for session {session['name']}.")
         return _run_interactive_provider_command_impl(session, action, **kwargs)
 
 
@@ -1114,16 +1148,26 @@ def _ensure_session_authentication(session, service, spawn=None, spawn_sync=None
         raise CdxError(
             f"Session {session['name']} is not authenticated. Run: cdx login {session['name']}"
         )
-    is_authenticated = _probe_provider_auth(
+    auth_status = _probe_provider_auth_status(
         session,
         spawn_sync=spawn_sync,
         env_override=env_override,
         trust_local_credentials=trust_local_credentials,
     )
-    if is_authenticated:
-        return {"authenticated": True, "checked": True}
+    if auth_status == AUTH_PROBE_AUTHENTICATED:
+        return {"authenticated": True, "checked": True, "status": auth_status}
+    if auth_status == AUTH_PROBE_DEGRADED:
+        result = {
+            "authenticated": False,
+            "checked": True,
+            "status": auth_status,
+            "error": _auth_probe_degraded_message(session),
+        }
+        if behavior == "probe-only":
+            return result
+        raise CdxError(f"{result['error']} Retry, or run: cdx login {session['name']}")
     if behavior == "probe-only":
-        return {"authenticated": False, "checked": True}
+        return {"authenticated": False, "checked": True, "status": auth_status}
     if behavior == "launch":
         raise CdxError(
             f"Session {session['name']} is not authenticated. Run: cdx login {session['name']}"