cdx-manager 0.7.2 → 0.7.4

package/src/provider_runtime.py

@@ -39,6 +39,7 @@ HEADLESS_CODEX_PERMISSION_ARGS = {
     "auto": ["-s", "workspace-write", "-c", 'approval_policy="never"'],
     "full": ["--dangerously-bypass-approvals-and-sandbox"],
 }
+REDACTED_PROMPT_ARG = "[prompt redacted]"
 
 
 def _home_env_overrides(auth_home):
@@ -108,6 +109,12 @@ def _has_local_claude_auth(auth_home):
     return bool(isinstance(oauth, dict) and _clean_oauth_token(oauth.get("accessToken")))
 
 
+def _read_claude_launch_oauth_token(auth_home):
+    if _has_local_claude_auth(auth_home):
+        return None
+    return _read_anthropic_oauth_token(auth_home)
+
+
 def _has_local_codex_auth(auth_home):
     try:
         with open(os.path.join(auth_home, "auth.json"), "r", encoding="utf-8") as handle:
@@ -312,7 +319,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             args.append(initial_prompt)
         auth_home = _get_auth_home(session)
         claude_env = _claude_env(env, auth_home)
-        oauth_token = _read_anthropic_oauth_token(auth_home)
+        oauth_token = _read_claude_launch_oauth_token(auth_home)
         if oauth_token:
             claude_env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
         return _wrap_launch_with_transcript(session, {
@@ -393,7 +400,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
             args.append(initial_prompt)
         auth_home = _get_auth_home(session)
         claude_env = _claude_env(env, auth_home)
-        oauth_token = _read_anthropic_oauth_token(auth_home)
+        oauth_token = _read_claude_launch_oauth_token(auth_home)
         if oauth_token:
             claude_env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
         return {
@@ -401,6 +408,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
             "args": args,
             "options": {"cwd": cwd, "env": claude_env},
             "label": "claude",
+            "sensitive_args": [initial_prompt] if initial_prompt else [],
         }
 
     if session["provider"] == PROVIDER_CODEX:
@@ -418,6 +426,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
             "args": args,
             "options": {"cwd": cwd, "env": {**env, "CODEX_HOME": _get_auth_home(session)}},
             "label": "codex",
+            "sensitive_args": [initial_prompt] if initial_prompt else [],
         }
 
     return _build_launch_spec(
@@ -468,7 +477,7 @@ def _headless_run_info(paths, spec, start_time, returncode):
         "ended_at": end_time.isoformat().replace("+00:00", "Z"),
         "duration_ms": int((end_time - start_time).total_seconds() * 1000),
         "command": spec.get("command"),
-        "args": list(spec.get("args") or []),
+        "args": _redact_sensitive_args(spec),
         "label": spec.get("label"),
         "pid": None,
         "returncode": returncode,
@@ -476,6 +485,14 @@ def _headless_run_info(paths, spec, start_time, returncode):
     }
 
 
+def _redact_sensitive_args(spec):
+    args = list(spec.get("args") or [])
+    sensitive = {value for value in (spec.get("sensitive_args") or []) if value}
+    if not sensitive:
+        return args
+    return [REDACTED_PROMPT_ARG if arg in sensitive else arg for arg in args]
+
+
 def _run_headless_provider_command(session, cwd=None, env_override=None, initial_prompt=None,
                                    timeout_seconds=None, spawn=None, run_id=None):
     spawn = spawn or subprocess.Popen
@@ -545,7 +562,7 @@ def _run_headless_provider_command(session, cwd=None, env_override=None, initial
         "ended_at": end_time.isoformat().replace("+00:00", "Z"),
         "duration_ms": int((end_time - start_time).total_seconds() * 1000),
         "command": spec.get("command"),
-        "args": list(spec.get("args") or []),
+        "args": _redact_sensitive_args(spec),
         "label": spec.get("label"),
         "pid": getattr(child, "pid", None),
         "returncode": returncode,
@@ -558,7 +575,7 @@ def _build_login_status_spec(session, env_override=None):
     if session["provider"] == PROVIDER_CLAUDE:
         auth_home = _get_auth_home(session)
         env = _claude_env(env, auth_home)
-        oauth_token = _read_anthropic_oauth_token(auth_home)
+        oauth_token = _read_claude_launch_oauth_token(auth_home)
         if oauth_token:
             env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
 
@@ -639,13 +656,14 @@ def _resolve_command(command, env=None):
     return shutil.which(command, path=env.get("PATH")) or command
 
 
-def _probe_provider_auth(session, spawn_sync=None, env_override=None):
+def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_local_credentials=True):
     spawn_sync = spawn_sync or subprocess.run
     spec = _build_login_status_spec(session, env_override)
-    if session.get("provider") == PROVIDER_CLAUDE and _has_local_claude_auth(_get_auth_home(session)):
-        return True
-    if session.get("provider") == PROVIDER_CODEX and _has_local_codex_auth(_get_auth_home(session)):
-        return True
+    if trust_local_credentials:
+        if session.get("provider") == PROVIDER_CLAUDE and _has_local_claude_auth(_get_auth_home(session)):
+            return True
+        if session.get("provider") == PROVIDER_CODEX and _has_local_codex_auth(_get_auth_home(session)):
+            return True
     try:
         if spawn_sync is subprocess.run:
             command = _resolve_command(spec["command"], spec["env"])
@@ -830,8 +848,17 @@ def _should_retry_without_transcript(spec):
 
 def _ensure_session_authentication(session, service, spawn=None, spawn_sync=None,
                                    stdin_is_tty=True, env_override=None, behavior="launch",
-                                   signal_emitter=None):
-    is_authenticated = _probe_provider_auth(session, spawn_sync=spawn_sync, env_override=env_override)
+                                   signal_emitter=None, trust_local_credentials=True):
+    if behavior == "launch" and (session.get("auth") or {}).get("status") == "logged_out":
+        raise CdxError(
+            f"Session {session['name']} is not authenticated. Run: cdx login {session['name']}"
+        )
+    is_authenticated = _probe_provider_auth(
+        session,
+        spawn_sync=spawn_sync,
+        env_override=env_override,
+        trust_local_credentials=trust_local_credentials,
+    )
     if is_authenticated:
         return {"authenticated": True, "checked": True}
     if behavior == "probe-only":

package/src/run_command.py

@@ -0,0 +1,83 @@
+import os
+
+from .errors import CdxError
+from .run_usage import empty_usage, extract_run_usage
+
+
+def read_run_prompt(parsed):
+    if parsed.get("prompt") is not None:
+        return parsed["prompt"]
+    try:
+        with open(parsed["prompt_file"], "r", encoding="utf-8") as handle:
+            return handle.read()
+    except OSError as error:
+        raise CdxError(f"Unable to read prompt file: {parsed['prompt_file']}") from error
+
+
+def run_cdx_error_code(error):
+    message = str(error)
+    if message.startswith("Usage:"):
+        return "invalid_request"
+    if message.startswith("Invalid cwd:"):
+        return "invalid_cwd"
+    if message.startswith("Session is disabled:"):
+        return "session_disabled"
+    if "CLI not found on PATH" in message:
+        return "provider_cli_not_found"
+    if message.startswith("Failed to start "):
+        return "provider_start_failed"
+    if (
+        message.startswith("Unsupported reasoning effort:")
+        or message.startswith("Unsupported power:")
+        or "--reasoning-effort and --power must match" in message
+    ):
+        return "invalid_reasoning_effort"
+    return "cdx_error"
+
+
+def run_payload_reasoning_effort(parsed, session):
+    launch = (session.get("launch") or {}) if session else {}
+    return (
+        parsed.get("reasoning_effort")
+        or parsed.get("power")
+        or launch.get("reasoning_effort")
+        or launch.get("reasoningEffort")
+        or launch.get("power")
+        or ("low" if launch.get("fast") is True else None)
+    )
+
+
+def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
+                       error=None, error_source=None, error_code=None):
+    run_info = run_info or {}
+    usage = run_info.get("usage") if isinstance(run_info.get("usage"), dict) else (
+        extract_run_usage(session.get("provider"), run_info.get("stdout_path"))
+        if session else
+        empty_usage()
+    )
+    return {
+        "schema_version": api_schema_version,
+        "ok": bool(ok),
+        "action": "run",
+        "launcher": "cdx",
+        "session": session.get("name") if session else None,
+        "provider": session.get("provider") if session else parsed.get("provider"),
+        "model": parsed.get("model") or ((session.get("launch") or {}).get("model") if session else None),
+        "reasoning_effort": run_payload_reasoning_effort(parsed, session),
+        "power": parsed.get("power") or ((session.get("launch") or {}).get("power") if session else None),
+        "cwd": os.path.abspath(parsed.get("cwd") or os.getcwd()),
+        "run_id": run_info.get("run_id"),
+        "exit_code": run_info.get("returncode"),
+        "duration_seconds": (run_info.get("duration_ms") / 1000.0) if run_info.get("duration_ms") is not None else None,
+        "transcript_path": run_info.get("transcript_path"),
+        "stdout_path": run_info.get("stdout_path"),
+        "stderr_path": run_info.get("stderr_path"),
+        "usage": usage,
+        "warnings": [],
+        "error": None if ok else {
+            "source": error_source or "cdx",
+            "code": error_code or "cdx_error",
+            "message": str(error) if error else "Run failed.",
+            "provider_code": run_info.get("returncode") if error_source == "provider" else None,
+        },
+    }

package/src/session_service.py

@@ -5,6 +5,7 @@ import base64
 import sys
 import tempfile
 import uuid
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from urllib.parse import quote
 
@@ -22,19 +23,26 @@ RESERVED_SESSION_NAMES = {
     "add",
     "clean",
     "context",
+    "configs",
     "cp",
     "disable",
     "doctor",
     "enable",
     "export",
+    "fast",
     "help",
     "handoff",
     "history",
     "import",
+    "last",
     "login",
     "logout",
+    "model",
     "mv",
+    "next",
     "notify",
+    "perm",
+    "power",
     "ready",
     "repair",
     "ren",
@@ -44,6 +52,7 @@ RESERVED_SESSION_NAMES = {
     "select",
     "config",
     "set",
+    "stats",
     "status",
     "unset",
     "update",
@@ -55,12 +64,17 @@ RESERVED_SESSION_NAMES = {
 }
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+MAX_STATUS_WORKERS = 8
 LAUNCH_POWER_VALUES = {"low", "medium", "high", "xhigh", "max"}
 LAUNCH_REASONING_EFFORT_VALUES = {"low", "medium", "high"}
 LAUNCH_PERMISSION_VALUES = {"review", "default", "auto", "full"}
 MAX_LAUNCH_MODEL_LENGTH = 128
 MIN_LAUNCH_PRIORITY = 0
 MAX_LAUNCH_PRIORITY = 100
+DEFAULT_LAUNCH_SETTINGS = {
+    "power": "medium",
+    "fast": False,
+}
 
 
 def _encode(name):
@@ -448,6 +462,8 @@ def create_session_service(options=None):
             raise CdxError("Session name is required")
         if str(name) != str(name).strip():
             raise CdxError("Session name cannot start or end with whitespace")
+        if str(name) in (".", ".."):
+            raise CdxError("Session name cannot be . or ..")
         if len(str(name)) > MAX_SESSION_NAME_LENGTH:
             raise CdxError(f"Session name is too long (max {MAX_SESSION_NAME_LENGTH} characters)")
         if any(ord(ch) < 32 or ord(ch) == 127 for ch in str(name)):
@@ -542,6 +558,7 @@ def create_session_service(options=None):
             "lastLaunchedAt": None,
             "lastStatusAt": None,
             "lastStatus": None,
+            "launch": dict(DEFAULT_LAUNCH_SETTINGS),
             "auth": {
                 "status": "unknown",
                 "lastCheckedAt": None,
@@ -939,14 +956,9 @@ def create_session_service(options=None):
 
     def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         sessions = list_sessions()
-        if progress_callback:
-            progress_callback({
-                "event": "status_started",
-                "session_count": len(sessions),
-            })
-        resolved = []
-        for s in sessions:
-            cache_hit = (
+
+        def _status_cache_hit(s):
+            return (
                 s.get("enabled", True) is False
                 or (
                     s.get("lastStatus")
@@ -954,28 +966,56 @@ def create_session_service(options=None):
                     and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
                 )
             )
-            if progress_callback and not cache_hit:
-                progress_callback({
-                    "event": "session_started",
-                    "session_name": s["name"],
-                    "provider": s["provider"],
-                })
+
+        cache_hits = {
+            s["name"]: _status_cache_hit(s)
+            for s in sessions
+        }
+        if progress_callback:
+            progress_callback({
+                "event": "status_started",
+                "session_count": len(sessions),
+                "check_count": sum(1 for cache_hit in cache_hits.values() if not cache_hit),
+            })
+
+        def _resolve_row_session(s):
             status = _resolve_session_status(
                 s,
                 force_refresh=force_refresh,
                 cache_ttl_seconds=cache_ttl_seconds,
             )
-            if progress_callback:
-                progress_callback({
-                    "event": "session_finished",
-                    "session_name": s["name"],
-                    "has_status": bool(status),
-                })
-            resolved.append({
+            return {
                 **s,
                 "lastStatus": status,
                 "lastStatusAt": (status and status.get("updated_at")) or s.get("lastStatusAt"),
-            })
+            }
+
+        resolved_by_name = {}
+        if sessions:
+            max_workers = min(MAX_STATUS_WORKERS, len(sessions))
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = {}
+                for s in sessions:
+                    cache_hit = cache_hits[s["name"]]
+                    if progress_callback and not cache_hit:
+                        progress_callback({
+                            "event": "session_started",
+                            "session_name": s["name"],
+                            "provider": s["provider"],
+                        })
+                    futures[executor.submit(_resolve_row_session, s)] = s
+                for future in as_completed(futures):
+                    s = futures[future]
+                    resolved = future.result()
+                    resolved_by_name[s["name"]] = resolved
+                    if progress_callback:
+                        progress_callback({
+                            "event": "session_finished",
+                            "session_name": s["name"],
+                            "has_status": bool(resolved.get("lastStatus")),
+                            "cache_hit": cache_hits[s["name"]],
+                        })
+        resolved = [resolved_by_name[s["name"]] for s in sessions]
 
         def sort_key(s):
             at = s.get("lastStatusAt") or ""
@@ -1092,7 +1132,7 @@ def create_session_service(options=None):
         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 ".")
+        os.makedirs(os.path.dirname(os.path.abspath(file_path)) or ".", exist_ok=True)
         with open(file_path, "wb") as handle:
             handle.write(bundle_bytes)
         if sys.platform != "win32":

package/src/status_view.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
 
 from .cli_render import (
     _dim,
@@ -61,6 +62,17 @@ def _style_reset_time(value, use_color=False):
     return text
 
 
+def _format_credits(value, empty="n/a"):
+    if value is None:
+        return empty
+    try:
+        normalized = str(value).strip().replace(",", "")
+        rounded = Decimal(normalized).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+        return f"{rounded:.2f}"
+    except (InvalidOperation, ValueError):
+        return str(value)
+
+
 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:
@@ -75,15 +87,11 @@ def _format_status_rows(rows, use_color=False, small=False):
         return "SESSION  STATUS  OK  5H  WEEK  BLOCK  CR  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_candidates = [
-        r for r in active_rows
-        if _format_auth_status(r) != "logged out"
-    ]
+    priority = recommend_priority_rows(rows)
     disabled_rows = sorted(
         [r for r in rows if r.get("enabled", True) is False],
         key=lambda r: r.get("session_name") or "",
     )
-    priority = _recommend_priority_sessions(priority_candidates)
     priority_names = {r.get("session_name") for r in priority}
     non_priority_active = [
         r for r in active_rows
@@ -114,7 +122,7 @@ def _format_status_rows(rows, use_color=False, small=False):
             base += usage_columns
         else:
             block = "-" if r.get("enabled", True) is False else _format_blocking_quota(r)
-            credits = str(r["credits"]) if r.get("credits") is not None else "-"
+            credits = _format_credits(r.get("credits"), empty="-")
             base += usage_columns[:3] + [
                 _style(block, "33" if block not in ("?", "-") else "2", use_color),
                 _style(credits, "33" if r.get("credits") is not None else "2", use_color),
@@ -168,6 +176,19 @@ def _format_auth_status(row):
     return "unknown"
 
 
+def recommend_priority_rows(rows):
+    active_rows = [r for r in rows if r.get("enabled", True) is not False]
+    priority_candidates = [
+        r for r in active_rows
+        if _format_auth_status(r) != "logged out"
+    ]
+    return _recommend_priority_sessions(priority_candidates)
+
+
+def format_priority_instruction(row, position="first"):
+    return _priority_instruction(row, position)
+
+
 def _recommend_priority_sessions(rows):
     if not rows:
         return []
@@ -332,7 +353,7 @@ def _format_status_detail(row, use_color=False):
         f"{_style('5h left:', '1', use_color)} {_style_pct(row.get('remaining_5h_pct'), use_color)}",
         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(row['credits'] if row.get('credits') is not None else 'n/a', '33' if row.get('credits') is not None else '2', 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('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)}",