cdx-manager 0.6.0 → 0.6.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.6.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.6.1-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -67,6 +67,7 @@ One command to launch any session. Zero auth juggling.
   - Codex live source: `codex app-server` JSON-RPC `account/rateLimits/read`, normalized into 5-hour, weekly, reset, credit, and plan fields.
   - Fallback: `status-source` scans provider JSONL history files and terminal log transcripts, strips ANSI/OSC sequences, and extracts `usage%`, `5h remaining%`, and `week remaining%` via pattern matching.
 - Claude status refreshes are cached briefly by default; pass `--refresh` to force a live rate-limit probe.
+- On Linux, transcript capture uses the `util-linux` `script -c` command form.
 - If `script` is unavailable, Codex launch falls back to running without transcript capture.
 - On Windows, transcript capture is optional. If no compatible `script` wrapper is installed, Codex still launches normally without transcript capture.
 - Auth probe: synchronous subprocess call to `codex login status` or `claude auth status` before any interactive launch.
@@ -131,7 +132,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.6.0 sh install.sh
+CDX_VERSION=v0.6.1 sh install.sh
 ```
 
 From source:

package/changelogs/CHANGELOGS_0_6_1.md

@@ -0,0 +1,30 @@
+# Changelog (`0.6.0 -> 0.6.1`)
+
+Release date: 2026-05-28
+
+## Handoff Reliability
+
+- Fixed `cdx handoff <source> <target>` when a source session has no `cdx-session*.log` launch transcript.
+- Added fallback discovery for native provider histories, including Claude project JSONL files under the isolated session home.
+- Converted JSONL message records into readable role-prefixed handoff context instead of requiring raw terminal logs.
+
+## Linux Transcript Capture
+
+- Fixed default transcript capture on Linux and Arch Linux by using the `util-linux` `script -q -F -c "<command>" <transcript>` form.
+- Kept the existing BSD/macOS `script` invocation unchanged.
+- Preserved custom `CDX_SCRIPT_ARGS` behavior for users who explicitly configure their wrapper.
+
+## Release Metadata and Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.6.1`.
+- Documented the Linux-specific transcript capture behavior in the README.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for Claude-to-Claude handoff from native `.claude/projects/*.jsonl` history when no launch log exists.
+- Added runtime coverage for the Linux `script` invocation shape.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`

package/package.json

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

package/src/cli.py

@@ -54,7 +54,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.6.0"
+VERSION = "0.6.1"
 
 
 # ---------------------------------------------------------------------------

package/src/cli_commands.py

@@ -2,6 +2,7 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import time
 from datetime import datetime, timedelta
@@ -37,7 +38,7 @@ from .provider_runtime import (
 from .repair import format_repair_report, repair_health
 from .backup_bundle import read_bundle_meta
 from .status_view import _format_status_detail, _format_status_rows
-from .update_check import fetch_latest_release, is_newer_version
+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
 
 
@@ -56,6 +57,7 @@ HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|t
 LAST_USAGE = "Usage: cdx last [--json]"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
+HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES = 64
 
 
 def _local_now_iso():
@@ -194,9 +196,132 @@ def _latest_launch_transcript_path(session):
     return max(paths, key=lambda path: (os.path.getmtime(path), path))
 
 
-def _read_handoff_transcript(path):
+def _get_session_home(session):
+    return session.get("authHome") or session.get("sessionRoot") or session.get("codexHome", "")
+
+
+def _safe_stat(path):
+    try:
+        return os.stat(path)
+    except OSError:
+        return None
+
+
+def _sort_recent_paths(paths):
+    stats = {path: stat for path, stat in ((_path, _safe_stat(_path)) for _path in set(paths)) if stat}
+    return sorted(stats, key=lambda path: (stats[path].st_mtime, path), reverse=True)
+
+
+def _collect_native_handoff_transcript_paths(session):
+    root = _get_session_home(session)
+    if not root:
+        return []
+    candidates = []
+    direct = [
+        os.path.join(root, "history.jsonl"),
+        os.path.join(root, "session_index.jsonl"),
+    ]
+    candidates.extend(path for path in direct if _safe_stat(path))
+
+    scan_roots = [
+        os.path.join(root, "sessions"),
+        os.path.join(root, ".claude", "projects"),
+        os.path.join(root, "projects"),
+    ]
+    skip_dirs = {"cache", "plugins", "skills", "memories", "sqlite", "shell_snapshots", "tmp", "__pycache__"}
+    for scan_root in scan_roots:
+        if not os.path.isdir(scan_root):
+            continue
+        for dirpath, dirnames, filenames in os.walk(scan_root):
+            dirnames[:] = [name for name in dirnames if not name.startswith(".") and name not in skip_dirs]
+            for filename in filenames:
+                if filename.endswith(".jsonl") or filename.endswith(".log"):
+                    candidates.append(os.path.join(dirpath, filename))
+    return _sort_recent_paths(candidates)[:HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES]
+
+
+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
+
+
+def _collect_handoff_text_fragments(value):
+    fragments = []
+    if isinstance(value, str):
+        text = value.strip()
+        if text:
+            fragments.append(text)
+    elif isinstance(value, list):
+        for item in value:
+            fragments.extend(_collect_handoff_text_fragments(item))
+    elif isinstance(value, dict):
+        if isinstance(value.get("text"), str):
+            fragments.extend(_collect_handoff_text_fragments(value.get("text")))
+        if isinstance(value.get("content"), (str, list, dict)):
+            fragments.extend(_collect_handoff_text_fragments(value.get("content")))
+        if isinstance(value.get("message"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("message")))
+        if isinstance(value.get("payload"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("payload")))
+    return fragments
+
+
+def _jsonl_record_to_handoff_text(record):
+    if not isinstance(record, dict):
+        return None
+    message = record.get("message") if isinstance(record.get("message"), dict) else {}
+    role = (
+        message.get("role")
+        or record.get("role")
+        or record.get("type")
+        or record.get("sender")
+        or "entry"
+    )
+    text_sources = []
+    for key in ("content", "text", "payload"):
+        if key in record:
+            text_sources.append(record.get(key))
+    for key in ("content", "text"):
+        if key in message:
+            text_sources.append(message.get(key))
+    fragments = []
+    for value in text_sources:
+        fragments.extend(_collect_handoff_text_fragments(value))
+    text = "\n".join(fragment for fragment in fragments if fragment).strip()
+    if not text:
+        return None
+    role = re.sub(r"[^A-Za-z0-9_-]+", "-", str(role).strip()).strip("-") or "entry"
+    return f"[{role}]\n{text}"
+
+
+def _read_jsonl_handoff_transcript(path):
+    entries = []
+    with open(path, "r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                text = _jsonl_record_to_handoff_text(json.loads(line))
+            except json.JSONDecodeError:
+                text = None
+            if text:
+                entries.append(text)
+    if entries:
+        return "\n\n".join(entries)
     with open(path, "r", encoding="utf-8", errors="replace") as handle:
-        content = handle.read()
+        return handle.read()
+
+
+def _read_handoff_transcript(path):
+    if path.endswith(".jsonl"):
+        content = _read_jsonl_handoff_transcript(path)
+    else:
+        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+            content = handle.read()
     if len(content) <= HANDOFF_TRANSCRIPT_CHARS:
         return content, False
     return content[-HANDOFF_TRANSCRIPT_CHARS:], True
@@ -1437,7 +1562,14 @@ def handle_update(rest, ctx):
     if parsed["version"] is not None:
         target_version = str(parsed["version"]).strip().lstrip("v")
     else:
-        latest = release_fetcher()
+        try:
+            latest = (
+                release_fetcher()
+                if ctx["options"].get("fetchLatestRelease")
+                else fetch_latest_release_or_raise(env=ctx.get("env"))
+            )
+        except LatestReleaseCheckError as error:
+            raise CdxError(str(error)) from error
         if not latest:
             raise CdxError("Unable to check for the latest cdx-manager release. Check your network and try again.")
         target_version = str(latest.get("latest_version") or "").strip()
@@ -1613,9 +1745,9 @@ def handle_handoff(rest, ctx):
     target = ctx["service"]["get_session"](target_name)
     if not target:
         raise CdxError(f"Unknown session: {target_name}")
-    transcript_path = _latest_launch_transcript_path(source)
+    transcript_path = _latest_handoff_transcript_path(source)
     if not transcript_path:
-        raise CdxError(f"No launch transcript found for session: {source_name}")
+        raise CdxError(f"No transcript found for session: {source_name}")
     transcript, truncated = _read_handoff_transcript(transcript_path)
     context = _build_handoff_context(source, target, transcript_path, transcript, truncated=truncated)
     write_result = write_context(ctx["service"]["base_dir"], context, ctx.get("cwd"))

package/src/provider_runtime.py

@@ -131,7 +131,7 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
             args = args + [transcript_path]
         args = args + [spec["command"]] + spec["args"]
     else:
-        args = ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
+        args = _default_script_args(transcript_path, spec)
     return {
         "command": script_bin,
         "args": args,
@@ -142,6 +142,13 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
     }
 
 
+def _default_script_args(transcript_path, spec):
+    if sys.platform.startswith("linux"):
+        command = shlex.join([spec["command"]] + spec["args"])
+        return ["-q", "-F", "-c", command, transcript_path]
+    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):

package/src/update_check.py

@@ -9,6 +9,10 @@ UPDATE_CHECK_TTL_SECONDS = 12 * 60 * 60
 LATEST_RELEASE_URL = "https://api.github.com/repos/AlexAgo83/cdx-manager/releases/latest"
 
 
+class LatestReleaseCheckError(Exception):
+    pass
+
+
 def _parse_version(value):
     raw = str(value or "").strip().lstrip("v")
     parts = raw.split(".")
@@ -51,13 +55,22 @@ def _write_cache(path, payload):
         handle.write("\n")
 
 
-def _fetch_latest_release():
+def _github_token(env=None):
+    env = env or os.environ
+    return env.get("GH_TOKEN") or env.get("GITHUB_TOKEN")
+
+
+def _fetch_latest_release(env=None):
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "cdx-manager-update-check",
+    }
+    token = _github_token(env)
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
     request = urllib.request.Request(
         LATEST_RELEASE_URL,
-        headers={
-            "Accept": "application/vnd.github+json",
-            "User-Agent": "cdx-manager-update-check",
-        },
+        headers=headers,
     )
     with urllib.request.urlopen(request, timeout=5) as response:
         payload = json.loads(response.read().decode("utf-8"))
@@ -67,13 +80,39 @@ def _fetch_latest_release():
     }
 
 
-def fetch_latest_release():
+def _format_fetch_error(error):
+    if isinstance(error, urllib.error.HTTPError):
+        if error.code == 403:
+            return (
+                "GitHub API rate limit reached while checking the latest cdx-manager release. "
+                "Try again later, set GH_TOKEN or GITHUB_TOKEN, or run cdx update --version <version>."
+            )
+        if error.code == 404:
+            return "Unable to find the latest cdx-manager release on GitHub."
+        return f"GitHub returned HTTP {error.code} while checking the latest cdx-manager release."
+    if isinstance(error, urllib.error.URLError):
+        reason = getattr(error, "reason", None)
+        suffix = f" ({reason})" if reason else ""
+        return f"Unable to reach GitHub while checking the latest cdx-manager release{suffix}."
+    if isinstance(error, TimeoutError):
+        return "Timed out while checking the latest cdx-manager release."
+    return "Unable to check for the latest cdx-manager release."
+
+
+def fetch_latest_release(env=None):
     try:
-        return _fetch_latest_release()
+        return _fetch_latest_release(env=env)
     except (urllib.error.URLError, TimeoutError, ValueError, OSError):
         return None
 
 
+def fetch_latest_release_or_raise(env=None):
+    try:
+        return _fetch_latest_release(env=env)
+    except (urllib.error.URLError, TimeoutError, ValueError, OSError) as error:
+        raise LatestReleaseCheckError(_format_fetch_error(error)) from error
+
+
 def check_for_update(base_dir, current_version, env=None, now_fn=None):
     env = env or os.environ
     now_fn = now_fn or (lambda: datetime.now(timezone.utc).timestamp())
@@ -94,7 +133,7 @@ def check_for_update(base_dir, current_version, env=None, now_fn=None):
             }
         return None
 
-    latest = fetch_latest_release()
+    latest = fetch_latest_release(env=env)
     if not latest:
         return None