cdx-manager 0.5.4 → 0.5.5

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.5-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -35,7 +35,7 @@ One command to launch any session. Zero auth juggling.
 - **Multiple accounts, one tool.** Register as many Codex or Claude sessions as you need. Each one gets its own isolated auth environment — no cross-contamination between accounts.
 - **Instant launch.** `cdx work` opens your "work" session. `cdx personal` opens another. No config files to edit mid-flow.
 - **Auth guardrails.** `cdx` checks authentication before launching. If a session is not logged in, it tells you exactly what to run — no silent failures.
-- **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, and last-updated timestamps for every session in one aligned table.
+- **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, last-updated timestamps, priority guidance, and the last launched session in one aligned table.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
 - **Shared handoff context.** Keep a per-workspace Markdown context, or build one from a source session transcript, and install it into another assistant session before switching providers or accounts.
 - **Passive status resolution.** Codex status is read from the local Codex app-server rate-limit API when available, with legacy transcript/history parsing kept as a fallback.
@@ -126,7 +126,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.4 sh install.sh
+CDX_VERSION=v0.5.5 sh install.sh
 ```
 
 From source:
@@ -349,7 +349,7 @@ cdx import backup-auth.cdx --passphrase-env CDX_BUNDLE_PASSPHRASE
 
 Notes:
 
-- `--include-auth` is encrypted and requires a passphrase.
+- `--include-auth` is encrypted, requires a passphrase, and exports only provider credential files rather than full profile caches or logs.
 - Without `--passphrase-env`, `cdx` prompts in an interactive terminal.
 - `--sessions work,perso` exports or imports only a subset.
 - `--force` allows overwriting existing destination sessions during import or replacing an existing bundle file during export.

package/changelogs/CHANGELOGS_0_5_5.md

@@ -0,0 +1,48 @@
+# Changelog (`0.5.4 -> 0.5.5`)
+
+Release date: 2026-05-24
+
+## Major Highlights
+
+- Fixed Claude usage probing for OAuth credentials by using bearer-token authentication.
+- Improved `cdx status` guidance with progress output, conservative reset timing, near-empty account handling, and last-launched session context.
+- Made encrypted auth exports lightweight by backing up provider credential files instead of full profile caches, logs, and runtime artifacts.
+
+## Usage and Status
+
+- Added progress output while `cdx status` resolves session statuses in text mode, while keeping `--json` output clean.
+- Added a `Current:` line under the priority recommendation showing the last launched session, useful before running a handoff.
+- Removed the older status tip line now that status output carries actionable priority and current-session context.
+- Treated sessions with `5%` or less availability as empty for priority recommendations, while preserving the true percentage in the table.
+- Added a conservative one-minute reset countdown margin so users are less likely to switch back before a reset is usable.
+
+## Claude Usage Handling
+
+- Fixed the Claude rate-limit probe to send OAuth access tokens as `Authorization: Bearer ...`.
+- Surfaced Claude HTTP failures without rate-limit headers as structured refresh warnings, including API error text when available.
+- Preserved existing fallback behavior for unavailable network probes and historical status data.
+
+## Export and Backup
+
+- Limited `cdx export --include-auth` to provider credential files:
+  - Codex: `auth.json`
+  - Claude: `claude-home/.claude/.credentials.json`, `claude-home/.claude.json`, and legacy `claude-home/auth.json`
+- Excluded profile caches, logs, SQLite usage databases, temporary files, and provider runtime artifacts from auth bundles.
+- Added export progress output in text mode and a final summary with bundle size, auth file count, and auth data size.
+- Kept `cdx export --json` clean and added bundle metrics to its JSON payload.
+
+## Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.5`.
+- Clarified that encrypted auth exports include credential files rather than full profile caches or logs.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for Claude HTTP failures without usage headers.
+- Added status rendering tests for progress output, last-launched context, near-empty priority handling, and removed tip text.
+- Added export/import tests proving auth bundles exclude non-auth profile files such as `logs_2.sqlite`.
+
+## Validation and Regression Evidence
+
+- `python3 -m pytest test/test_cli_py.py test/test_session_service_py.py`
+- `python3 -m pytest test/test_runtime_py.py test/test_cli_py.py test/test_status_source_py.py`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.5.4"
+version = "0.5.5"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/claude_usage.py

@@ -4,6 +4,8 @@ import urllib.request
 import urllib.error
 from datetime import datetime, timezone
 
+from .errors import CdxError
+
 MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 CLAUDE_STATUS_PROBE_MODEL = os.environ.get("CDX_CLAUDE_STATUS_MODEL", "claude-haiku-4-5-20251001")
@@ -24,6 +26,29 @@ def _format_reset_date(unix_seconds):
     return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
 
 
+def _read_http_error_message(error):
+    try:
+        body = error.read().decode("utf-8", errors="replace")
+    except (AttributeError, OSError, UnicodeDecodeError):
+        body = ""
+    if not body:
+        return ""
+    try:
+        payload = json.loads(body)
+    except json.JSONDecodeError:
+        return body.strip()
+    detail = payload.get("error") if isinstance(payload, dict) else None
+    if isinstance(detail, dict):
+        message = detail.get("message") or detail.get("type")
+        if message:
+            return str(message)
+    if isinstance(payload, dict):
+        message = payload.get("message") or payload.get("detail")
+        if message:
+            return str(message)
+    return body.strip()
+
+
 def fetch_claude_rate_limit_headers(access_token):
     body = json.dumps({
         "model": CLAUDE_STATUS_PROBE_MODEL,
@@ -35,7 +60,7 @@ def fetch_claude_rate_limit_headers(access_token):
         "https://api.anthropic.com/v1/messages",
         data=body,
         headers={
-            "x-api-key": access_token,
+            "Authorization": f"Bearer {access_token}",
             "anthropic-version": "2023-06-01",
             "content-type": "application/json",
         },
@@ -47,6 +72,13 @@ def fetch_claude_rate_limit_headers(access_token):
             headers = {k.lower(): v for k, v in resp.getheaders()}
     except urllib.error.HTTPError as e:
         headers = {k.lower(): v for k, v in e.headers.items()}
+        if (
+            "anthropic-ratelimit-unified-5h-utilization" not in headers
+            and "anthropic-ratelimit-unified-7d-utilization" not in headers
+        ):
+            message = _read_http_error_message(e)
+            suffix = f": {message}" if message else ""
+            raise CdxError(f"Claude usage unavailable (HTTP {e.code}{suffix})") from e
     except urllib.error.URLError:
         return None
 

package/src/cli.py

@@ -49,7 +49,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.4"
+VERSION = "0.5.5"
 
 
 # ---------------------------------------------------------------------------

package/src/cli_commands.py

@@ -69,6 +69,76 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
+def _format_bytes(value):
+    if value is None:
+        return "n/a"
+    try:
+        amount = float(value)
+    except (TypeError, ValueError):
+        return str(value)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit = units[0]
+    for unit in units:
+        if amount < 1024 or unit == units[-1]:
+            break
+        amount /= 1024
+    if unit == "B":
+        return f"{int(amount)} B"
+    return f"{amount:.1f} {unit}"
+
+
+def _format_export_report(result):
+    lines = [
+        f"Path: {result['path']}",
+        f"Sessions: {', '.join(result['session_names']) or '-'}",
+        f"Auth: {'included and encrypted' if result['include_auth'] else 'not included'}",
+        f"Bundle size: {_format_bytes(result.get('bundle_size_bytes'))}",
+    ]
+    if result.get("include_auth"):
+        lines.extend([
+            f"Auth files: {result.get('profile_file_count', 0)}",
+            f"Auth data: {_format_bytes(result.get('profile_bytes'))}",
+        ])
+    return "\n".join(lines)
+
+
+def _make_export_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "export_started":
+            auth = " with auth" if event.get("include_auth") else ""
+            message = f"Exporting {event.get('session_count', 0)} session(s){auth}..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            message = f"Collecting {event.get('session_name')}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "profile_progress":
+            message = f"  {event.get('session_name')}: {event.get('file_count', 0)} files, {_format_bytes(event.get('bytes'))}"
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "encoding_started":
+            ctx["out"](f"{_dim('Encoding and encrypting bundle...', ctx['use_color'])}\n")
+        elif kind == "writing_started":
+            message = f"Writing {_format_bytes(event.get('bundle_size_bytes'))}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _make_status_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "status_started":
+            message = f"Resolving status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "status_finished":
+            message = f"Resolved {event.get('row_count', 0)} status row(s)."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
 def _latest_launch_transcript_path(session):
     paths = _list_launch_transcript_paths(session)
     if not paths:
@@ -696,7 +766,8 @@ def handle_status(rest, ctx):
         for item in refresh_errors
     ]
 
-    rows = ctx["service"]["get_status_rows"]()
+    status_progress = None if parsed["json"] else _make_status_progress(ctx)
+    rows = ctx["service"]["get_status_rows"](progress_callback=status_progress)
     if len(args) == 0:
         if parsed["json"]:
             _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
@@ -740,6 +811,7 @@ def handle_export(rest, ctx):
         session_names=parsed["session_names"],
         passphrase=passphrase,
         force=parsed["force"],
+        progress_callback=None if parsed["json"] else _make_export_progress(ctx),
     )
     session_count = len(result["session_names"])
     auth_suffix = " with auth" if result["include_auth"] else ""
@@ -753,6 +825,7 @@ def handle_export(rest, ctx):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_export_report(result)}\n")
     return 0
 
 
@@ -961,9 +1034,6 @@ def handle_launch(command, ctx, initial_prompt=None):
             if update_notice.get("url"):
                 text = f"{text} {update_notice['url']}"
             ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
-    if session["provider"] == PROVIDER_CODEX:
-        if not json_flag:
-            ctx["out"](f"{_dim('Tip: cdx status reads Codex rate limits from the local app-server when available.', ctx['use_color'])}\n")
     _run_interactive_provider_command(
         session, "launch", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
         signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,

package/src/session_service.py

@@ -295,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:
@@ -627,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,
@@ -666,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
 
@@ -695,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:
@@ -710,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)
@@ -732,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_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: