cdx-manager 0.6.5 → 0.7.1

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"],
@@ -27,6 +29,12 @@ LAUNCH_PERMISSION_ARGS = {
         "full": ["-s", "danger-full-access", "-a", "never"],
     },
 }
+HEADLESS_CODEX_PERMISSION_ARGS = {
+    "review": ["-s", "read-only"],
+    "default": ["-s", "workspace-write"],
+    "auto": ["-s", "workspace-write", "-c", 'approval_policy="never"'],
+    "full": ["--dangerously-bypass-approvals-and-sandbox"],
+}
 
 
 def _home_env_overrides(auth_home):
@@ -158,7 +166,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:
@@ -166,6 +174,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 = []
@@ -254,12 +284,8 @@ 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):
-    if initial_prompt is not None:
-        if not isinstance(initial_prompt, str):
-            raise CdxError("initial_prompt must be a string.")
-        if len(initial_prompt) > 32768:
-            raise CdxError("initial_prompt exceeds maximum allowed length.")
+def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None, capture_transcript=True):
+    _validate_initial_prompt(initial_prompt)
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
@@ -280,7 +306,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:
@@ -293,7 +319,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"]
@@ -309,7 +335,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)
@@ -320,7 +346,193 @@ 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 _validate_initial_prompt(initial_prompt):
+    if initial_prompt is not None:
+        if not isinstance(initial_prompt, str):
+            raise CdxError("initial_prompt must be a string.")
+        if len(initial_prompt) > 32768:
+            raise CdxError("initial_prompt exceeds maximum allowed length.")
+
+
+def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
+    _validate_initial_prompt(initial_prompt)
+    cwd = cwd or os.getcwd()
+    env = {**os.environ, **(env_override or {})}
+    launch = session.get("launch") or {}
+    power = _launch_power(session)
+    permission = launch.get("permission")
+    model = launch.get("model")
+
+    if session["provider"] == PROVIDER_CLAUDE:
+        args = ["--print", "--output-format", "json", "--name", session["name"]]
+        if model:
+            args += ["--model", model]
+        args += _launch_config_args(session)
+        if initial_prompt:
+            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)
+        if oauth_token:
+            claude_env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
+        return {
+            "command": "claude",
+            "args": args,
+            "options": {"cwd": cwd, "env": claude_env},
+            "label": "claude",
+        }
+
+    if session["provider"] == PROVIDER_CODEX:
+        args = ["exec", "--json", "-C", cwd]
+        if model:
+            args += ["-m", model]
+        if power:
+            args += ["-c", f'model_reasoning_effort="{power}"']
+        if permission:
+            args += HEADLESS_CODEX_PERMISSION_ARGS.get(permission, [])
+        if initial_prompt:
+            args.append(initial_prompt)
+        return {
+            "command": "codex",
+            "args": args,
+            "options": {"cwd": cwd, "env": {**env, "CODEX_HOME": _get_auth_home(session)}},
+            "label": "codex",
+        }
+
+    return _build_launch_spec(
+        session,
+        cwd=cwd,
+        env_override=env_override,
+        initial_prompt=initial_prompt,
+        capture_transcript=False,
+    )
+
+
+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_headless_launch_spec(
+        session,
+        cwd=cwd,
+        env_override=env_override,
+        initial_prompt=initial_prompt,
+    )
+    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):

package/src/run_usage.py

@@ -0,0 +1,133 @@
+import json
+
+
+USAGE_KEYS = ("input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
+SUPPORTED_PROVIDERS = {"claude", "codex"}
+
+
+def empty_usage():
+    return {key: None for key in USAGE_KEYS}
+
+
+def extract_run_usage(provider, stdout_path):
+    if not stdout_path or not provider:
+        return empty_usage()
+    if provider not in SUPPORTED_PROVIDERS:
+        return empty_usage()
+    try:
+        with open(stdout_path, "r", encoding="utf-8", errors="replace") as handle:
+            text = handle.read()
+    except OSError:
+        return empty_usage()
+    if not text.strip():
+        return empty_usage()
+
+    records = _parse_json_records(text)
+    if not records:
+        return empty_usage()
+
+    usage = _extract_usage_from_records(records)
+    if not _has_usage(usage):
+        return empty_usage()
+    return usage
+
+
+def _parse_json_records(text):
+    stripped = text.strip()
+    try:
+        return [json.loads(stripped)]
+    except json.JSONDecodeError:
+        pass
+
+    records = []
+    for line in stripped.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            records.append(json.loads(line))
+        except json.JSONDecodeError:
+            return []
+    return records
+
+
+def _extract_usage_from_records(records):
+    latest = None
+    for record in records:
+        candidate = _find_usage(record)
+        if _has_usage(candidate):
+            latest = candidate
+    return latest or empty_usage()
+
+
+def _find_usage(value):
+    if isinstance(value, dict):
+        direct = _usage_from_dict(value)
+        if _has_usage(direct):
+            return direct
+        for child in value.values():
+            found = _find_usage(child)
+            if _has_usage(found):
+                return found
+    if isinstance(value, list):
+        for child in value:
+            found = _find_usage(child)
+            if _has_usage(found):
+                return found
+    return empty_usage()
+
+
+def _usage_from_dict(value):
+    usage = value.get("usage") if isinstance(value.get("usage"), dict) else value
+    if not isinstance(usage, dict):
+        return empty_usage()
+
+    input_tokens = _int_value(
+        usage.get("input_tokens"),
+        usage.get("prompt_tokens"),
+        usage.get("cache_creation_input_tokens"),
+        usage.get("cache_read_input_tokens"),
+    )
+    output_tokens = _int_value(usage.get("output_tokens"), usage.get("completion_tokens"))
+    reasoning_tokens = _int_value(
+        usage.get("reasoning_tokens"),
+        _nested_int(usage, "output_tokens_details", "reasoning_tokens"),
+        _nested_int(usage, "completion_tokens_details", "reasoning_tokens"),
+    )
+    total_tokens = _first_int(usage.get("total_tokens"))
+    if total_tokens is None and input_tokens is not None and output_tokens is not None:
+        total_tokens = input_tokens + output_tokens
+
+    return {
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "reasoning_tokens": reasoning_tokens,
+        "total_tokens": total_tokens,
+    }
+
+
+def _nested_int(value, parent, child):
+    nested = value.get(parent)
+    if not isinstance(nested, dict):
+        return None
+    return nested.get(child)
+
+
+def _first_int(value):
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed >= 0 else None
+
+
+def _int_value(*values):
+    parsed = [_first_int(value) for value in values]
+    parsed = [value for value in parsed if value is not None]
+    if not parsed:
+        return None
+    return sum(parsed)
+
+
+def _has_usage(usage):
+    return isinstance(usage, dict) and any(usage.get(key) is not None for key in USAGE_KEYS)

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
 
 
@@ -171,14 +189,23 @@ def _to_local_iso(value):
     return parsed.astimezone().isoformat()
 
 
+def _normalize_pct_value(value):
+    if value is None:
+        return None
+    try:
+        return max(0, min(100, round(float(value))))
+    except (TypeError, ValueError):
+        return None
+
+
 def _normalize_status_payload(payload=None):
     if payload is None:
         payload = {}
     now = _local_now_iso()
     return {
-        "usage_pct": payload.get("usage_pct"),
-        "remaining_5h_pct": payload.get("remaining_5h_pct"),
-        "remaining_week_pct": payload.get("remaining_week_pct"),
+        "usage_pct": _normalize_pct_value(payload.get("usage_pct")),
+        "remaining_5h_pct": _normalize_pct_value(payload.get("remaining_5h_pct")),
+        "remaining_week_pct": _normalize_pct_value(payload.get("remaining_week_pct")),
         "credits": payload.get("credits"),
         "reset_5h_at": payload.get("reset_5h_at"),
         "reset_week_at": payload.get("reset_week_at"),
@@ -279,8 +306,8 @@ def _compute_available_pct(status):
     if not status:
         return None
     values = [
-        status.get("remaining_5h_pct"),
-        status.get("remaining_week_pct"),
+        _normalize_pct_value(status.get("remaining_5h_pct")),
+        _normalize_pct_value(status.get("remaining_week_pct")),
     ]
     values = [value for value in values if value is not None]
     if not values:
@@ -773,7 +800,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)}")
@@ -963,8 +990,8 @@ def create_session_service(options=None):
                 "status": "enabled" if enabled else "disabled",
                 "auth_status": (s.get("auth") or {}).get("status") or "unknown",
                 "auth_checked_at": _to_local_iso((s.get("auth") or {}).get("lastCheckedAt")),
-                "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
-                "remaining_week_pct": row_status.get("remaining_week_pct") if row_status else None,
+                "remaining_5h_pct": _normalize_pct_value(row_status.get("remaining_5h_pct")) if row_status else None,
+                "remaining_week_pct": _normalize_pct_value(row_status.get("remaining_week_pct")) if row_status else None,
                 "credits": row_status.get("credits") if row_status else None,
                 "available_pct": _compute_available_pct(row_status),
                 "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,