cdx-manager 0.5.6 → 0.6.0

package/src/cli_render.py

@@ -98,6 +98,19 @@ def _dim(text, use_color=False):
     return _style(text, "2", use_color)
 
 
+def _format_launch_text(launch):
+    if not launch:
+        return "default"
+    parts = []
+    if launch.get("power"):
+        parts.append(launch["power"])
+    if launch.get("permission"):
+        parts.append(launch["permission"])
+    if launch.get("fast") is True:
+        parts.append("fast-on")
+    return "/".join(parts) or "default"
+
+
 def format_error(error, env=None, stderr=None):
     return _style(str(error), "31", _should_use_color(env or os.environ, stderr or sys.stderr))
 
@@ -105,35 +118,37 @@ def format_error(error, env=None, stderr=None):
 def _format_sessions(service, use_color=False):
     rows = service["format_list_rows"]()
     has_provider = any(r.get("provider") for r in rows)
+    has_launch = any(r.get("launch") for r in rows)
     headers = ["SESSION"]
     if has_provider:
         headers.append("PROVIDER")
     headers.append("STATUS")
+    if has_launch:
+        headers.append("LAUNCH")
     headers.append("UPDATED")
     headers = [_style(header, "1", use_color) for header in headers]
     table_rows = []
     for r in rows:
-        parts = [r["name"]]
+        name = f"{r['name']}*" if r.get("active") else r["name"]
+        parts = [name]
         if has_provider:
             parts.append(r.get("provider") or "n/a")
         status = r.get("enabled_status") or ("enabled" if r.get("enabled", True) else "disabled")
         parts.append(_style(status, "2" if status == "disabled" else "32", use_color))
+        if has_launch:
+            launch = r.get("launch") or {}
+            parts.append(_dim(_format_launch_text(launch), use_color))
         parts.append(_dim(_format_relative_age(r.get("updated_at")), use_color))
         table_rows.append(parts)
     lines = [_style("Known sessions:", "1", use_color), _pad_table([headers] + table_rows), ""]
     lines += [
         _style("Next actions:", "1", use_color),
-        f"  {_style('cdx add <name>', '36', use_color)}",
-        f"  {_style('cdx <name>', '36', use_color)}",
-        f"  {_style('cdx login <name>', '36', use_color)}",
-        f"  {_style('cdx logout <name>', '36', use_color)}",
-        f"  {_style('cdx context show', '36', use_color)}",
-        f"  {_style('cdx handoff <name>', '36', use_color)}",
-        f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
-        f"  {_style('cdx disable <name>', '36', use_color)}",
-        f"  {_style('cdx enable <name>', '36', use_color)}",
-        f"  {_style('cdx ren <source> <dest>', '36', use_color)}",
-        f"  {_style('cdx rmv <name>', '36', use_color)}",
         f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx ready', '36', use_color)}",
+        f"  {_style('cdx set <name> --power medium --permission default --fast off', '36', use_color)}",
+        f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
+        f"  {_style('cdx history', '36', use_color)}",
+        f"  {_style('cdx help', '36', use_color)}",
+        f"  {_style('cdx update', '36', use_color)}",
     ]
     return "\n".join(lines)

package/src/notify.py

@@ -1,7 +1,9 @@
 import json
 import os
+import shlex
 import subprocess
 import time
+from datetime import datetime, timedelta
 
 from .errors import CdxError
 from .status_view import (
@@ -12,23 +14,27 @@ from .status_view import (
 )
 
 
+NOTIFY_USAGE = "Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]"
+
+
 def parse_notify_args(args):
     json_flag = "--json" in args
     once = "--once" in args
     at_reset = "--at-reset" in args
     next_ready = "--next-ready" in args
     refresh = "--refresh" in args
+    schedule = "--schedule" in args
     poll = 60
     cleaned = []
     i = 0
     while i < len(args):
         arg = args[i]
-        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh"):
+        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh", "--schedule"):
             i += 1
             continue
         if arg == "--poll":
             if i + 1 >= len(args):
-                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+                raise CdxError(NOTIFY_USAGE)
             try:
                 poll = max(1, int(args[i + 1]))
             except ValueError as error:
@@ -43,15 +49,15 @@ def parse_notify_args(args):
             i += 1
             continue
         if arg.startswith("-"):
-            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+            raise CdxError(NOTIFY_USAGE)
         cleaned.append(arg)
         i += 1
     if at_reset == next_ready:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+        raise CdxError(NOTIFY_USAGE)
     if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh]")
     if next_ready and cleaned:
-        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]")
     return {
         "name": cleaned[0] if cleaned else None,
         "mode": "at-reset" if at_reset else "next-ready",
@@ -59,6 +65,7 @@ def parse_notify_args(args):
         "once": once,
         "json": json_flag,
         "refresh": refresh,
+        "schedule": schedule,
     }
 
 
@@ -212,9 +219,225 @@ def _escape_applescript(value):
     return str(value).replace("\\", "\\\\").replace('"', '\\"')
 
 
+def schedule_notification_event(base_dir, parsed, event, spawn_sync=None, env=None, now_fn=None):
+    import sys
+    spawn_sync = spawn_sync or subprocess.run
+    env = env or os.environ
+    now_fn = now_fn or time.time
+    target_timestamp = event.get("target_timestamp")
+    if target_timestamp is None:
+        raise CdxError(f"Cannot schedule notification: {event['message']}")
+    if target_timestamp <= now_fn():
+        return {
+            "scheduled": False,
+            "backend": "immediate",
+            "message": event["message"],
+            "target_timestamp": target_timestamp,
+        }
+
+    argv = _scheduled_notify_argv(parsed, env)
+    if sys.platform == "darwin":
+        result = _schedule_macos_launchd(base_dir, parsed, event, argv, spawn_sync, env)
+    elif sys.platform == "win32":
+        result = _schedule_windows_task(parsed, event, argv, spawn_sync, env)
+    else:
+        result = _schedule_linux(parsed, event, argv, spawn_sync, env)
+    result["target_timestamp"] = target_timestamp
+    result["target_iso"] = _timestamp_to_local_iso(target_timestamp)
+    return result
+
+
+def _scheduled_notify_argv(parsed, env):
+    executable = env.get("CDX_BIN") or shutil_which("cdx", env) or "cdx"
+    argv = [executable, "notify"]
+    if parsed["mode"] == "at-reset":
+        argv.append(parsed["name"])
+        argv.append("--at-reset")
+    else:
+        argv.append("--next-ready")
+    argv.append("--once")
+    argv.append("--refresh")
+    return argv
+
+
+def _schedule_macos_launchd(base_dir, parsed, event, argv, spawn_sync, env):
+    label = _schedule_id("com.cdx-manager.notify", parsed, event)
+    schedule_dir = os.path.join(base_dir, "state", "notifications")
+    os.makedirs(schedule_dir, mode=0o700, exist_ok=True)
+    script_path = os.path.join(schedule_dir, f"{label}.sh")
+    launch_agents = os.path.join(os.path.expanduser("~"), "Library", "LaunchAgents")
+    os.makedirs(launch_agents, exist_ok=True)
+    plist_path = os.path.join(launch_agents, f"{label}.plist")
+    target = _round_up_to_next_minute(datetime.fromtimestamp(event["target_timestamp"]).astimezone())
+    script = _macos_schedule_script(argv, env, label, plist_path, script_path)
+    with open(script_path, "w", encoding="utf-8") as f:
+        f.write(script)
+    try:
+        os.chmod(script_path, 0o700)
+    except OSError:
+        pass
+    with open(plist_path, "w", encoding="utf-8") as f:
+        f.write(_launchd_plist(label, script_path, target))
+    result = _run_scheduler_command(["launchctl", "bootstrap", f"gui/{os.getuid()}", plist_path], spawn_sync, env)
+    if not result["ok"]:
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "launchd", "id": label, "path": plist_path}
+        result = _run_scheduler_command(["launchctl", "load", plist_path], spawn_sync, env)
+    if not result["ok"]:
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "launchd", "id": label, "path": plist_path}
+        raise CdxError(f"Failed to schedule notification with launchd: {result['error']}")
+    return {"scheduled": True, "existing": False, "backend": "launchd", "id": label, "path": plist_path}
+
+
+def _macos_schedule_script(argv, env, label, plist_path, script_path):
+    lines = ["#!/bin/sh", f"export PATH={shlex.quote(env.get('PATH', '/usr/local/bin:/usr/bin:/bin'))}"]
+    if env.get("CDX_HOME"):
+        lines.append(f"export CDX_HOME={shlex.quote(env['CDX_HOME'])}")
+    lines.extend([
+        f"{' '.join(shlex.quote(str(part)) for part in argv)}",
+        "status=$?",
+        f"launchctl bootout {shlex.quote('gui/' + str(os.getuid()) + '/' + label)} >/dev/null 2>&1 || launchctl unload {shlex.quote(plist_path)} >/dev/null 2>&1 || true",
+        f"rm -f {shlex.quote(plist_path)} {shlex.quote(script_path)}",
+        "exit $status",
+        "",
+    ])
+    return "\n".join(lines)
+
+
+def _launchd_plist(label, script_path, target):
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>{_escape_xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>{_escape_xml(script_path)}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Month</key><integer>{target.month}</integer>
+    <key>Day</key><integer>{target.day}</integer>
+    <key>Hour</key><integer>{target.hour}</integer>
+    <key>Minute</key><integer>{target.minute}</integer>
+  </dict>
+</dict>
+</plist>
+"""
+
+
+def _schedule_linux(parsed, event, argv, spawn_sync, env):
+    unit = _schedule_id("cdx-manager-notify", parsed, event)
+    target = _round_up_to_next_minute(datetime.fromtimestamp(event["target_timestamp"]).astimezone())
+    if shutil_which("systemd-run", env):
+        calendar = target.strftime("%Y-%m-%d %H:%M:%S")
+        result = _run_scheduler_command(
+            ["systemd-run", "--user", f"--unit={unit}", f"--on-calendar={calendar}", *argv],
+            spawn_sync,
+            env,
+        )
+        if result["ok"]:
+            return {"scheduled": True, "existing": False, "backend": "systemd", "id": unit}
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "systemd", "id": unit}
+        raise CdxError(f"Failed to schedule notification with systemd-run: {result['error']}")
+    if shutil_which("at", env):
+        at_time = target.strftime("%Y%m%d%H%M.%S")
+        command = " ".join(shlex.quote(str(part)) for part in argv)
+        result = _run_scheduler_command(["at", "-t", at_time], spawn_sync, env, input_text=f"{command}\n")
+        if result["ok"]:
+            return {"scheduled": True, "existing": False, "backend": "at", "id": unit}
+        raise CdxError(f"Failed to schedule notification with at: {result['error']}")
+    raise CdxError("Cannot schedule notification: install systemd-run or at, or run cdx notify without --schedule")
+
+
+def _schedule_windows_task(parsed, event, argv, spawn_sync, env):
+    name = _schedule_id("cdx-manager-notify", parsed, event)
+    target = datetime.fromtimestamp(event["target_timestamp"]).astimezone()
+    command = subprocess.list2cmdline([str(part) for part in argv])
+    result = _run_scheduler_command([
+        "schtasks",
+        "/Create",
+        "/SC",
+        "ONCE",
+        "/TN",
+        name,
+        "/TR",
+        command,
+        "/ST",
+        target.strftime("%H:%M"),
+        "/SD",
+        target.strftime("%m/%d/%Y"),
+        "/F",
+        "/Z",
+    ], spawn_sync, env)
+    if not result["ok"]:
+        raise CdxError(f"Failed to schedule notification with Task Scheduler: {result['error']}")
+    return {"scheduled": True, "existing": False, "backend": "schtasks", "id": name}
+
+
+def _run_scheduler_command(argv, spawn_sync, env, input_text=None):
+    try:
+        completed = spawn_sync(
+            argv,
+            env=env,
+            input=input_text,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (FileNotFoundError, OSError) as error:
+        return {"ok": False, "error": str(error)}
+    return {
+        "ok": getattr(completed, "returncode", 0) == 0,
+        "error": (getattr(completed, "stderr", "") or getattr(completed, "stdout", "") or "").strip(),
+    }
+
+
+def _schedule_id(prefix, parsed, event):
+    session = parsed.get("name") or event.get("session") or "next-ready"
+    safe_session = "".join(ch if ch.isalnum() else "-" for ch in str(session).lower()).strip("-") or "session"
+    return f"{prefix}.{parsed['mode']}.{safe_session}.{int(event['target_timestamp'])}"
+
+
+def _scheduler_error_means_exists(error):
+    normalized = str(error or "").lower()
+    return any(fragment in normalized for fragment in (
+        "already exists",
+        "file exists",
+        "unit exists",
+        "unit already",
+        "service already",
+        "bootstrap failed: 5",
+    ))
+
+
+def _timestamp_to_local_iso(timestamp):
+    return datetime.fromtimestamp(timestamp).astimezone().isoformat()
+
+
+def _round_up_to_next_minute(value):
+    if value.second == 0 and value.microsecond == 0:
+        return value
+    return (value + timedelta(minutes=1)).replace(second=0, microsecond=0)
+
+
+def _escape_xml(value):
+    return str(value).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
+
+
 def format_notify_event(event):
     return event["message"]
 
 
+def format_scheduled_notification(schedule):
+    if schedule.get("scheduled"):
+        return f"Scheduled notification via {schedule['backend']} for {schedule['target_iso']}"
+    return schedule["message"]
+
+
 def notify_json(event):
     return json.dumps(event, indent=2)

package/src/provider_runtime.py

@@ -12,6 +12,20 @@ from .errors import CdxError
 
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
+LAUNCH_PERMISSION_ARGS = {
+    PROVIDER_CLAUDE: {
+        "review": ["--permission-mode", "plan"],
+        "default": ["--permission-mode", "default"],
+        "auto": ["--permission-mode", "auto"],
+        "full": ["--permission-mode", "bypassPermissions"],
+    },
+    PROVIDER_CODEX: {
+        "review": ["-s", "read-only", "-a", "on-request"],
+        "default": ["-s", "workspace-write", "-a", "on-request"],
+        "auto": ["-s", "workspace-write", "-a", "never"],
+        "full": ["-s", "danger-full-access", "-a", "never"],
+    },
+}
 
 
 def _home_env_overrides(auth_home):
@@ -49,6 +63,35 @@ def _build_launch_transcript_path(session):
     )
 
 
+def _launch_power(session):
+    launch = session.get("launch") or {}
+    power = launch.get("power")
+    if power:
+        return power
+    if launch.get("fast") is True:
+        return "low"
+    return None
+
+
+def _launch_config_args(session):
+    launch = session.get("launch") or {}
+    args = []
+    power = _launch_power(session)
+    permission = launch.get("permission")
+    provider = session["provider"]
+    if provider == PROVIDER_CLAUDE:
+        if power:
+            args += ["--effort", power]
+        if permission:
+            args += LAUNCH_PERMISSION_ARGS[PROVIDER_CLAUDE].get(permission, [])
+        return args
+    if power:
+        args += ["-c", f'model_reasoning_effort="{power}"']
+    if permission:
+        args += LAUNCH_PERMISSION_ARGS[PROVIDER_CODEX].get(permission, [])
+    return args
+
+
 def _list_launch_transcript_paths(session, glob_fn=None):
     import glob
 
@@ -109,7 +152,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     env_override = env_override or {}
     env = {**os.environ, **env_override}
     if session["provider"] == PROVIDER_CLAUDE:
-        args = ["--name", session["name"]]
+        args = ["--name", session["name"]] + _launch_config_args(session)
         if initial_prompt:
             args.append(initial_prompt)
         return _wrap_launch_with_transcript(session, {
@@ -121,7 +164,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             },
             "label": "claude",
         }, env=env)
-    args = ["--no-alt-screen", "--cd", cwd]
+    args = ["--no-alt-screen", "--cd", cwd] + _launch_config_args(session)
     if initial_prompt:
         args.append(initial_prompt)
     return _wrap_launch_with_transcript(session, {
@@ -234,7 +277,7 @@ def _signal_name(sig):
 
 def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                                       env_override=None, signal_emitter=None,
-                                      initial_prompt=None):
+                                      initial_prompt=None, lifecycle_callback=None):
     spawn = spawn or subprocess.Popen
     spec = (
         _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)
@@ -250,11 +293,32 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
             **{k: v for k, v in current_spec.get("options", {}).items() if k != "stdio"},
         )
 
+    start_time = datetime.now(timezone.utc)
+
+    child_pid = None
+
+    def run_info(current_spec, returncode=None):
+        end_time = datetime.now(timezone.utc)
+        return {
+            "started_at": start_time.isoformat().replace("+00:00", "Z"),
+            "ended_at": end_time.isoformat().replace("+00:00", "Z"),
+            "duration_ms": int((end_time - start_time).total_seconds() * 1000),
+            "command": current_spec.get("command"),
+            "args": list(current_spec.get("args") or []),
+            "label": current_spec.get("label"),
+            "transcript_path": current_spec.get("transcript_path"),
+            "pid": child_pid,
+            "returncode": returncode,
+        }
+
     try:
         child = start_child(spec)
     except FileNotFoundError as error:
         spec = _fallback_launch_spec_or_raise(spec, error)
         child = start_child(spec)
+    child_pid = getattr(child, "pid", None) or os.getpid()
+    if lifecycle_callback:
+        lifecycle_callback("started", run_info(spec))
 
     forwarded_signal = None
     handlers = []
@@ -293,6 +357,9 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
         if forwarded_signal is None and child.returncode != 0 and _should_retry_without_transcript(spec):
             spec = _fallback_launch_spec_or_raise(spec)
             child = start_child(spec)
+            child_pid = getattr(child, "pid", None) or os.getpid()
+            if lifecycle_callback:
+                lifecycle_callback("started", run_info(spec))
             child.wait()
     finally:
         if use_emitter:
@@ -309,14 +376,26 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                     pass
 
     if forwarded_signal is not None:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} interrupted by {_signal_name(forwarded_signal)} for session {session['name']}",
             _signal_exit_code(forwarded_signal),
         )
+        error.run_info = run_info(spec, returncode=error.exit_code)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
     if child.returncode != 0:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} exited with code {child.returncode} for session {session['name']}"
         )
+        error.run_info = run_info(spec, returncode=child.returncode)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
+    info = run_info(spec, returncode=child.returncode)
+    if lifecycle_callback:
+        lifecycle_callback("finished", info)
+    return info
 
 
 def _fallback_launch_spec_or_raise(spec, original_error=None):