cdx-manager 0.5.3 → 0.5.5

package/src/provider_runtime.py

@@ -7,6 +7,7 @@ import subprocess
 import sys
 from datetime import datetime, timezone
 
+from .config import PROVIDER_CLAUDE, PROVIDER_CODEX
 from .errors import CdxError
 
 
@@ -99,10 +100,15 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
 
 
 def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
+    if initial_prompt is not None:
+        if not isinstance(initial_prompt, str):
+            raise CdxError("initial_prompt must be a string.")
+        if len(initial_prompt) > 32768:
+            raise CdxError("initial_prompt exceeds maximum allowed length.")
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
-    if session["provider"] == "claude":
+    if session["provider"] == PROVIDER_CLAUDE:
         args = ["--name", session["name"]]
         if initial_prompt:
             args.append(initial_prompt)
@@ -130,7 +136,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
 
 def _build_login_status_spec(session, env_override=None):
     env = {**os.environ, **(env_override or {})}
-    if session["provider"] == "claude":
+    if session["provider"] == PROVIDER_CLAUDE:
         env.update(_home_env_overrides(_get_auth_home(session)))
 
         def parser(output):
@@ -155,7 +161,7 @@ def _build_login_status_spec(session, env_override=None):
 def _build_auth_action_spec(session, action, cwd=None, env_override=None):
     cwd = cwd or os.getcwd()
     env = {**os.environ, **(env_override or {})}
-    if session["provider"] == "claude":
+    if session["provider"] == PROVIDER_CLAUDE:
         env.update(_home_env_overrides(_get_auth_home(session)))
         return {"command": "claude", "args": ["auth", action],
                 "options": {"cwd": cwd, "env": env}, "label": f"claude auth {action}"}
@@ -184,7 +190,7 @@ def _resolve_command(command, env=None):
 def _probe_provider_auth(session, spawn_sync=None, env_override=None):
     spawn_sync = spawn_sync or subprocess.run
     spec = _build_login_status_spec(session, env_override)
-    if session.get("provider") == "codex":
+    if session.get("provider") == PROVIDER_CODEX:
         auth_path = os.path.join(_get_auth_home(session), "auth.json")
         if os.path.isfile(auth_path):
             return True
@@ -250,11 +256,12 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
         spec = _fallback_launch_spec_or_raise(spec, error)
         child = start_child(spec)
 
-    forwarded_signal = [None]
+    forwarded_signal = None
     handlers = []
 
     def forward(sig, _frame=None):
-        forwarded_signal[0] = sig
+        nonlocal forwarded_signal
+        forwarded_signal = sig
         try:
             if hasattr(child, "send_signal"):
                 child.send_signal(sig)
@@ -283,7 +290,7 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
 
     try:
         child.wait()
-        if forwarded_signal[0] is None and child.returncode != 0 and _should_retry_without_transcript(spec):
+        if forwarded_signal is None and child.returncode != 0 and _should_retry_without_transcript(spec):
             spec = _fallback_launch_spec_or_raise(spec)
             child = start_child(spec)
             child.wait()
@@ -301,10 +308,10 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                 except (OSError, ValueError):
                     pass
 
-    if forwarded_signal[0] is not None:
+    if forwarded_signal is not None:
         raise CdxError(
-            f"{spec['label']} interrupted by {_signal_name(forwarded_signal[0])} for session {session['name']}",
-            _signal_exit_code(forwarded_signal[0]),
+            f"{spec['label']} interrupted by {_signal_name(forwarded_signal)} for session {session['name']}",
+            _signal_exit_code(forwarded_signal),
         )
     if child.returncode != 0:
         raise CdxError(

package/src/session_service.py

@@ -8,14 +8,14 @@ from datetime import datetime, timezone
 from urllib.parse import quote
 
 from .backup_bundle import decode_bundle, encode_bundle
-from .config import get_cdx_home
+from .config import PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
 from .codex_usage import fetch_codex_rate_limits
 from .errors import CdxError
 from .session_store import create_session_store
 from .status_source import find_latest_status_artifact
 
-DEFAULT_PROVIDER = "codex"
-ALLOWED_PROVIDERS = {"codex", "claude"}
+DEFAULT_PROVIDER = PROVIDER_CODEX
+ALLOWED_PROVIDERS = set(PROVIDERS)
 MAX_SESSION_NAME_LENGTH = 64
 RESERVED_SESSION_NAMES = {
     "add",
@@ -81,8 +81,15 @@ def _local_now_iso():
 
 
 def _safe_relpath(path):
-    normalized = str(path or "").replace("\\", "/").strip("/")
-    if not normalized or normalized.startswith("../") or "/../" in f"/{normalized}/":
+    normalized = os.path.normpath(str(path or "").replace("\\", "/")).replace("\\", "/")
+    if (
+        not normalized
+        or normalized == "."
+        or normalized.startswith("/")
+        or (len(normalized) > 1 and normalized[1] == ":")
+        or normalized == ".."
+        or normalized.startswith("../")
+    ):
         raise CdxError("Bundle contains an unsafe file path.")
     return normalized
 
@@ -253,7 +260,7 @@ def create_session_service(options=None):
 
     def _get_session_auth_home(name, provider):
         root = _get_session_root(name)
-        if provider == "claude":
+        if provider == PROVIDER_CLAUDE:
             return os.path.join(root, "claude-home")
         return root
 
@@ -288,22 +295,39 @@ def create_session_service(options=None):
             "auth": session.get("auth"),
         }
 
-    def _collect_profile_files(session_root):
-        excluded_dirs = {"log", "tmp", "cache", "__pycache__", "shell_snapshots"}
+    def _auth_bundle_paths(provider):
+        if provider == PROVIDER_CLAUDE:
+            return [
+                "claude-home/.claude/.credentials.json",
+                "claude-home/.claude.json",
+                "claude-home/auth.json",
+            ]
+        return [
+            "auth.json",
+        ]
+
+    def _collect_auth_files(session_root, provider, session_name=None, progress_callback=None):
         files = []
+        total_bytes = 0
         if not os.path.isdir(session_root):
-            return files
-        for dirpath, dirnames, filenames in os.walk(session_root):
-            dirnames[:] = [name for name in dirnames if name not in excluded_dirs]
-            for filename in filenames:
-                full_path = os.path.join(dirpath, filename)
-                if not os.path.isfile(full_path):
-                    continue
-                rel_path = os.path.relpath(full_path, session_root)
-                with open(full_path, "rb") as handle:
-                    content = base64.b64encode(handle.read()).decode("ascii")
-                files.append({"path": rel_path.replace(os.sep, "/"), "data_b64": content})
-        return files
+            return {"files": files, "file_count": 0, "bytes": 0}
+        for rel_path in _auth_bundle_paths(provider):
+            full_path = os.path.join(session_root, rel_path)
+            if not os.path.isfile(full_path):
+                continue
+            with open(full_path, "rb") as handle:
+                raw_content = handle.read()
+                total_bytes += len(raw_content)
+                content = base64.b64encode(raw_content).decode("ascii")
+            files.append({"path": rel_path.replace(os.sep, "/"), "data_b64": content})
+            if progress_callback:
+                progress_callback({
+                    "event": "profile_progress",
+                    "session_name": session_name,
+                    "file_count": len(files),
+                    "bytes": total_bytes,
+                })
+        return {"files": files, "file_count": len(files), "bytes": total_bytes}
 
     def _resolve_session_subset(session_names):
         if not session_names:
@@ -326,7 +350,7 @@ def create_session_service(options=None):
         _ensure_private_dir(os.path.join(base_dir, "profiles"))
         _ensure_private_dir(session_root)
         _ensure_private_dir(auth_home)
-        if normalized_provider == "codex":
+        if normalized_provider == PROVIDER_CODEX:
             _seed_codex_auth_from_global(auth_home, env=env)
         now = _local_now_iso()
         session = {
@@ -553,7 +577,7 @@ def create_session_service(options=None):
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
-        if session["provider"] == "codex" and codex_status_fetcher:
+        if session["provider"] == PROVIDER_CODEX and codex_status_fetcher:
             live_status = codex_status_fetcher({**session, "authHome": source_root})
             if live_status:
                 record_status(session["name"], live_status)
@@ -561,7 +585,7 @@ def create_session_service(options=None):
 
         expected_account_email = (
             _read_expected_account_email(source_root)
-            if session["provider"] == "codex"
+            if session["provider"] == PROVIDER_CODEX
             else None
         )
         artifact = find_latest_status_artifact(
@@ -570,7 +594,7 @@ def create_session_service(options=None):
             expected_account_email=expected_account_email,
         )
         if (
-            session["provider"] == "codex"
+            session["provider"] == PROVIDER_CODEX
             and not artifact
             and os.path.abspath(base_dir) == os.path.abspath(get_cdx_home(env))
         ):
@@ -620,11 +644,28 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows():
+    def get_status_rows(progress_callback=None):
         sessions = list_sessions()
+        if progress_callback:
+            progress_callback({
+                "event": "status_started",
+                "session_count": len(sessions),
+            })
         resolved = []
         for s in sessions:
+            if progress_callback:
+                progress_callback({
+                    "event": "session_started",
+                    "session_name": s["name"],
+                    "provider": s["provider"],
+                })
             status = _resolve_session_status(s)
+            if progress_callback:
+                progress_callback({
+                    "event": "session_finished",
+                    "session_name": s["name"],
+                    "has_status": bool(status),
+                })
             resolved.append({
                 **s,
                 "lastStatus": status,
@@ -659,6 +700,12 @@ def create_session_service(options=None):
                 "reset_week_at": status.get("reset_week_at") if status else None,
                 "reset_at": status.get("reset_at") if status else None,
                 "updated_at": _to_local_iso(s.get("lastStatusAt")),
+                "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
+            })
+        if progress_callback:
+            progress_callback({
+                "event": "status_finished",
+                "row_count": len(rows),
             })
         return rows
 
@@ -688,7 +735,7 @@ def create_session_service(options=None):
     def get_session_root(name):
         return _get_session_root(name)
 
-    def export_bundle(file_path, include_auth=False, session_names=None, passphrase=None, force=False):
+    def export_bundle(file_path, include_auth=False, session_names=None, passphrase=None, force=False, progress_callback=None):
         if not file_path:
             raise CdxError("Export path is required.")
         if os.path.exists(file_path) and not force:
@@ -703,16 +750,36 @@ def create_session_service(options=None):
             "states": {},
             "profiles": {},
         }
+        profile_file_count = 0
+        profile_bytes = 0
+        if progress_callback:
+            progress_callback({
+                "event": "export_started",
+                "include_auth": bool(include_auth),
+                "session_count": len(sessions),
+                "session_names": [session["name"] for session in sessions],
+            })
         for session in sessions:
+            if progress_callback:
+                progress_callback({"event": "session_started", "session_name": session["name"]})
             payload["sessions"].append(_build_export_session_record(session))
             state = store["read_session_state"](session["name"])
             if state is not None:
                 payload["states"][session["name"]] = state
             if include_auth:
                 session_root = session.get("sessionRoot") or _get_session_root(session["name"])
-                payload["profiles"][session["name"]] = _collect_profile_files(session_root)
-
+                profile = _collect_auth_files(session_root, session["provider"], session["name"], progress_callback)
+                payload["profiles"][session["name"]] = profile["files"]
+                profile_file_count += profile["file_count"]
+                profile_bytes += profile["bytes"]
+            if progress_callback:
+                progress_callback({"event": "session_finished", "session_name": session["name"]})
+
+        if progress_callback:
+            progress_callback({"event": "encoding_started"})
         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)})
         _ensure_private_dir(os.path.dirname(os.path.abspath(file_path)) or ".")
         with open(file_path, "wb") as handle:
             handle.write(bundle_bytes)
@@ -725,6 +792,10 @@ def create_session_service(options=None):
             "path": file_path,
             "include_auth": include_auth,
             "session_names": [session["name"] for session in sessions],
+            "session_count": len(sessions),
+            "profile_file_count": profile_file_count if include_auth else None,
+            "profile_bytes": profile_bytes if include_auth else None,
+            "bundle_size_bytes": len(bundle_bytes),
         }
 
     def import_bundle(file_path, passphrase=None, session_names=None, force=False):

package/src/status_source.py

@@ -3,6 +3,7 @@ import os
 import re
 from datetime import datetime, timezone
 
+from .config import PROVIDER_CLAUDE, PROVIDER_CODEX
 
 _ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
 _ANSI_TERMINAL_CONTROL = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
@@ -14,6 +15,23 @@ MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
 MAX_STATUS_READ_BYTES = 512 * 1024
 MAX_STATUS_CANDIDATE_FILES = 64
 
+_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)),
+    ("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)),
+    ("remaining_5h_pct", re.compile(r"remaining\s+5h\s*[:=]\s*(\d{1,3})%", re.I)),
+    ("remaining_week_pct", re.compile(r"week(?:\s+remaining)?\s*[:=]\s*(\d{1,3})%", re.I)),
+    ("remaining_week_pct", re.compile(r"remaining\s+week\s*[:=]\s*(\d{1,3})%", re.I)),
+]
+
 
 def _strip_ansi(text):
     return _ANSI_ESCAPE.sub("", str(text or ""))
@@ -185,7 +203,7 @@ def _extract_status_blocks_from_text(text, provider=None, source_ref=None, times
             index = max(index + 1, end_index)
         return blocks
 
-    if provider != "codex":
+    if provider != PROVIDER_CODEX:
         for block in collect_blocks(
             re.compile(r"^\s*(?:[│|]\s*)?Current session\b", re.I),
             [re.compile(p, re.I) for p in [
@@ -195,7 +213,7 @@ def _extract_status_blocks_from_text(text, provider=None, source_ref=None, times
         ):
             items.append({"source_ref": source_ref, "timestamp": timestamp, "text": block})
 
-    if provider != "claude":
+    if provider != PROVIDER_CLAUDE:
         for block in collect_blocks(
             re.compile(r"^\s*(?:[│|]\s*)?5h\s+limit\b", re.I),
             [re.compile(p, re.I) for p in [
@@ -412,23 +430,7 @@ def extract_named_statuses_from_text(text):
     lines = [l.strip() for l in normalized.split("\n") if l.strip()]
     result = {}
 
-    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)),
-        ("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)),
-        ("remaining_5h_pct", re.compile(r"remaining\s+5h\s*[:=]\s*(\d{1,3})%", re.I)),
-        ("remaining_week_pct", re.compile(r"week(?:\s+remaining)?\s*[:=]\s*(\d{1,3})%", re.I)),
-        ("remaining_week_pct", re.compile(r"remaining\s+week\s*[:=]\s*(\d{1,3})%", re.I)),
-    ]
-    for field, pattern in key_value_patterns:
+    for field, pattern in _KEY_VALUE_PATTERNS:
         if field not in result:
             m = pattern.search(normalized)
             if m:
@@ -620,7 +622,7 @@ def find_latest_status_artifact(root_dir, provider=None, expected_account_email=
 
     best = None
     for candidate in records:
-        if provider == "codex" and not _account_matches_expected(
+        if provider == PROVIDER_CODEX and not _account_matches_expected(
             candidate["text"], expected_account_email
         ):
             continue

package/src/status_view.py

@@ -9,6 +9,9 @@ from .cli_render import (
     _style_pct,
 )
 
+RESET_COUNTDOWN_SAFETY_SECONDS = 60
+PRIORITY_EMPTY_AVAILABLE_THRESHOLD = 5
+
 
 def _format_reset_time(value):
     if not value:
@@ -27,6 +30,7 @@ def _format_reset_time(value):
         if hours_ago < 24:
             return f"passed {hours_ago}h ago"
         return value
+    delta_s = delta_s + RESET_COUNTDOWN_SAFETY_SECONDS
     if delta_s < 60:
         return "now"
     if delta_s < 24 * 60 * 60:
@@ -104,14 +108,28 @@ def _format_status_rows(rows, use_color=False, small=False):
             if len(priority) > 1 else "."
         )
     ) if priority else "Priority: no usable session status yet."
+    current_line = _format_current_session_line(rows)
     return "\n".join([
         _pad_table([headers] + table_rows),
         "",
         _style(priority_line, "1", use_color),
-        _style("Tip: Codex status uses the local app-server rate-limit API when available; Claude sessions auto-refresh, use --refresh to force.", "2", use_color),
+        _style(current_line, "2", use_color),
     ])
 
 
+def _format_current_session_line(rows):
+    launched = []
+    for row in rows:
+        timestamp = _parse_reset_timestamp(row.get("last_launched_at"))
+        if timestamp is not None:
+            launched.append((timestamp, row))
+    if not launched:
+        return "Current: no launched session known yet."
+    timestamp, row = max(launched, key=lambda item: (item[0], item[1].get("session_name") or ""))
+    label = _format_relative_age(row.get("last_launched_at"))
+    return f"Current: last launched {row['session_name']} ({label})."
+
+
 def _recommend_priority_sessions(rows):
     if not rows:
         return []
@@ -120,7 +138,7 @@ def _recommend_priority_sessions(rows):
         has_credits = row.get("credits") is not None
         credit_rank = 0 if has_credits else 1
         available = row.get("available_pct")
-        usable_now = available is not None and available > 0
+        usable_now = available is not None and available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD
         known_available = available is not None
         reset_timestamp = _priority_reset_timestamp(row)
         reset_is_future = reset_timestamp is not None and reset_timestamp >= _now_timestamp()
@@ -165,7 +183,7 @@ def _priority_instruction(row, position):
 
 def _priority_needs_refresh(row):
     available = row.get("available_pct")
-    if available is None or available > 0:
+    if available is None or available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
         return False
     _label, is_past = _priority_reset_info(row)
     return is_past
@@ -175,7 +193,7 @@ def _priority_reason(row):
     available = row.get("available_pct")
     if available is None:
         return "status unknown"
-    if available > 0:
+    if available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
         return f"{_format_pct(available)} OK"
     label, is_past = _priority_reset_info(row)
     if label: