cdx-manager 0.5.6 → 0.6.0

package/src/cli_commands.py

@@ -3,7 +3,8 @@ import getpass
 import json
 import os
 import sys
-from datetime import datetime
+import time
+from datetime import datetime, timedelta
 
 from .claude_refresh import _refresh_claude_sessions
 from .cli_render import _dim, _info, _success, _warn
@@ -21,7 +22,10 @@ from .errors import CdxError
 from .health import collect_health_report, format_health_report
 from .notify import (
     format_notify_event,
+    format_scheduled_notification,
     parse_notify_args,
+    resolve_notify_event,
+    schedule_notification_event,
     send_desktop_notification,
     wait_for_notification_event,
 )
@@ -45,6 +49,11 @@ EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--
 IMPORT_USAGE = "Usage: cdx import <file> [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--json]"
+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
 
@@ -69,6 +78,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"
@@ -302,6 +331,209 @@ def _parse_toggle_args(args, usage):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_fast_value(value):
+    text = str(value).strip().lower()
+    if text in ("on", "true", "1", "yes"):
+        return True
+    if text in ("off", "false", "0", "no"):
+        return False
+    raise CdxError(SET_USAGE)
+
+
+def _parse_set_args(args):
+    parsed = _parse_flag_args(args, {
+        "--power": {"key": "power", "type": "str", "default": None},
+        "--permission": {"key": "permission", "type": "str", "default": None},
+        "--fast": {"key": "fast", "type": "str", "default": None, "transform": _parse_fast_value},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, SET_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(SET_USAGE)
+    settings = {
+        key: parsed[key]
+        for key in ("power", "permission", "fast")
+        if parsed[key] is not None
+    }
+    if not settings:
+        raise CdxError(SET_USAGE)
+    return {"name": parsed["names"][0], "settings": settings, "json": parsed["json"]}
+
+
+def _parse_unset_args(args):
+    parsed = _parse_flag_args(args, {
+        "--power": {"key": "power", "type": "bool", "default": False},
+        "--permission": {"key": "permission", "type": "bool", "default": False},
+        "--fast": {"key": "fast", "type": "bool", "default": False},
+        "--all": {"key": "all", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, UNSET_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(UNSET_USAGE)
+    keys = ["power", "permission", "fast"] if parsed["all"] else [
+        key for key in ("power", "permission", "fast") if parsed[key]
+    ]
+    if not keys:
+        raise CdxError(UNSET_USAGE)
+    return {"name": parsed["names"][0], "keys": keys, "json": parsed["json"]}
+
+
+def _parse_config_args(args):
+    parsed = _parse_flag_args(args, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, CONFIG_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(CONFIG_USAGE)
+    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)
@@ -518,6 +750,220 @@ def handle_enable(rest, ctx):
     return 0
 
 
+def _format_launch_config(session):
+    launch = session.get("launch") or {}
+    return "\n".join([
+        f"{session['name']} ({session['provider']})",
+        f"power:      {launch.get('power') or 'default'}",
+        f"permission: {launch.get('permission') or 'default'}",
+        f"fast:       {'on' if launch.get('fast') is True else 'off' if launch.get('fast') is False else 'default'}",
+    ])
+
+
+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"])
+    message = f"Updated launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("set", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    return 0
+
+
+def handle_unset(rest, ctx):
+    parsed = _parse_unset_args(rest)
+    session = ctx["service"]["unset_launch_settings"](parsed["name"], parsed["keys"])
+    message = f"Cleared launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("unset", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    return 0
+
+
+def handle_config(rest, ctx):
+    parsed = _parse_config_args(rest)
+    session = ctx["service"]["get_session"](parsed["name"])
+    if not session:
+        raise CdxError(f"Unknown session: {parsed['name']}")
+    message = f"Launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("config", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    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"]
@@ -639,6 +1085,38 @@ def handle_notify(rest, ctx):
             env=ctx.get("env"),
         )
 
+    if parsed["schedule"]:
+        event = resolve_notify_event(
+            ctx["service"]["get_status_rows"](
+                progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
+                force_refresh=parsed.get("refresh", False),
+            ),
+            parsed,
+            (ctx["options"].get("now") or time.time)(),
+        )
+        if event["ready"]:
+            notifier(event["title"], event["message"])
+            schedule = {
+                "scheduled": False,
+                "backend": "immediate",
+                "message": event["message"],
+                "target_timestamp": event.get("target_timestamp"),
+            }
+        else:
+            schedule = schedule_notification_event(
+                ctx["service"]["base_dir"],
+                parsed,
+                event,
+                spawn_sync=ctx.get("spawn_sync"),
+                env=ctx.get("env"),
+                now_fn=ctx["options"].get("now"),
+            )
+        if parsed["json"]:
+            _write_json(ctx, _json_success("notify", "Scheduled notification event", event=event, schedule=schedule))
+        else:
+            ctx["out"](f"{format_scheduled_notification(schedule)}\n")
+        return 0
+
     event = wait_for_notification_event(
         ctx["service"],
         parsed,
@@ -785,6 +1263,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"](
@@ -797,6 +1278,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)
@@ -807,6 +1289,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
 
 
@@ -1028,16 +1511,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,
@@ -1052,15 +1530,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