cdx-manager 0.6.4 → 0.7.0

package/src/cli_commands.py

@@ -33,7 +33,9 @@ from .notify import (
 from .provider_runtime import (
     _ensure_session_authentication,
     _list_launch_transcript_paths,
+    _normalize_reasoning_effort,
     _probe_provider_auth,
+    _run_headless_provider_command,
     _run_interactive_provider_command,
 )
 from .repair import format_repair_report, repair_health
@@ -51,12 +53,14 @@ EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--
 IMPORT_USAGE = "Usage: cdx import <file> [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--json]"
-SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--model MODEL] [--json]"
-UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--model|--all) [--json]"
+SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--model MODEL] [--priority 0..100] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--model|--priority|--all) [--json]"
 SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
 LAST_USAGE = "Usage: cdx last [--json]"
+SELECT_USAGE = "Usage: cdx select --provider PROVIDER [--min-reasoning-effort low|medium|high] [--min-power low|medium|high] [--require-ready] [--refresh] --json"
+RUN_USAGE = "Usage: cdx run [session] --cwd PATH (--prompt-file PATH|--prompt TEXT) [--provider PROVIDER] [--model MODEL] [--reasoning-effort low|medium|high] [--power low|medium|high] [--permission review|default|auto|full|workspace-write|read-only|danger-full-access] [--timeout-seconds N] --json"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
 HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES = 64
@@ -78,6 +82,23 @@ def _json_success(action, message, warnings=None, **extra):
     return payload
 
 
+def _json_failure(action, code, message, source="cdx", exit_code=1, warnings=None, **extra):
+    payload = {
+        "schema_version": API_SCHEMA_VERSION,
+        "ok": False,
+        "action": action,
+        "warnings": warnings or [],
+        "error": {
+            "source": source,
+            "code": code,
+            "message": message,
+            "exit_code": exit_code,
+        },
+    }
+    payload.update(extra)
+    return payload
+
+
 def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
@@ -467,12 +488,23 @@ def _parse_fast_value(value):
     raise CdxError(SET_USAGE)
 
 
+def _parse_priority_value(value):
+    try:
+        priority = int(value)
+    except (TypeError, ValueError) as error:
+        raise CdxError(SET_USAGE) from error
+    if priority < 0 or priority > 100:
+        raise CdxError(SET_USAGE)
+    return priority
+
+
 def _parse_set_args(args):
     parsed = _parse_flag_args(args, {
         "--power": {"key": "power", "type": "str", "default": None},
         "--permission": {"key": "permission", "type": "str", "default": None},
         "--fast": {"key": "fast", "type": "str", "default": None, "transform": _parse_fast_value},
         "--model": {"key": "model", "type": "str", "default": None},
+        "--priority": {"key": "priority", "type": "str", "default": None, "transform": _parse_priority_value},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SET_USAGE)},
         "--json": {"key": "json", "type": "bool", "default": False},
@@ -487,7 +519,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "model")
+        for key in ("power", "permission", "fast", "model", "priority")
         if parsed[key] is not None
     }
     if not settings:
@@ -507,6 +539,7 @@ def _parse_unset_args(args):
         "--permission": {"key": "permission", "type": "bool", "default": False},
         "--fast": {"key": "fast", "type": "bool", "default": False},
         "--model": {"key": "model", "type": "bool", "default": False},
+        "--priority": {"key": "priority", "type": "bool", "default": False},
         "--all": {"key": "all", "type": "bool", "default": False},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, UNSET_USAGE)},
@@ -520,8 +553,8 @@ def _parse_unset_args(args):
         raise CdxError(UNSET_USAGE)
     if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
-    keys = ["power", "permission", "fast", "model"] if parsed["all"] else [
-        key for key in ("power", "permission", "fast", "model") if parsed[key]
+    keys = ["power", "permission", "fast", "model", "priority"] if parsed["all"] else [
+        key for key in ("power", "permission", "fast", "model", "priority") if parsed[key]
     ]
     if not keys:
         raise CdxError(UNSET_USAGE)
@@ -543,6 +576,99 @@ def _parse_config_args(args):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_select_args(args):
+    parsed = _parse_flag_args(args, {
+        "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SELECT_USAGE)},
+        "--min-reasoning-effort": {"key": "min_reasoning_effort", "type": "str", "default": None},
+        "--min-power": {"key": "min_power", "type": "str", "default": None},
+        "--require-ready": {"key": "require_ready", "type": "bool", "default": False},
+        "--refresh": {"key": "refresh", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, SELECT_USAGE)
+    if not parsed["provider"] or not parsed["json"]:
+        raise CdxError(SELECT_USAGE)
+    effort = _normalize_reasoning_effort(
+        reasoning_effort=parsed["min_reasoning_effort"],
+        power=parsed["min_power"],
+        usage=SELECT_USAGE,
+    ).get("reasoning_effort")
+    return {
+        "provider": parsed["provider"],
+        "min_reasoning_effort": effort,
+        "require_ready": parsed["require_ready"],
+        "refresh": parsed["refresh"],
+        "json": parsed["json"],
+    }
+
+
+def _parse_timeout_seconds(value):
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError) as error:
+        raise CdxError(RUN_USAGE) from error
+    if parsed <= 0:
+        raise CdxError(RUN_USAGE)
+    return parsed
+
+
+def _normalize_run_permission(value):
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    aliases = {
+        "workspace-write": "default",
+        "read-only": "review",
+        "danger-full-access": "full",
+    }
+    text = aliases.get(text, text)
+    if text not in ("review", "default", "auto", "full"):
+        raise CdxError(RUN_USAGE)
+    return text
+
+
+def _parse_run_args(args):
+    parsed = _parse_flag_args(args, {
+        "--cwd": {"key": "cwd", "type": "str", "default": None},
+        "--prompt-file": {"key": "prompt_file", "type": "str", "default": None},
+        "--prompt": {"key": "prompt", "type": "str", "default": None},
+        "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, RUN_USAGE)},
+        "--model": {"key": "model", "type": "str", "default": None},
+        "--reasoning-effort": {"key": "reasoning_effort", "type": "str", "default": None},
+        "--power": {"key": "power", "type": "str", "default": None},
+        "--permission": {"key": "permission", "type": "str", "default": None, "transform": _normalize_run_permission},
+        "--timeout-seconds": {"key": "timeout_seconds", "type": "str", "default": None, "transform": _parse_timeout_seconds},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, RUN_USAGE, positionals_key="names", max_positionals=1)
+    if not parsed["json"]:
+        raise CdxError(RUN_USAGE)
+    name = parsed["names"][0] if parsed["names"] else None
+    if name and parsed["provider"]:
+        raise CdxError(RUN_USAGE)
+    if not name and not parsed["provider"]:
+        raise CdxError(RUN_USAGE)
+    if not parsed["cwd"]:
+        raise CdxError(RUN_USAGE)
+    if bool(parsed["prompt_file"]) == bool(parsed["prompt"]):
+        raise CdxError(RUN_USAGE)
+    effort = _normalize_reasoning_effort(
+        reasoning_effort=parsed["reasoning_effort"],
+        power=parsed["power"],
+        usage=RUN_USAGE,
+    )
+    return {
+        "name": name,
+        "provider": parsed["provider"],
+        "cwd": parsed["cwd"],
+        "prompt_file": parsed["prompt_file"],
+        "prompt": parsed["prompt"],
+        "model": parsed["model"],
+        "permission": parsed["permission"],
+        "timeout_seconds": parsed["timeout_seconds"],
+        "reasoning_effort": effort.get("reasoning_effort"),
+        "power": effort.get("power"),
+    }
+
+
 def _parse_positive_int(value):
     try:
         parsed = int(value)
@@ -892,19 +1018,18 @@ def _bootstrap_claude_setup_token(session, ctx):
             "Claude setup-token completed, but cdx could not capture the token. "
             "Run claude setup-token and save the token under credentials/default.json."
         )
-    try:
-        with open(transcript_path, "r", encoding="utf-8", errors="replace") as handle:
-            transcript = handle.read()
-    finally:
-        try:
-            os.remove(transcript_path)
-        except OSError:
-            pass
+    with open(transcript_path, "r", encoding="utf-8", errors="replace") as handle:
+        transcript = handle.read()
     token = _extract_claude_oauth_token(transcript)
     if not token:
         raise CdxError(
-            "Claude setup-token completed, but cdx could not find CLAUDE_CODE_OAUTH_TOKEN in the output."
+            "Claude setup-token completed, but cdx could not find CLAUDE_CODE_OAUTH_TOKEN in the output. "
+            f"Transcript kept at: {transcript_path}"
         )
+    try:
+        os.remove(transcript_path)
+    except OSError:
+        pass
     return _write_claude_oauth_token(session.get("authHome") or "", token)
 
 
@@ -1026,6 +1151,223 @@ def handle_enable(rest, ctx):
     return 0
 
 
+def handle_select(rest, ctx):
+    parsed = _parse_select_args(rest)
+    selected = _select_headless_session(
+        ctx,
+        parsed["provider"],
+        min_reasoning_effort=parsed["min_reasoning_effort"],
+        require_ready=parsed["require_ready"],
+        force_refresh=parsed["refresh"],
+    )
+    policy = "ready_then_cooldown_then_health_then_priority_then_name"
+    if not selected:
+        message = "No suitable session found."
+        _write_json(ctx, _json_failure(
+            "select",
+            "no_suitable_session",
+            message,
+            provider=parsed["provider"],
+            min_reasoning_effort=parsed["min_reasoning_effort"],
+            require_ready=parsed["require_ready"],
+            selection_policy=policy,
+        ))
+        return 1
+    session = selected["session"]
+    row = selected.get("row") or {}
+    reason = "highest availability suitable session"
+    _write_json(ctx, _json_success(
+        "select",
+        f"Selected session {session['name']}",
+        session=session["name"],
+        provider=session["provider"],
+        reason=reason,
+        selection_policy=policy,
+        min_reasoning_effort=parsed["min_reasoning_effort"],
+        reasoning_effort=_session_reasoning_effort(session),
+        available_pct=row.get("available_pct"),
+        auth_status=row.get("auth_status"),
+    ))
+    return 0
+
+
+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_usage_payload():
+    return {
+        "input_tokens": None,
+        "output_tokens": None,
+        "reasoning_tokens": None,
+        "total_tokens": None,
+    }
+
+
+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_result_payload(ok, parsed, session, run_info=None, error=None, error_source=None, error_code=None):
+    run_info = run_info or {}
+    return {
+        "schema_version": API_SCHEMA_VERSION,
+        "ok": bool(ok),
+        "action": "run",
+        "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": parsed.get("reasoning_effort") or ((session.get("launch") or {}).get("reasoning_effort") if session else None),
+        "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": _run_usage_payload(),
+        "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,
+        },
+    }
+
+
+def handle_run(rest, ctx):
+    try:
+        parsed = _parse_run_args(rest)
+        session = None
+        if parsed["name"]:
+            session = ctx["service"]["get_session"](parsed["name"])
+            if not session:
+                raise CdxError(f"Unknown session: {parsed['name']}")
+            if session.get("enabled", True) is False:
+                raise CdxError(f"Session is disabled: {parsed['name']}")
+        else:
+            selected = _select_headless_session(
+                ctx,
+                parsed["provider"],
+                min_reasoning_effort=parsed["reasoning_effort"],
+                require_ready=True,
+                force_refresh=False,
+            )
+            if not selected:
+                _write_json(ctx, _json_failure(
+                    "run",
+                    "no_suitable_session",
+                    "No suitable session found.",
+                    provider=parsed["provider"],
+                ))
+                return 1
+            session = selected["session"]
+
+        cwd = os.path.abspath(parsed["cwd"])
+        if not os.path.isdir(cwd):
+            raise CdxError(f"Invalid cwd: {parsed['cwd']}")
+        prompt = _read_run_prompt(parsed)
+        launch_updates = {}
+        if parsed.get("model"):
+            launch_updates["model"] = parsed["model"]
+        if parsed.get("permission"):
+            launch_updates["permission"] = parsed["permission"]
+        if parsed.get("reasoning_effort"):
+            launch_updates["reasoning_effort"] = parsed["reasoning_effort"]
+            launch_updates["power"] = parsed["reasoning_effort"]
+        run_session = {
+            **session,
+            "launch": {
+                **(session.get("launch") or {}),
+                **launch_updates,
+            },
+        }
+        _ensure_session_authentication(
+            run_session,
+            ctx["service"],
+            spawn=ctx.get("spawn"),
+            spawn_sync=ctx.get("spawn_sync"),
+            env_override=ctx.get("env"),
+            stdin_is_tty=False,
+            behavior="launch",
+            signal_emitter=ctx.get("signal_emitter"),
+        )
+        run_info = _run_headless_provider_command(
+            run_session,
+            cwd=cwd,
+            env_override=ctx.get("env"),
+            initial_prompt=prompt,
+            timeout_seconds=parsed.get("timeout_seconds"),
+            spawn=ctx.get("spawn_headless") or ctx.get("spawn"),
+        )
+        ok = run_info.get("returncode") == 0
+        if ok:
+            ctx["service"]["record_launch_history"](session["name"], {
+                "status": "success",
+                "cwd": cwd,
+                "exit_code": 0,
+                **run_info,
+            })
+            _write_json(ctx, _run_result_payload(True, parsed, run_session, run_info=run_info))
+            return 0
+        message = "Provider process timed out." if run_info.get("timed_out") else "Provider process exited with a non-zero status."
+        error = CdxError(message, run_info.get("returncode") or 1)
+        ctx["service"]["record_launch_history"](session["name"], {
+            "status": "failed",
+            "cwd": cwd,
+            "error": str(error),
+            "exit_code": error.exit_code,
+            **run_info,
+        })
+        _write_json(ctx, _run_result_payload(
+            False,
+            parsed,
+            run_session,
+            run_info=run_info,
+            error=error,
+            error_source="provider",
+            error_code="provider_timeout" if run_info.get("timed_out") else "provider_failed",
+        ))
+        return error.exit_code or 1
+    except CdxError as error:
+        run_info = getattr(error, "run_info", None)
+        _write_json(ctx, _run_result_payload(
+            False,
+            locals().get("parsed", {}) or {},
+            locals().get("session"),
+            run_info=run_info,
+            error=error,
+            error_source="cdx",
+            error_code=_run_cdx_error_code(error),
+        ))
+        return error.exit_code
+
+
 def _format_launch_config(session):
     launch = session.get("launch") or {}
     return "\n".join([
@@ -1034,6 +1376,7 @@ def _format_launch_config(session):
         f"permission: {launch.get('permission') or 'default'}",
         f"fast:       {'on' if launch.get('fast') is True else 'off' if launch.get('fast') is False else 'default'}",
         f"model:      {launch.get('model') or 'default'}",
+        f"priority:   {launch.get('priority') if launch.get('priority') is not None else 'default'}",
     ])
 
 
@@ -1063,6 +1406,87 @@ def _resolve_bulk_launch_targets(parsed, service):
     return targets
 
 
+def _reasoning_rank(value):
+    order = {"low": 0, "medium": 1, "high": 2, "xhigh": 2, "max": 2}
+    return order.get(str(value or "low").lower(), 0)
+
+
+def _session_reasoning_effort(session):
+    launch = session.get("launch") or {}
+    return (
+        launch.get("reasoning_effort")
+        or launch.get("reasoningEffort")
+        or launch.get("power")
+        or ("low" if launch.get("fast") is True else None)
+        or "low"
+    )
+
+
+def _session_selection_priority(session):
+    launch = session.get("launch") or {}
+    try:
+        return int(launch.get("priority") or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _row_blocks_ready(row):
+    if row.get("provider") in (PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA):
+        auth = "n/a"
+    else:
+        auth = row.get("auth_status") or "unknown"
+    if auth not in ("authenticated", "n/a"):
+        return True
+    available = row.get("available_pct")
+    if available is not None:
+        try:
+            if float(available) <= 0:
+                return True
+        except (TypeError, ValueError):
+            return True
+    return False
+
+
+def _select_headless_session(ctx, provider, min_reasoning_effort=None, require_ready=False, force_refresh=False):
+    sessions = [
+        session for session in ctx["service"]["list_sessions"]()
+        if session.get("provider") == provider and session.get("enabled", True) is not False
+    ]
+    minimum = _reasoning_rank(min_reasoning_effort)
+    sessions = [
+        session for session in sessions
+        if _reasoning_rank(_session_reasoning_effort(session)) >= minimum
+    ]
+    rows = ctx["service"]["get_status_rows"](force_refresh=force_refresh)
+    row_by_name = {row.get("session_name"): row for row in rows}
+    candidates = []
+    for session in sessions:
+        row = row_by_name.get(session["name"], {})
+        if require_ready and _row_blocks_ready(row):
+            continue
+        available = row.get("available_pct")
+        try:
+            available_sort = float(available) if available is not None else -1.0
+        except (TypeError, ValueError):
+            available_sort = -1.0
+        cooldown_sort = 1 if available_sort > 0 else 0
+        candidates.append({
+            "session": session,
+            "row": row,
+            "sort_key": (
+                -cooldown_sort,
+                -available_sort,
+                -_session_selection_priority(session),
+                _reasoning_rank(_session_reasoning_effort(session)),
+                session["name"],
+            ),
+        })
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: item["sort_key"])
+    return candidates[0]
+
+
 def _format_bulk_launch_summary(sessions):
     names = [session["name"] for session in sessions]
     if len(names) <= 8:
@@ -1599,6 +2023,20 @@ def handle_status(rest, ctx):
     if len(args) == 1 and parsed["small"]:
         raise CdxError(STATUS_USAGE)
 
+    auth_refresh = _refresh_claude_auth_states(
+        ctx["service"],
+        target_names=args if len(args) == 1 else None,
+        spawn_sync=ctx.get("spawn_sync"),
+        env_override=ctx.get("env"),
+    )
+    warnings = [
+        {
+            "code": "claude_auth_probe_failed",
+            "session": item.get("session") or "unknown",
+            "message": item.get("error") or "unknown error",
+        }
+        for item in auth_refresh.get("errors", [])
+    ]
     refresh_result = _refresh_claude_sessions(
         ctx["service"],
         ctx.get("refresh_fn"),
@@ -1612,27 +2050,13 @@ def handle_status(rest, ctx):
         }
         for item in refresh_result.get("errors", [])
     ]
-    warnings = [
+    warnings.extend([
         {
             "code": "claude_refresh_failed",
             "session": item.get("session") or "unknown",
             "message": item.get("error") or "unknown error",
         }
         for item in refresh_errors
-    ]
-    auth_refresh = _refresh_claude_auth_states(
-        ctx["service"],
-        target_names=args if len(args) == 1 else None,
-        spawn_sync=ctx.get("spawn_sync"),
-        env_override=ctx.get("env"),
-    )
-    warnings.extend([
-        {
-            "code": "claude_auth_probe_failed",
-            "session": item.get("session") or "unknown",
-            "message": item.get("error") or "unknown error",
-        }
-        for item in auth_refresh.get("errors", [])
     ])
     update_warning = _update_notice_warning(ctx)
     if update_warning: