cdx-manager 0.7.0 → 0.7.1

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.7.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.7.1-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 
@@ -134,7 +134,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.7.0 sh install.sh
+CDX_VERSION=v0.7.1 sh install.sh
 ```
 
 From source:
@@ -437,7 +437,7 @@ cdx run \
   --json
 ```
 
-The result includes `run_id`, selected `session`, `provider`, `exit_code`, `duration_seconds`, absolute `transcript_path`, `stdout_path`, `stderr_path`, and normalized usage token fields. Token counts are `null` when the provider does not expose them.
+The result includes `launcher: "cdx"`, `run_id`, selected `session`, `provider`, `exit_code`, `duration_seconds`, absolute `transcript_path`, `stdout_path`, `stderr_path`, and normalized usage token fields. Codex headless runs use `codex exec --json`; Claude headless runs use `claude --print --output-format json`. Token counts are `null` when the provider does not expose a supported JSON or JSONL usage shape.
 
 `cdx select` exposes the same session selection logic directly:
 

package/changelogs/CHANGELOGS_0_7_1.md

@@ -0,0 +1,41 @@
+# Changelog (`0.7.0 -> 0.7.1`)
+
+Release date: 2026-05-29
+
+## Headless Automation
+
+- Switched `cdx run --json` Codex execution to the provider-native `codex exec --json` path so headless runs no longer depend on an interactive terminal launch mode.
+- Switched Claude headless execution to `claude --print --output-format json` while preserving isolated auth homes, model selection, permission mode, and effort mapping.
+- Preserved Codex unattended `auto` permission behavior in headless mode with an explicit `approval_policy="never"` config override.
+- Kept provider stdout and stderr captured in artifact files while cdx stdout remains reserved for the final JSON payload.
+
+## JSON Contract
+
+- Added top-level `launcher: "cdx"` to `cdx run --json` result payloads so subprocess callers can identify cdx-manager responses directly.
+- Ensured `launcher: "cdx"` is also present when provider auto-selection cannot find a suitable session.
+- Added conservative token usage extraction for supported Codex and Claude JSON or JSONL stdout artifact shapes.
+- Preserved all-null token usage when artifacts are missing, malformed, unsupported, or do not expose trusted usage data.
+
+## Status Display
+
+- Clamped Claude rate-limit percentage calculations to the `0..100` range so over-limit provider utilization cannot display negative remaining availability.
+- Clamped cached status percentages defensively so already-persisted invalid values render as valid availability values.
+- Colored fully depleted or invalid low availability as red and high availability above 80% as bright cyan.
+
+## Planning Docs
+
+- Added and completed Logics request, backlog items, and tasks for Orchestia headless token usage and provider-native launch modes.
+
+## Release Metadata
+
+- Updated package metadata, CLI version output, README badge, pinned installer example, and release changelog to `v0.7.1`.
+
+## Validation and Regression Evidence
+
+- `python -m unittest discover -s test -p 'test_*_py.py'`
+- `npm run lint`
+- `npm test`
+- `npm pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`
+- `python3 -m logics_manager lint --require-status`

package/checksums/release-archives.json

@@ -28,6 +28,10 @@
     "v0.6.5": {
       "github_tarball_sha256": "f2280917ea75b5ae1e99a99b011f09704d89b1a7ae42497f5093e6fff9f814d9",
       "github_zip_sha256": "0b8491037310ed82cf44419d0de887bc0f768c6690c69153992fc4d5cda69676"
+    },
+    "v0.7.0": {
+      "github_tarball_sha256": "c80231884bf20c9ae74144a1ec16e0685c2fdac67d7d93a3c6219c5ac6fc14dd",
+      "github_zip_sha256": "0e6af29e59d3a93a07e07656d6c0c93803a674e65830ef33fa2322649b7139c2"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.7.0"
+version = "0.7.1"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/claude_usage.py

@@ -87,6 +87,15 @@ def _format_reset_date(unix_seconds):
     return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
 
 
+def _remaining_from_utilization(value):
+    if value is None:
+        return None
+    try:
+        return max(0, min(100, round((1 - float(value)) * 100)))
+    except (TypeError, ValueError):
+        return None
+
+
 def _read_http_error_message(error):
     try:
         body = error.read().decode("utf-8", errors="replace")
@@ -159,8 +168,8 @@ def fetch_claude_rate_limit_headers(access_token):
     reset_at = reset_week_at or reset_5h_at
 
     return {
-        "remaining_5h_pct": round((1 - utilization_5h) * 100) if utilization_5h is not None else None,
-        "remaining_week_pct": round((1 - utilization_7d) * 100) if utilization_7d is not None else None,
+        "remaining_5h_pct": _remaining_from_utilization(utilization_5h),
+        "remaining_week_pct": _remaining_from_utilization(utilization_7d),
         "reset_5h_at": reset_5h_at,
         "reset_week_at": reset_week_at,
         "reset_at": reset_at,

package/src/cli.py

@@ -57,7 +57,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.7.0"
+VERSION = "0.7.1"
 
 
 # ---------------------------------------------------------------------------

package/src/cli_commands.py

@@ -40,6 +40,7 @@ from .provider_runtime import (
 )
 from .repair import format_repair_report, repair_health
 from .backup_bundle import read_bundle_meta
+from .run_usage import empty_usage, extract_run_usage
 from .status_view import _format_status_detail, _format_status_rows
 from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_latest_release_or_raise, is_newer_version
 from .update_manager import build_update_plan, format_update_failure, run_update_plan
@@ -1201,15 +1202,6 @@ def _read_run_prompt(parsed):
         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:"):
@@ -1233,10 +1225,16 @@ def _run_cdx_error_code(error):
 
 def _run_result_payload(ok, parsed, session, run_info=None, error=None, error_source=None, error_code=None):
     run_info = run_info or {}
+    usage = (
+        extract_run_usage(session.get("provider"), run_info.get("stdout_path"))
+        if ok and 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),
@@ -1249,7 +1247,7 @@ def _run_result_payload(ok, parsed, session, run_info=None, error=None, error_so
         "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(),
+        "usage": usage,
         "warnings": [],
         "error": None if ok else {
             "source": error_source or "cdx",
@@ -1283,6 +1281,7 @@ def handle_run(rest, ctx):
                     "run",
                     "no_suitable_session",
                     "No suitable session found.",
+                    launcher="cdx",
                     provider=parsed["provider"],
                 ))
                 return 1

package/src/cli_render.py

@@ -75,10 +75,12 @@ def _style_pct(value, use_color=False):
     text = _format_pct(value)
     if value is None:
         return _style(text, "2", use_color)
-    if value == 0:
+    if value <= 0:
         return _style(text, "31", use_color)
     if value <= 10:
         return _style(text, "33", use_color)
+    if value > 80:
+        return _style(text, "96", use_color)
     return _style(text, "32", use_color)
 
 

package/src/provider_runtime.py

@@ -29,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):
@@ -279,11 +285,7 @@ def _default_script_args(transcript_path, spec):
 
 
 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.")
-        if len(initial_prompt) > 32768:
-            raise CdxError("initial_prompt exceeds maximum allowed length.")
+    _validate_initial_prompt(initial_prompt)
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
@@ -347,6 +349,68 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     }, 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)
@@ -397,12 +461,11 @@ def _headless_run_info(paths, spec, start_time, returncode):
 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(
+    spec = _build_headless_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)

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

@@ -189,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"),
@@ -297,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:
@@ -981,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,