cdx-manager 0.10.0 → 0.11.1

package/src/session_service.py

@@ -1,4 +1,5 @@
 import base64
+import binascii
 import json
 import os
 import shutil
@@ -21,6 +22,7 @@ from .status_source import find_latest_status_artifact
 DEFAULT_PROVIDER = PROVIDER_CODEX
 ALLOWED_PROVIDERS = set(PROVIDERS)
 MAX_SESSION_NAME_LENGTH = 64
+MAX_SESSION_LABEL_LENGTH = 64
 RESERVED_SESSION_NAMES = {
     "add",
     "can-resume",
@@ -39,6 +41,7 @@ RESERVED_SESSION_NAMES = {
     "history",
     "import",
     "last",
+    "label",
     "login",
     "logout",
     "model",
@@ -533,10 +536,21 @@ def create_session_service(options=None):
         if name in RESERVED_SESSION_NAMES:
             raise CdxError(f"Session name is reserved: {name}")
 
+    def _normalize_session_label(label):
+        text = str(label or "").strip()
+        if not text:
+            raise CdxError("Session label is required")
+        if len(text) > MAX_SESSION_LABEL_LENGTH:
+            raise CdxError(f"Session label is too long (max {MAX_SESSION_LABEL_LENGTH} characters)")
+        if any(ord(ch) < 32 or ord(ch) == 127 for ch in text):
+            raise CdxError("Session label cannot contain control characters")
+        return text
+
     def _build_export_session_record(session):
         return {
             "name": session["name"],
             "provider": session["provider"],
+            "label": session.get("label"),
             "enabled": session.get("enabled", True) is not False,
             "createdAt": session.get("createdAt"),
             "updatedAt": session.get("updatedAt"),
@@ -697,6 +711,7 @@ def create_session_service(options=None):
             "lastStatusAt": None,
             "lastStatus": None,
             **({"launch": source.get("launch")} if source.get("launch") else {}),
+            **({"label": source.get("label")} if source.get("label") else {}),
             "auth": {
                 "status": "unknown",
                 "lastCheckedAt": None,
@@ -887,6 +902,31 @@ def create_session_service(options=None):
             "updatedAt": now,
         })
 
+    def set_session_label(name, label):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        normalized = _normalize_session_label(label)
+        now = _local_now_iso()
+        return store["update_session"](name, lambda s: {
+            **s,
+            "label": normalized,
+            "updatedAt": now,
+        })
+
+    def clear_session_label(name):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        now = _local_now_iso()
+
+        def updater(s):
+            updated = {**s, "updatedAt": now}
+            updated.pop("label", None)
+            return updated
+
+        return store["update_session"](name, updater)
+
     def set_launch_settings(name, settings):
         session = store["get_session"](name)
         if not session:
@@ -901,6 +941,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
@@ -923,7 +968,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)}")
@@ -1100,6 +1145,7 @@ def create_session_service(options=None):
         row_status = status if enabled else None
         return {
             "session_name": s["name"],
+            "label": s.get("label"),
             "provider": s["provider"],
             "enabled": enabled,
             "active": bool(_session_runtime(s["name"])) if enabled else False,
@@ -1216,7 +1262,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({
@@ -1225,7 +1276,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 ""
@@ -1262,6 +1313,7 @@ def create_session_service(options=None):
         )
         return [{
             "name": s["name"],
+            "label": s.get("label"),
             "provider": s["provider"] if has_multiple else None,
             "enabled": s.get("enabled", True) is not False,
             "active": bool(_session_runtime(s["name"])) if s.get("enabled", True) is not False else False,
@@ -1336,7 +1388,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:
@@ -1358,73 +1455,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,
@@ -1445,6 +1560,8 @@ def create_session_service(options=None):
         "list_sessions": list_sessions,
         "get_session": get_session,
         "set_session_enabled": set_session_enabled,
+        "set_session_label": set_session_label,
+        "clear_session_label": clear_session_label,
         "set_launch_settings": set_launch_settings,
         "unset_launch_settings": unset_launch_settings,
         "record_status": record_status,

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

@@ -75,12 +75,19 @@ 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
+    has_label = any(r.get("label") for r in rows) and not small
     if small:
         headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESETS", "RESET 5H", "RESET WEEK"]
     elif has_provider:
-        headers = ["SESSION", "PROV.", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "PROV."]
+        if has_label:
+            headers.append("LABEL")
+        headers += ["STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     else:
-        headers = ["SESSION", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION"]
+        if has_label:
+            headers.append("LABEL")
+        headers += ["STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     if not rows:
         if small:
             return "SESSION  STATUS  OK  5H  WEEK  RESETS  RESET 5H  RESET WEEK\nNo saved sessions yet."
@@ -102,6 +109,8 @@ def _format_status_rows(rows, use_color=False, small=False):
         base = [_format_session_name(r)]
         if has_provider:
             base.append(r.get("provider") or "n/a")
+        if has_label:
+            base.append(r.get("label") or "-")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
         base.append(_style(status, "2" if status == "disabled" else "32", use_color))
         if not small: