cdx-manager 0.5.7 → 0.6.1

package/src/cli_commands.py

@@ -2,9 +2,10 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import time
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from .claude_refresh import _refresh_claude_sessions
 from .cli_render import _dim, _info, _success, _warn
@@ -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
 
 
@@ -52,8 +53,11 @@ HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <targ
 SET_USAGE = "Usage: cdx set <name> [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--json]"
 UNSET_USAGE = "Usage: cdx unset <name> (--power|--permission|--fast|--all) [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
+HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
+LAST_USAGE = "Usage: cdx last [--json]"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
+HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES = 64
 
 
 def _local_now_iso():
@@ -76,6 +80,26 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
+def _update_notice_warning(ctx):
+    notice = ctx.get("update_notice")
+    if not notice:
+        return None
+    return {
+        "code": "update_available",
+        "message": f"Update available: cdx-manager {notice['latest_version']}",
+        "latest_version": notice["latest_version"],
+        "url": notice.get("url"),
+    }
+
+
+def _write_update_notice(ctx):
+    notice = ctx.get("update_notice")
+    if not notice:
+        return
+    text = f"Update available: cdx-manager {notice['latest_version']} (current version installed may be older). Run: cdx update"
+    ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
+
+
 def _format_bytes(value):
     if value is None:
         return "n/a"
@@ -172,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
@@ -364,6 +511,154 @@ def _parse_config_args(args):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_positive_int(value):
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as error:
+        raise CdxError(HISTORY_USAGE) from error
+    if parsed < 1:
+        raise CdxError(HISTORY_USAGE)
+    return parsed
+
+
+def _local_timezone():
+    return datetime.now().astimezone().tzinfo
+
+
+def _parse_datetime_value(value, usage, end_of_day=False):
+    text = str(value or "").strip()
+    if not text:
+        raise CdxError(usage)
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    is_date_only = len(text) == 10 and text[4] == "-" and text[7] == "-"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError as error:
+        raise CdxError(usage) from error
+    if is_date_only and end_of_day:
+        parsed = parsed.replace(hour=23, minute=59, second=59, microsecond=999999)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=_local_timezone())
+    return parsed.astimezone()
+
+
+def _parse_since_value(value, now, usage):
+    text = str(value or "").strip().lower()
+    if not text:
+        raise CdxError(usage)
+    if text == "today":
+        return now.replace(hour=0, minute=0, second=0, microsecond=0)
+    if text == "yesterday":
+        today = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        return today - timedelta(days=1)
+    unit = text[-1:]
+    amount_text = text[:-1]
+    if unit in ("m", "h", "d", "w") and amount_text.isdigit():
+        amount = int(amount_text)
+        if amount < 1:
+            raise CdxError(usage)
+        multipliers = {
+            "m": timedelta(minutes=amount),
+            "h": timedelta(hours=amount),
+            "d": timedelta(days=amount),
+            "w": timedelta(weeks=amount),
+        }
+        return now - multipliers[unit]
+    return _parse_datetime_value(value, usage, end_of_day=False)
+
+
+def _format_period_datetime(value):
+    if value is None:
+        return None
+    return value.isoformat(timespec="seconds")
+
+
+def _parse_history_period(parsed, now):
+    since = parsed.get("since")
+    from_value = parsed.get("from")
+    to_value = parsed.get("to")
+    if since and from_value:
+        raise CdxError("Usage: cdx history cannot combine --since and --from.")
+    start = _parse_since_value(since, now, HISTORY_USAGE) if since else None
+    if from_value:
+        start = _parse_datetime_value(from_value, HISTORY_USAGE, end_of_day=False)
+    end = _parse_datetime_value(to_value, HISTORY_USAGE, end_of_day=True) if to_value else None
+    if start and end and start.timestamp() > end.timestamp():
+        raise CdxError("Usage: cdx history period start must be before period end.")
+    return {
+        "from": _format_period_datetime(start),
+        "to": _format_period_datetime(end),
+        "from_ts": start.timestamp() if start else None,
+        "to_ts": end.timestamp() if end else None,
+    }
+
+
+def _has_history_period(period):
+    return period.get("from_ts") is not None or period.get("to_ts") is not None
+
+
+def _parse_entry_timestamp(entry):
+    value = entry.get("started_at")
+    if not value:
+        return None
+    text = str(value)
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=_local_timezone())
+    return parsed.timestamp()
+
+
+def _filter_history_period(entries, period):
+    if not _has_history_period(period):
+        return entries
+    filtered = []
+    start = period.get("from_ts")
+    end = period.get("to_ts")
+    for entry in entries:
+        timestamp = _parse_entry_timestamp(entry)
+        if timestamp is None:
+            continue
+        if start is not None and timestamp < start:
+            continue
+        if end is not None and timestamp > end:
+            continue
+        filtered.append(entry)
+    return filtered
+
+
+def _public_history_period(period):
+    return {
+        "from": period.get("from"),
+        "to": period.get("to"),
+    }
+
+
+def _parse_history_args(args, now=None):
+    now = now or datetime.now().astimezone()
+    parsed = _parse_flag_args(args, {
+        "--limit": {"key": "limit", "type": "str", "default": 20, "transform": _parse_positive_int},
+        "--summary": {"key": "summary", "type": "bool", "default": False},
+        "--since": {"key": "since", "type": "str", "default": None},
+        "--from": {"key": "from", "type": "str", "default": None},
+        "--to": {"key": "to", "type": "str", "default": None},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, HISTORY_USAGE, positionals_key="names", max_positionals=1)
+    period = _parse_history_period(parsed, now)
+    return {
+        "name": parsed["names"][0] if parsed["names"] else None,
+        "limit": parsed["limit"],
+        "summary": parsed["summary"],
+        "period": period,
+        "json": parsed["json"],
+    }
+
+
 def _read_option_value(args, index, usage):
     if index + 1 >= len(args):
         raise CdxError(usage)
@@ -590,6 +885,123 @@ def _format_launch_config(session):
     ])
 
 
+def _format_duration_ms(value):
+    if value is None:
+        return "-"
+    try:
+        amount = int(value)
+    except (TypeError, ValueError):
+        return str(value)
+    if amount < 1000:
+        return f"{amount}ms"
+    seconds = amount / 1000
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes = int(seconds // 60)
+    remaining = int(seconds % 60)
+    return f"{minutes}m{remaining:02d}s"
+
+
+def _summarize_history(entries):
+    by_session = {}
+    for entry in entries:
+        name = entry.get("session_name") or "-"
+        row = by_session.setdefault(name, {
+            "session_name": name,
+            "provider": entry.get("provider") or "-",
+            "launches": 0,
+            "successes": 0,
+            "failures": 0,
+            "duration_ms": 0,
+            "last_started_at": None,
+        })
+        row["launches"] += 1
+        if entry.get("status") == "success":
+            row["successes"] += 1
+        elif entry.get("status") == "failed":
+            row["failures"] += 1
+        try:
+            row["duration_ms"] += int(entry.get("duration_ms") or 0)
+        except (TypeError, ValueError):
+            pass
+        started = entry.get("started_at")
+        if started and (not row["last_started_at"] or started > row["last_started_at"]):
+            row["last_started_at"] = started
+            row["provider"] = entry.get("provider") or row["provider"]
+    return sorted(
+        by_session.values(),
+        key=lambda item: (item["duration_ms"], item.get("last_started_at") or "", item["session_name"]),
+        reverse=True,
+    )
+
+
+def _format_history_period(period):
+    if not _has_history_period(period or {}):
+        return None
+    start = _format_period_display(period.get("from")) or "beginning"
+    end = _format_period_display(period.get("to")) or "now"
+    return f"Period: {start} -> {end}"
+
+
+def _format_period_display(value):
+    if not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(str(value))
+    except ValueError:
+        return str(value)
+    return parsed.strftime("%Y-%m-%d %H:%M")
+
+
+def _format_history_summary(entries, period=None, use_color=False):
+    from .cli_render import _format_relative_age, _pad_table
+
+    summary = _summarize_history(entries)
+    if not summary:
+        return "No launch history for this period." if _has_history_period(period or {}) else "No launch history."
+    rows = [["SESSION", "PROV.", "LAUNCHES", "OK", "FAIL", "TIME", "LAST"]]
+    for row in summary:
+        rows.append([
+            row["session_name"],
+            row["provider"],
+            str(row["launches"]),
+            str(row["successes"]),
+            str(row["failures"]),
+            _format_duration_ms(row["duration_ms"]),
+            _format_relative_age(row.get("last_started_at")),
+        ])
+    lines = ["Assistant time:"]
+    period_line = _format_history_period(period or {})
+    if period_line:
+        lines.extend([period_line, ""])
+    lines.append(_pad_table(rows))
+    return "\n".join(lines)
+
+
+def _format_history(entries, use_color=False):
+    from .cli_render import _format_relative_age, _pad_table
+
+    if not entries:
+        return "No launch history."
+    rows = [["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TRANSCRIPT"]]
+    for entry in entries:
+        transcript_path = entry.get("transcript_path")
+        rows.append([
+            entry.get("session_name") or "-",
+            entry.get("provider") or "-",
+            entry.get("status") or "-",
+            _format_duration_ms(entry.get("duration_ms")),
+            _format_relative_age(entry.get("started_at")),
+            os.path.basename(transcript_path) if transcript_path else "-",
+        ])
+    return "\n".join([
+        "Recent launches:",
+        _pad_table(rows),
+        "",
+        _dim("Full transcript paths and cwd are available with --json.", use_color),
+    ])
+
+
 def handle_set(rest, ctx):
     parsed = _parse_set_args(rest)
     session = ctx["service"]["set_launch_settings"](parsed["name"], parsed["settings"])
@@ -627,6 +1039,56 @@ def handle_config(rest, ctx):
     return 0
 
 
+def handle_history(rest, ctx):
+    now_fn = ctx["options"].get("now") or time.time
+    now = datetime.fromtimestamp(now_fn()).astimezone()
+    parsed = _parse_history_args(rest, now=now)
+    has_period = _has_history_period(parsed["period"])
+    limit = 0 if parsed["summary"] or has_period else parsed["limit"]
+    entries = ctx["service"]["get_launch_history"](parsed["name"], limit=limit)
+    entries = _filter_history_period(entries, parsed["period"])
+    if has_period and not parsed["summary"]:
+        entries = entries[:parsed["limit"]]
+    message = (
+        f"Listed launch history for {parsed['name']}"
+        if parsed["name"]
+        else "Listed launch history"
+    )
+    if parsed["json"]:
+        payload = {"history": entries, "period": _public_history_period(parsed["period"])}
+        if parsed["summary"]:
+            payload["summary"] = _summarize_history(entries)
+        _write_json(ctx, _json_success("history", message, **payload))
+        return 0
+    if parsed["summary"]:
+        ctx["out"](f"{_format_history_summary(entries, period=parsed['period'], use_color=ctx['use_color'])}\n")
+        return 0
+    ctx["out"](f"{_format_history(entries, use_color=ctx['use_color'])}\n")
+    return 0
+
+
+def _resolve_last_launch_session(ctx):
+    for entry in ctx["service"]["get_launch_history"](limit=0):
+        name = entry.get("session_name")
+        if not name:
+            continue
+        session = ctx["service"]["get_session"](name)
+        if session:
+            return session
+    raise CdxError("No launch history yet. Run cdx <name> first.")
+
+
+def handle_last(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if args:
+        raise CdxError(LAST_USAGE)
+    session = _resolve_last_launch_session(ctx)
+    if not json_flag:
+        message = f"Launching last session: {session['name']}"
+        ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+    return handle_launch(session["name"], ctx)
+
+
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     service = ctx["service"]
@@ -926,6 +1388,9 @@ def handle_status(rest, ctx):
         }
         for item in refresh_errors
     ]
+    update_warning = _update_notice_warning(ctx)
+    if update_warning:
+        warnings.append(update_warning)
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     rows = ctx["service"]["get_status_rows"](
@@ -938,6 +1403,7 @@ def handle_status(rest, ctx):
             return 0
         ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
         _write_refresh_warnings(refresh_errors, ctx)
+        _write_update_notice(ctx)
         return 0
 
     row = next((r for r in rows if r["session_name"] == args[0]), None)
@@ -948,6 +1414,7 @@ def handle_status(rest, ctx):
         return 0
     ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
     _write_refresh_warnings(refresh_errors, ctx)
+    _write_update_notice(ctx)
     return 0
 
 
@@ -1095,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()
@@ -1169,16 +1643,11 @@ def handle_update(rest, ctx):
 
 
 def handle_launch(command, ctx, initial_prompt=None):
-    json_flag = "--json" in ctx["options"].get("raw_args", [])
+    json_flag = "--json" in ctx.get("raw_args", ctx["options"].get("raw_args", []))
     update_notice = ctx.get("update_notice")
     warnings = []
     if update_notice:
-        warnings.append({
-            "code": "update_available",
-            "message": f"Update available: cdx-manager {update_notice['latest_version']}",
-            "latest_version": update_notice["latest_version"],
-            "url": update_notice.get("url"),
-        })
+        warnings.append(_update_notice_warning(ctx))
     session = ctx["service"]["launch_session"](command)
     _ensure_session_authentication(
         session,
@@ -1193,15 +1662,51 @@ def handle_launch(command, ctx, initial_prompt=None):
     message = f"Launching {session['provider']} session {session['name']}"
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
-        if update_notice:
-            text = f"Update available: cdx-manager {update_notice['latest_version']} (current version installed may be older)."
-            if update_notice.get("url"):
-                text = f"{text} {update_notice['url']}"
-            ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
-    _run_interactive_provider_command(
-        session, "launch", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
-        signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
-    )
+        _write_update_notice(ctx)
+    cwd = ctx.get("cwd") or os.getcwd()
+    runtime_run_id = None
+
+    def runtime_lifecycle(event, info):
+        nonlocal runtime_run_id
+        if event == "started":
+            runtime = ctx["service"]["start_session_runtime"](session["name"], info)
+            runtime_run_id = runtime.get("runId")
+        elif event == "finished" and runtime_run_id:
+            ctx["service"]["finish_session_runtime"](
+                session["name"],
+                runtime_run_id,
+                {"status": "stopped", "returncode": info.get("returncode")},
+            )
+
+    try:
+        run_info = _run_interactive_provider_command(
+            session, "launch", spawn=ctx.get("spawn"), cwd=cwd, env_override=ctx.get("env"),
+            signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
+            lifecycle_callback=runtime_lifecycle,
+        )
+    except CdxError as error:
+        run_info = getattr(error, "run_info", {}) or {}
+        if runtime_run_id:
+            ctx["service"]["finish_session_runtime"](
+                session["name"],
+                runtime_run_id,
+                {"status": "failed", "returncode": run_info.get("returncode")},
+            )
+        if run_info:
+            ctx["service"]["record_launch_history"](session["name"], {
+                "status": "failed",
+                "cwd": cwd,
+                "error": str(error),
+                "exit_code": error.exit_code,
+                **run_info,
+            })
+        raise
+    ctx["service"]["record_launch_history"](session["name"], {
+        "status": "success",
+        "cwd": cwd,
+        "exit_code": 0,
+        **run_info,
+    })
     if json_flag:
         _write_json(ctx, _json_success("launch", message, warnings=warnings, session=ctx["service"]["get_session"](session["name"])))
     return 0
@@ -1240,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"))