cdx-manager 0.12.3 → 0.14.0

package/src/cli_helpers.py

@@ -5,14 +5,17 @@ Split out of cli_commands.py as the low-level, side-effect-light helper layer
 (no command dispatch). Imported back into cli_commands and used by handlers.
 """
 
+import asyncio
 import json
 import os
 import re
 from datetime import datetime
 
-from .cli_render import _dim, _info, _warn
+from .cli_render import _dim, _info, _pad_table, _style, _warn
 from .config import PROVIDER_CODEX
-from .provider_runtime import _list_launch_transcript_paths
+from .errors import CdxError
+from .fs_utils import atomic_write
+from .provider_runtime import _list_launch_transcript_paths, _run_interactive_provider_command, get_resume_capability
 from .status_source import _normalize_terminal_transcript
 
 API_SCHEMA_VERSION = 1
@@ -383,3 +386,175 @@ def _handoff_launch_prompt(session, install=None):
         f"Read {context_ref} first, then resume the previous session "
         "from the latest actionable state. Do not ask me to paste the context again."
     )
+
+
+def _resolve_confirmation(confirm_fn, name):
+    confirmed = (
+        asyncio.get_event_loop().run_until_complete(confirm_fn(name))
+        if asyncio.iscoroutinefunction(confirm_fn)
+        else confirm_fn(name)
+    )
+    if hasattr(confirmed, "__await__"):
+        confirmed = asyncio.get_event_loop().run_until_complete(confirmed)
+    return confirmed
+
+
+def _extract_claude_oauth_token(text):
+    if not text:
+        return None
+    text = re.sub(r"\x1b\[[0-9;?]*[ -/]*[@-~]", "", str(text))
+    patterns = [
+        r"CLAUDE_CODE_OAUTH_TOKEN=([^\s\"']+)",
+        r"(sk-ant-oat[0-9A-Za-z._-]+)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            token = match.group(1).strip()
+            if token.startswith("<") or any(ord(ch) < 32 or ord(ch) == 127 for ch in token):
+                continue
+            return token
+    return None
+
+def _write_claude_oauth_token(auth_home, token):
+    cred_dir = os.path.join(auth_home, "credentials")
+    os.makedirs(cred_dir, mode=0o700, exist_ok=True)
+    try:
+        os.chmod(cred_dir, 0o700)
+    except OSError:
+        pass
+    cred_path = os.path.join(cred_dir, "default.json")
+    payload = {
+        "version": "1.0",
+        "type": "oauth_token",
+        "access_token": token,
+    }
+    # atomic_write keeps the token 0o600 from creation — no umask window.
+    atomic_write(cred_path, json.dumps(payload, indent=2) + "\n", mode=0o600)
+    return cred_path
+
+def _bootstrap_claude_setup_token(session, ctx):
+    ctx["out"](
+        "Claude login did not create isolated credentials; falling back to claude setup-token.\n"
+    )
+    run_info = _run_interactive_provider_command(
+        session,
+        "setup-token",
+        spawn=ctx.get("spawn"),
+        env_override=ctx.get("env"),
+        signal_emitter=ctx.get("signal_emitter"),
+    )
+    transcript_path = run_info.get("transcript_path")
+    if not transcript_path or not os.path.isfile(transcript_path):
+        raise CdxError(
+            "Claude setup-token completed, but cdx could not capture the token. "
+            "Run claude setup-token and save the token under credentials/default.json."
+        )
+    try:
+        with open(transcript_path, encoding="utf-8", errors="replace") as handle:
+            transcript = handle.read()
+    finally:
+        # The transcript holds the ~1-year OAuth token in cleartext; it must
+        # not outlive the extraction, whether it succeeds or not.
+        try:
+            os.remove(transcript_path)
+        except OSError:
+            pass
+    token = _extract_claude_oauth_token(transcript)
+    if not token:
+        raise CdxError(
+            "Claude setup-token completed, but cdx could not find CLAUDE_CODE_OAUTH_TOKEN in the output. "
+            "Run claude setup-token manually and save the token under credentials/default.json."
+        )
+    auth_home = session.get("authHome") or ""
+    cred_path = _write_claude_oauth_token(auth_home, token)
+    # ponytail: drop short-lived claude login creds so the ~1yr token wins at launch (provider_runtime _read_claude_launch_oauth_token)
+    try:
+        os.remove(os.path.join(auth_home, ".claude", ".credentials.json"))
+    except OSError:
+        pass
+    return cred_path
+
+def _format_launch_config(session, use_color=False):
+    from .cli_render import _dim, _style
+
+    launch = session.get("launch") or {}
+    rows = [[_style("SETTING", "1", use_color), _style("VALUE", "1", use_color)]]
+    for key, label in [
+        ("power", "Power"),
+        ("permission", "Permission"),
+        ("fast", "Fast"),
+        ("rtk", "RTK"),
+        ("logics", "Logics"),
+        ("model", "Model"),
+        ("priority", "Priority"),
+    ]:
+        rows.append([
+            _dim(label, use_color),
+            _format_launch_setting_value(launch, key, use_color=use_color),
+        ])
+    provider_label = f"({session['provider']})"
+    return "\n".join([
+        _style("Launch settings:", "1", use_color),
+        f"{_style(session['name'], '36', use_color)} {_dim(provider_label, use_color)}",
+        _pad_table(rows),
+        "",
+        _dim(_format_launch_settings_hint(session["name"]), use_color),
+    ])
+
+def _format_launch_settings_hint(name="<name>"):
+    return (
+        f"Set a value: cdx set {name} --power medium --permission auto "
+        "--fast on --rtk on --logics on --model MODEL --priority 80"
+    )
+
+def _format_launch_setting_value(launch, key, use_color=False):
+    if key in ("fast", "rtk", "logics"):
+        if launch.get(key) is True:
+            return _style("on", "32", use_color)
+        if launch.get(key) is False:
+            return _style("off", "2", use_color)
+        if key == "logics":
+            return _dim("auto", use_color)
+        return _dim("default", use_color)
+    value = launch.get(key)
+    if value is None or value == "":
+        return _dim("default", use_color)
+    if key == "priority":
+        return _style(str(value), "33", use_color)
+    if key == "power":
+        return _style(str(value), "96", use_color)
+    if key == "permission":
+        return _style(str(value), "32", use_color)
+    return str(value)
+
+def _resume_capability_for_session(session, ctx):
+    capability = get_resume_capability(session, cwd=ctx.get("cwd") or os.getcwd())
+    return {
+        "session": session["name"],
+        "provider": session["provider"],
+        "resumable": bool(capability.get("resumable")),
+        "strategy": capability.get("strategy"),
+        "reason": capability.get("reason"),
+        "command_preview": capability.get("command_preview") or [],
+    }
+
+def _warn_if_session_already_running(name, ctx):
+    # ponytail: concurrent sessions on one profile share its single OAuth
+    # .credentials.json; both refresh near token expiry and the rotated refresh
+    # token invalidates the other session -> surprise logout. Warn before adding
+    # a second live session on the same profile.
+    active = ctx["service"].get("active_session_runtime")
+    runtime = active(name) if active else None
+    if not runtime:
+        return
+    pid = runtime.get("pid")
+    ctx["out"](f"{_warn(f'A session named {name} is already running (pid {pid}).', ctx['use_color'])}\n")
+    ctx["out"](
+        f"{_dim('Two sessions on one profile share its login and can log each other out. Use a different profile instead.', ctx['use_color'])}\n"
+    )
+    if not ctx["stdin_is_tty"]:
+        return
+    answer = input(f"Launch a second {name} session anyway? [y/N] ")
+    if answer.strip().lower() not in ("y", "yes"):
+        raise CdxError("Launch cancelled.")

package/src/commands/__init__.py

@@ -0,0 +1,6 @@
+"""Per-domain command modules.
+
+Each module owns one group of `handle_*` entry points plus the helpers used
+only by that group. `cli_commands` re-exports them so existing imports of
+`src.cli_commands` keep resolving; see `src/cli.py` for the same convention.
+"""

package/src/commands/auth.py

@@ -0,0 +1,224 @@
+"""Authentication domain commands: login, logout, reset, notify.
+
+Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
+"""
+
+import time
+import uuid
+
+from ..cli_args import _parse_flag_args, _parse_json_flag
+from ..cli_helpers import (
+    _bootstrap_claude_setup_token,
+    _json_success,
+    _local_now_iso,
+    _make_notify_progress,
+    _resolve_confirmation,
+    _write_json,
+)
+from ..cli_render import _success, _warn
+from ..codex_usage import consume_codex_rate_limit_reset_credit
+from ..config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+from ..errors import CdxError
+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,
+)
+from ..provider_runtime import _ensure_session_authentication, _run_interactive_provider_command
+
+
+def _confirm_reset(name):
+    answer = input(f"Consume one banked Codex reset for {name}? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+def handle_notify(rest, ctx):
+    parsed = parse_notify_args(rest)
+
+    def notifier(title, message):
+        send_desktop_notification(
+            title,
+            message,
+            spawn_sync=ctx.get("spawn_sync"),
+            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,
+        notifier=notifier,
+        sleep_fn=ctx["options"].get("sleep"),
+        now_fn=ctx["options"].get("now"),
+        progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
+    )
+    if parsed["json"]:
+        _write_json(ctx, _json_success("notify", "Resolved notification event", event=event))
+    else:
+        ctx["out"](f"{format_notify_event(event)}\n")
+    return 0
+
+def handle_reset(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+        "--yes": {"key": "yes", "type": "bool", "default": False},
+    }, "Usage: cdx reset <name> [--yes] [--json]", positionals_key="args", max_positionals=1)
+    if len(parsed["args"]) != 1:
+        raise CdxError("Usage: cdx reset <name> [--yes] [--json]")
+    name = parsed["args"][0]
+    session = ctx["service"]["get_session"](name)
+    if not session:
+        raise CdxError(f"Unknown session: {name}")
+    if session["provider"] != PROVIDER_CODEX:
+        raise CdxError("Banked rate-limit resets are only available for Codex sessions.")
+
+    status = ctx["service"]["get_status_row"](name, force_refresh=True)
+    if status.get("reset_credits_available") == 0:
+        raise CdxError(f"No banked Codex reset is available for {name}.")
+    if not parsed["yes"]:
+        confirm_fn = ctx["options"].get("confirmReset")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, name)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Reset activation requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_reset(name)
+        if not confirmed:
+            if parsed["json"]:
+                _write_json(ctx, _json_success("reset", "Cancelled.", cancelled=True, session=name))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
+
+    credit_rows = status.get("reset_credits") or []
+    credit_id = credit_rows[0].get("id") if credit_rows else None
+    consumer = ctx["options"].get("consumeCodexReset") or consume_codex_rate_limit_reset_credit
+    result = consumer(
+        session,
+        ctx["options"].get("resetIdempotencyKey") or str(uuid.uuid4()),
+        credit_id=credit_id,
+    )
+    if not result.get("ok"):
+        if result.get("reason") == "reset_consume_failed":
+            raise CdxError(
+                f"Unable to activate Codex reset for {name}. "
+                "The installed Codex version or account may not support reset activation."
+            )
+        raise CdxError(f"Unable to activate Codex reset for {name}: {result.get('reason') or 'unknown error'}")
+    outcome = result.get("outcome")
+    if outcome == "noCredit":
+        raise CdxError(f"No banked Codex reset is available for {name}.")
+    if outcome == "nothingToReset":
+        raise CdxError(f"No current Codex rate-limit window is eligible for reset on {name}.")
+    if outcome not in ("reset", "alreadyRedeemed"):
+        raise CdxError(f"Unexpected Codex reset outcome for {name}: {outcome or 'missing'}")
+    refreshed = ctx["service"]["get_status_row"](name, force_refresh=True)
+    message = f"Activated banked Codex reset for {name}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("reset", message, cancelled=False, outcome=outcome, session=refreshed))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+def handle_login(rest, ctx):
+    rest = [arg for arg in rest if arg != "--setup-token"]  # accepted for back-compat; setup-token is now the default for Claude
+    json_flag, args = _parse_json_flag(rest)
+    if len(args) != 1:
+        raise CdxError("Usage: cdx login <name> [--json]")
+    if not ctx["stdin_is_tty"]:
+        raise CdxError("Login requires an interactive terminal.")
+    session = ctx["service"]["get_session"](args[0])
+    if not session:
+        raise CdxError(f"Unknown session: {args[0]}")
+    if session["provider"] == PROVIDER_CLAUDE:
+        # ponytail: setup-token mints a ~1yr token; claude login mints a ~daily one that forces reconnects
+        _bootstrap_claude_setup_token(session, ctx)
+    else:
+        _run_interactive_provider_command(
+            session, "login", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
+            signal_emitter=ctx.get("signal_emitter")
+        )
+    auth_probe = _ensure_session_authentication(
+        session,
+        ctx["service"],
+        spawn_sync=ctx.get("spawn_sync"),
+        env_override=ctx.get("env"),
+        behavior="probe-only",
+        trust_local_credentials=False,
+    )
+    if not auth_probe.get("authenticated"):
+        raise CdxError(
+            f"Login command completed, but session {session['name']} is still not authenticated."
+        )
+    now = _local_now_iso()
+    ctx["service"]["update_auth_state"](args[0], lambda auth: {
+        **auth, "status": "authenticated",
+        "lastCheckedAt": now, "lastAuthenticatedAt": now,
+    })
+    message = f"Reauthenticated session {session['name']} ({session['provider']})"
+    if json_flag:
+        _write_json(ctx, _json_success("login", message, session=ctx["service"]["get_session"](session["name"])))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+def handle_logout(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if len(args) != 1:
+        raise CdxError("Usage: cdx logout <name> [--json]")
+    session = ctx["service"]["get_session"](args[0])
+    if not session:
+        raise CdxError(f"Unknown session: {args[0]}")
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        raise CdxError("Antigravity logout is managed inside agy. Launch the session and run /logout.")
+    if session["provider"] == PROVIDER_OLLAMA:
+        raise CdxError("Ollama sessions do not use cdx-managed authentication.")
+    _run_interactive_provider_command(
+        session, "logout", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
+        signal_emitter=ctx.get("signal_emitter")
+    )
+    now = _local_now_iso()
+    ctx["service"]["update_auth_state"](args[0], lambda auth: {
+        **auth, "status": "logged_out",
+        "lastCheckedAt": now, "lastLoggedOutAt": now,
+    })
+    message = f"Logged out session {session['name']} ({session['provider']})"
+    if json_flag:
+        _write_json(ctx, _json_success("logout", message, session=ctx["service"]["get_session"](session["name"])))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0

package/src/commands/backup.py

@@ -0,0 +1,112 @@
+"""Backup domain commands: export, import.
+
+Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
+"""
+
+import getpass
+import sys
+
+from ..backup_bundle import read_bundle_meta
+from ..cli_args import _parse_export_args, _parse_import_args
+from ..cli_helpers import _format_export_report, _json_success, _make_export_progress, _write_json
+from ..cli_render import _success
+from ..errors import CdxError
+
+
+def _resolve_bundle_passphrase(ctx, env_var, prompt, confirm=False, use_stdin=False):
+    env = ctx.get("env", {})
+    if env_var:
+        passphrase = env.get(env_var)
+        if not passphrase:
+            raise CdxError(f"Environment variable {env_var} is empty or unset.")
+        return passphrase
+    if use_stdin:
+        reader = ctx["options"].get("read_stdin")
+        raw = reader() if callable(reader) else sys.stdin.readline()
+        passphrase = (raw or "").rstrip("\r\n")
+        if not passphrase:
+            raise CdxError("Bundle passphrase from stdin is empty.")
+        return passphrase
+    if not ctx["stdin_is_tty"]:
+        raise CdxError("Encrypted bundle export/import requires an interactive terminal, --passphrase-env, or --passphrase-stdin.")
+    getpass_fn = ctx["options"].get("getpass") or getpass.getpass
+    passphrase = getpass_fn(prompt)
+    if not passphrase:
+        raise CdxError("Bundle passphrase cannot be empty.")
+    if confirm:
+        confirmation = getpass_fn("Confirm bundle passphrase: ")
+        if passphrase != confirmation:
+            raise CdxError("Bundle passphrase confirmation does not match.")
+    return passphrase
+
+def handle_export(rest, ctx):
+    parsed = _parse_export_args(rest)
+    passphrase = None
+    if parsed["include_auth"]:
+        passphrase = _resolve_bundle_passphrase(
+            ctx,
+            parsed["passphrase_env"],
+            "Bundle passphrase: ",
+            confirm=True,
+            use_stdin=parsed["passphrase_stdin"],
+        )
+    result = ctx["service"]["export_bundle"](
+        parsed["file_path"],
+        include_auth=parsed["include_auth"],
+        session_names=parsed["session_names"],
+        passphrase=passphrase,
+        force=parsed["force"],
+        progress_callback=None if parsed["json"] else _make_export_progress(ctx),
+    )
+    session_count = len(result["session_names"])
+    auth_suffix = " with auth" if result["include_auth"] else ""
+    message = f"Exported {session_count} session{'s' if session_count != 1 else ''}{auth_suffix} to {result['path']}"
+    payload = _json_success(
+        "export",
+        message,
+        bundle=result,
+    )
+    if parsed["json"]:
+        _write_json(ctx, payload)
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_export_report(result)}\n")
+    return 0
+
+def handle_import(rest, ctx):
+    parsed = _parse_import_args(rest)
+    passphrase = None
+    try:
+        with open(parsed["file_path"], "rb") as handle:
+            meta = read_bundle_meta(handle.read())
+    except OSError as error:
+        raise CdxError(f"Bundle file not found: {parsed['file_path']}") from error
+    if meta.get("encrypted"):
+        passphrase = _resolve_bundle_passphrase(
+            ctx,
+            parsed["passphrase_env"],
+            "Bundle passphrase: ",
+            confirm=False,
+            use_stdin=parsed["passphrase_stdin"],
+        )
+    result = ctx["service"]["import_bundle"](
+        parsed["file_path"],
+        passphrase=passphrase,
+        session_names=parsed["session_names"],
+        force=parsed["force"],
+        merge=parsed["merge"],
+        allow_authless_force=parsed["allow_authless_force"],
+    )
+    session_count = len(result["session_names"])
+    auth_suffix = " with auth" if result["include_auth"] else ""
+    message = f"Imported {session_count} session{'s' if session_count != 1 else ''}{auth_suffix} from {result['path']}"
+    payload = _json_success(
+        "import",
+        message,
+        bundle=result,
+    )
+    if parsed["json"]:
+        _write_json(ctx, payload)
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0