cdx-manager 0.19.1 → 0.19.3

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.19.1-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.19.3-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Stop guessing which AI account still has quota.** `cdx` tracks the rate-limit window of every Codex and Claude account you own, tells you which one is usable right now, and launches it with isolated auth — in one command.
 
@@ -112,7 +112,7 @@ The reason `cdx` exists: knowing, across every account you own, which one you ca
 ### Maintenance
 
 - **Launch history.** Inspect recent launches with provider, result, duration, working directory, launch settings, and transcript path.
-- **Aggregate usage.** `cdx stats` totals runs, token usage, and time spent per session over any period.
+- **Aggregate usage.** `cdx stats` totals runs, token usage, and time spent per session over any period. Interactive Codex and Claude launches also record provider-native token totals when their local session transcript is available.
 
 - **Disk usage and cleanup.** `cdx disk` reports `CDX_HOME` usage, `cdx disk profiles --candidates` identifies reclaimable profile caches/logs with evidence, and `cdx clean profiles ...` applies explicit cleanup actions.
 - **Health and repair.** `cdx doctor` inspects dependencies, permissions, and orphan profiles; `cdx repair` plans or applies safe fixes.
@@ -708,7 +708,7 @@ cdx run \
 
 The result includes `launcher: "cdx"`, `run_id`, selected `session`, `provider`, `exit_code`, `duration_seconds`, absolute `transcript_path`, `stdout_path`, `stderr_path`, and normalized usage token fields. Codex headless runs use `codex exec --json`; Claude headless runs use `claude --print --output-format json`. Token counts are `null` when the provider does not expose a supported JSON or JSONL usage shape.
 
-Known headless token usage is persisted in launch history and can be aggregated later:
+Known headless and completed interactive token usage is persisted in launch history and can be aggregated later. Interactive records are best-effort local data: Codex reads its latest cumulative rollout snapshot and Claude reads its assistant usage records. Cached input is retained separately from the provider's total, so it is never counted twice.
 
 ```bash
 cdx stats --since 7d --json

package/VERSION

@@ -1 +1 @@
-0.19.1
+0.19.3

package/changelogs/CHANGELOGS_0_19_2.md

@@ -0,0 +1,11 @@
+# CDX Manager 0.19.2
+
+## Features
+
+- Record Codex and Claude interactive CLI token usage, including cached input tokens, in existing run history and status statistics.
+
+## Fixes
+
+- Make detached-run registry persistence durable and lock acquisition bounded on POSIX and Windows.
+- Bound interactive transcript discovery and parsing while preserving fail-open behavior.
+- Verify tray tests, macOS CI coverage, and installable npm/wheel package artifacts before release.

package/changelogs/CHANGELOGS_0_19_3.md

@@ -0,0 +1,6 @@
+# CDX Manager 0.19.3
+
+## Fixes
+
+- Make release-validation tests portable across Windows, macOS, and Linux.
+- Includes all reliability, interactive token-usage, CI, and package-verification changes prepared for 0.19.2.

package/checksums/release-archives.json

@@ -283,6 +283,21 @@
     "v0.19.0": {
       "github_tarball_sha256": "d9816c0e4a2313bc10d8d9b527795b3027798607af49c5ef820f491d167176b4",
       "github_zip_sha256": "656090f68694695fd947b0e73fc8c1ef66785054fd04054f8659b03997daedfb"
+    },
+    "v0.19.1": {
+      "github_tarball_sha256": "351b8840a1dc073a91d198c2d565d9666f9ea7a8d545bac6a01e31ae41aec3ca",
+      "github_zip_sha256": "7e74a60fdf20b66faec25d11a8b8780fe4c1fad4a62b24f2395ea7d3667549ae",
+      "tray_assets": {
+        "aarch64-apple-darwin": "fd07386f7d7d8528927980929a260f3816b050a8d985186a18dae0ce8563af56",
+        "aarch64-unknown-linux-musl": "ca963298f96bb125892472cbcb125513f11941cb29258ad2b1ea3b9fb441ff74",
+        "x86_64-apple-darwin": "b22601c1c203a17f143ce83e19c5a4c54c546ea52f927f2ad8042ce5aa57a16c",
+        "x86_64-pc-windows-msvc": "7d5b01ab05a83c5e5a18f515a7010b799c19b3b6b6374ed39d8fa386ea66892b",
+        "x86_64-unknown-linux-musl": "2b318774e1ddccda5e070475042c395c6c90dda3ec89a6cf6498ba11dbdc04e8"
+      }
+    },
+    "v0.19.2": {
+      "github_tarball_sha256": "d644666c727b2a29fa022700da1c23483173a2110606b994d200f72feb959c3b",
+      "github_zip_sha256": "bca42637ddab4502e2dd6d9d63239eca322d953f8d910d8ada209fcfdd2f98d4"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "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.19.1"
+version = "0.19.3"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/commands/launch.py

@@ -25,6 +25,7 @@ from ..cli_render import _dim, _info, _success, _warn
 from ..config import PROVIDER_CODEX
 from ..context_store import install_context_for_session, write_context
 from ..errors import CdxError
+from ..interactive_usage import extract_interactive_usage
 from ..provider_runtime import _ensure_session_authentication, _get_auth_home, _run_interactive_provider_command
 
 
@@ -264,6 +265,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         )
     except CdxError as error:
         run_info = getattr(error, "run_info", {}) or {}
+        _attach_interactive_usage(session, run_info)
         if runtime_run_id:
             ctx["service"]["finish_session_runtime"](
                 session["name"],
@@ -284,7 +286,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         "action": "resume" if resume else "launch",
         "cwd": cwd,
         "exit_code": 0,
-        **run_info,
+        **_attach_interactive_usage(session, run_info),
     })
     if json_flag:
         extra = {"session": ctx["service"]["get_session"](session["name"]), "cwd": cwd}
@@ -293,6 +295,19 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         _write_json(ctx, _json_success("resume" if resume else "launch", message, warnings=warnings, **extra))
     return 0
 
+
+def _attach_interactive_usage(session, run_info):
+    """Attach best-effort local provider usage without affecting launch outcome."""
+    run_info = dict(run_info or {})
+    usage, provider_transcript = extract_interactive_usage(
+        session.get("provider"), _get_auth_home(session), run_info.get("started_at")
+    )
+    if usage:
+        run_info["usage"] = usage
+    if provider_transcript:
+        run_info["provider_transcript_path"] = provider_transcript
+    return run_info
+
 def handle_handoff(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     if len(args) not in (1, 2):

package/src/commands/status.py

@@ -253,6 +253,7 @@ def _summarize_stats(entries):
             "duration_ms": 0,
             "usage_runs": 0,
             "input_tokens": 0,
+            "cached_input_tokens": 0,
             "output_tokens": 0,
             "reasoning_tokens": 0,
             "total_tokens": 0,
@@ -270,7 +271,7 @@ def _summarize_stats(entries):
         usage = entry.get("usage") if isinstance(entry.get("usage"), dict) else {}
         parsed_usage = {
             key: _token_value(usage, key)
-            for key in ("input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
+            for key in ("input_tokens", "cached_input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
         }
         if any(value is not None for value in parsed_usage.values()):
             row["usage_runs"] += 1
@@ -295,6 +296,7 @@ def _stats_totals(rows):
         "duration_ms": sum(row["duration_ms"] for row in rows),
         "usage_runs": sum(row["usage_runs"] for row in rows),
         "input_tokens": sum(row["input_tokens"] for row in rows),
+        "cached_input_tokens": sum(row["cached_input_tokens"] for row in rows),
         "output_tokens": sum(row["output_tokens"] for row in rows),
         "reasoning_tokens": sum(row["reasoning_tokens"] for row in rows),
         "total_tokens": sum(row["total_tokens"] for row in rows),
@@ -389,7 +391,7 @@ def _format_stats(rows, totals, period=None, use_color=False, active_sessions=No
     if not rows:
         return "No launch stats for this period." if _has_history_period(period or {}) else "No launch stats."
     table = [[_style(value, "1", use_color) for value in [
-        "SESSION", "PROV.", "RUNS", "USAGE", "IN", "OUT", "REASON", "TOTAL", "TIME", "LAST"
+        "SESSION", "PROV.", "RUNS", "USAGE", "IN", "CACHE", "OUT", "REASON", "TOTAL", "TIME", "LAST"
     ]]]
     for row in rows:
         session_name = row["session_name"]
@@ -400,6 +402,7 @@ def _format_stats(rows, totals, period=None, use_color=False, active_sessions=No
             _style(str(row["launches"]), "1", use_color),
             _style(str(row["usage_runs"]), "32" if row["usage_runs"] else "2", use_color),
             _style(_format_token_count(row["input_tokens"]), "96" if row["input_tokens"] else "2", use_color),
+            _style(_format_token_count(row["cached_input_tokens"]), "96" if row["cached_input_tokens"] else "2", use_color),
             _style(_format_token_count(row["output_tokens"]), "96" if row["output_tokens"] else "2", use_color),
             _style(_format_token_count(row["reasoning_tokens"]), "95" if row["reasoning_tokens"] else "2", use_color),
             _style(_format_token_count(row["total_tokens"]), "1;96" if row["total_tokens"] else "2", use_color),

package/src/fs_utils.py

@@ -28,6 +28,15 @@ def atomic_write(path, data, mode=None):
         if mode is not None and os.name != "nt":
             os.chmod(temp_path, mode)
         os.replace(temp_path, path)
+        if os.name != "nt":
+            try:
+                directory_fd = os.open(directory, os.O_RDONLY)
+                try:
+                    os.fsync(directory_fd)
+                finally:
+                    os.close(directory_fd)
+            except OSError:
+                pass
     except Exception:
         try:
             os.unlink(temp_path)

package/src/interactive_usage.py

@@ -0,0 +1,124 @@
+"""Best-effort usage readers for interactive provider sessions."""
+
+import json
+import os
+import time
+
+MAX_TRANSCRIPT_BYTES = 16 * 1024 * 1024
+MAX_TRANSCRIPT_CANDIDATES = 1000
+MAX_TRANSCRIPT_SCAN_SECONDS = 1
+
+def extract_interactive_usage(provider, auth_home, started_at=None):
+    """Return the newest provider-native usage after an interactive session.
+
+    Provider transcripts are not stable public APIs.  A missing or changed
+    record is therefore ordinary absence, never a launch failure.
+    """
+    path = _latest_transcript(provider, auth_home, started_at)
+    if not path:
+        return None, None
+    try:
+        if os.path.getsize(path) > MAX_TRANSCRIPT_BYTES:
+            return None, path
+        with open(path, encoding="utf-8", errors="replace") as handle:
+            return (_codex_usage(handle) if provider == "codex" else _claude_usage(handle)), path
+    except OSError:
+        return None, path
+
+
+def _latest_transcript(provider, auth_home, started_at):
+    if not auth_home:
+        return None
+    root = os.path.join(auth_home, "sessions") if provider == "codex" else os.path.join(auth_home, ".claude", "projects")
+    if not os.path.isdir(root):
+        return None
+    cutoff = _timestamp(started_at)
+    candidates = []
+    deadline = time.monotonic() + MAX_TRANSCRIPT_SCAN_SECONDS
+    for directory, subdirs, names in os.walk(root):
+        if time.monotonic() >= deadline:
+            return max(candidates, default=(None, None))[1]
+        if provider == "claude":
+            subdirs[:] = [name for name in subdirs if name != "subagents"]
+        for name in names:
+            if not name.endswith(".jsonl"):
+                continue
+            path = os.path.join(directory, name)
+            try:
+                modified = os.path.getmtime(path)
+            except OSError:
+                continue
+            if cutoff is None or modified >= cutoff:
+                candidates.append((modified, path))
+                if len(candidates) > MAX_TRANSCRIPT_CANDIDATES:
+                    return max(candidates)[1]
+    return max(candidates, default=(None, None))[1]
+
+
+def _timestamp(value):
+    if not value:
+        return None
+    try:
+        from datetime import datetime
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00")).timestamp()
+    except ValueError:
+        return None
+
+
+def _codex_usage(handle):
+    latest = None
+    for line in handle:
+        try:
+            record = json.loads(line)
+            payload = record.get("payload") or {}
+            usage = ((payload.get("info") or {}).get("total_token_usage") or {}) if payload.get("type") == "token_count" else {}
+            candidate = _normalize(usage, cached_key="cached_input_tokens", reasoning_key="reasoning_output_tokens")
+            if candidate:
+                latest = candidate
+        except (TypeError, ValueError):
+            continue
+    return latest
+
+
+def _claude_usage(handle):
+    totals = {"input_tokens": 0, "cached_input_tokens": 0, "output_tokens": 0, "reasoning_tokens": 0}
+    seen = set()
+    for line in handle:
+        try:
+            record = json.loads(line)
+            message = record.get("message") or {}
+            usage = message.get("usage") or {}
+            identifier = record.get("uuid")
+            if record.get("type") != "assistant" or not usage or (identifier and identifier in seen):
+                continue
+            if identifier:
+                seen.add(identifier)
+            totals["input_tokens"] += _number(usage.get("input_tokens"))
+            totals["cached_input_tokens"] += _number(usage.get("cache_creation_input_tokens")) + _number(usage.get("cache_read_input_tokens"))
+            totals["output_tokens"] += _number(usage.get("output_tokens"))
+        except (TypeError, ValueError):
+            continue
+    if not seen and not any(totals.values()):
+        return None
+    totals["reasoning_tokens"] = None
+    totals["total_tokens"] = totals["input_tokens"] + totals["output_tokens"]
+    return totals
+
+
+def _normalize(usage, cached_key, reasoning_key):
+    if not isinstance(usage, dict) or not usage:
+        return None
+    return {
+        "input_tokens": _number(usage.get("input_tokens")),
+        "cached_input_tokens": _number(usage.get(cached_key)),
+        "output_tokens": _number(usage.get("output_tokens")),
+        "reasoning_tokens": _number(usage.get(reasoning_key)) or None,
+        "total_tokens": _number(usage.get("total_tokens")) or None,
+    }
+
+
+def _number(value):
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0

package/src/run_registry.py

@@ -1,12 +1,12 @@
 import json
 import os
 import sys
-import tempfile
 import time
 from contextlib import contextmanager
 from datetime import datetime, timezone
 
 from .errors import CdxError
+from .fs_utils import atomic_write
 
 
 def utc_now_iso():
@@ -53,6 +53,25 @@ def _acquire_windows_lock(handle, timeout_seconds):
             time.sleep(_LOCK_RETRY_SECONDS)
 
 
+def _acquire_posix_lock(handle, timeout_seconds):
+    """Acquire a POSIX advisory lock within the same bounded wait as Windows."""
+    import fcntl
+
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        try:
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return
+        except OSError:
+            if time.monotonic() >= deadline:
+                raise CdxError(
+                    "Timed out waiting for the run registry lock after "
+                    f"{timeout_seconds}s. Another cdx process may be stuck holding it.",
+                    75,
+                ) from None
+            time.sleep(_LOCK_RETRY_SECONDS)
+
+
 @contextmanager
 def _registry_lock(path, timeout_seconds=REGISTRY_LOCK_TIMEOUT_SECONDS):
     os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -67,7 +86,7 @@ def _registry_lock(path, timeout_seconds=REGISTRY_LOCK_TIMEOUT_SECONDS):
                 msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
         else:
             import fcntl
-            fcntl.flock(handle, fcntl.LOCK_EX)
+            _acquire_posix_lock(handle, timeout_seconds)
             try:
                 yield
             finally:
@@ -89,18 +108,7 @@ def _read_registry(path):
 
 
 def _write_registry(path, data):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    fd, temp_path = tempfile.mkstemp(prefix=".runs-", suffix=".json", dir=os.path.dirname(path))
-    try:
-        with os.fdopen(fd, "w", encoding="utf-8") as handle:
-            json.dump(data, handle, indent=2, sort_keys=True)
-            handle.write("\n")
-        os.replace(temp_path, path)
-    finally:
-        try:
-            os.unlink(temp_path)
-        except FileNotFoundError:
-            pass
+    atomic_write(path, json.dumps(data, indent=2, sort_keys=True) + "\n", mode=0o600)
 
 
 def _is_pid_alive(pid):

package/src/run_usage.py

@@ -1,6 +1,6 @@
 import json
 
-USAGE_KEYS = ("input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
+USAGE_KEYS = ("input_tokens", "cached_input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
 SUPPORTED_PROVIDERS = {"claude", "codex"}
 
 
@@ -89,6 +89,12 @@ def _usage_from_dict(value):
         usage.get("cache_creation_input_tokens"),
         usage.get("cache_read_input_tokens"),
     )
+    cached_input_tokens = _first_int(usage.get("cached_input_tokens"))
+    if cached_input_tokens is None:
+        cached_input_tokens = _int_value(
+            usage.get("cache_creation_input_tokens"),
+            usage.get("cache_read_input_tokens"),
+        )
     output_tokens = _int_value(usage.get("output_tokens"), usage.get("completion_tokens"))
     reasoning_tokens = _int_value(
         usage.get("reasoning_tokens"),
@@ -102,6 +108,7 @@ def _usage_from_dict(value):
 
     return {
         "input_tokens": input_tokens,
+        "cached_input_tokens": cached_input_tokens,
         "output_tokens": output_tokens,
         "reasoning_tokens": reasoning_tokens,
         "total_tokens": total_tokens,