cdx-manager 0.9.13 → 0.9.15

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