cdx-manager 0.9.16 → 0.11.0

package/src/session_service.py

@@ -1,4 +1,5 @@
 import base64
+import binascii
 import json
 import os
 import shutil
@@ -29,6 +30,7 @@ RESERVED_SESSION_NAMES = {
     "configs",
     "cp",
     "disable",
+    "disk",
     "doctor",
     "enable",
     "export",
@@ -48,6 +50,7 @@ RESERVED_SESSION_NAMES = {
     "power",
     "ready",
     "repair",
+    "reset",
     "resume",
     "ren",
     "rename",
@@ -260,6 +263,8 @@ def _normalize_status_payload(payload=None):
         "remaining_5h_pct": _normalize_pct_value(payload.get("remaining_5h_pct")),
         "remaining_week_pct": _normalize_pct_value(payload.get("remaining_week_pct")),
         "credits": payload.get("credits"),
+        "reset_credits_available": payload.get("reset_credits_available"),
+        "reset_credits": payload.get("reset_credits"),
         "reset_5h_at": payload.get("reset_5h_at"),
         "reset_week_at": payload.get("reset_week_at"),
         "reset_at": payload.get("reset_at") or payload.get("reset_week_at") or payload.get("reset_5h_at"),
@@ -337,6 +342,8 @@ def _status_has_more_detail(candidate, current):
         "remaining_5h_pct",
         "remaining_week_pct",
         "credits",
+        "reset_credits_available",
+        "reset_credits",
         "reset_5h_at",
         "reset_week_at",
         "reset_at",
@@ -358,6 +365,8 @@ def _merge_status_payload(current, candidate):
         "remaining_5h_pct",
         "remaining_week_pct",
         "credits",
+        "reset_credits_available",
+        "reset_credits",
         "reset_5h_at",
         "reset_week_at",
         "reset_at",
@@ -893,6 +902,11 @@ def create_session_service(options=None):
             # 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}
+            if "power" in updates:
+                launch.pop("reasoning_effort", None)
+                launch.pop("reasoningEffort", None)
+            if "reasoning_effort" in updates:
+                launch.pop("power", None)
             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
@@ -915,7 +929,7 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         if not keys:
             raise CdxError("At least one launch setting is required.")
-        allowed = {"power", "permission", "fast", "rtk", "logics", "model", "priority"}
+        allowed = {"power", "reasoning_effort", "reasoningEffort", "permission", "fast", "rtk", "logics", "model", "priority"}
         unknown = [key for key in keys if key not in allowed]
         if unknown:
             raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")
@@ -1101,6 +1115,8 @@ def create_session_service(options=None):
             "remaining_5h_pct": _normalize_pct_value(row_status.get("remaining_5h_pct")) if row_status else None,
             "remaining_week_pct": _normalize_pct_value(row_status.get("remaining_week_pct")) if row_status else None,
             "credits": row_status.get("credits") if row_status else None,
+            "reset_credits_available": row_status.get("reset_credits_available") if row_status else None,
+            "reset_credits": row_status.get("reset_credits") if row_status else None,
             "available_pct": _compute_available_pct(row_status),
             "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,
             "reset_week_at": row_status.get("reset_week_at") if row_status else None,
@@ -1206,7 +1222,12 @@ def create_session_service(options=None):
                     )] = s
                 for future in as_completed(futures):
                     s = futures[future]
-                    resolved = future.result()
+                    try:
+                        resolved = future.result()
+                    except CdxError as error:
+                        if not str(error).startswith("Unknown session:"):
+                            raise
+                        continue
                     resolved_by_name[s["name"]] = resolved
                     if progress_callback:
                         progress_callback({
@@ -1215,7 +1236,7 @@ def create_session_service(options=None):
                             "has_status": bool(resolved.get("lastStatus")),
                             "cache_hit": cache_hits[s["name"]],
                         })
-        resolved = [resolved_by_name[s["name"]] for s in sessions]
+        resolved = [resolved_by_name[s["name"]] for s in sessions if s["name"] in resolved_by_name]
 
         def sort_key(s):
             at = s.get("lastStatusAt") or ""
@@ -1326,7 +1347,52 @@ def create_session_service(options=None):
             "bundle_size_bytes": len(bundle_bytes),
         }
 
-    def import_bundle(file_path, passphrase=None, session_names=None, force=False, merge=False):
+    def _validate_import_profile_files(payload, imported_sessions):
+        profiles = payload.get("profiles") or {}
+        if not isinstance(profiles, dict):
+            raise CdxError("Bundle contains invalid profile data.")
+        decoded_profiles = {}
+        for session_payload in imported_sessions:
+            name = session_payload["name"]
+            files = []
+            profile_items = profiles.get(name, [])
+            if not isinstance(profile_items, list):
+                raise CdxError(f"Bundle contains invalid profile data for session {name}.")
+            for item in profile_items:
+                if not isinstance(item, dict):
+                    raise CdxError(f"Bundle contains invalid profile entry for session {name}.")
+                rel_path = _safe_relpath(item.get("path"))
+                data_b64 = item.get("data_b64")
+                if not isinstance(data_b64, str):
+                    raise CdxError(f"Bundle contains invalid file data for session {name}: {rel_path}")
+                try:
+                    content = base64.b64decode(data_b64.encode("ascii"), validate=True)
+                except (binascii.Error, UnicodeEncodeError) as error:
+                    raise CdxError(f"Bundle contains invalid file data for session {name}: {rel_path}") from error
+                files.append({"path": rel_path, "content": content})
+            decoded_profiles[name] = files
+        return decoded_profiles
+
+    def _restore_import_backup(name, backup_root, session_root, old_record, old_state):
+        if os.path.exists(session_root):
+            remove_tree(session_root, ignore_errors=True)
+        if backup_root and os.path.exists(backup_root):
+            os.rename(backup_root, session_root)
+        if old_record:
+            store["replace_session"](name, old_record)
+            if old_state is not None:
+                store["write_session_state"](name, old_state)
+        else:
+            store["remove_session"](name)
+
+    def import_bundle(
+        file_path,
+        passphrase=None,
+        session_names=None,
+        force=False,
+        merge=False,
+        allow_authless_force=False,
+    ):
         if not file_path or not os.path.isfile(file_path):
             raise CdxError(f"Bundle file not found: {file_path}")
         with open(file_path, "rb") as handle:
@@ -1348,73 +1414,91 @@ def create_session_service(options=None):
         conflicts = [name for name in names if name in existing]
         if conflicts and not force and not merge:
             raise CdxError(f"Import would overwrite existing sessions: {', '.join(conflicts)}")
+        if conflicts and force and not decoded["meta"].get("include_auth") and not allow_authless_force:
+            raise CdxError(
+                "Import --force would overwrite existing session credentials, but this bundle has no auth payloads. "
+                "Re-export with --include-auth, use --merge, or pass --allow-authless-force to discard local credentials."
+            )
+
+        for session_payload in imported_sessions:
+            _validate_new_session_name(session_payload["name"])
+            _normalize_provider(session_payload["provider"])
+        decoded_profiles = _validate_import_profile_files(payload, imported_sessions)
 
         for session_payload in imported_sessions:
             name = session_payload["name"]
-            _validate_new_session_name(name)
             provider = _normalize_provider(session_payload["provider"])
             is_existing = name in existing
 
-            if is_existing and force:
-                remove_session(name)
-                is_existing = False
-
             session_root = _get_session_root(name)
             auth_home = _get_session_auth_home(name, provider)
             _ensure_private_dir(base_dir)
             _ensure_private_dir(os.path.join(base_dir, "profiles"))
+            backup_root = None
+            old_record = None
+            old_state = None
+            if is_existing and force:
+                old_record = store["get_session"](name)
+                old_state = store["read_session_state"](name)
+                if os.path.exists(session_root):
+                    backup_root = tempfile.mkdtemp(prefix=f".{_encode(name)}.import.", dir=os.path.dirname(session_root))
+                    os.rmdir(backup_root)
+                    os.rename(session_root, backup_root)
+                is_existing = False
             _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,
-                    "enabled": session_payload.get("enabled", True) is not False,
-                    "sessionRoot": session_root,
-                    "authHome": auth_home,
-                }
-                # Existing values take precedence; bundle fills in missing keys only.
-                merged_record = {**bundle_record, **{k: v for k, v in existing_record.items() if v is not None}}
-                merged_record["sessionRoot"] = session_root
-                merged_record["authHome"] = auth_home
-                store["replace_session"](name, merged_record)
-            else:
-                session_record = {
-                    **session_payload,
-                    "provider": provider,
-                    "enabled": session_payload.get("enabled", True) is not False,
-                    "sessionRoot": session_root,
-                    "authHome": auth_home,
-                }
-                store["replace_session"](name, session_record)
-
-            state = (payload.get("states") or {}).get(name)
-            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)
-            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"))
-                try:
-                    content = base64.b64decode(item.get("data_b64", "").encode("ascii"))
-                except (AttributeError, ValueError, UnicodeEncodeError) as error:
-                    raise CdxError(f"Bundle contains invalid file data for session {name}: {rel_path}") from error
-                dest_path = os.path.join(session_root, rel_path)
-                # In merge mode, skip files that already exist locally.
-                if is_existing and merge and os.path.exists(dest_path):
-                    continue
-                _ensure_private_dir(os.path.dirname(dest_path))
-                # Decrypted credentials: 0o600 from creation, no umask window.
-                atomic_write(dest_path, content, mode=0o600)
+            try:
+                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,
+                        "enabled": session_payload.get("enabled", True) is not False,
+                        "sessionRoot": session_root,
+                        "authHome": auth_home,
+                    }
+                    # Existing values take precedence; bundle fills in missing keys only.
+                    merged_record = {**bundle_record, **{k: v for k, v in existing_record.items() if v is not None}}
+                    merged_record["sessionRoot"] = session_root
+                    merged_record["authHome"] = auth_home
+                    store["replace_session"](name, merged_record)
+                else:
+                    session_record = {
+                        **session_payload,
+                        "provider": provider,
+                        "enabled": session_payload.get("enabled", True) is not False,
+                        "sessionRoot": session_root,
+                        "authHome": auth_home,
+                    }
+                    store["replace_session"](name, session_record)
+
+                state = (payload.get("states") or {}).get(name)
+                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)
+                elif state is not None:
+                    store["write_session_state"](name, state)
+
+                for item in decoded_profiles.get(name, []):
+                    dest_path = os.path.join(session_root, item["path"])
+                    # In merge mode, skip files that already exist locally.
+                    if is_existing and merge and os.path.exists(dest_path):
+                        continue
+                    _ensure_private_dir(os.path.dirname(dest_path))
+                    # Decrypted credentials: 0o600 from creation, no umask window.
+                    atomic_write(dest_path, item["content"], mode=0o600)
+            except Exception:
+                _restore_import_backup(name, backup_root, session_root, old_record, old_state)
+                raise
+            finally:
+                if backup_root and os.path.exists(backup_root):
+                    remove_tree(backup_root, ignore_errors=True)
 
         return {
             "path": file_path,

package/src/session_store.py

@@ -294,8 +294,8 @@ def create_session_store(base_dir):
                     continue
                 try:
                     entry = json.loads(line)
-                except json.JSONDecodeError as error:
-                    raise CdxError(f"Corrupt JSONL file: {launch_history_file}") from error
+                except json.JSONDecodeError:
+                    continue
                 if session_name and entry.get("session_name") != session_name:
                     continue
                 entries.append(entry)

package/src/status_source.py

@@ -20,10 +20,6 @@ _KEY_VALUE_PATTERNS = [
     ("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)),
-    ("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)),
-    ("remaining_week_pct", re.compile(r"weekly\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})(?:%|\b)", re.I)),
     ("usage_pct", re.compile(r"usage\s*[:=]\s*(\d{1,3})%", re.I)),
     ("usage_pct", re.compile(r"current\s*[:=]\s*(\d{1,3})%", re.I)),
     ("remaining_5h_pct", re.compile(r"5h(?:\s+remaining)?\s*[:=]\s*(\d{1,3})%", re.I)),
@@ -32,6 +28,14 @@ _KEY_VALUE_PATTERNS = [
     ("remaining_week_pct", re.compile(r"remaining\s+week\s*[:=]\s*(\d{1,3})%", re.I)),
 ]
 
+_CODEX_LIMIT_PERCENT_PATTERNS = [
+    ("remaining_5h_pct", re.compile(r"5h\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)),
+    ("remaining_week_pct", re.compile(r"weekly\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})(?:%|\b)", re.I)),
+]
+_KEY_VALUE_PATTERNS.extend(_CODEX_LIMIT_PERCENT_PATTERNS)
+
 
 def _strip_ansi(text):
     return _ANSI_ESCAPE.sub("", str(text or ""))
@@ -103,6 +107,27 @@ def _is_zero_credit_balance(value):
         return False
 
 
+def _get_structured_rate_limit_window(rate_limits, duration_mins, fallback_key):
+    for key in ("primary", "secondary"):
+        window = rate_limits.get(key) or {}
+        if window.get("windowDurationMins") == duration_mins:
+            return window
+        if window.get("window_minutes") == duration_mins:
+            return window
+    fallback = rate_limits.get(fallback_key) or {}
+    if "windowDurationMins" in fallback or "window_minutes" in fallback:
+        return {}
+    return fallback
+
+
+def _get_rate_limit_used_percent(window):
+    return window.get("used_percent", window.get("usedPercent"))
+
+
+def _get_rate_limit_reset_at(window):
+    return window.get("resets_at", window.get("resetsAt"))
+
+
 def _extract_structured_rate_limits(record):
     if not isinstance(record, dict):
         return None
@@ -111,25 +136,27 @@ def _extract_structured_rate_limits(record):
     if not isinstance(rate_limits, dict):
         return None
 
-    primary = rate_limits.get("primary") or {}
-    secondary = rate_limits.get("secondary") or {}
+    five_hour = _get_structured_rate_limit_window(rate_limits, 300, "primary")
+    weekly = _get_structured_rate_limit_window(rate_limits, 10080, "secondary")
     credits = rate_limits.get("credits") or {}
 
-    primary_used = _coerce_percentage(primary.get("used_percent"))
-    secondary_used = _coerce_percentage(secondary.get("used_percent"))
-    remaining_5h_pct = None if primary_used is None else max(0, 100 - primary_used)
-    remaining_week_pct = None if secondary_used is None else max(0, 100 - secondary_used)
+    five_hour_used = _coerce_percentage(_get_rate_limit_used_percent(five_hour))
+    weekly_used = _coerce_percentage(_get_rate_limit_used_percent(weekly))
+    remaining_5h_pct = None if five_hour_used is None else max(0, 100 - five_hour_used)
+    remaining_week_pct = None if weekly_used is None else max(0, 100 - weekly_used)
 
     result = {
-        "usage_pct": primary_used if primary_used is not None else secondary_used,
+        "usage_pct": five_hour_used if five_hour_used is not None else weekly_used,
         "remaining_5h_pct": remaining_5h_pct,
         "remaining_week_pct": remaining_week_pct,
         "credits": None,
-        "reset_5h_at": _normalize_timestamp_value(primary.get("resets_at")),
-        "reset_week_at": _normalize_timestamp_value(secondary.get("resets_at")),
+        "reset_5h_at": _normalize_timestamp_value(_get_rate_limit_reset_at(five_hour)),
+        "reset_week_at": _normalize_timestamp_value(_get_rate_limit_reset_at(weekly)),
         "reset_at": None,
         "raw_status_text": json.dumps(rate_limits, sort_keys=True),
     }
+    if not five_hour and weekly:
+        result["_skip_5h_backfill"] = True
 
     balance = credits.get("balance")
     if balance not in (None, "") and not (
@@ -496,18 +523,10 @@ def extract_named_statuses_from_text(text):
                 break
 
     for line in lines:
-        m = re.search(r"5h\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})%\s*left", line, re.I)
-        if m and "remaining_5h_pct" not in result:
-            result["remaining_5h_pct"] = int(m[1])
-        m = re.search(r"5h\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})(?:%|\b)", line, re.I)
-        if m and "remaining_5h_pct" not in result:
-            result["remaining_5h_pct"] = int(m[1])
-        m = re.search(r"weekly\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})%\s*left", line, re.I)
-        if m and "remaining_week_pct" not in result:
-            result["remaining_week_pct"] = int(m[1])
-        m = re.search(r"weekly\s+limit\s*:\s*\[[^\]]*\]\s*(\d{1,3})(?:%|\b)", line, re.I)
-        if m and "remaining_week_pct" not in result:
-            result["remaining_week_pct"] = int(m[1])
+        for field, pattern in _CODEX_LIMIT_PERCENT_PATTERNS:
+            m = pattern.search(line)
+            if m and field not in result:
+                result[field] = int(m[1])
 
     if "remaining_5h_pct" in result and "usage_pct" not in result:
         result["usage_pct"] = max(0, 100 - result["remaining_5h_pct"])
@@ -640,6 +659,8 @@ _STATUS_VALUE_FIELDS = (
 
 def _backfill_missing_fields(target, source):
     for field in _STATUS_VALUE_FIELDS:
+        if target.get("_skip_5h_backfill") and field in ("remaining_5h_pct", "reset_5h_at"):
+            continue
         if target.get(field) is None and source.get(field) is not None:
             target[field] = source[field]
 
@@ -694,6 +715,7 @@ def find_latest_status_artifact(
                 "reset_week_at": candidate["structured"].get("reset_week_at"),
                 "reset_at": candidate["structured"].get("reset_at"),
                 "raw_status_text": candidate["structured"].get("raw_status_text"),
+                "_skip_5h_backfill": candidate["structured"].get("_skip_5h_backfill"),
             }
         if not parsed:
             continue

package/src/status_view.py

@@ -76,15 +76,15 @@ def _format_credits(value, empty="n/a"):
 def _format_status_rows(rows, use_color=False, small=False):
     has_provider = len({r["provider"] for r in rows}) > 1 and not small
     if small:
-        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESET 5H", "RESET WEEK"]
+        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESETS", "RESET 5H", "RESET WEEK"]
     elif has_provider:
-        headers = ["SESSION", "PROV.", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "PROV.", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     else:
-        headers = ["SESSION", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     if not rows:
         if small:
-            return "SESSION  STATUS  OK  5H  WEEK  RESET 5H  RESET WEEK\nNo saved sessions yet."
-        return "SESSION  STATUS  OK  5H  WEEK  BLOCK  CR  RESET 5H  RESET WEEK  UPDATED\nNo saved sessions yet."
+            return "SESSION  STATUS  OK  5H  WEEK  RESETS  RESET 5H  RESET WEEK\nNo saved sessions yet."
+        return "SESSION  STATUS  OK  5H  WEEK  BLOCK  CR  RESETS  RESET 5H  RESET WEEK  UPDATED\nNo saved sessions yet."
     headers = [_style(header, "1", use_color) for header in headers]
     active_rows = [r for r in rows if r.get("enabled", True) is not False]
     priority = recommend_priority_rows(rows)
@@ -109,12 +109,13 @@ def _format_status_rows(rows, use_color=False, small=False):
             auth_color = "32" if auth == "logged" else "31" if auth == "logged out" else "2"
             base.append(_style(auth, auth_color, use_color))
         if r.get("enabled", True) is False:
-            usage_columns = [_style("-", "2", use_color)] * 5
+            usage_columns = [_style("-", "2", use_color)] * 6
         else:
             usage_columns = [
                 _style_pct(r.get("available_pct"), use_color),
                 _style_pct(r.get("remaining_5h_pct"), use_color),
                 _style_pct(r.get("remaining_week_pct"), use_color),
+                _style(str(r["reset_credits_available"]), "33", use_color) if r.get("reset_credits_available") is not None else _style("-", "2", use_color),
                 _style_reset_time(r.get("reset_5h_at"), use_color),
                 _style_reset_time(r.get("reset_week_at"), use_color),
             ]
@@ -367,8 +368,15 @@ def _format_status_detail(row, use_color=False):
         f"{_style('Week left:', '1', use_color)} {_style_pct(row.get('remaining_week_pct'), use_color)}",
         f"{_style('Block:', '1', use_color)} {_style(_format_blocking_quota(row), '33', use_color)}",
         f"{_style('Credits:', '1', use_color)} {_style(_format_credits(row.get('credits')), '33' if row.get('credits') is not None else '2', use_color)}",
+        f"{_style('Bonus resets:', '1', use_color)} {_style(str(row['reset_credits_available']), '33', use_color) if row.get('reset_credits_available') is not None else _style('-', '2', use_color)}",
+        f"{_style('Reset expiry:', '1', use_color)} {_style_reset_time(_nearest_reset_expiry(row), use_color)}",
         f"{_style('5h reset:', '1', use_color)} {_style_reset_time(row.get('reset_5h_at'), use_color)}",
         f"{_style('Week reset:', '1', use_color)} {_style_reset_time(row.get('reset_week_at'), use_color)}",
         f"{_style('Updated:', '1', use_color)} {_dim(_format_relative_age(row.get('updated_at')), use_color)}",
     ]
     return "\n".join(lines)
+
+
+def _nearest_reset_expiry(row):
+    values = [credit.get("expires_at") for credit in row.get("reset_credits") or [] if credit.get("expires_at")]
+    return min(values, key=lambda value: _parse_reset_timestamp(value) or float("inf")) if values else None