cdx-manager 0.12.4 → 0.15.0

package/src/provider_runtime.py

@@ -12,7 +12,14 @@ from datetime import datetime, timezone
 
 from .claude_usage import _clean_oauth_token, _decode_jwt_claims
 from .codex_usage import codex_auth_lock
-from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+from .config import (
+    PROVIDER_ANTIGRAVITY,
+    PROVIDER_CLAUDE,
+    PROVIDER_CODEX,
+    PROVIDER_OLLAMA,
+    REASONING_EFFORT_VALUES,
+    split_extra_args,
+)
 from .errors import CdxError
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
@@ -21,7 +28,6 @@ CODEX_INTERACTIVE_AUTH_LOCK_TIMEOUT_SECONDS = 10
 AUTH_PROBE_AUTHENTICATED = "authenticated"
 AUTH_PROBE_LOGGED_OUT = "logged_out"
 AUTH_PROBE_DEGRADED = "degraded"
-REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 RTK_PROMPT = (
     "When running noisy shell commands, prefer RTK wrappers (`rtk <command>`) if `rtk` is available. "
     "Use raw commands when exact, unfiltered output is required."
@@ -47,6 +53,15 @@ LAUNCH_PERMISSION_ARGS = {
         "auto": ["-s", "workspace-write", "-a", "never"],
         "full": ["-s", "danger-full-access", "-a", "never"],
     },
+    PROVIDER_ANTIGRAVITY: {
+        "review": ["--sandbox"],
+        "full": ["--dangerously-skip-permissions"],
+    },
+    # ollama has no sandbox or permission concept, so it maps to nothing. The
+    # entry is present and deliberately empty: that is what tells the
+    # provider-flag health check there is nothing to verify here, as opposed to
+    # a provider whose mapping nobody ever declared.
+    PROVIDER_OLLAMA: {},
 }
 HEADLESS_CODEX_PERMISSION_ARGS = {
     "review": ["-s", "read-only"],
@@ -54,6 +69,30 @@ HEADLESS_CODEX_PERMISSION_ARGS = {
     "auto": ["-s", "workspace-write", "-c", 'approval_policy="never"'],
     "full": ["--dangerously-bypass-approvals-and-sandbox"],
 }
+
+
+def headless_permission_disables_network(provider, permission):
+    """True when this provider/permission pair silently costs the run network access.
+
+    Codex ties network access to its sandbox: every permission except `full`
+    maps to `-s <sandbox>` above, and inside that sandbox a tool like `gh`
+    cannot resolve DNS. The run still exits zero, so without a warning the
+    caller only finds out by reading the transcript.
+
+    Read off the same mapping the launch spec uses rather than a parallel list
+    of permissions, so adding a permission cannot leave this behind.
+
+    No permission at all is the common case, not an exemption: the launch spec
+    simply appends no sandbox flag, and `codex exec` then applies its own
+    sandboxed default. Only an explicit `full` actually buys network access.
+    """
+    if provider != PROVIDER_CODEX:
+        return False
+    if not permission:
+        return True
+    return "-s" in HEADLESS_CODEX_PERMISSION_ARGS.get(permission, [])
+
+
 REDACTED_PROMPT_ARG = "[prompt redacted]"
 CLAUDE_CLI_MODEL_ALIASES = {
     "claude-sonnet": "sonnet",
@@ -316,6 +355,45 @@ def _claude_cli_model(model):
     return raw
 
 
+def _conversation_id(session):
+    conversation = session.get("conversation") or {}
+    identifier = conversation.get("id")
+    return identifier if identifier else None
+
+
+def _claude_fallback_model(value):
+    """Normalize each element of the comma-separated fallback list.
+
+    Claude tries the entries in order, so the separator has to survive while
+    each name goes through the same aliasing a primary `--model` gets.
+    """
+    if not value:
+        return value
+    return ",".join(_claude_cli_model(element) for element in str(value).split(","))
+
+
+def _format_budget_arg(value):
+    """Render a budget without the float artefacts a bare str() would show.
+
+    A stored 5.0 must reach the CLI as `5`, not `5.0`, and 2.50 as `2.5`.
+    """
+    number = float(value)
+    if number == int(number):
+        return str(int(number))
+    return f"{number:g}"
+
+
+def _extra_args(session):
+    """Unvalidated provider arguments, appended after everything cdx maps.
+
+    Last wins in both provider CLIs, so a passthrough value overrides the
+    mapped setting it duplicates. That is the useful default - the escape hatch
+    would be pointless if `cdx set` always won - but it is why `cdx configs`
+    shows the raw string: the override has to be visible somewhere.
+    """
+    return split_extra_args((session.get("launch") or {}).get("extra_args")) or []
+
+
 def _launch_config_args(session):
     launch = session.get("launch") or {}
     args = []
@@ -328,15 +406,12 @@ def _launch_config_args(session):
         if permission:
             args += LAUNCH_PERMISSION_ARGS[PROVIDER_CLAUDE].get(permission, [])
         return args
-    if provider == PROVIDER_ANTIGRAVITY:
-        if permission == "review":
-            args += ["--sandbox"]
-        if permission == "full":
-            args += ["--dangerously-skip-permissions"]
-        return args
-    if provider == PROVIDER_OLLAMA:
-        if permission == "full":
-            args += ["--experimental-yolo"]
+    if provider in (PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA):
+        # Both read their mapping from the shared table rather than inline
+        # branches, so the provider-flag health check can verify what they emit
+        # instead of a hand-copied restatement of it.
+        if permission:
+            args += LAUNCH_PERMISSION_ARGS[provider].get(permission, [])
         return args
     if power:
         args += ["-c", f'model_reasoning_effort="{power}"']
@@ -447,9 +522,13 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     if session["provider"] == PROVIDER_CLAUDE:
         launch = session.get("launch") or {}
         args = ["--name", session["name"]]
+        conversation_id = _conversation_id(session)
+        if conversation_id:
+            args += ["--session-id", conversation_id]
         if launch.get("model"):
             args += ["--model", _claude_cli_model(launch["model"])]
         args += _launch_config_args(session)
+        args += _extra_args(session)
         if initial_prompt:
             args.append(initial_prompt)
         auth_home = _get_auth_home(session)
@@ -520,20 +599,48 @@ def _redacted_resume_command_preview(session, cwd=None):
 def get_resume_capability(session, cwd=None):
     provider = session.get("provider")
     cwd = cwd or os.getcwd()
+    conversation = session.get("conversation") or {}
+    conversation_id = _conversation_id(session)
     if provider == PROVIDER_CODEX:
+        if conversation_id:
+            return {
+                "resumable": True,
+                "provider": provider,
+                "strategy": "provider_conversation_id",
+                "identity": conversation_id,
+                "provenance": conversation.get("provenance"),
+                "reason": "supported",
+                "command_preview": ["codex", "resume", conversation_id, "--cd", cwd],
+            }
         return {
             "resumable": True,
             "provider": provider,
             "strategy": "provider_last",
-            "reason": "supported",
+            "identity": None,
+            "provenance": None,
+            # Codex only reveals a conversation id once a run has written its
+            # rollout, so a session that has never run legitimately has none.
+            "reason": "no_recorded_conversation",
             "command_preview": ["codex", "resume", "--last", "--cd", cwd],
         }
     if provider == PROVIDER_CLAUDE:
+        if conversation_id:
+            return {
+                "resumable": True,
+                "provider": provider,
+                "strategy": "provider_conversation_id",
+                "identity": conversation_id,
+                "provenance": conversation.get("provenance"),
+                "reason": "supported",
+                "command_preview": ["claude", "--resume", conversation_id],
+            }
         return {
             "resumable": True,
             "provider": provider,
             "strategy": "provider_continue",
-            "reason": "supported",
+            "identity": None,
+            "provenance": None,
+            "reason": "no_recorded_conversation",
             "command_preview": ["claude", "--continue"],
         }
     return {
@@ -558,10 +665,16 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
 
     if session["provider"] == PROVIDER_CLAUDE:
         launch = session.get("launch") or {}
-        args = ["--continue", "--name", session["name"]]
+        # Resuming by id targets the conversation this session actually last
+        # opened; --continue only means "the most recent one in this directory",
+        # which another session or another cwd can silently change.
+        conversation_id = _conversation_id(session)
+        args = ["--resume", conversation_id] if conversation_id else ["--continue"]
+        args += ["--name", session["name"]]
         if launch.get("model"):
             args += ["--model", _claude_cli_model(launch["model"])]
         args += _launch_config_args(session)
+        args += _extra_args(session)
         if resume_prompt:
             args.append(resume_prompt)
         auth_home = _get_auth_home(session)
@@ -580,10 +693,13 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
         }, capture_transcript=capture_transcript, env=env)
 
     launch = session.get("launch") or {}
-    args = ["resume", "--last", "--cd", cwd]
+    conversation_id = _conversation_id(session)
+    args = ["resume", conversation_id] if conversation_id else ["resume", "--last"]
+    args += ["--cd", cwd]
     if launch.get("model"):
         args += ["--model", launch["model"]]
     args += _launch_config_args(session)
+    args += _extra_args(session)
     if resume_prompt:
         args.append(resume_prompt)
     return _wrap_launch_with_transcript(session, {
@@ -617,9 +733,20 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
 
     if session["provider"] == PROVIDER_CLAUDE:
         args = ["--print", "--output-format", "json", "--name", session["name"]]
+        conversation_id = _conversation_id(session)
+        if conversation_id:
+            args += ["--session-id", conversation_id]
         if model:
             args += ["--model", _claude_cli_model(model)]
+        # --max-budget-usd and --fallback-model are --print-only in the claude
+        # CLI, so they belong to this spec alone: the interactive and resume
+        # specs would be rejected by the provider for carrying them.
+        if launch.get("budget") is not None:
+            args += ["--max-budget-usd", _format_budget_arg(launch["budget"])]
+        if launch.get("fallback_model"):
+            args += ["--fallback-model", _claude_fallback_model(launch["fallback_model"])]
         args += _launch_config_args(session)
+        args += _extra_args(session)
         if initial_prompt:
             args.append(initial_prompt)
         auth_home = _get_auth_home(session)

package/src/run_command.py

@@ -1,12 +1,27 @@
 import os
+import sys
 
-from .errors import CdxError
+from .cli_args import ARG_CODE_INVALID_VALUE
+from .errors import CdxArgumentError, CdxError
+from .provider_runtime import headless_permission_disables_network
 from .run_usage import empty_usage, extract_run_usage
 
+PROMPT_STDIN = "-"
 
-def read_run_prompt(parsed):
+
+def read_run_prompt(parsed, stdin=None):
     if parsed.get("prompt") is not None:
         return parsed["prompt"]
+    if parsed.get("prompt_file") == PROMPT_STDIN:
+        stream = stdin if stdin is not None else sys.stdin
+        if stream is None or getattr(stream, "isatty", lambda: False)():
+            raise CdxArgumentError(
+                "cdx run: --prompt-file - reads the prompt from standard input, but standard "
+                "input is a terminal. Pipe the prompt in, or pass a file path.",
+                code=ARG_CODE_INVALID_VALUE,
+                arguments=["--prompt-file"],
+            )
+        return stream.read()
     try:
         with open(parsed["prompt_file"], encoding="utf-8") as handle:
             return handle.read()
@@ -15,6 +30,9 @@ def read_run_prompt(parsed):
 
 
 def run_cdx_error_code(error):
+    code = getattr(error, "code", None)
+    if code:
+        return code
     message = str(error)
     if message.startswith("Usage:"):
         return "invalid_request"
@@ -73,8 +91,96 @@ def _provider_failure_message(error, run_info, error_code):
     return f"{base}: {detail}" if detail else base
 
 
+def run_error_arguments(error):
+    """The argument names a `CdxArgumentError` blames, as data.
+
+    Always a list so the error object keeps one shape: an empty list means the
+    failure is not about specific arguments, never that the caller should go
+    parse the message to find out.
+    """
+    return list(getattr(error, "arguments", ()) or [])
+
+
+def run_error_allowed_values(error):
+    allowed = getattr(error, "allowed", None)
+    return list(allowed) if allowed else None
+
+
+def run_effective_permission(parsed, session):
+    launch = (session.get("launch") or {}) if session else {}
+    return parsed.get("permission") or launch.get("permission")
+
+
+def run_warnings(parsed, session, selection_row=None):
+    """Known degradations that a zero exit code would otherwise hide.
+
+    Emitted on success as much as on failure: the whole point is that the run
+    looks fine and quietly did less than it was asked to.
+    """
+    warnings = []
+    if selection_row is not None and selection_row.get("available_pct") is None:
+        # Auto-selection ranked this session without ever having seen its
+        # status. That is not "low availability" — it is no information, and on
+        # a freshly imported or long-idle set of sessions it is the normal case.
+        warnings.append({
+            "code": "session_selected_without_status",
+            "message": (
+                f"Session {selection_row.get('session_name')!r} was auto-selected without any "
+                "recorded availability; the choice was made on missing status data. "
+                "Pass --refresh to fetch status before selecting."
+            ),
+            "session": selection_row.get("session_name"),
+        })
+    provider = session.get("provider") if session else parsed.get("provider")
+    permission = run_effective_permission(parsed, session)
+    if headless_permission_disables_network(provider, permission):
+        described = repr(permission) if permission else "its default (none set)"
+        warnings.append({
+            "code": "network_disabled_by_permission",
+            "message": (
+                f"{provider} runs at permission {described} inside a sandbox with no network "
+                "access, so tools needing the network (DNS, HTTPS) fail inside this run even "
+                "though it exits successfully. Use --permission full if the run needs network."
+            ),
+            "provider": provider,
+            "permission": permission,
+        })
+    return warnings
+
+
+def run_launch_payload(api_schema_version, parsed, session, artifacts, cwd=None,
+                       pid=None, launch_log_path=None, selection_row=None):
+    """Payload for a detached launch: identity and artifact paths, no outcome.
+
+    Deliberately shaped like `run_result_payload` minus the fields only a
+    finished run can fill (`exit_code`, `duration_seconds`, `usage`), so a
+    caller reads `run_id` from the same place either way.
+    """
+    return {
+        "schema_version": api_schema_version,
+        "ok": True,
+        "action": "run",
+        "launcher": "cdx",
+        "detached": True,
+        "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(cwd or parsed.get("cwd") or os.getcwd()),
+        "run_id": artifacts.get("run_id"),
+        "pid": pid,
+        "transcript_path": artifacts.get("transcript_path"),
+        "stdout_path": artifacts.get("stdout_path"),
+        "stderr_path": artifacts.get("stderr_path"),
+        "launch_log_path": launch_log_path,
+        "warnings": run_warnings(parsed, session, selection_row),
+        "error": None,
+    }
+
+
 def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
-                       error=None, error_source=None, error_code=None):
+                       error=None, error_source=None, error_code=None, selection_row=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"))
@@ -104,11 +210,13 @@ def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
         "stdout_path": run_info.get("stdout_path"),
         "stderr_path": run_info.get("stderr_path"),
         "usage": usage,
-        "warnings": [],
+        "warnings": run_warnings(parsed, session, selection_row),
         "error": None if ok else {
             "source": error_source or "cdx",
             "code": error_code or "cdx_error",
             "message": message,
+            "arguments": run_error_arguments(error),
+            "allowed_values": run_error_allowed_values(error),
             "provider_code": run_info.get("returncode") if error_source == "provider" else None,
         },
     }

package/src/run_failover.py

@@ -0,0 +1,221 @@
+"""Deciding whether a finished run stopped because its account ran out.
+
+Two independent signals have to agree before cdx moves a task to another
+account, because the two ways of being wrong are not symmetric. Missing a rate
+limit costs nothing new: the run fails exactly as it does today. Inventing one
+migrates a healthy run off a working account, discards its progress, and
+consumes a second account's quota to redo it. So every ambiguous case here
+resolves to "not rate limited".
+
+Signal one is the provider's own structured output, which both headless paths
+already produce - `codex exec --json` emits JSONL events, and the claude spec
+passes `--print --output-format json`. Signal two is the account's rate-limit
+status, refreshed once and read through the existing status pipeline.
+
+The matchers below are deliberately the only place that knows what exhaustion
+looks like on the wire. That shape is version-specific and is the part most
+likely to drift, so it is one function per provider and nothing else in the
+codebase reads provider output for this purpose.
+"""
+
+import json
+import os
+
+from .config import PROVIDER_CLAUDE, PROVIDER_CODEX
+
+MAX_FAILOVER_TRANSITIONS = 4
+
+# Read from the tail: a rate limit ends the run, so its marker is near the end,
+# and a long transcript should not be loaded whole to find it.
+_MAX_TAIL_BYTES = 64 * 1024
+
+# Observed against codex-cli 0.147.0 on an exhausted account:
+#   {"type":"error","message":"Your workspace is out of credits. Add credits to continue."}
+#   {"type":"turn.failed","error":{"message":"Your workspace is out of credits..."}}
+# "out of credits" was missing from the first version of this list, which is why
+# it never matched anything real. Credit exhaustion and a rate limit are the
+# same thing for this decision: the account cannot serve the task, try another.
+_RATE_LIMIT_MARKERS = (
+    "out of credits",
+    "rate_limit",
+    "rate limit",
+    "usage limit",
+    "quota exceeded",
+    "insufficient_quota",
+)
+
+# Records the provider itself labelled as failures. Scoping the search to these
+# is what keeps assistant prose out of the decision - the model's own words are
+# never inside a record of this shape. The first version instead excluded the
+# `message` key everywhere, which also excluded the field codex actually puts
+# its error text in, so nothing could ever match.
+_CODEX_ERROR_TYPES = ("error", "turn.failed", "thread.failed")
+
+
+def _read_tail(path):
+    if not path or not os.path.isfile(path):
+        return ""
+    try:
+        size = os.path.getsize(path)
+        with open(path, encoding="utf-8", errors="replace") as handle:
+            if size > _MAX_TAIL_BYTES:
+                handle.seek(size - _MAX_TAIL_BYTES)
+            return handle.read()
+    except OSError:
+        return ""
+
+
+def _error_texts(provider, record):
+    """Message strings from a record the provider marked as a failure.
+
+    Returns nothing for any other record, which is what keeps the assistant's
+    own words out of the decision: prose lives in successful results, never in
+    an error record.
+    """
+    if not isinstance(record, dict):
+        return []
+    texts = []
+    if provider == PROVIDER_CODEX:
+        if str(record.get("type") or "") not in _CODEX_ERROR_TYPES:
+            return []
+        texts.append(record.get("message"))
+        error = record.get("error")
+        if isinstance(error, dict):
+            texts.append(error.get("message"))
+    elif provider == PROVIDER_CLAUDE:
+        # `--print --output-format json` returns one result object; its own
+        # is_error flag says whether `result` holds an error or an answer.
+        if record.get("is_error") is not True:
+            return []
+        texts.append(record.get("result"))
+        texts.append(record.get("subtype"))
+        error = record.get("error")
+        if isinstance(error, dict):
+            texts.append(error.get("message"))
+    return [text for text in texts if isinstance(text, str)]
+
+
+def _mentions_exhaustion(texts):
+    return any(
+        marker in text.lower()
+        for text in texts
+        for marker in _RATE_LIMIT_MARKERS
+    )
+
+
+def _structured_records(provider, text):
+    """The structured payloads a provider wrote, newest last.
+
+    Codex emits one JSON object per line; claude emits a single object. Lines
+    that do not decode are skipped rather than pattern-matched as raw text:
+    unparsed output is not a signal, it is an absence of one.
+    """
+    records = []
+    if not text:
+        return records
+    if provider == PROVIDER_CODEX:
+        for line in text.splitlines():
+            line = line.strip()
+            if not line.startswith("{"):
+                continue
+            try:
+                records.append(json.loads(line))
+            except ValueError:
+                continue
+        return records
+    if provider == PROVIDER_CLAUDE:
+        stripped = text.strip()
+        start = stripped.find("{")
+        if start >= 0:
+            try:
+                records.append(json.loads(stripped[start:]))
+            except ValueError:
+                return records
+    return records
+
+
+def looks_rate_limited(provider, run_info):
+    """Whether the provider's structured output says the account is exhausted.
+
+    This is the weaker of the two signals and is never acted on alone; see
+    `should_fail_over`.
+    """
+    if provider not in (PROVIDER_CODEX, PROVIDER_CLAUDE):
+        return False
+    if run_info.get("timed_out"):
+        # A timeout is cdx's own deadline, not the provider's verdict.
+        return False
+    if run_info.get("returncode") == 0:
+        return False
+    for record in _structured_records(provider, _read_tail(run_info.get("stdout_path"))):
+        if _mentions_exhaustion(_error_texts(provider, record)):
+            return True
+    return False
+
+
+def status_confirms_exhaustion(row):
+    """Whether a freshly refreshed status row agrees the account is spent.
+
+    An unreadable or empty row is not a confirmation. Treating "no status" as
+    exhaustion would make every probe failure look like a rate limit.
+    """
+    if not row:
+        return False
+    if row.get("blocking"):
+        return True
+    for key in ("remaining_5h_pct", "remaining_week_pct"):
+        value = row.get(key)
+        if isinstance(value, (int, float)) and value <= 0:
+            return True
+    return False
+
+
+def provider_reported_failure(provider, run_info):
+    """A failure the provider itself emitted, whatever it says.
+
+    Deliberately wording-free. A timeout is cdx's own deadline, and a zero exit
+    is not a failure; everything else that produced a provider error record
+    counts.
+    """
+    if provider not in (PROVIDER_CODEX, PROVIDER_CLAUDE):
+        return False
+    if run_info.get("timed_out") or run_info.get("returncode") == 0:
+        return False
+    for record in _structured_records(provider, _read_tail(run_info.get("stdout_path"))):
+        if _error_texts(provider, record):
+            return True
+    return False
+
+
+def failover_reason(provider, run_info, status_row):
+    """Why this run should move, or None to stay put.
+
+    Two independent routes, because relying on either alone has been shown to
+    fail:
+
+    `provider_reported_exhaustion` - the provider said so in words cdx
+    recognises. Precise, but the wording is not one thing: an enterprise
+    workspace out of credits, a personal plan hitting its 5-hour window, and
+    Claude's own phrasing are all different sentences, and only the first has
+    ever been observed. Matching prose alone would silently miss the rest.
+
+    `account_status_exhausted` - the account's own rate-limit status says it has
+    nothing left, and the run failed. This is the authoritative route: it comes
+    from the provider's rate-limit API rather than from English, so it holds for
+    plans and providers whose wording nobody has seen. An account at zero cannot
+    serve the task no matter which sentence it used to say so.
+
+    Status confirmation is required either way, so a healthy account is never
+    abandoned on the strength of a matched phrase.
+    """
+    if not status_confirms_exhaustion(status_row):
+        return None
+    if looks_rate_limited(provider, run_info):
+        return "provider_reported_exhaustion"
+    if provider_reported_failure(provider, run_info):
+        return "account_status_exhausted"
+    return None
+
+
+def should_fail_over(provider, run_info, status_row):
+    return failover_reason(provider, run_info, status_row) is not None