cdx-manager 0.6.4 → 0.7.0

package/src/provider_runtime.py

@@ -6,6 +6,7 @@ import shlex
 import shutil
 import subprocess
 import sys
+import uuid
 from datetime import datetime, timezone
 
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
@@ -13,6 +14,7 @@ from .errors import CdxError
 
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
+REASONING_EFFORT_VALUES = {"low", "medium", "high"}
 LAUNCH_PERMISSION_ARGS = {
     PROVIDER_CLAUDE: {
         "review": ["--permission-mode", "plan"],
@@ -96,6 +98,23 @@ def _has_local_claude_auth(auth_home):
     return bool(isinstance(oauth, dict) and _clean_oauth_token(oauth.get("accessToken")))
 
 
+def _has_local_codex_auth(auth_home):
+    try:
+        with open(os.path.join(auth_home, "auth.json"), "r", encoding="utf-8") as handle:
+            auth = json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return False
+    if not isinstance(auth, dict):
+        return False
+    tokens = auth.get("tokens")
+    if not isinstance(tokens, dict):
+        return False
+    return any(
+        _clean_oauth_token(tokens.get(name))
+        for name in ("id_token", "access_token", "refresh_token")
+    )
+
+
 def _read_claude_account_email(auth_home):
     config_path = os.path.join(auth_home, ".claude.json")
     try:
@@ -141,7 +160,7 @@ def _build_launch_transcript_path(session):
 
 def _launch_power(session):
     launch = session.get("launch") or {}
-    power = launch.get("power")
+    power = launch.get("reasoning_effort") or launch.get("reasoningEffort") or launch.get("power")
     if power:
         return power
     if launch.get("fast") is True:
@@ -149,6 +168,28 @@ def _launch_power(session):
     return None
 
 
+def _normalize_reasoning_effort(reasoning_effort=None, power=None, usage="Unsupported reasoning effort."):
+    effort = str(reasoning_effort).strip().lower() if reasoning_effort is not None else None
+    alias = str(power).strip().lower() if power is not None else None
+    if effort == "":
+        raise CdxError(usage)
+    if alias == "":
+        raise CdxError(usage)
+    if effort and effort not in REASONING_EFFORT_VALUES:
+        raise CdxError(f"Unsupported reasoning effort: {reasoning_effort}")
+    if alias and alias not in REASONING_EFFORT_VALUES:
+        raise CdxError(f"Unsupported power: {power}")
+    if effort and alias and effort != alias:
+        raise CdxError("--reasoning-effort and --power must match when both are provided.")
+    resolved = effort or alias
+    if not resolved:
+        return {}
+    return {
+        "reasoning_effort": resolved,
+        "power": resolved,
+    }
+
+
 def _launch_config_args(session):
     launch = session.get("launch") or {}
     args = []
@@ -237,7 +278,7 @@ def _default_script_args(transcript_path, spec):
     return ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
 
 
-def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
+def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None, capture_transcript=True):
     if initial_prompt is not None:
         if not isinstance(initial_prompt, str):
             raise CdxError("initial_prompt must be a string.")
@@ -263,7 +304,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
                 "env": claude_env,
             },
             "label": "claude",
-        }, env=env)
+        }, capture_transcript=capture_transcript, env=env)
     if session["provider"] == PROVIDER_ANTIGRAVITY:
         args = _launch_config_args(session)
         if initial_prompt:
@@ -276,7 +317,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
                 "env": {**env, **_antigravity_env_overrides(_get_auth_home(session))},
             },
             "label": "antigravity",
-        }, env=env)
+        }, capture_transcript=capture_transcript, env=env)
     if session["provider"] == PROVIDER_OLLAMA:
         launch = session.get("launch") or {}
         model = launch.get("model") or session["name"]
@@ -292,7 +333,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
                 "env": ollama_env,
             },
             "label": "ollama",
-        }, env=env)
+        }, capture_transcript=capture_transcript, env=env)
     args = ["--no-alt-screen", "--cd", cwd] + _launch_config_args(session)
     if initial_prompt:
         args.append(initial_prompt)
@@ -303,7 +344,132 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             "env": {**env, "CODEX_HOME": _get_auth_home(session)},
         },
         "label": "codex",
-    }, env=env)
+    }, capture_transcript=capture_transcript, env=env)
+
+
+def _headless_artifact_paths(session, run_id=None):
+    run_id = run_id or uuid.uuid4().hex
+    log_dir = _get_launch_transcript_dir(session)
+    os.makedirs(log_dir, exist_ok=True)
+    prefix = os.path.join(log_dir, f"cdx-run-{run_id}")
+    return {
+        "run_id": run_id,
+        "transcript_path": os.path.abspath(f"{prefix}.log"),
+        "stdout_path": os.path.abspath(f"{prefix}.stdout.log"),
+        "stderr_path": os.path.abspath(f"{prefix}.stderr.log"),
+    }
+
+
+def _combine_headless_transcript(paths):
+    transcript_path = paths["transcript_path"]
+    with open(transcript_path, "w", encoding="utf-8", errors="replace") as transcript:
+        for label, path_key in (("stdout", "stdout_path"), ("stderr", "stderr_path")):
+            path = paths.get(path_key)
+            if not path:
+                continue
+            transcript.write(f"--- {label} ---\n")
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as handle:
+                    content = handle.read()
+            except OSError:
+                content = ""
+            transcript.write(content)
+            if content and not content.endswith("\n"):
+                transcript.write("\n")
+
+
+def _headless_run_info(paths, spec, start_time, returncode):
+    end_time = datetime.now(timezone.utc)
+    return {
+        **paths,
+        "started_at": start_time.isoformat().replace("+00:00", "Z"),
+        "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 []),
+        "label": spec.get("label"),
+        "pid": None,
+        "returncode": returncode,
+        "timed_out": False,
+    }
+
+
+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
+    spec = _build_launch_spec(
+        session,
+        cwd=cwd,
+        env_override=env_override,
+        initial_prompt=initial_prompt,
+        capture_transcript=False,
+    )
+    paths = _headless_artifact_paths(session, run_id=run_id)
+    start_time = datetime.now(timezone.utc)
+    command = spec["command"]
+    if spawn is subprocess.Popen:
+        command = _resolve_command(command, spec.get("options", {}).get("env"))
+
+    child = None
+    timed_out = False
+    with open(paths["stdout_path"], "w", encoding="utf-8", errors="replace") as stdout_file, \
+            open(paths["stderr_path"], "w", encoding="utf-8", errors="replace") as stderr_file:
+        try:
+            child = spawn(
+                [command] + spec["args"],
+                stdout=stdout_file,
+                stderr=stderr_file,
+                **{k: v for k, v in spec.get("options", {}).items() if k not in ("stdio", "stdout", "stderr")},
+            )
+        except FileNotFoundError as error:
+            _combine_headless_transcript(paths)
+            cdx_error = CdxError(f"{spec['label']} CLI not found on PATH: {spec['command']}", 127)
+            cdx_error.run_info = _headless_run_info(paths, spec, start_time, 127)
+            raise cdx_error from error
+        except OSError as error:
+            _combine_headless_transcript(paths)
+            cdx_error = CdxError(f"Failed to start {spec['label']}: {error}", 126)
+            cdx_error.run_info = _headless_run_info(paths, spec, start_time, 126)
+            raise cdx_error from error
+        try:
+            if timeout_seconds is None:
+                child.wait()
+            else:
+                child.wait(timeout=timeout_seconds)
+        except TypeError:
+            child.wait()
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            try:
+                child.terminate()
+                child.wait(timeout=5)
+            except Exception:
+                try:
+                    child.kill()
+                except Exception:
+                    pass
+                try:
+                    child.wait()
+                except Exception:
+                    pass
+
+    _combine_headless_transcript(paths)
+    end_time = datetime.now(timezone.utc)
+    returncode = getattr(child, "returncode", None) if child is not None else None
+    if timed_out and (returncode is None or returncode == 0):
+        returncode = 124
+    return {
+        **paths,
+        "started_at": start_time.isoformat().replace("+00:00", "Z"),
+        "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 []),
+        "label": spec.get("label"),
+        "pid": getattr(child, "pid", None),
+        "returncode": returncode,
+        "timed_out": timed_out,
+    }
 
 
 def _build_login_status_spec(session, env_override=None):
@@ -397,10 +563,8 @@ def _probe_provider_auth(session, spawn_sync=None, env_override=None):
     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:
-        auth_path = os.path.join(_get_auth_home(session), "auth.json")
-        if os.path.isfile(auth_path):
-            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"])

package/src/session_service.py

@@ -40,6 +40,8 @@ RESERVED_SESSION_NAMES = {
     "ren",
     "rename",
     "rmv",
+    "run",
+    "select",
     "config",
     "set",
     "status",
@@ -54,8 +56,11 @@ RESERVED_SESSION_NAMES = {
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
 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
 
 
 def _encode(name):
@@ -96,6 +101,11 @@ def _normalize_launch_settings(settings):
         if power not in LAUNCH_POWER_VALUES:
             raise CdxError(f"Unsupported power: {settings['power']}")
         normalized["power"] = power
+    if "reasoning_effort" in settings and settings["reasoning_effort"] is not None:
+        effort = str(settings["reasoning_effort"]).strip().lower()
+        if effort not in LAUNCH_REASONING_EFFORT_VALUES:
+            raise CdxError(f"Unsupported reasoning effort: {settings['reasoning_effort']}")
+        normalized["reasoning_effort"] = effort
     if "permission" in settings and settings["permission"] is not None:
         permission = str(settings["permission"]).strip().lower()
         if permission not in LAUNCH_PERMISSION_VALUES:
@@ -120,6 +130,14 @@ def _normalize_launch_settings(settings):
         if len(model) > MAX_LAUNCH_MODEL_LENGTH or any(ord(ch) < 32 or ord(ch) == 127 for ch in model):
             raise CdxError("Model contains unsupported characters.")
         normalized["model"] = model
+    if "priority" in settings and settings["priority"] is not None:
+        try:
+            priority = int(settings["priority"])
+        except (TypeError, ValueError) as error:
+            raise CdxError(f"Unsupported priority: {settings['priority']}") from error
+        if priority < MIN_LAUNCH_PRIORITY or priority > MAX_LAUNCH_PRIORITY:
+            raise CdxError(f"Unsupported priority: {settings['priority']}")
+        normalized["priority"] = priority
     return normalized
 
 
@@ -773,7 +791,7 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         if not keys:
             raise CdxError("At least one launch setting is required.")
-        allowed = {"power", "permission", "fast", "model"}
+        allowed = {"power", "permission", "fast", "model", "priority"}
         unknown = [key for key in keys if key not in allowed]
         if unknown:
             raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")