cdx-manager 0.20.1 → 0.20.2

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.20.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.20.2-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.
 

package/VERSION

@@ -1 +1 @@
-0.20.1
+0.20.2

package/changelogs/CHANGELOGS_0_20_2.md

@@ -0,0 +1,12 @@
+# CDX Manager 0.20.2
+
+## Fixes
+
+- Claude transcripts up to 128 MiB are now measured. Before each relaunch, CDX
+  reconciles the preceding Claude conversation when its exact transcript was
+  not captured; `cdx repair --force` also repairs safely attributable history.
+- Token pricing now ignores synthetic transcript model placeholders when a real
+  provider model is present, so measured Claude sessions receive their price.
+- `cdx history` and `cdx stats --since` now include sessions that overlap the
+  requested period, including sessions that started before the window and
+  completed inside it.

package/checksums/release-archives.json

@@ -320,6 +320,17 @@
         "x86_64-pc-windows-msvc": "e88d296e706ae90624a1f82bf14d36d67787d5f73bbb04986c1ca82293178c68",
         "x86_64-unknown-linux-musl": "cf8ec3f5a56bf50ba42d2dfa44f05ecc4471c5a5a819ca8b5180c6d9eff75ff1"
       }
+    },
+    "v0.20.1": {
+      "github_tarball_sha256": "00922589fbfa5edaee8bff2b9328bd185e91551eb63932fd7e0642a2fd101923",
+      "github_zip_sha256": "16aa1e4376368454769150b3adfec146dde5c88ddef8a157c343c00025ed58ce",
+      "tray_assets": {
+        "aarch64-apple-darwin": "4f73559113b77a67612e47be3cb3d81bfd9cee7b99fd8b5257f01ea6ec1b9d36",
+        "aarch64-unknown-linux-musl": "27f3bd4a6c03d164340a753387ac522d43ce0523f70f0251484b2d24a8e504df",
+        "x86_64-apple-darwin": "6a11eee823a76e00f02ab1c75c247b079f1e264351f467c41f4aeeb46bc9a3c3",
+        "x86_64-pc-windows-msvc": "3513680e96fd5f669c2f2868b3a195899e48ed4d5f3dce080289f90648e60199",
+        "x86_64-unknown-linux-musl": "ee86688537638671ceec1d805d23124d8511c11ab62836f14fa2545b418741d2"
+      }
     }
   }
 }

package/package.json

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

package/src/cli_args.py

@@ -745,8 +745,8 @@ def _has_history_period(period):
     return period.get("from_ts") is not None or period.get("to_ts") is not None
 
 
-def _parse_entry_timestamp(entry):
-    value = entry.get("started_at")
+def _parse_entry_timestamp(entry, field="started_at"):
+    value = entry.get(field)
     if not value:
         return None
     text = str(value)
@@ -768,12 +768,16 @@ def _filter_history_period(entries, period):
     start = period.get("from_ts")
     end = period.get("to_ts")
     for entry in entries:
-        timestamp = _parse_entry_timestamp(entry)
-        if timestamp is None:
+        started = _parse_entry_timestamp(entry)
+        if started is None:
             continue
-        if start is not None and timestamp < start:
+        # A long run belongs to a period it overlaps, not only the day it was
+        # launched. Usage is recorded per run, so include its whole measured
+        # total rather than inventing a time-proportional split.
+        ended = _parse_entry_timestamp(entry, "ended_at") or started
+        if start is not None and ended < start:
             continue
-        if end is not None and timestamp > end:
+        if end is not None and started > end:
             continue
         filtered.append(entry)
     return filtered

package/src/interactive_usage.py

@@ -22,7 +22,10 @@ import time
 from .run_usage import claude_usage_dedup_key, normalize_usage
 from .status_source import _normalize_terminal_transcript
 
-MAX_TRANSCRIPT_BYTES = 16 * 1024 * 1024
+# Readers stream JSONL line-by-line.  A 16 MiB cap excluded ordinary long
+# Claude sessions (for example a five-hour session at 26 MiB) without saving
+# meaningful memory; keep a bounded ceiling for genuinely pathological files.
+MAX_TRANSCRIPT_BYTES = 128 * 1024 * 1024
 MAX_TRANSCRIPT_CANDIDATES = 1000
 MAX_TRANSCRIPT_SCAN_SECONDS = 1
 
@@ -298,7 +301,7 @@ def _claude_usage(handle):
             totals["cache_creation_tokens"] += _number(usage.get("cache_creation_input_tokens"))
             totals["cache_read_tokens"] += _number(usage.get("cache_read_input_tokens"))
             totals["output_tokens"] += _number(usage.get("output_tokens"))
-            if message.get("model"):
+            if isinstance(message.get("model"), str) and not message["model"].startswith("<"):
                 model = message["model"]
         except (TypeError, ValueError):
             continue

package/src/repair.py

@@ -51,6 +51,24 @@ def repair_health(service, base_dir, env=None, dry_run=True, force=False):
             None,
             None if dry_run else "applied",
         ))
+    backfill = service["backfill_interactive_usage"](dry_run=dry_run)
+    if backfill["backfilled"]:
+        actions.append(_action(
+            "backfill_interactive_usage",
+            f"backfill token usage for {backfill['backfilled']} exactly matched Claude launch record"
+            f"{'s' if backfill['backfilled'] != 1 else ''} (of {backfill['scanned']} scanned)",
+            None,
+            None if dry_run else "applied",
+        ))
+    models = service["refresh_interactive_usage_models"](dry_run=dry_run)
+    if models["backfilled"]:
+        actions.append(_action(
+            "refresh_interactive_usage_models",
+            f"replace placeholder models on {models['backfilled']} launch record"
+            f"{'s' if models['backfilled'] != 1 else ''}",
+            None,
+            None if dry_run else "applied",
+        ))
     return {
         "dry_run": dry_run,
         "force": force,

package/src/session_service.py

@@ -727,6 +727,72 @@ def get_launch_history(store, name=None, limit=20):
     return store["list_launch_history"](session_name=name, limit=limit)
 
 
+def backfill_interactive_usage(store, name=None, dry_run=True):
+    """Recover one safely attributable missing Claude launch per profile."""
+    from datetime import datetime
+
+    from .interactive_usage import MATCH_CONVERSATION_ID, extract_interactive_usage
+
+    updates = {}
+    sessions = [store["get_session"](name)] if name else store["list_sessions"]()
+    for session in sessions:
+        if not session:
+            continue
+        if session.get("provider") != PROVIDER_CLAUDE:
+            continue
+        conversation = session.get("conversation") or {}
+        identifier = conversation.get("id")
+        recorded = conversation.get("recordedAt")
+        if not identifier or not recorded:
+            continue
+        usage, path, match, model = extract_interactive_usage(
+            PROVIDER_CLAUDE, session.get("authHome"), conversation_id=identifier
+        )
+        if not usage or match != MATCH_CONVERSATION_ID:
+            continue
+        history = store["list_launch_history"](session_name=session["name"], limit=0)
+        target = next((entry for entry in history if not entry.get("usage") and entry.get("provider_transcript_path") in (None, path)), None)
+        if not target or not target.get("started_at"):
+            continue
+        try:
+            delta = abs((datetime.fromisoformat(recorded.replace("Z", "+00:00")) - datetime.fromisoformat(target["started_at"].replace("Z", "+00:00"))).total_seconds())
+        except ValueError:
+            continue
+        if delta > 300:
+            continue
+        updates[(session["name"], target["started_at"])] = {
+            "usage": usage,
+            "usage_cumulative": usage,
+            "usage_model": model,
+            "provider_transcript_path": path,
+            "provider_transcript_match": match,
+            "usage_backfilled_reason": "exact_current_conversation",
+        }
+    return store["backfill_launch_usage"](updates, dry_run=dry_run)
+
+
+def refresh_interactive_usage_models(store, dry_run=True):
+    """Replace a placeholder model with the exact transcript's real model."""
+    from .interactive_usage import MATCH_CONVERSATION_ID, extract_interactive_usage
+
+    updates = {}
+    for session in store["list_sessions"]():
+        if session.get("provider") != PROVIDER_CLAUDE:
+            continue
+        identifier = ((session.get("conversation") or {}).get("id"))
+        if not identifier:
+            continue
+        _usage, path, match, model = extract_interactive_usage(
+            PROVIDER_CLAUDE, session.get("authHome"), conversation_id=identifier
+        )
+        if not path or match != MATCH_CONVERSATION_ID or not model or model.startswith("<"):
+            continue
+        for entry in store["list_launch_history"](session_name=session["name"], limit=0):
+            if entry.get("provider_transcript_path") == path and str(entry.get("usage_model") or "").startswith("<"):
+                updates[(session["name"], entry.get("started_at"))] = {"usage_model": model}
+    return store["backfill_launch_usage"](updates, dry_run=dry_run)
+
+
 def start_session_runtime(store, name, payload=None):
     session = store["get_session"](name)
     if not session:
@@ -803,6 +869,9 @@ def launch_session(store, name, resume=False):
         raise CdxError(f"Unknown session: {name}")
     if session.get("enabled", True) is False:
         raise CdxError(f"Session is disabled: {name}")
+    # Reconcile the prior Claude conversation before a fresh launch replaces
+    # its id. This is a single exact transcript lookup, not a global stats scan.
+    backfill_interactive_usage(store, name=name, dry_run=False)
     now = _local_now_iso()
 
     def state_updater(state):
@@ -921,6 +990,8 @@ def create_session_service(options=None):
         "record_launch_history": partial(record_launch_history, store),
         "get_launch_history": partial(get_launch_history, store),
         "drop_unvouched_usage": store["drop_unvouched_usage"],
+        "backfill_interactive_usage": partial(backfill_interactive_usage, store),
+        "refresh_interactive_usage_models": partial(refresh_interactive_usage_models, store),
         "update_auth_state": partial(update_auth_state, store),
         "get_status_row": partial(get_status_row, store, base_dir, env, fetch_codex_status),
         "get_status_rows": partial(get_status_rows, store, base_dir, env, fetch_codex_status),

package/src/session_store.py

@@ -333,6 +333,37 @@ def create_session_store(base_dir):
                 _fsync_directory(state_dir)
             return {"scanned": scanned, "dropped": dropped, "dry_run": dry_run}
 
+    def backfill_launch_usage(updates, dry_run=True):
+        """Apply pre-validated usage updates to otherwise empty history rows."""
+        with _file_lock(lock_file):
+            try:
+                with open(launch_history_file, encoding="utf-8") as handle:
+                    lines = handle.readlines()
+            except FileNotFoundError:
+                return {"scanned": 0, "backfilled": 0, "dry_run": dry_run}
+            scanned = backfilled = 0
+            rewritten = []
+            for line in lines:
+                stripped = line.strip()
+                if not stripped:
+                    continue
+                try:
+                    entry = json.loads(stripped)
+                except ValueError:
+                    rewritten.append(line)
+                    continue
+                scanned += 1
+                update = updates.get((entry.get("session_name"), entry.get("started_at")))
+                if update and (not entry.get("usage") or str(entry.get("usage_model") or "").startswith("<")):
+                    entry.update(update)
+                    line = json.dumps(entry, separators=(",", ":")) + "\n"
+                    backfilled += 1
+                rewritten.append(line)
+            if not dry_run and backfilled:
+                atomic_write(launch_history_file, "".join(rewritten))
+                _fsync_directory(state_dir)
+            return {"scanned": scanned, "backfilled": backfilled, "dry_run": dry_run}
+
     def list_launch_history(session_name=None, limit=20):
         with _file_lock(lock_file):
             try:
@@ -369,5 +400,6 @@ def create_session_store(base_dir):
         "update_session_state": update_session_state,
         "append_launch_history": append_launch_history,
         "drop_unvouched_usage": drop_unvouched_usage,
+        "backfill_launch_usage": backfill_launch_usage,
         "list_launch_history": list_launch_history,
     }