cdx-manager 0.12.0 → 0.12.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.12.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.12.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.**
 
@@ -376,6 +376,7 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx view [--json] [--lan] [--lan-rw] [--focus <ref>] [--read] [--port <port>] [--host <host>] [--refresh-interval <s>] [--tls] [--tls-cert <path>] [--tls-key <path>] [--open] [--no-open]` | Open the Logics browser/focus viewer by delegating to `logics-manager view`; all viewer flags are forwarded; JSON mode reports diagnostics without launching it |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
+| `cdx update all [--yes] [--json]` | Check installed providers, RTK, and Ponytail across Codex profiles; show the plan and ask once before applying safe native/Homebrew updates and missing RTK/Ponytail setup |
 | `cdx ready [--refresh] [--json]` | Schedule an OS notification for the next cooling-down assistant that becomes ready, then return immediately |
 | `cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait for a session reset time or schedule an OS wake-up notification when due |
 | `cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait until the recommended session is usable, or schedule the next known reset notification |

package/changelogs/CHANGELOGS_0_12_1.md

@@ -0,0 +1,25 @@
+# CDX Manager 0.12.1
+
+## Highlights
+
+- Added `cdx update all` to inventory and safely update the installed provider CLIs, RTK, and Ponytail across Codex profiles.
+- Made account handoffs use native provider transcripts before terminal capture, preserving actionable conversation instead of terminal noise.
+
+## Changes
+
+### Workstation updates
+
+`cdx update all` now reports installed versions and session setup, asks once before applying its plan, and shows progress plus the command and error output when an action fails. It follows the actual installer provenance of each CLI, including the Claude Code cask rather than the separate Claude desktop app.
+
+RTK is enabled for sessions that lack it when available. Ponytail marketplaces and plugins are checked per Codex profile; current Codex marketplace caches without a `last_revision` field are resolved from their Git checkout.
+
+### Reliable handoffs
+
+Cross-session handoffs now prefer native JSONL transcripts and retain only user and assistant messages. Script-captured terminal logs remain a fallback, but no longer displace structured provider conversation or tool-output noise into the shared context.
+
+## Validation
+
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit --group-by-doc`

package/checksums/release-archives.json

@@ -148,6 +148,14 @@
     "v0.11.2": {
       "github_tarball_sha256": "513d7c586a662da5ac5daf792fc76f746e924bbd95157a9d0cbbeba34f2991e0",
       "github_zip_sha256": "d6d633efcbdc28818f68bd87efe3f246fe2983a9f4aa24d03868c978645c593e"
+    },
+    "v0.12.0": {
+      "github_tarball_sha256": "de1bac90e790b5d557f90fd22f7dd317c45646d0e07320c05c8b2336ed9bbced",
+      "github_zip_sha256": "213f6217dfd8c7aa979af691c2d63598b4589ca40f36e816f4ae9c9f2da27073"
+    },
+    "v0.12.1": {
+      "github_tarball_sha256": "87e3b11886a8e7fb10233d425f6a1986e62395c89049947678a50cfb20384278",
+      "github_zip_sha256": "249f75eb240de7cc421f17579e0040d35eb06e3213568673f743c92191dda0f0"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.12.0",
+  "version": "0.12.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.12.0"
+version = "0.12.1"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -78,7 +78,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.12.0"
+VERSION = "0.12.1"
 
 # Public surface: this module is a facade. Names below are imported above
 # purely to be re-exported (consumed by tests and external callers); listing
@@ -219,7 +219,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx view [--json]', '36', use_color)}",
-        f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
+        f"  {_style('cdx update [all] [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
         f"  {_style('cdx ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",

package/src/cli_args.py

@@ -15,7 +15,7 @@ STATUS_USAGE = "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECON
 DOCTOR_USAGE = "Usage: cdx doctor [--json]"
 DISK_USAGE = "Usage: cdx disk [profiles] [--candidates] [--json]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
-UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
+UPDATE_USAGE = "Usage: cdx update [all] [--check] [--yes] [--json] [--version TAG]"
 EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 IMPORT_USAGE = "Usage: cdx import <file> [--force|--merge] [--allow-authless-force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text...] [--json]"
@@ -594,11 +594,16 @@ def _parse_update_args(args):
         "--json": {"key": "json", "type": "bool", "default": False},
         "--yes": {"key": "yes", "type": "bool", "default": False},
         "--version": {"key": "version", "type": "str", "default": None},
-    }, UPDATE_USAGE)
+    }, UPDATE_USAGE, positionals_key="values", max_positionals=1)
+    if parsed["values"] not in ([], ["all"]):
+        raise CdxError(UPDATE_USAGE)
+    parsed["all"] = bool(parsed["values"])
+    if parsed["all"] and (parsed["check"] or parsed["version"]):
+        raise CdxError("Usage: cdx update all [--yes] [--json]")
     if parsed["check"] and parsed["version"]:
         raise CdxError("Usage: cdx update --check cannot be combined with --version.")
     if parsed["version"] is not None and not parsed["version"].strip():
-        raise CdxError("Usage: cdx update [--check] [--yes] [--json] [--version TAG]")
+        raise CdxError(UPDATE_USAGE)
     return parsed
 
 

package/src/cli_commands.py

@@ -124,10 +124,46 @@ from .run_command import read_run_prompt, run_cdx_error_code, run_result_payload
 from .run_registry import RunRegistry, build_code_review_report
 from .run_usage import extract_run_usage
 from .status_view import _format_status_detail, _format_status_rows, format_priority_instruction, recommend_priority_rows
+from .update_all import apply_update_all_plan, collect_update_all_plan
 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, verify_updated_command
 
 
+def _format_update_all(plan, use_color=False):
+    labels = {
+        "up_to_date": _success("OK", use_color),
+        "update_available": _warn("UPDATE", use_color),
+        "not_installed": _warn("MISSING", use_color),
+        "check_with_native_updater": _info("CHECK", use_color),
+    }
+    rows = [[_style("TOOL", "1", use_color), _style("CURRENT", "1", use_color), _style("LATEST", "1", use_color), _style("STATUS", "1", use_color)]]
+    for item in plan["items"]:
+        rows.append([_info(item["name"], use_color), item.get("version") or _dim("-", use_color), item.get("latest_version") or _dim("-", use_color), labels.get(item["status"], item["status"].replace("_", " "))])
+    lines = [_style("Workstation update", "1", use_color), _dim("Inventory only — nothing has changed.", use_color), "", _pad_table(rows)]
+    missing_rtk = plan["setup"]["rtk_missing_sessions"]
+    setup = [f"RTK: enable for {', '.join(missing_rtk)}" if missing_rtk else "RTK: configured for every session"]
+    setup.extend(f"Ponytail {plugin['session']}: {labels.get(plugin['status'], plugin['status'].replace('_', ' '))}" for plugin in plan["setup"]["ponytail"])
+    lines.extend(["", _style("Session setup", "1", use_color), *setup])
+    if plan["steps"]:
+        lines.extend(["", _warn(f"{len(plan['steps'])} action(s) ready", use_color), _dim("Confirm to update only the tools listed above.", use_color)])
+    else:
+        lines.extend(["", _success("Everything managed by CDX is current and configured.", use_color)])
+    return "\n".join(lines)
+
+
+def _format_update_all_result(result, use_color=False):
+    if result.get("skipped"):
+        return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
+    if result.get("returncode") == 0:
+        return _success(f"done: {result['name']}", use_color)
+    detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
+    detail = detail[-500:]
+    command = shlex.join(result.get("command") or [])
+    suffix = f"\n  {_dim(command, use_color)}" if command else ""
+    label = _warn(f"failed: {result['name']} (exit {result.get('returncode')})", use_color)
+    return f"{label}\n  {detail}{suffix}"
+
+
 def _resolve_bundle_passphrase(ctx, env_var, prompt, confirm=False, use_stdin=False):
     env = ctx.get("env", {})
     if env_var:
@@ -2674,6 +2710,38 @@ def handle_logout(rest, ctx):
 
 def handle_update(rest, ctx):
     parsed = _parse_update_args(rest)
+    if parsed["all"]:
+        plan = collect_update_all_plan(ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"))
+        if not parsed["yes"]:
+            if parsed["json"]:
+                _write_json(ctx, _json_success("update.all", "Collected workstation update plan", plan=plan, apply_required=bool(plan["steps"])))
+                return 0
+            ctx["out"](f"{_format_update_all(plan, ctx['use_color'])}\n")
+            if not plan["steps"]:
+                return 0
+            if not ctx["stdin_is_tty"]:
+                raise CdxError("cdx update all requires an interactive terminal or --yes.")
+            if input("Apply this plan? [y/N] ").strip().lower() not in ("y", "yes"):
+                ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+                return 0
+        def progress(event):
+            if parsed["json"]:
+                return
+            step_name = event["step"]["name"]
+            if event["phase"] == "start":
+                progress_label = _info(f"[{event['index']}/{event['total']}]", ctx["use_color"])
+                ctx["out"](f"{progress_label} {step_name}...\n")
+            else:
+                ctx["out"](f"  {_format_update_all_result(event['result'], ctx['use_color'])}\n")
+
+        results = apply_update_all_plan(plan, ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"), progress=progress)
+        failed = [row for row in results if row.get("returncode") != 0]
+        message = "Applied workstation update plan" if not failed else "Workstation update plan completed with failures"
+        if parsed["json"]:
+            _write_json(ctx, _json_success("update.all", message, plan=plan, results=results, failed=len(failed)))
+        else:
+            ctx["out"](f"{_success(message, ctx['use_color']) if not failed else _warn(message, ctx['use_color'])}\n")
+        return 1 if failed else 0
     json_flag = parsed["json"]
     current_version = str(ctx.get("version") or "").strip()
     release_fetcher = ctx["options"].get("fetchLatestRelease") or fetch_latest_release

package/src/cli_helpers.py

@@ -250,11 +250,10 @@ def _collect_native_handoff_transcript_paths(session):
 
 
 def _latest_handoff_transcript_path(session):
-    launch_path = _latest_launch_transcript_path(session)
-    if launch_path:
-        return launch_path
     native_paths = _collect_native_handoff_transcript_paths(session)
-    return native_paths[0] if native_paths else None
+    if native_paths:
+        return native_paths[0]
+    return _latest_launch_transcript_path(session)
 
 
 def _collect_handoff_text_fragments(value):
@@ -281,6 +280,10 @@ def _collect_handoff_text_fragments(value):
 def _jsonl_record_to_handoff_text(record):
     if not isinstance(record, dict):
         return None
+    if record.get("type") == "response_item":
+        record = record.get("payload")
+        if not isinstance(record, dict):
+            return None
     message = record.get("message") if isinstance(record.get("message"), dict) else {}
     role = (
         message.get("role")
@@ -289,6 +292,8 @@ def _jsonl_record_to_handoff_text(record):
         or record.get("sender")
         or "entry"
     )
+    if role not in ("user", "assistant"):
+        return None
     text_sources = []
     for key in ("content", "text", "payload"):
         if key in record:

package/src/update_all.py

@@ -0,0 +1,184 @@
+"""Inventory and apply the safe, known updates for a CDX workstation."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+
+_TOOLS = (
+    (PROVIDER_CODEX, "codex", None, ["codex", "update"]),
+    (PROVIDER_CLAUDE, "claude", "claude", ["brew", "upgrade", "--cask", "claude"]),
+    (PROVIDER_ANTIGRAVITY, "agy", "antigravity", ["brew", "upgrade", "--cask", "antigravity"]),
+    (PROVIDER_OLLAMA, "ollama", "ollama", ["brew", "upgrade", "ollama"]),
+    ("rtk", "rtk", "rtk", ["brew", "upgrade", "rtk"]),
+)
+_PONYTAIL_URL = "https://github.com/DietrichGebert/ponytail.git"
+
+
+def _which(command, env):
+    path = env.get("PATH")
+    resolved = shutil.which(command, path=path)
+    if resolved or not path:
+        return resolved
+    for directory in path.split(os.pathsep):
+        candidate = os.path.join(directory, command)
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
+
+def _run(command, env, runner=None, timeout=15):
+    runner = runner or subprocess.run
+    try:
+        result = runner(command, env=env, capture_output=True, text=True, check=False, timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        return {"returncode": 1, "stdout": "", "stderr": str(error)}
+    if isinstance(result, dict):
+        return result
+    return {"returncode": result.returncode, "stdout": result.stdout or "", "stderr": result.stderr or ""}
+
+
+def _version(command, env, runner):
+    result = _run([command, "--version"], env, runner)
+    text = (result["stdout"] or result["stderr"] or "").strip()
+    match = re.search(r"\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b", text)
+    return match.group(1) if match else None
+
+
+def _npm_latest(package, env, runner):
+    if not _which("npm", env):
+        return None
+    result = _run(["npm", "view", package, "version"], env, runner)
+    value = (result["stdout"] or "").strip()
+    return value if re.fullmatch(r"\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?", value) else None
+
+
+def _newer(latest, current):
+    def key(value):
+        return tuple(int(part) for part in str(value).split("-", 1)[0].split("+", 1)[0].split("."))
+    return bool(latest and current and key(latest) > key(current))
+
+
+def _brew_outdated(env, runner):
+    if not _which("brew", env):
+        return {}
+    result = _run(["brew", "outdated", "--json=v2"], env, runner, timeout=30)
+    try:
+        payload = json.loads(result["stdout"])
+    except (TypeError, ValueError):
+        return {}
+    rows = {}
+    for group in ("formulae", "casks"):
+        for item in payload.get(group, []):
+            rows[item.get("name")] = item
+    return rows
+
+
+def _brew_cask_for_path(path):
+    match = re.search(r"/Caskroom/([^/]+)/", os.path.realpath(path or ""))
+    return match.group(1) if match else None
+
+
+def _ponytail_revision(auth_home, env=None, runner=None):
+    try:
+        with open(os.path.join(auth_home, "config.toml"), encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError:
+        text = ""
+    match = re.search(r'\[marketplaces\.ponytail\].*?last_revision\s*=\s*"([0-9a-f]+)"', text, re.S)
+    if match:
+        return match.group(1)
+    cache = os.path.join(auth_home, ".tmp", "marketplaces", "ponytail")
+    result = _run(["git", "-C", cache, "rev-parse", "HEAD"], env or os.environ, runner)
+    revision = (result["stdout"] or "").strip()
+    return revision if re.fullmatch(r"[0-9a-f]{40}", revision) else None
+
+
+def collect_update_all_plan(service, env=None, runner=None):
+    env = dict(env or os.environ)
+    outdated = _brew_outdated(env, runner)
+    items, steps = [], []
+    for name, command, brew_name, update_command in _TOOLS:
+        path = _which(command, env)
+        item = {"name": name, "command": command, "installed": bool(path), "path": path, "version": _version(command, env, runner) if path else None}
+        cask_name = _brew_cask_for_path(path)
+        brew_target = cask_name or brew_name
+        brew_row = outdated.get(brew_target) if brew_target else None
+        if brew_row:
+            command_to_run = ["brew", "upgrade", "--cask", brew_target] if cask_name else update_command
+            item.update({"status": "update_available", "latest_version": brew_row.get("current_version"), "update_command": command_to_run, "package": brew_target})
+            steps.append({"name": name, "command": command_to_run, "env": {}})
+        elif path and name == PROVIDER_CODEX:
+            # Codex owns its installer; it is the only reliable updater across npm, Homebrew and standalone installs.
+            latest = _npm_latest("@openai/codex", env, runner)
+            item.update({"latest_version": latest, "status": "update_available" if _newer(latest, item["version"]) else "up_to_date" if latest else "check_with_native_updater", "update_command": update_command})
+            if item["status"] != "up_to_date":
+                steps.append({"name": name, "command": update_command, "env": {}})
+        else:
+            item["status"] = "up_to_date" if path else "not_installed"
+        items.append(item)
+
+    rtk_available = any(item["name"] == "rtk" and item["installed"] for item in items)
+    missing_rtk = [session["name"] for session in service["list_sessions"]() if not (session.get("launch") or {}).get("rtk")]
+    setup = {"rtk_available": rtk_available, "rtk_missing_sessions": missing_rtk, "ponytail": []}
+    if rtk_available and missing_rtk:
+        steps.append({"name": "enable RTK", "command": None, "sessions": missing_rtk})
+
+    codex_sessions = [session for session in service["list_sessions"]() if session.get("provider") == PROVIDER_CODEX]
+    ponytail_head = None
+    if any(_ponytail_revision(session.get("authHome") or "", env, runner) for session in codex_sessions):
+        remote = _run(["git", "ls-remote", _PONYTAIL_URL, "HEAD"], env, runner)
+        ponytail_head = (remote["stdout"] or "").split("\t", 1)[0].strip() or None
+    for session in codex_sessions:
+        revision = _ponytail_revision(session.get("authHome") or "", env, runner)
+        row = {"session": session["name"], "installed": bool(revision), "revision": revision}
+        if revision:
+            row["latest_revision"] = ponytail_head
+            row["status"] = "update_available" if ponytail_head and not ponytail_head.startswith(revision) else "up_to_date"
+            if row["status"] == "update_available":
+                steps.append({"name": f"update Ponytail ({session['name']})", "command": ["codex", "plugin", "marketplace", "upgrade", "ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}})
+        else:
+            row["status"] = "not_installed"
+            marketplace_id = f"ponytail-marketplace:{session['name']}"
+            steps.extend([
+                {"id": marketplace_id, "name": f"add Ponytail marketplace ({session['name']})", "command": ["codex", "plugin", "marketplace", "add", _PONYTAIL_URL], "env": {"CODEX_HOME": session["authHome"]}},
+                {"name": f"install Ponytail ({session['name']})", "command": ["codex", "plugin", "add", "ponytail@ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}, "requires": marketplace_id},
+            ])
+        setup["ponytail"].append(row)
+    return {"items": items, "setup": setup, "steps": steps}
+
+
+def apply_update_all_plan(plan, service, env=None, runner=None, progress=None):
+    env = dict(env or os.environ)
+    results = []
+    completed = set()
+    for index, step in enumerate(plan["steps"], start=1):
+        if progress:
+            progress({"phase": "start", "index": index, "total": len(plan["steps"]), "step": step})
+        if step.get("requires") and step["requires"] not in completed:
+            result = {"name": step["name"], "returncode": None, "skipped": True, "blocked_by": step["requires"]}
+            results.append(result)
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        if step["command"] is None:
+            for name in step["sessions"]:
+                service["set_launch_settings"](name, {"rtk": True})
+            result = {"name": step["name"], "returncode": 0, "sessions": step["sessions"]}
+            results.append(result)
+            if step.get("id"):
+                completed.add(step["id"])
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        result = _run(step["command"], {**env, **step.get("env", {})}, runner, timeout=120)
+        result = {"name": step["name"], "command": step["command"], **result}
+        results.append(result)
+        if result["returncode"] == 0 and step.get("id"):
+            completed.add(step["id"])
+        if progress:
+            progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+    return results