cdx-manager 0.9.15 → 0.10.0

package/src/cli_commands.py

@@ -4,8 +4,11 @@ import json
 import os
 import re
 import shlex
+import shutil
+import subprocess
 import sys
 import time
+import uuid
 from datetime import datetime
 
 from .backup_bundle import read_bundle_meta
@@ -13,6 +16,7 @@ from .claude_refresh import _refresh_claude_sessions
 from .cli_args import (
     CAN_RESUME_USAGE,
     CONTEXT_USAGE,
+    DISK_USAGE,
     DOCTOR_USAGE,
     HANDOFF_USAGE,
     LAST_USAGE,
@@ -66,9 +70,10 @@ from .cli_helpers import (
     _write_json,
     _write_update_notice,
 )
-from .cli_render import _dim, _info, _style, _success, _warn
+from .cli_render import _dim, _info, _pad_table, _style, _success, _warn
 from .cli_view import handle_view as handle_view  # re-export for cli.py / tests
-from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_OLLAMA
+from .codex_usage import consume_codex_rate_limit_reset_credit
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .context_store import (
     clear_context,
     edit_context,
@@ -140,6 +145,21 @@ def _confirm_removal(name):
     return answer.strip().lower() in ("y", "yes")
 
 
+def _confirm_reset(name):
+    answer = input(f"Consume one banked Codex reset for {name}? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+def _confirm_profile_cleanup(action):
+    answer = input(f"Delete matching profile {action} candidates? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+def _confirm_log_cleanup(target):
+    answer = input(f"Clear launch transcript logs for {target}? [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))
@@ -151,6 +171,412 @@ def _resolve_confirmation(confirm_fn, name):
     return confirmed
 
 
+def _format_bytes(value):
+    size = float(value)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{int(size)} {unit}" if unit == "B" or size.is_integer() else f"{size:.1f} {unit}"
+        size /= 1024
+
+
+def _directory_size_bytes(path, runner=None):
+    if not os.path.exists(path):
+        raise CdxError(f"CDX home does not exist: {path}")
+    runner = runner or subprocess.check_output
+    try:
+        output = runner(["du", "-sk", path], text=True, stderr=subprocess.DEVNULL)
+        return int(str(output).split()[0]) * 1024
+    except (OSError, subprocess.CalledProcessError, ValueError, IndexError):
+        total = 0
+        for root, _, files in os.walk(path):
+            for name in files:
+                try:
+                    total += os.path.getsize(os.path.join(root, name))
+                except OSError:
+                    pass
+        return total
+
+
+def _directory_child_sizes(path, runner=None, progress=None):
+    rows = []
+    try:
+        names = os.listdir(path)
+    except OSError:
+        return rows
+    children = [(name, os.path.join(path, name)) for name in names if os.path.isdir(os.path.join(path, name))]
+    for index, (name, child_path) in enumerate(children, start=1):
+        if progress:
+            progress("profile", name, index, len(children))
+        rows.append({
+            "name": name,
+            "path": child_path,
+            "bytes": _directory_size_bytes(child_path, runner=runner),
+        })
+    rows.sort(key=lambda row: row["bytes"], reverse=True)
+    for row in rows:
+        row["size"] = _format_bytes(row["bytes"])
+    return rows
+
+
+def _parse_days(value, usage):
+    match = re.fullmatch(r"(\d+)(?:d)?", str(value or "").strip())
+    if not match or int(match.group(1)) <= 0:
+        raise CdxError(usage)
+    return int(match.group(1))
+
+
+def _candidate(profile, kind, path, bytes_used, reason, risk="safe", evidence=None):
+    return {
+        "profile": profile,
+        "kind": kind,
+        "path": path,
+        "bytes": bytes_used,
+        "size": _format_bytes(bytes_used),
+        "reason": reason,
+        "risk": risk,
+        "evidence": evidence or {},
+    }
+
+
+def _iter_profile_dirs(base_dir):
+    profiles_dir = os.path.join(base_dir, "profiles")
+    try:
+        names = sorted(os.listdir(profiles_dir))
+    except OSError:
+        return
+    for name in names:
+        path = os.path.join(profiles_dir, name)
+        if os.path.isdir(path):
+            yield name, path
+
+
+def _collect_old_logs(profile_name, profile_path, days, now=None):
+    cutoff = (time.time() if now is None else now) - (days * 86400)
+    paths = []
+    bytes_used = 0
+    latest_mtime = 0
+    for root, _, files in os.walk(profile_path):
+        if os.path.basename(root) != "log":
+            continue
+        for filename in files:
+            if not filename.endswith(".log"):
+                continue
+            path = os.path.join(root, filename)
+            try:
+                stat = os.stat(path)
+            except OSError:
+                continue
+            if stat.st_mtime >= cutoff:
+                continue
+            paths.append(path)
+            bytes_used += stat.st_size
+            latest_mtime = max(latest_mtime, stat.st_mtime)
+    if not paths:
+        return None
+    return _candidate(
+        profile_name,
+        f"old-logs-{days}d",
+        profile_path,
+        bytes_used,
+        f"{len(paths)} .log files older than {days}d",
+        risk="review",
+        evidence={
+            "days": days,
+            "file_count": len(paths),
+            "newest_old_log_mtime": datetime.fromtimestamp(latest_mtime).isoformat() if latest_mtime else None,
+            "sample_paths": paths[:5],
+        },
+    )
+
+
+def _collect_profile_cleanup_candidates(base_dir, *, old_log_days=30, runner=None, now=None, progress=None):
+    candidates = []
+    profiles = list(_iter_profile_dirs(base_dir))
+    for index, (profile_name, profile_path) in enumerate(profiles, start=1):
+        if progress:
+            progress("candidates", profile_name, index, len(profiles))
+        tmp_dir = os.path.join(profile_path, ".tmp")
+        tmp_targets = [
+            ("tmp-marketplaces", os.path.join(tmp_dir, "marketplaces"), "temporary marketplace cache/staging"),
+        ]
+        try:
+            tmp_names = os.listdir(tmp_dir)
+        except OSError:
+            tmp_names = []
+        for name in tmp_names:
+            if name.startswith("plugins-clone-"):
+                tmp_targets.append(("tmp-plugin-clone", os.path.join(tmp_dir, name), "temporary plugin clone"))
+            elif name.startswith("plugins-backup-"):
+                tmp_targets.append(("tmp-plugin-backup", os.path.join(tmp_dir, name), "temporary plugin backup"))
+        for kind, path, reason in tmp_targets:
+            if not os.path.exists(path):
+                continue
+            bytes_used = _directory_size_bytes(path, runner=runner)
+            if bytes_used <= 0:
+                continue
+            try:
+                mtime = datetime.fromtimestamp(os.path.getmtime(path)).isoformat()
+            except OSError:
+                mtime = None
+            candidates.append(_candidate(
+                profile_name,
+                kind,
+                path,
+                bytes_used,
+                reason,
+                evidence={"modified_at": mtime},
+            ))
+        old_logs = _collect_old_logs(profile_name, profile_path, old_log_days, now=now)
+        if old_logs and old_logs["bytes"] > 0:
+            candidates.append(old_logs)
+    candidates.sort(key=lambda item: item["bytes"], reverse=True)
+    return candidates
+
+
+def _format_cleanup_candidates(candidates, use_color=False):
+    if not candidates:
+        return _dim("No cleanup candidates found.", use_color)
+    reclaimable = sum(item["bytes"] for item in candidates)
+    lines = [
+        _style("Cleanup candidates", "1", use_color),
+        f"{_style(_format_bytes(reclaimable), '33', use_color)} reclaimable across {len({item['profile'] for item in candidates})} profile(s)",
+    ]
+    by_profile = {}
+    for item in candidates:
+        by_profile.setdefault(item["profile"], []).append(item)
+    for profile, items in sorted(by_profile.items(), key=lambda row: sum(i["bytes"] for i in row[1]), reverse=True):
+        total = sum(item["bytes"] for item in items)
+        lines.extend(["", f"{_style(profile, '1', use_color)}  {_style(_format_bytes(total), '33', use_color)}"])
+        rows = [[
+            _style("SIZE", "1", use_color),
+            _style("TYPE", "1", use_color),
+            _style("RISK", "1", use_color),
+            _style("EVIDENCE", "1", use_color),
+        ]]
+        for item in items:
+            risk_color = "32" if item["risk"] == "safe" else "33"
+            rows.append([
+                _style(item["size"], "36", use_color),
+                item["kind"],
+                _style(item["risk"], risk_color, use_color),
+                item["reason"],
+            ])
+        lines.append(_pad_table(rows))
+    return "\n".join(lines)
+
+
+def _format_disk_report(payload, use_color=False):
+    title = "CDX profiles" if payload["target"] == "profiles" else "CDX home"
+    lines = [
+        _style(title, "1", use_color),
+        f"Path:  {_dim(payload['path'], use_color)}",
+        f"Total: {_style(payload['size'], '36', use_color)}",
+    ]
+    children = payload.get("children") or []
+    if children:
+        reclaimable_by_profile = {}
+        for item in payload.get("candidates") or []:
+            reclaimable_by_profile[item["profile"]] = reclaimable_by_profile.get(item["profile"], 0) + item["bytes"]
+        headers = ["PROFILE", "SIZE", "SHARE"]
+        if "candidates" in payload:
+            headers.append("RECLAIMABLE")
+        rows = [[_style(header, "1", use_color) for header in headers]]
+        for child in children:
+            share = (child["bytes"] / payload["bytes"] * 100) if payload["bytes"] else 0
+            row = [
+                _style(child["name"], "1", use_color),
+                _style(child["size"], "36", use_color),
+                f"{share:.1f}%",
+            ]
+            if "candidates" in payload:
+                reclaimable = reclaimable_by_profile.get(child["name"], 0)
+                row.append(_style(_format_bytes(reclaimable), "33", use_color) if reclaimable else _dim("-", use_color))
+            rows.append(row)
+        lines.extend(["", _style(f"Profiles ({len(children)})", "1", use_color), _pad_table(rows)])
+    if "candidates" in payload:
+        lines.extend(["", _format_cleanup_candidates(payload["candidates"], use_color=use_color)])
+    return "\n".join(lines)
+
+
+def _remove_path(path):
+    try:
+        if os.path.isdir(path):
+            size = _directory_size_bytes(path)
+            shutil.rmtree(path)
+        else:
+            size = os.path.getsize(path)
+            os.remove(path)
+        return size
+    except OSError as error:
+        raise CdxError(f"Failed to remove cleanup candidate {path}: {error}") from error
+
+
+def _clean_profile_tmp(profile_path):
+    tmp_dir = os.path.join(profile_path, ".tmp")
+    targets = [os.path.join(tmp_dir, "marketplaces")]
+    try:
+        names = os.listdir(tmp_dir)
+    except OSError:
+        names = []
+    targets.extend(os.path.join(tmp_dir, name) for name in names if name.startswith(("plugins-clone-", "plugins-backup-")))
+    freed = 0
+    removed = []
+    for path in targets:
+        if os.path.exists(path):
+            size = _remove_path(path)
+            if size:
+                freed += size
+                removed.append(path)
+    return freed, removed
+
+
+def _clean_profile_old_logs(profile_path, days, now=None):
+    cutoff = (time.time() if now is None else now) - (days * 86400)
+    freed = 0
+    removed = []
+    for root, _, files in os.walk(profile_path):
+        if os.path.basename(root) != "log":
+            continue
+        for filename in files:
+            if not filename.endswith(".log"):
+                continue
+            path = os.path.join(root, filename)
+            try:
+                stat = os.stat(path)
+            except OSError:
+                continue
+            if stat.st_mtime >= cutoff:
+                continue
+            try:
+                os.remove(path)
+            except OSError as error:
+                raise CdxError(f"Failed to remove old log {path}: {error}") from error
+            freed += stat.st_size
+            removed.append(path)
+    return freed, removed
+
+
+def _handle_clean_profiles(args, ctx, json_flag):
+    usage = "Usage: cdx clean profiles (--tmp|--old-logs DAYS) [--yes] [--json]"
+    yes = "--yes" in args
+    args = [arg for arg in args if arg != "--yes"]
+    clean_tmp = "--tmp" in args
+    old_logs = None
+    if "--old-logs" in args:
+        index = args.index("--old-logs")
+        if index + 1 >= len(args):
+            raise CdxError(usage)
+        old_logs = _parse_days(args[index + 1], usage)
+        args = [arg for i, arg in enumerate(args) if i not in (index, index + 1)]
+    args = [arg for arg in args if arg != "--tmp"]
+    if args or clean_tmp == (old_logs is not None):
+        raise CdxError(usage)
+
+    action = "temporary cache" if clean_tmp else f"logs older than {old_logs}d"
+    if not yes:
+        confirm_fn = ctx["options"].get("confirmProfileCleanup")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, action)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Profile cleanup requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_profile_cleanup(action)
+        if not confirmed:
+            if json_flag:
+                _write_json(ctx, _json_success("clean.profiles", "Cancelled.", cancelled=True, freed_bytes=0, freed_size="0 B", profiles=[]))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
+
+    results = []
+    now = ctx["options"].get("now")() if callable(ctx["options"].get("now")) else None
+    for profile_name, profile_path in _iter_profile_dirs(ctx["service"]["base_dir"]):
+        if clean_tmp:
+            freed, removed = _clean_profile_tmp(profile_path)
+            result_action = "tmp"
+        else:
+            freed, removed = _clean_profile_old_logs(profile_path, old_logs, now=now)
+            result_action = f"old-logs-{old_logs}d"
+        if not freed and not removed:
+            continue
+        results.append({
+            "profile": profile_name,
+            "action": result_action,
+            "freed_bytes": freed,
+            "freed_size": _format_bytes(freed),
+            "removed_count": len(removed),
+            "removed_paths": removed,
+        })
+    total = sum(item["freed_bytes"] for item in results)
+    if json_flag:
+        _write_json(ctx, _json_success("clean.profiles", f"Cleaned profiles ({_format_bytes(total)} freed)", cancelled=False, freed_bytes=total, freed_size=_format_bytes(total), profiles=results))
+        return 0
+    if not results:
+        ctx["out"](f"{_dim('No matching profile cleanup candidates found.', ctx['use_color'])}\n")
+        return 0
+    for item in results:
+        message = f"Cleaned {item['profile']} {item['action']} ({item['freed_size']} freed)"
+        ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_success(f'Total freed: {_format_bytes(total)}', ctx['use_color'])}\n")
+    return 0
+
+
+def handle_disk(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--candidates": {"key": "candidates", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, DISK_USAGE, positionals_key="targets", max_positionals=1)
+    target = parsed["targets"][0] if parsed["targets"] else "home"
+    if target == "home":
+        path = ctx["service"]["base_dir"]
+    elif target == "profiles":
+        path = os.path.join(ctx["service"]["base_dir"], "profiles")
+    else:
+        raise CdxError(DISK_USAGE)
+    stderr = ctx["options"].get("stderr", sys.stderr)
+    show_progress = not parsed["json"] and hasattr(stderr, "isatty") and stderr.isatty()
+
+    def progress(stage, name=None, index=None, total=None):
+        if not show_progress:
+            return
+        if stage == "total":
+            label = "CDX profiles" if target == "profiles" else "CDX home"
+            ctx["err"](f"Measuring {label} disk usage...\n")
+        elif stage == "profile":
+            ctx["err"](f"Measuring profile {name} ({index}/{total})...\n")
+        elif stage == "candidates":
+            ctx["err"](f"Scanning cleanup candidates in {name} ({index}/{total})...\n")
+
+    progress("total")
+    bytes_used = _directory_size_bytes(path, runner=ctx["options"].get("diskUsageRunner"))
+    payload = {
+        "target": target,
+        "path": path,
+        "bytes": bytes_used,
+        "size": _format_bytes(bytes_used),
+    }
+    if target == "profiles":
+        payload["children"] = _directory_child_sizes(path, runner=ctx["options"].get("diskUsageRunner"), progress=progress)
+    if parsed["candidates"]:
+        if target != "profiles":
+            raise CdxError(DISK_USAGE)
+        candidates = _collect_profile_cleanup_candidates(
+            ctx["service"]["base_dir"],
+            runner=ctx["options"].get("diskUsageRunner"),
+            now=ctx["options"].get("now")() if callable(ctx["options"].get("now")) else None,
+            progress=progress,
+        )
+        payload["candidates"] = candidates
+        payload["reclaimable_bytes"] = sum(item["bytes"] for item in candidates)
+        payload["reclaimable_size"] = _format_bytes(payload["reclaimable_bytes"])
+    if parsed["json"]:
+        label = "CDX profiles" if target == "profiles" else "CDX home"
+        _write_json(ctx, _json_success("disk", f"Measured {label} disk usage: {payload['size']}", disk=payload))
+        return 0
+    ctx["out"](f"{_format_disk_report(payload, use_color=ctx['use_color'])}\n")
+    return 0
+
+
 def _extract_claude_oauth_token(text):
     if not text:
         return None
@@ -1309,6 +1735,10 @@ def handle_last(rest, ctx):
 
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
+    if args[:1] == ["profiles"] and any(arg in ("--tmp", "--old-logs") for arg in args[1:]):
+        return _handle_clean_profiles(args[1:], ctx, json_flag)
+    yes = "--yes" in args
+    args = [arg for arg in args if arg != "--yes"]
     service = ctx["service"]
     if len(args) == 0:
         targets = service["list_sessions"]()
@@ -1318,7 +1748,23 @@ def handle_clean(rest, ctx):
             raise CdxError(f"Unknown session: {args[0]}")
         targets = [session]
     else:
-        raise CdxError("Usage: cdx clean [name] [--json]")
+        raise CdxError("Usage: cdx clean [name] [--yes] [--json]")
+
+    if not yes:
+        target = targets[0]["name"] if len(targets) == 1 else f"all {len(targets)} sessions"
+        confirm_fn = ctx["options"].get("confirmClean")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, target)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Log cleanup requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_log_cleanup(target)
+        if not confirmed:
+            if json_flag:
+                _write_json(ctx, _json_success("clean", "Cancelled.", cancelled=True, sessions=[]))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
 
     cleaned_sessions = []
     for session in targets:
@@ -1373,7 +1819,7 @@ def handle_clean(rest, ctx):
                 continue
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
     if json_flag:
-        _write_json(ctx, _json_success("clean", "Cleaned session logs", sessions=cleaned_sessions))
+        _write_json(ctx, _json_success("clean", "Cleaned session logs", cancelled=False, sessions=cleaned_sessions))
     return 0
 
 
@@ -1667,6 +2113,69 @@ def handle_status(rest, ctx):
     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 _refresh_claude_auth_states(service, target_names=None, spawn_sync=None, env_override=None):
     target_names = set(target_names or [])
     errors = []

package/src/cli_helpers.py

@@ -68,6 +68,13 @@ def _update_notice_warning(ctx):
 def _update_notice_warnings(ctx):
     warnings = []
     for notice in ctx.get("update_notices") or []:
+        if notice.get("code") == "disk_cleanup_available":
+            warnings.append({
+                "code": "disk_cleanup_available",
+                "message": notice["message"],
+                **{key: value for key, value in notice.items() if key not in ("code", "message")},
+            })
+            continue
         tool = notice.get("tool") or "cdx-manager"
         current = notice.get("current_version") or ctx.get("version")
         command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)