cdx-manager 0.9.8 → 0.9.10

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.9.8-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.9.10-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 

package/changelogs/CHANGELOGS_0_9_10.md

@@ -0,0 +1,33 @@
+# CDX Manager 0.9.10
+
+## Highlights
+
+- Clarified Claude status warnings when quota refresh fails but local Claude auth is still valid.
+
+## Changes
+
+### Claude status diagnostics
+
+`cdx status` now distinguishes a Claude quota refresh failure from a local Claude login failure.
+
+When Anthropic quota probing returns an invalid-credentials response while `claude auth status` still reports an authenticated session, the JSON warning keeps the existing `claude_refresh_failed` code for compatibility and adds:
+
+- `auth_status: authenticated`
+- `status_freshness: stale`
+- a message explaining that cached quota values may be stale
+
+The text-mode warning now says that local auth is still valid instead of implying that the Claude account itself is down.
+
+Regression coverage verifies both the JSON payload and terminal warning for this mixed auth/quota-refresh state.
+
+## Validation
+
+- `npm run release:validate`
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/changelogs/CHANGELOGS_0_9_9.md

@@ -0,0 +1,36 @@
+# CDX Manager 0.9.9
+
+## Highlights
+
+- Fixed Codex session logouts caused by concurrent OAuth token refresh races.
+- Refreshed the local Logics assistant bridge and canonical workflow instructions.
+
+## Changes
+
+### Codex token refresh stability
+
+Codex session startup now serializes OAuth token refresh work per source session and reuses a freshly refreshed source token when multiple sessions start at the same time.
+
+This prevents parallel launches from copying stale credentials into isolated Codex profiles while another launch is already rotating the shared token.
+
+### Runtime observability
+
+The provider runtime now recognizes Codex refresh-rate errors as refresh failures, making status and failure reporting more precise when token refresh is blocked or rate-limited.
+
+Regression coverage exercises concurrent Codex launches and verifies that all isolated profiles receive the refreshed token.
+
+### Logics workflow instructions
+
+The local `LOGICS.md` bridge and `logics/instructions.md` were refreshed to keep release and workflow operations aligned with the current `logics-manager` commands.
+
+## Validation
+
+- `npm run release:validate`
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -100,6 +100,10 @@
     "v0.9.8": {
       "github_tarball_sha256": "8f05d052b7890d74de7ac510c20376430515ad2616e139941cb9bb8edc4fb680",
       "github_zip_sha256": "3bc3834ecf84784c77cf603fcd4f6f439e42005612f82fabab588886519179eb"
+    },
+    "v0.9.9": {
+      "github_tarball_sha256": "092c564803dd9a674250040ac308055de3701aa993237f257676403c24eb1318",
+      "github_zip_sha256": "0fbd8de7a97cde5aef14f23036def2e34dd690c2aa78ef93ddfeef0bb3e9547b"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.9.8"
+version = "0.9.10"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -66,7 +66,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.9.8"
+VERSION = "0.9.10"
 
 
 _COMMAND_HANDLERS = {

package/src/cli_commands.py

@@ -2533,16 +2533,6 @@ def handle_status(rest, ctx):
         }
         for item in refresh_result.get("errors", [])
     ]
-    warnings.extend([
-        {
-            "code": "claude_refresh_failed",
-            "session": item.get("session") or "unknown",
-            "message": item.get("error") or "unknown error",
-        }
-        for item in refresh_errors
-    ])
-    warnings.extend(_update_notice_warnings(ctx))
-
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     if len(args) == 1:
         row = ctx["service"]["get_status_row"](
@@ -2552,11 +2542,16 @@ def handle_status(rest, ctx):
             cache_only=parsed["cached"],
             status_timeout_seconds=parsed["timeout"],
         )
+        output_warnings = [
+            *warnings,
+            *_refresh_warning_payloads(refresh_errors, [row]),
+            *_update_notice_warnings(ctx),
+        ]
         if parsed["json"]:
-            _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=warnings, session=row))
+            _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=output_warnings, session=row))
             return 0
         ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
-        _write_refresh_warnings(refresh_errors, ctx)
+        _write_refresh_warnings(refresh_errors, ctx, rows=[row])
         _write_update_notice(ctx)
         return 0
 
@@ -2566,11 +2561,16 @@ def handle_status(rest, ctx):
         cache_only=parsed["cached"],
         status_timeout_seconds=parsed["timeout"],
     )
+    output_warnings = [
+        *warnings,
+        *_refresh_warning_payloads(refresh_errors, rows),
+        *_update_notice_warnings(ctx),
+    ]
     if parsed["json"]:
-        _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
+        _write_json(ctx, _json_success("status", "Collected session status rows", warnings=output_warnings, rows=rows))
         return 0
     ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
-    _write_refresh_warnings(refresh_errors, ctx)
+    _write_refresh_warnings(refresh_errors, ctx, rows=rows)
     _write_update_notice(ctx)
     return 0
 
@@ -2607,12 +2607,65 @@ def _refresh_claude_auth_states(service, target_names=None, spawn_sync=None, env
     return {"updated": updated, "errors": errors}
 
 
-def _write_refresh_warnings(refresh_errors, ctx, stream="out"):
-    write = ctx["err"] if stream == "err" and "err" in ctx else ctx["out"]
+def _rows_by_session(rows):
+    return {
+        row.get("session_name"): row
+        for row in (rows or [])
+        if row.get("session_name")
+    }
+
+
+def _is_invalid_claude_usage_auth(error):
+    text = str(error or "").lower()
+    return "http 401" in text and "invalid authentication credentials" in text
+
+
+def _has_valid_local_claude_auth(item, rows_by_name):
+    session = item.get("session")
+    row = rows_by_name.get(session)
+    return bool(row and row.get("provider") == PROVIDER_CLAUDE and row.get("auth_status") == "authenticated")
+
+
+def _refresh_warning_payloads(refresh_errors, rows=None):
+    rows_by_name = _rows_by_session(rows)
+    warnings = []
     for item in refresh_errors:
         session = item.get("session") or "unknown"
         error = item.get("error") or "unknown error"
-        write(f"{_warn(f'Warning: Claude refresh failed for {session}: {error}', ctx['use_color'])}\n")
+        warning = {
+            "code": "claude_refresh_failed",
+            "session": session,
+            "message": error,
+        }
+        if _is_invalid_claude_usage_auth(error) and _has_valid_local_claude_auth(item, rows_by_name):
+            warning.update({
+                "auth_status": "authenticated",
+                "status_freshness": "stale",
+                "message": (
+                    "Claude quota refresh failed, but local Claude auth is still valid; "
+                    f"cached quota may be stale. Original error: {error}"
+                ),
+            })
+        warnings.append(warning)
+    return warnings
+
+
+def _format_refresh_warning(item, rows_by_name):
+    session = item.get("session") or "unknown"
+    error = item.get("error") or "unknown error"
+    if _is_invalid_claude_usage_auth(error) and _has_valid_local_claude_auth(item, rows_by_name):
+        return (
+            f"Warning: Claude quota refresh failed for {session}, but local auth is still valid; "
+            f"cached quota may be stale. ({error})"
+        )
+    return f"Warning: Claude refresh failed for {session}: {error}"
+
+
+def _write_refresh_warnings(refresh_errors, ctx, stream="out", rows=None):
+    write = ctx["err"] if stream == "err" and "err" in ctx else ctx["out"]
+    rows_by_name = _rows_by_session(rows)
+    for item in refresh_errors:
+        write(f"{_warn(_format_refresh_warning(item, rows_by_name), ctx['use_color'])}\n")
 
 
 def handle_export(rest, ctx):

package/src/codex_usage.py

@@ -1,3 +1,4 @@
+import contextlib
 import json
 import os
 import queue
@@ -5,6 +6,49 @@ import subprocess
 import threading
 from datetime import datetime, timezone
 
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - non-POSIX platforms
+    fcntl = None
+
+CODEX_AUTH_LOCK_NAME = ".cdx-auth.lock"
+
+
+@contextlib.contextmanager
+def codex_auth_lock(auth_home, blocking=False):
+    """Serialize codex token refreshes per CODEX_HOME.
+
+    Codex rotates its OAuth refresh_token on refresh and invalidates the old
+    one. If a status probe and an interactive session refresh the same
+    auth.json concurrently, one rotates the token from under the other and that
+    session gets logged out. This flock makes them take turns. Yields True when
+    the lock is held, False when a non-blocking acquire found it already taken.
+    ponytail: POSIX flock only; on Windows (no fcntl) this is a no-op.
+    """
+    if not auth_home or fcntl is None:
+        yield True
+        return
+    try:
+        os.makedirs(auth_home, exist_ok=True)
+        handle = open(os.path.join(auth_home, CODEX_AUTH_LOCK_NAME), "w")
+    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
+    try:
+        yield True
+    finally:
+        try:
+            fcntl.flock(handle, fcntl.LOCK_UN)
+        finally:
+            handle.close()
+
 MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 
@@ -110,7 +154,16 @@ def fetch_codex_rate_limit_diagnostic(session, timeout=5, popen_factory=None):
     auth_home = session.get("authHome")
     if not auth_home:
         return {"ok": False, "reason": "missing_auth_home", "status": None}
+    # Back off to cached status rather than racing an interactive session's
+    # token refresh (which would log it out). The launcher holds this lock for
+    # the whole session, so a busy account simply skips the live probe.
+    with codex_auth_lock(auth_home) as acquired:
+        if not acquired:
+            return {"ok": False, "reason": "auth_locked", "status": None}
+        return _probe_codex_rate_limit_diagnostic(session, auth_home, timeout, popen_factory)
+
 
+def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_factory=None):
     env = os.environ.copy()
     env["CODEX_HOME"] = auth_home
     popen_factory = popen_factory or subprocess.Popen

package/src/provider_runtime.py

@@ -10,6 +10,7 @@ import uuid
 import base64
 from datetime import datetime, timezone
 
+from .codex_usage import codex_auth_lock
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .errors import CdxError
 
@@ -929,6 +930,21 @@ def _signal_name(sig):
 def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                                       env_override=None, signal_emitter=None,
                                       initial_prompt=None, lifecycle_callback=None):
+    kwargs = dict(spawn=spawn, cwd=cwd, env_override=env_override,
+                  signal_emitter=signal_emitter, initial_prompt=initial_prompt,
+                  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)):
+        return _run_interactive_provider_command_impl(session, action, **kwargs)
+
+
+def _run_interactive_provider_command_impl(session, action, spawn=None, cwd=None,
+                                           env_override=None, signal_emitter=None,
+                                           initial_prompt=None, lifecycle_callback=None):
     spawn = spawn or subprocess.Popen
     if action == "launch":
         spec = _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)

package/src/session_service.py

@@ -68,6 +68,9 @@ RESERVED_SESSION_NAMES = {
 }
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+# Each live Codex probe spawns app-server, which can refresh+rotate the OAuth
+# token. Cache longer so routine status calls don't keep triggering refreshes.
+CODEX_STATUS_CACHE_TTL_SECONDS = 5 * 60
 STATUS_PROBE_TIMEOUT_SECONDS = 5
 MAX_STATUS_WORKERS = 8
 LAUNCH_POWER_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
@@ -275,8 +278,11 @@ def _parse_status_timestamp(value):
 
 
 def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
-    if session.get("provider") == PROVIDER_CLAUDE and ttl_seconds == STATUS_CACHE_TTL_SECONDS:
-        return CLAUDE_STATUS_CACHE_TTL_SECONDS
+    if ttl_seconds == STATUS_CACHE_TTL_SECONDS:
+        if session.get("provider") == PROVIDER_CLAUDE:
+            return CLAUDE_STATUS_CACHE_TTL_SECONDS
+        if session.get("provider") == PROVIDER_CODEX:
+            return CODEX_STATUS_CACHE_TTL_SECONDS
     return ttl_seconds