cdx-manager 0.9.8 → 0.9.9

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.9-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_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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "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.9"
 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.9"
 
 
 _COMMAND_HANDLERS = {

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