cdx-manager 0.9.14 → 0.9.15

package/src/session_service.py

@@ -14,7 +14,7 @@ from .claude_usage import _decode_jwt_claims
 from .codex_usage import fetch_codex_rate_limits
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
 from .errors import CdxError
-from .fs_utils import remove_tree
+from .fs_utils import atomic_write, remove_tree
 from .session_store import create_session_store
 from .status_source import find_latest_status_artifact
 
@@ -266,6 +266,7 @@ def _normalize_status_payload(payload=None):
         "updated_at": _to_local_iso(payload.get("updated_at") or payload.get("captured_at") or now),
         "raw_status_text": payload.get("raw_status_text"),
         "source_ref": payload.get("source_ref"),
+        "structured": bool(payload.get("structured")),
     }
 
 
@@ -366,6 +367,12 @@ def _merge_status_payload(current, candidate):
         if merged.get(field) is None and candidate.get(field) is not None:
             merged[field] = candidate[field]
 
+    # The structured marker qualifies the source_ref; keep them in sync when
+    # the merge adopts the candidate's ref, else a structured rollout ref
+    # would read as low-confidence scraped text.
+    if merged.get("source_ref") is not None and merged["source_ref"] == candidate.get("source_ref"):
+        merged["structured"] = bool(candidate.get("structured"))
+
     merged["updated_at"] = candidate.get("updated_at") or current.get("updated_at")
     return merged
 
@@ -386,6 +393,10 @@ def _compute_available_pct(status):
 def _is_low_confidence_status_source(status):
     if not status:
         return False
+    if status.get("structured"):
+        # Exact rate_limits API data: trustworthy even when it comes from a
+        # sessions/rollout path, which otherwise flags scraped-text noise.
+        return False
     source_ref = str(status.get("source_ref") or "").replace(os.sep, "/")
     return "/sessions/" in source_ref and "/rollout" in source_ref
 
@@ -425,9 +436,7 @@ def _ensure_claude_attribution_disabled(auth_home):
         settings = {}
     settings["includeCoAuthoredBy"] = False
     try:
-        with open(settings_path, "w", encoding="utf-8") as handle:
-            json.dump(settings, handle, indent=2, sort_keys=True)
-            handle.write("\n")
+        atomic_write(settings_path, json.dumps(settings, indent=2, sort_keys=True) + "\n", mode=0o644)
     except OSError:
         return False
     return True
@@ -478,23 +487,29 @@ def create_session_service(options=None):
         )
 
     def _session_runtime(name):
-        state = store["read_session_state"](name)
-        if not state:
+        found = {}
+
+        def updater(state):
+            if not state:
+                return None
+            runtime = state.get("runtime")
+            if _runtime_is_active(runtime):
+                found["runtime"] = runtime
+                return None
+            if isinstance(runtime, dict) and runtime.get("status") == "running":
+                return {
+                    **state,
+                    "status": "ready",
+                    "runtime": {
+                        **runtime,
+                        "status": "stale",
+                        "endedAt": _local_now_iso(),
+                    },
+                }
             return None
-        runtime = state.get("runtime")
-        if _runtime_is_active(runtime):
-            return runtime
-        if isinstance(runtime, dict) and runtime.get("status") == "running":
-            store["write_session_state"](name, {
-                **state,
-                "status": "ready",
-                "runtime": {
-                    **runtime,
-                    "status": "stale",
-                    "endedAt": _local_now_iso(),
-                },
-            })
-        return None
+
+        store["update_session_state"](name, updater)
+        return found.get("runtime")
 
     def _validate_new_session_name(name):
         if not name:
@@ -755,11 +770,14 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         if session.get("enabled", True) is False:
             raise CdxError(f"Session is disabled: {name}")
-        state = store["read_session_state"](name)
-        if not state:
-            raise CdxError(f"Session state missing for {name}. Reconnect required.")
         now = _local_now_iso()
-        store["write_session_state"](name, {**state, "rehydratedAt": now})
+
+        def state_updater(state):
+            if not state:
+                raise CdxError(f"Session state missing for {name}. Reconnect required.")
+            return {**state, "rehydratedAt": now}
+
+        store["update_session_state"](name, state_updater)
         return store["update_session"](name, lambda s: {
             **s, "updatedAt": now, "lastLaunchedAt": now
         })
@@ -768,9 +786,6 @@ def create_session_service(options=None):
         session = store["get_session"](name)
         if not session:
             raise CdxError(f"Unknown session: {name}")
-        state = store["read_session_state"](name)
-        if not state:
-            raise CdxError(f"Session state missing for {name}. Reconnect required.")
         payload = dict(payload or {})
         now = _local_now_iso()
         runtime = {
@@ -782,52 +797,70 @@ def create_session_service(options=None):
             "label": payload.get("label"),
             "transcriptPath": payload.get("transcript_path") or payload.get("transcriptPath"),
         }
-        store["write_session_state"](name, {
-            **state,
-            "status": "running",
-            "runtime": runtime,
-        })
+
+        def updater(state):
+            if not state:
+                raise CdxError(f"Session state missing for {name}. Reconnect required.")
+            return {
+                **state,
+                "status": "running",
+                "runtime": runtime,
+            }
+
+        store["update_session_state"](name, updater)
         return runtime
 
     def finish_session_runtime(name, run_id=None, payload=None):
         session = store["get_session"](name)
         if not session:
             raise CdxError(f"Unknown session: {name}")
-        state = store["read_session_state"](name)
-        if not state:
-            return None
-        runtime = state.get("runtime") or {}
-        if run_id and runtime.get("runId") != run_id:
-            return runtime
         payload = dict(payload or {})
-        updated_runtime = {
-            **runtime,
-            "status": payload.get("status") or "stopped",
-            "endedAt": payload.get("endedAt") or _local_now_iso(),
-        }
-        if "returncode" in payload:
-            updated_runtime["returncode"] = payload["returncode"]
-        store["write_session_state"](name, {
-            **state,
-            "status": "ready",
-            "runtime": updated_runtime,
-        })
-        return updated_runtime
+        outcome = {}
+
+        def updater(state):
+            if not state:
+                return None
+            runtime = state.get("runtime") or {}
+            if run_id and runtime.get("runId") != run_id:
+                outcome["runtime"] = runtime
+                return None
+            updated_runtime = {
+                **runtime,
+                "status": payload.get("status") or "stopped",
+                "endedAt": payload.get("endedAt") or _local_now_iso(),
+            }
+            if "returncode" in payload:
+                updated_runtime["returncode"] = payload["returncode"]
+            outcome["runtime"] = updated_runtime
+            return {
+                **state,
+                "status": "ready",
+                "runtime": updated_runtime,
+            }
+
+        store["update_session_state"](name, updater)
+        return outcome.get("runtime")
 
     def ensure_session_state(name):
         session = store["get_session"](name)
         if not session:
             raise CdxError(f"Unknown session: {name}")
-        state = store["read_session_state"](name)
-        if state:
-            return state
-        repaired = {
-            "provider": session["provider"],
-            "status": "ready",
-            "rehydratedAt": None,
-        }
-        store["write_session_state"](name, repaired)
-        return repaired
+        result = {}
+
+        def updater(state):
+            if state:
+                result["state"] = state
+                return None
+            repaired = {
+                "provider": session["provider"],
+                "status": "ready",
+                "rehydratedAt": None,
+            }
+            result["state"] = repaired
+            return repaired
+
+        store["update_session_state"](name, updater)
+        return result["state"]
 
     def list_sessions():
         return store["list_sessions"]()
@@ -853,22 +886,28 @@ def create_session_service(options=None):
         updates = _normalize_launch_settings(settings)
         if not updates:
             raise CdxError("At least one launch setting is required.")
-        current = _normalize_launch_settings(session.get("launch") or {}, mark_fast_service_tier=False)
-        launch = {**current, **updates}
-        explicit_power = "power" in updates or "reasoning_effort" in updates
-        if explicit_power and "fast" not in updates and launch.get("fastMode") != "service_tier":
-            launch["fast"] = False
-            launch.pop("fastMode", None)
-        if updates.get("fast") is False:
-            launch.pop("fastMode", None)
-            if not any(key in launch for key in ("power", "reasoning_effort", "reasoningEffort")):
-                launch["power"] = DEFAULT_LAUNCH_SETTINGS["power"]
         now = _local_now_iso()
-        return store["update_session"](name, lambda s: {
-            **s,
-            "launch": launch,
-            "updatedAt": now,
-        })
+
+        def updater(s):
+            # Build the new launch dict from the fresh record inside the store
+            # lock; a pre-lock snapshot loses a concurrent setting change.
+            current = _normalize_launch_settings(s.get("launch") or {}, mark_fast_service_tier=False)
+            launch = {**current, **updates}
+            explicit_power = "power" in updates or "reasoning_effort" in updates
+            if explicit_power and "fast" not in updates and launch.get("fastMode") != "service_tier":
+                launch["fast"] = False
+                launch.pop("fastMode", None)
+            if updates.get("fast") is False:
+                launch.pop("fastMode", None)
+                if not any(key in launch for key in ("power", "reasoning_effort", "reasoningEffort")):
+                    launch["power"] = DEFAULT_LAUNCH_SETTINGS["power"]
+            return {
+                **s,
+                "launch": launch,
+                "updatedAt": now,
+            }
+
+        return store["update_session"](name, updater)
 
     def unset_launch_settings(name, keys):
         session = store["get_session"](name)
@@ -880,12 +919,12 @@ def create_session_service(options=None):
         unknown = [key for key in keys if key not in allowed]
         if unknown:
             raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")
-        current = dict(session.get("launch") or {})
-        for key in keys:
-            current.pop(key, None)
         now = _local_now_iso()
 
         def updater(s):
+            current = dict(s.get("launch") or {})
+            for key in keys:
+                current.pop(key, None)
             updated = {**s, "updatedAt": now}
             if current:
                 updated["launch"] = current
@@ -972,6 +1011,9 @@ def create_session_service(options=None):
                     global_root,
                     session["provider"],
                     expected_account_email=expected_account_email,
+                    # The shared codex home can hold other accounts' rollouts;
+                    # structured payloads there cannot be attributed to ours.
+                    trust_unattributed_structured=False,
                 )
         if not artifact:
             if _is_low_confidence_status_source(current_status):
@@ -988,6 +1030,7 @@ def create_session_service(options=None):
             "updated_at": artifact.get("updated_at"),
             "raw_status_text": artifact.get("raw_status_text"),
             "source_ref": artifact.get("source_ref"),
+            "structured": artifact.get("structured"),
         })
         if _is_low_confidence_status_source(current_status) and not _is_low_confidence_status_source(resolved):
             record_status(session["name"], resolved)
@@ -1269,14 +1312,10 @@ def create_session_service(options=None):
         bundle_bytes = encode_bundle(payload, include_auth=include_auth, passphrase=passphrase)
         if progress_callback:
             progress_callback({"event": "writing_started", "path": file_path, "bundle_size_bytes": len(bundle_bytes)})
-        os.makedirs(os.path.dirname(os.path.abspath(file_path)) or ".", exist_ok=True)
-        with open(file_path, "wb") as handle:
-            handle.write(bundle_bytes)
-        if sys.platform != "win32":
-            try:
-                os.chmod(file_path, 0o600)
-            except OSError:
-                pass
+        # Atomic + 0o600 from the start: the export path may live in a
+        # world-traversable directory, and a crash must not clobber a
+        # previous good bundle with a truncated one.
+        atomic_write(os.path.abspath(file_path), bundle_bytes, mode=0o600)
         return {
             "path": file_path,
             "include_auth": include_auth,
@@ -1327,8 +1366,12 @@ def create_session_service(options=None):
             _ensure_private_dir(session_root)
             _ensure_private_dir(auth_home)
 
+            existing_state_before = None
             if is_existing and merge:
                 existing_record = store["get_session"](name) or {}
+                # replace_session resets the state file to defaults, so the
+                # local state must be captured before it runs.
+                existing_state_before = store["read_session_state"](name) or {}
                 bundle_record = {
                     **session_payload,
                     "provider": provider,
@@ -1352,13 +1395,12 @@ def create_session_service(options=None):
                 store["replace_session"](name, session_record)
 
             state = (payload.get("states") or {}).get(name)
-            if state is not None:
-                if is_existing and merge:
-                    existing_state = store["read_session_state"](name) or {}
-                    merged_state = {**state, **{k: v for k, v in existing_state.items() if v is not None}}
+            if is_existing and merge:
+                merged_state = {**(state or {}), **{k: v for k, v in (existing_state_before or {}).items() if v is not None}}
+                if merged_state:
                     store["write_session_state"](name, merged_state)
-                else:
-                    store["write_session_state"](name, state)
+            elif state is not None:
+                store["write_session_state"](name, state)
 
             for item in (payload.get("profiles") or {}).get(name, []):
                 rel_path = _safe_relpath(item.get("path"))
@@ -1371,13 +1413,8 @@ def create_session_service(options=None):
                 if is_existing and merge and os.path.exists(dest_path):
                     continue
                 _ensure_private_dir(os.path.dirname(dest_path))
-                with open(dest_path, "wb") as handle:
-                    handle.write(content)
-                if sys.platform != "win32":
-                    try:
-                        os.chmod(dest_path, 0o600)
-                    except OSError:
-                        pass
+                # Decrypted credentials: 0o600 from creation, no umask window.
+                atomic_write(dest_path, content, mode=0o600)
 
         return {
             "path": file_path,

package/src/session_store.py

@@ -260,6 +260,16 @@ def create_session_store(base_dir):
         with _file_lock(lock_file):
             _write_session_state_unlocked(name, state)
 
+    def update_session_state(name, updater):
+        # Read-modify-write under one lock; separate read/write calls let a
+        # concurrent writer's update be clobbered between the two.
+        with _file_lock(lock_file):
+            state = _read_session_state_unlocked(name)
+            updated = updater(state)
+            if updated is not None:
+                _write_session_state_unlocked(name, updated)
+            return updated
+
     def append_launch_history(entry):
         with _file_lock(lock_file):
             _ensure_dir(state_dir)
@@ -303,6 +313,7 @@ def create_session_store(base_dir):
         "replace_session": replace_session,
         "read_session_state": read_session_state,
         "write_session_state": write_session_state,
+        "update_session_state": update_session_state,
         "append_launch_history": append_launch_history,
         "list_launch_history": list_launch_history,
     }

package/src/status_source.py

@@ -19,7 +19,7 @@ _KEY_VALUE_PATTERNS = [
     ("usage_pct", re.compile(r"usage_pct\s*[:=]\s*(\d{1,3})%?", re.I)),
     ("remaining_5h_pct", re.compile(r"remaining_?5h_pct\s*[:=]\s*(\d{1,3})%?", re.I)),
     ("remaining_week_pct", re.compile(r"remaining_?week_pct\s*[:=]\s*(\d{1,3})%?", re.I)),
-    ("credits", re.compile(r"credits?\s*[:=]\s*([\d, ]*\d[\d, ]*)\s*(?:credits?)?", re.I)),
+    ("credits", re.compile(r"credits?\s*[:=]\s*(\d[\d, ]*(?:\.\d+)?)\s*(?:credits?)?", re.I)),
     ("remaining_5h_pct", re.compile(r"5h\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})%\s*left", re.I)),
     ("remaining_week_pct", re.compile(r"weekly\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})%\s*left", re.I)),
     ("remaining_5h_pct", re.compile(r"5h\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})(?:%|\b)", re.I)),
@@ -94,6 +94,15 @@ def _coerce_percentage(value):
         return None
 
 
+def _is_zero_credit_balance(value):
+    if value in (None, ""):
+        return True
+    try:
+        return float(str(value).replace(",", "").strip()) == 0
+    except (TypeError, ValueError):
+        return False
+
+
 def _extract_structured_rate_limits(record):
     if not isinstance(record, dict):
         return None
@@ -123,7 +132,11 @@ def _extract_structured_rate_limits(record):
     }
 
     balance = credits.get("balance")
-    if balance not in (None, ""):
+    if balance not in (None, "") and not (
+        _is_zero_credit_balance(balance)
+        and not credits.get("hasCredits")
+        and not credits.get("unlimited")
+    ):
         result["credits"] = str(balance).strip()
 
     result["reset_at"] = result["reset_week_at"] or result["reset_5h_at"]
@@ -277,6 +290,8 @@ def _extract_jsonl_texts(file_path, provider=None):
                     "timestamp": record.get("timestamp"),
                     "text": structured["raw_status_text"],
                     "structured": structured,
+                    # Exact API data, as trustworthy as a /status screen.
+                    "trusted": True,
                 })
             payload_texts = _collect_text_values(record.get("payload") or {})
             for candidate in payload_texts:
@@ -296,7 +311,11 @@ def _extract_log_block(file_path, provider=None):
     text = _safe_read_text(file_path)
     if not text:
         return []
-    return _extract_status_blocks_from_text(text, provider=provider, source_ref=file_path, timestamp=None)
+    items = _extract_status_blocks_from_text(text, provider=provider, source_ref=file_path, timestamp=None)
+    for item in items:
+        # A /status screen captured in a terminal log is authoritative.
+        item["trusted"] = True
+    return items
 
 
 def _parse_month_index(name):
@@ -422,7 +441,14 @@ def extract_named_statuses_from_text(text):
     for field, pattern in _KEY_VALUE_PATTERNS:
         if field not in result:
             m = pattern.search(normalized)
-            if m:
+            if not m:
+                continue
+            if field == "credits":
+                # Keep the decimal part; a zero balance is no credit at all.
+                value = m[1].replace(",", "").replace(" ", "")
+                if not _is_zero_credit_balance(value):
+                    result[field] = value
+            else:
                 result[field] = int(re.sub(r"\D", "", m[1]))
 
     # Claude "Current session / Current week" block
@@ -596,12 +622,49 @@ def _sort_recent(paths):
     }
     return sorted(
         candidate_stats,
-        key=lambda fp: candidate_stats[fp].st_mtime,
+        key=lambda fp: (candidate_stats[fp].st_mtime, fp),
         reverse=True,
     )
 
 
-def find_latest_status_artifact(root_dir, provider=None, expected_account_email=None):
+_STATUS_VALUE_FIELDS = (
+    "usage_pct",
+    "remaining_5h_pct",
+    "remaining_week_pct",
+    "credits",
+    "reset_5h_at",
+    "reset_week_at",
+    "reset_at",
+)
+
+
+def _backfill_missing_fields(target, source):
+    for field in _STATUS_VALUE_FIELDS:
+        if target.get(field) is None and source.get(field) is not None:
+            target[field] = source[field]
+
+
+def _record_timestamp_epoch(value):
+    """Best-effort epoch seconds from a record timestamp (ISO string, epoch s or ms)."""
+    if value in (None, ""):
+        return None
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        try:
+            return datetime.fromisoformat(str(value).replace("Z", "+00:00")).timestamp()
+        except (TypeError, ValueError):
+            return None
+    # ponytail: >1e11 means epoch milliseconds (that's year 5138 in seconds)
+    return number / 1000 if number > 1e11 else number
+
+
+def find_latest_status_artifact(
+    root_dir,
+    provider=None,
+    expected_account_email=None,
+    trust_unattributed_structured=True,
+):
     priority_candidates, history_candidates = _collect_candidate_files(root_dir)
     candidates = (
         _sort_recent(priority_candidates)
@@ -634,35 +697,48 @@ def find_latest_status_artifact(root_dir, provider=None, expected_account_email=
             }
         if not parsed:
             continue
-        ts = candidate.get("timestamp")
-        try:
-            score = float(ts) if ts else 0
-        except (TypeError, ValueError):
-            score = 0
+        # Score on the record's own time so sources stay comparable: falling
+        # back to file mtime would let a stale block in an actively-appended
+        # jsonl outrank a genuinely fresher terminal log.
+        epoch = _record_timestamp_epoch(candidate.get("timestamp"))
         src_file = re.sub(r":\d+$", "", candidate["source_ref"])
         stat = _safe_stat(src_file)
-        if not score and stat:
+        if epoch is not None:
+            score = epoch
+        elif stat:
             score = stat.st_mtime
-        priority = 2 if src_file.endswith(".log") else 1
+        else:
+            score = 0
+        # Each record producer stamps "trusted" where it knows the source kind.
+        # Untrusted records are text scraped from jsonl payloads: they can be
+        # conversational noise quoting an old status block.
+        trusted = bool(candidate.get("trusted"))
+        # Structured payloads carry no account identity, so the email guard
+        # above cannot filter them. In roots shared by several accounts the
+        # caller demotes them below account-verified /status screens.
+        if trusted and candidate.get("structured") and not trust_unattributed_structured:
+            trusted = False
+        priority = 2 if trusted else 1
 
         if best is None or (priority, score) >= (best["priority"], best["score"]):
+            previous = best
             best = {
                 "priority": priority,
                 "score": score,
                 "source_ref": candidate["source_ref"],
+                "structured": bool(candidate.get("structured")),
                 **parsed,
             }
-            if ts:
-                try:
-                    best["updated_at"] = datetime.fromtimestamp(
-                        float(ts) / 1000, tz=timezone.utc
-                    ).astimezone().isoformat()
-                except (TypeError, ValueError):
-                    pass
-            if "updated_at" not in best:
-                if stat:
-                    best["updated_at"] = datetime.fromtimestamp(
-                        stat.st_mtime, tz=timezone.utc
-                    ).astimezone().isoformat()
+            if score:
+                best["updated_at"] = datetime.fromtimestamp(
+                    score, tz=timezone.utc
+                ).astimezone().isoformat()
+            # A fresher-but-partial winner (e.g. rate_limits with only the
+            # primary window) must not erase fields an equally trusted
+            # candidate provided.
+            if previous and previous["priority"] == priority:
+                _backfill_missing_fields(best, previous)
+        elif priority == best["priority"]:
+            _backfill_missing_fields(best, parsed)
 
     return best

package/src/status_view.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
 
 from .cli_render import (
@@ -328,12 +328,25 @@ def _parse_reset_timestamp(value):
         return parsed.timestamp()
     except (TypeError, ValueError):
         pass
-    try:
-        parsed = datetime.strptime(text, "%b %d %H:%M")
-    except (TypeError, ValueError):
-        return None
     now = datetime.now().astimezone()
-    parsed = parsed.replace(year=now.year, tzinfo=now.tzinfo)
+    parsed = None
+    # Parse with an explicit year: strptime's implicit 1900 rejects "Feb 29",
+    # and the current year may not hold the date at all around new year.
+    for year in (now.year, now.year + 1):
+        try:
+            parsed = datetime.strptime(f"{year} {text}", "%Y %b %d %H:%M").replace(tzinfo=now.tzinfo)
+            break
+        except (TypeError, ValueError):
+            continue
+    if parsed is None:
+        return None
+    # A year-less date nearly a year in the past is a year wrap ("Jan 2"
+    # rendered on Dec 31), not a reset that passed months ago.
+    if parsed < now - timedelta(days=182):
+        try:
+            parsed = parsed.replace(year=parsed.year + 1)
+        except ValueError:
+            pass
     return parsed.timestamp()
 
 

package/src/update_check.py

@@ -236,6 +236,10 @@ def check_logics_manager_for_update(base_dir, env=None, now_fn=None, runner=None
         return None
 
     latest_version = fetch_latest_logics_manager_version(env=env)
+    if not latest_version:
+        # Don't cache a failed fetch: a None latest_version would hide a
+        # real update for the whole TTL after the registry recovers.
+        return None
     payload = {
         "checked_at": now_ts,
         "latest_version": latest_version,

package/src/update_manager.py

@@ -204,7 +204,9 @@ def run_update_plan(plan, runner=None, env=None):
             "stdout": _result_text(result, "stdout"),
             "stderr": _result_text(result, "stderr"),
         })
-        if code not in (0, None):
+        # A runner that reports no return code is a failure, not a success:
+        # treating None as ok would let a failed step continue the plan.
+        if code != 0:
             break
     return results