cdx-manager 0.2.1

package/src/claude_usage.py

@@ -0,0 +1,84 @@
+import json
+import os
+import urllib.request
+import urllib.error
+from datetime import datetime, timezone
+
+MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
+              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+CLAUDE_STATUS_PROBE_MODEL = os.environ.get("CDX_CLAUDE_STATUS_MODEL", "claude-haiku-4-5-20251001")
+
+
+def _read_claude_credentials(auth_home):
+    cred_path = os.path.join(auth_home, ".claude", ".credentials.json")
+    try:
+        with open(cred_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data.get("claudeAiOauth")
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return None
+
+
+def _format_reset_date(unix_seconds):
+    dt = datetime.fromtimestamp(unix_seconds, tz=timezone.utc).astimezone()
+    return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
+
+
+def fetch_claude_rate_limit_headers(access_token):
+    body = json.dumps({
+        "model": CLAUDE_STATUS_PROBE_MODEL,
+        "max_tokens": 1,
+        "messages": [{"role": "user", "content": "hi"}],
+    }).encode("utf-8")
+
+    req = urllib.request.Request(
+        "https://api.anthropic.com/v1/messages",
+        data=body,
+        headers={
+            "x-api-key": access_token,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            headers = {k.lower(): v for k, v in resp.getheaders()}
+    except urllib.error.HTTPError as e:
+        headers = {k.lower(): v for k, v in e.headers.items()}
+    except urllib.error.URLError:
+        return None
+
+    util_5h = headers.get("anthropic-ratelimit-unified-5h-utilization")
+    reset_5h = headers.get("anthropic-ratelimit-unified-5h-reset")
+    util_7d = headers.get("anthropic-ratelimit-unified-7d-utilization")
+    reset_7d = headers.get("anthropic-ratelimit-unified-7d-reset")
+
+    if util_5h is None and util_7d is None:
+        return None
+
+    utilization_5h = float(util_5h) if util_5h is not None else None
+    utilization_7d = float(util_7d) if util_7d is not None else None
+
+    reset_5h_at = _format_reset_date(int(reset_5h)) if reset_5h else None
+    reset_week_at = _format_reset_date(int(reset_7d)) if reset_7d else None
+    reset_at = reset_week_at or reset_5h_at
+
+    return {
+        "remaining_5h_pct": round((1 - utilization_5h) * 100) if utilization_5h is not None else None,
+        "remaining_week_pct": round((1 - utilization_7d) * 100) if utilization_7d is not None else None,
+        "reset_5h_at": reset_5h_at,
+        "reset_week_at": reset_week_at,
+        "reset_at": reset_at,
+        "updated_at": datetime.now().astimezone().isoformat(),
+        "raw_status_text": None,
+        "source_ref": "api:anthropic-ratelimit-headers",
+    }
+
+
+def refresh_claude_session_status(session):
+    creds = _read_claude_credentials(session.get("authHome", ""))
+    if not creds or not creds.get("accessToken"):
+        return None
+    return fetch_claude_rate_limit_headers(creds["accessToken"])

package/src/cli.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+from .cli_commands import (
+    STATUS_USAGE,
+    handle_add,
+    handle_clean,
+    handle_copy,
+    handle_doctor,
+    handle_launch,
+    handle_login,
+    handle_logout,
+    handle_notify,
+    handle_remove,
+    handle_repair,
+    handle_rename,
+    handle_status,
+)
+from .cli_render import (
+    _format_sessions,
+    _pad_table,
+    _should_use_color,
+    _style,
+    _visible_len,
+    format_error,
+)
+from .errors import CdxError
+from .provider_runtime import (
+    LOG_ROTATE_BYTES,
+    _rotate_log_if_needed,
+)
+from .session_service import create_session_service
+from .status_view import (
+    _format_blocking_quota,
+    _format_reset_time,
+    _format_status_detail,
+    _format_status_rows,
+)
+
+VERSION = "0.2.1"
+
+
+# ---------------------------------------------------------------------------
+# Help / version
+# ---------------------------------------------------------------------------
+
+def _print_help(use_color=False):
+    return "\n".join([
+        _style("cdx - terminal session manager", "1", use_color),
+        "",
+        _style("Usage:", "1", use_color),
+        f"  {_style('cdx', '36', use_color)}",
+        f"  {_style('cdx status [--json] [--refresh]', '36', use_color)}",
+        f"  {_style('cdx status --small|-s [--refresh]', '36', use_color)}",
+        f"  {_style('cdx status <name> [--json] [--refresh]', '36', use_color)}",
+        f"  {_style('cdx add [provider] <name>', '36', use_color)}",
+        f"  {_style('cdx cp <source> <dest>', '36', use_color)}",
+        f"  {_style('cdx ren <source> <dest>', '36', use_color)}",
+        f"  {_style('cdx login <name>', '36', use_color)}",
+        f"  {_style('cdx logout <name>', '36', use_color)}",
+        f"  {_style('cdx rmv <name> [--force]', '36', use_color)}",
+        f"  {_style('cdx clean [name]', '36', use_color)}",
+        f"  {_style('cdx doctor [--json]', '36', use_color)}",
+        f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify <name> --at-reset', '36', use_color)}",
+        f"  {_style('cdx notify --next-ready', '36', use_color)}",
+        f"  {_style('cdx <name>', '36', use_color)}",
+        f"  {_style('cdx --help', '36', use_color)}",
+        f"  {_style('cdx --version', '36', use_color)}",
+    ])
+
+
+def _print_version():
+    return VERSION
+
+
+# ---------------------------------------------------------------------------
+# main()
+# ---------------------------------------------------------------------------
+
+def main(argv, options=None):
+    if options is None:
+        options = {}
+
+    env = options.get("env", os.environ)
+    stdout = options.get("stdout", sys.stdout)
+    stderr = options.get("stderr", sys.stderr)
+    stdin_is_tty = options.get("stdin", {}).get("isTTY", hasattr(sys.stdin, "isatty") and sys.stdin.isatty())
+    use_color = _should_use_color(env, stdout)
+    service = options.get("service") or create_session_service({"env": env})
+    spawn = options.get("spawn")
+    spawn_sync = options.get("spawn_sync")
+    refresh_fn = options.get("refreshClaudeSessionStatus")
+    signal_emitter = options.get("signalEmitter")
+
+    def out(text):
+        stdout.write(text)
+
+    def err(text):
+        stderr.write(text)
+
+    # Flags
+    if "--help" in argv or "-h" in argv:
+        if len(argv) != 1:
+            raise CdxError("Usage: cdx --help")
+        out(f"{_print_help(use_color=use_color)}\n")
+        return 0
+
+    if "--version" in argv or "-v" in argv:
+        if len(argv) != 1:
+            raise CdxError("Usage: cdx --version")
+        out(f"{_print_version()}\n")
+        return 0
+
+    if not argv:
+        out(f"{_format_sessions(service, use_color=use_color)}\n")
+        return 0
+
+    command, *rest = argv
+    ctx = {
+        "env": env,
+        "options": options,
+        "err": err,
+        "out": out,
+        "refresh_fn": refresh_fn,
+        "service": service,
+        "signal_emitter": signal_emitter,
+        "spawn": spawn,
+        "spawn_sync": spawn_sync,
+        "stdin_is_tty": stdin_is_tty,
+        "use_color": use_color,
+    }
+
+    if command == "add":
+        return handle_add(rest, ctx)
+
+    if command == "cp":
+        return handle_copy(rest, ctx)
+
+    if command in ("ren", "rename", "mv"):
+        return handle_rename(rest, ctx)
+
+    if command == "rmv":
+        return handle_remove(rest, ctx)
+
+    if command == "clean":
+        return handle_clean(rest, ctx)
+
+    if command == "doctor":
+        return handle_doctor(rest, ctx)
+
+    if command == "repair":
+        return handle_repair(rest, ctx)
+
+    if command == "notify":
+        return handle_notify(rest, ctx)
+
+    if command == "status":
+        return handle_status(rest, ctx)
+
+    if command == "login":
+        return handle_login(rest, ctx)
+
+    if command == "logout":
+        return handle_logout(rest, ctx)
+
+    if command in ("help",):
+        out(f"{_print_help(use_color=use_color)}\n")
+        return 0
+
+    if command in ("version",):
+        out(f"{_print_version()}\n")
+        return 0
+
+    if not rest:
+        return handle_launch(command, ctx)
+
+    raise CdxError(f"Unknown command: {command}. Use cdx --help.")
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main(sys.argv[1:]))
+    except CdxError as error:
+        sys.stderr.write(f"{format_error(error)}\n")
+        raise SystemExit(error.exit_code)

package/src/cli_commands.py

@@ -0,0 +1,369 @@
+import asyncio
+import json
+import os
+from datetime import datetime
+
+from .claude_refresh import _refresh_claude_sessions
+from .cli_render import _dim, _info, _success, _warn
+from .errors import CdxError
+from .health import collect_health_report, format_health_report, health_json
+from .notify import (
+    format_notify_event,
+    notify_json,
+    parse_notify_args,
+    send_desktop_notification,
+    wait_for_notification_event,
+)
+from .provider_runtime import (
+    _ensure_session_authentication,
+    _list_launch_transcript_paths,
+    _run_interactive_provider_command,
+)
+from .repair import format_repair_report, repair_health, repair_json
+from .status_view import _format_status_detail, _format_status_rows
+
+
+STATUS_USAGE = "Usage: cdx status [--json] [--refresh] | cdx status --small|-s [--refresh] | cdx status <name> [--json] [--refresh]"
+DOCTOR_USAGE = "Usage: cdx doctor [--json]"
+REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
+
+
+def _local_now_iso():
+    return datetime.now().astimezone().isoformat()
+
+
+def _parse_add_args(args):
+    if len(args) == 1:
+        return {"provider": "codex", "name": args[0]}
+    if len(args) == 2:
+        return {"provider": args[0], "name": args[1]}
+    raise CdxError("Usage: cdx add [provider] <name>")
+
+
+def _parse_copy_args(args):
+    if len(args) != 2:
+        raise CdxError("Usage: cdx cp <source> <dest>")
+    return {"source": args[0], "dest": args[1]}
+
+
+def _parse_rename_args(args):
+    if len(args) != 2:
+        raise CdxError("Usage: cdx ren <source> <dest>")
+    return {"source": args[0], "dest": args[1]}
+
+
+def _parse_remove_args(args):
+    force = "--force" in args
+    names = [a for a in args if a != "--force"]
+    unknown = [a for a in args if a.startswith("-") and a != "--force"]
+    if unknown or len(names) != 1 or len(args) > 2:
+        raise CdxError("Usage: cdx rmv <name> [--force]")
+    return {"name": names[0], "force": force}
+
+
+def _confirm_removal(name):
+    answer = input(f"Remove session {name}? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+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 handle_add(rest, ctx):
+    parsed = _parse_add_args(rest)
+    session = ctx["service"]["create_session"](parsed["name"], parsed["provider"])
+    message = f"Created session {parsed['name']} ({parsed['provider']})"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    _ensure_session_authentication(
+        session,
+        ctx["service"],
+        spawn=ctx.get("spawn"),
+        spawn_sync=ctx.get("spawn_sync"),
+        env_override=ctx.get("env"),
+        stdin_is_tty=ctx["stdin_is_tty"],
+        behavior="bootstrap",
+        signal_emitter=ctx.get("signal_emitter"),
+    )
+    now = _local_now_iso()
+    ctx["service"]["update_auth_state"](parsed["name"], lambda auth: {
+        **auth,
+        "status": "authenticated",
+        "lastCheckedAt": now,
+        "lastAuthenticatedAt": now,
+        "lastLoggedOutAt": auth.get("lastLoggedOutAt"),
+    })
+    return 0
+
+
+def handle_copy(rest, ctx):
+    parsed = _parse_copy_args(rest)
+    result = ctx["service"]["copy_session"](parsed["source"], parsed["dest"])
+    overwritten = " (overwritten)" if result["overwritten"] else ""
+    message = f"Copied session {parsed['source']} to {parsed['dest']}{overwritten}"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_rename(rest, ctx):
+    parsed = _parse_rename_args(rest)
+    ctx["service"]["rename_session"](parsed["source"], parsed["dest"])
+    message = f"Renamed session {parsed['source']} to {parsed['dest']}"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_remove(rest, ctx):
+    parsed = _parse_remove_args(rest)
+    if not parsed["force"]:
+        confirm_fn = ctx["options"].get("confirmRemove")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, parsed["name"])
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Removal requires confirmation in an interactive terminal or --force in non-interactive mode.")
+        else:
+            confirmed = _confirm_removal(parsed["name"])
+        if not confirmed:
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
+    ctx["service"]["remove_session"](parsed["name"])
+    message = f"Removed session {parsed['name']}"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_clean(rest, ctx):
+    service = ctx["service"]
+    if len(rest) == 0:
+        targets = service["list_sessions"]()
+    elif len(rest) == 1:
+        session = service["get_session"](rest[0])
+        if not session:
+            raise CdxError(f"Unknown session: {rest[0]}")
+        targets = [session]
+    else:
+        raise CdxError("Usage: cdx clean [name]")
+
+    for session in targets:
+        log_paths = _list_launch_transcript_paths(session)
+        if not log_paths:
+            message = f"{session['name']}: no log found"
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+            continue
+        total_size = 0
+        cleared = 0
+        for log_path in log_paths:
+            try:
+                total_size += os.path.getsize(log_path)
+                open(log_path, "w").close()
+                cleared += 1
+            except OSError:
+                continue
+        if cleared:
+            message = (
+                f"Cleared {session['name']} logs ({cleared} file"
+                f"{'' if cleared == 1 else 's'}, {round(total_size / 1024)} KB freed)"
+            )
+            ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+        else:
+            message = f"{session['name']}: no log found"
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_doctor(rest, ctx):
+    json_flag = "--json" in rest
+    unknown = [arg for arg in rest if arg != "--json"]
+    if unknown:
+        raise CdxError(DOCTOR_USAGE)
+    report = collect_health_report(
+        ctx["service"],
+        ctx["service"]["base_dir"],
+        env=ctx.get("env"),
+    )
+    if json_flag:
+        ctx["out"](f"{health_json(report)}\n")
+    else:
+        ctx["out"](f"{format_health_report(report, use_color=ctx['use_color'])}\n")
+    return 0
+
+
+def handle_repair(rest, ctx):
+    json_flag = "--json" in rest
+    dry_run = "--dry-run" in rest or "--force" not in rest
+    force = "--force" in rest
+    allowed = {"--json", "--dry-run", "--force"}
+    unknown = [arg for arg in rest if arg not in allowed]
+    if unknown:
+        raise CdxError(REPAIR_USAGE)
+    report = repair_health(
+        ctx["service"],
+        ctx["service"]["base_dir"],
+        env=ctx.get("env"),
+        dry_run=dry_run,
+        force=force,
+    )
+    if json_flag:
+        ctx["out"](f"{repair_json(report)}\n")
+    else:
+        ctx["out"](f"{format_repair_report(report, use_color=ctx['use_color'])}\n")
+        if dry_run:
+            ctx["out"](f"{_dim('Tip: run cdx repair --force to apply safe repairs.', ctx['use_color'])}\n")
+    return 0
+
+
+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"),
+        )
+
+    event = wait_for_notification_event(
+        ctx["service"],
+        parsed,
+        notifier=notifier,
+        sleep_fn=ctx["options"].get("sleep"),
+        now_fn=ctx["options"].get("now"),
+    )
+    if parsed["json"]:
+        ctx["out"](f"{notify_json(event)}\n")
+    else:
+        ctx["out"](f"{format_notify_event(event)}\n")
+    return 0
+
+
+def handle_status(rest, ctx):
+    json_flag = "--json" in rest
+    small_flag = "--small" in rest or "-s" in rest
+    refresh_flag = "--refresh" in rest
+    status_flags = {"--json", "--small", "-s", "--refresh"}
+    args = [a for a in rest if a not in status_flags]
+    unknown_flags = [a for a in args if a.startswith("-")]
+    if unknown_flags or (json_flag and small_flag):
+        raise CdxError(STATUS_USAGE)
+    if len(args) > 1 or (len(args) == 1 and small_flag):
+        raise CdxError(STATUS_USAGE)
+
+    refresh_result = _refresh_claude_sessions(
+        ctx["service"],
+        ctx.get("refresh_fn"),
+        target_names=args if len(args) == 1 else None,
+        force=refresh_flag,
+    )
+    refresh_errors = [
+        {
+            "session": item.get("session"),
+            "error": str(item.get("error")),
+        }
+        for item in refresh_result.get("errors", [])
+    ]
+
+    rows = ctx["service"]["get_status_rows"]()
+    if len(args) == 0:
+        if json_flag:
+            ctx["out"](f"{json.dumps(rows, indent=2)}\n")
+            _write_refresh_warnings(refresh_errors, ctx, stream="err")
+            return 0
+        ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=small_flag)}\n")
+        _write_refresh_warnings(refresh_errors, ctx)
+        return 0
+
+    row = next((r for r in rows if r["session_name"] == args[0]), None)
+    if not row:
+        raise CdxError(f"Unknown session: {args[0]}")
+    if json_flag:
+        ctx["out"](f"{json.dumps(row, indent=2)}\n")
+        _write_refresh_warnings(refresh_errors, ctx, stream="err")
+        return 0
+    ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
+    _write_refresh_warnings(refresh_errors, ctx)
+    return 0
+
+
+def _write_refresh_warnings(refresh_errors, ctx, stream="out"):
+    write = ctx["err"] if stream == "err" and "err" in ctx else ctx["out"]
+    for item in refresh_errors:
+        session = item.get("session") or "unknown"
+        error = item.get("error") or "unknown error"
+        write(f"{_warn(f'Warning: Claude refresh failed for {session}: {error}', ctx['use_color'])}\n")
+
+
+def handle_login(rest, ctx):
+    if len(rest) != 1:
+        raise CdxError("Usage: cdx login <name>")
+    if not ctx["stdin_is_tty"]:
+        raise CdxError("Login requires an interactive terminal.")
+    session = ctx["service"]["get_session"](rest[0])
+    if not session:
+        raise CdxError(f"Unknown session: {rest[0]}")
+    _run_interactive_provider_command(
+        session, "logout", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
+        signal_emitter=ctx.get("signal_emitter")
+    )
+    _run_interactive_provider_command(
+        session, "login", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
+        signal_emitter=ctx.get("signal_emitter")
+    )
+    now = _local_now_iso()
+    ctx["service"]["update_auth_state"](rest[0], lambda auth: {
+        **auth, "status": "authenticated",
+        "lastCheckedAt": now, "lastAuthenticatedAt": now,
+    })
+    message = f"Reauthenticated session {session['name']} ({session['provider']})"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_logout(rest, ctx):
+    if len(rest) != 1:
+        raise CdxError("Usage: cdx logout <name>")
+    session = ctx["service"]["get_session"](rest[0])
+    if not session:
+        raise CdxError(f"Unknown session: {rest[0]}")
+    _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"](rest[0], lambda auth: {
+        **auth, "status": "logged_out",
+        "lastCheckedAt": now, "lastLoggedOutAt": now,
+    })
+    message = f"Logged out session {session['name']} ({session['provider']})"
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_launch(command, ctx):
+    session = ctx["service"]["launch_session"](command)
+    _ensure_session_authentication(
+        session,
+        ctx["service"],
+        spawn=ctx.get("spawn"),
+        spawn_sync=ctx.get("spawn_sync"),
+        env_override=ctx.get("env"),
+        stdin_is_tty=ctx["stdin_is_tty"],
+        behavior="launch",
+        signal_emitter=ctx.get("signal_emitter"),
+    )
+    message = f"Launching {session['provider']} session {session['name']}"
+    ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+    if session["provider"] == "codex":
+        ctx["out"](f"{_dim('Tip: run /status once the Codex session opens.', 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")
+    )
+    return 0