cdx-manager 0.2.1

package/src/cli_render.py

@@ -0,0 +1,131 @@
+import os
+import re
+import sys
+from datetime import datetime, timezone
+
+
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _format_relative_age(iso_value):
+    if not iso_value:
+        return "-"
+    try:
+        ts = datetime.fromisoformat(iso_value.replace("Z", "+00:00"))
+        delta_s = (datetime.now(timezone.utc) - ts).total_seconds()
+    except (ValueError, TypeError):
+        return "-"
+    if delta_s < 0:
+        return "just now"
+    minutes = int(delta_s // 60)
+    if minutes < 1:
+        return "just now"
+    if minutes < 60:
+        return f"{minutes}m ago"
+    hours = minutes // 60
+    if hours < 24:
+        return f"{hours}h ago"
+    return f"{hours // 24}d ago"
+
+
+def _format_pct(value):
+    if value is None:
+        return "n/a"
+    return f"{value}%"
+
+
+def _visible_len(value):
+    return len(ANSI_RE.sub("", str(value)))
+
+
+def _pad_table(columns):
+    widths = [
+        max(_visible_len(row[i]) for row in columns)
+        for i in range(len(columns[0]))
+    ]
+    lines = []
+    for row in columns:
+        cells = []
+        for i in range(len(row)):
+            value = str(row[i])
+            cells.append(value + " " * (widths[i] - _visible_len(value)))
+        lines.append("  ".join(cells))
+    return "\n".join(lines)
+
+
+def _should_use_color(env, stdout):
+    if env.get("NO_COLOR") is not None:
+        return False
+    if env.get("CLICOLOR_FORCE") not in (None, "", "0"):
+        return True
+    if env.get("CLICOLOR") == "0":
+        return False
+    if env.get("TERM") == "dumb":
+        return False
+    return bool(hasattr(stdout, "isatty") and stdout.isatty())
+
+
+def _style(text, code, use_color=False):
+    if not use_color:
+        return str(text)
+    return f"\033[{code}m{text}\033[0m"
+
+
+def _style_pct(value, use_color=False):
+    text = _format_pct(value)
+    if value is None:
+        return _style(text, "2", use_color)
+    if value == 0:
+        return _style(text, "31", use_color)
+    if value <= 10:
+        return _style(text, "33", use_color)
+    return _style(text, "32", use_color)
+
+
+def _success(text, use_color=False):
+    return _style(text, "32", use_color)
+
+
+def _warn(text, use_color=False):
+    return _style(text, "33", use_color)
+
+
+def _info(text, use_color=False):
+    return _style(text, "36", use_color)
+
+
+def _dim(text, use_color=False):
+    return _style(text, "2", use_color)
+
+
+def format_error(error, env=None, stderr=None):
+    return _style(str(error), "31", _should_use_color(env or os.environ, stderr or sys.stderr))
+
+
+def _format_sessions(service, use_color=False):
+    rows = service["format_list_rows"]()
+    has_provider = any(r.get("provider") for r in rows)
+    headers = ["SESSION"]
+    if has_provider:
+        headers.append("PROVIDER")
+    headers.append("UPDATED")
+    headers = [_style(header, "1", use_color) for header in headers]
+    table_rows = []
+    for r in rows:
+        parts = [r["name"]]
+        if has_provider:
+            parts.append(r.get("provider") or "n/a")
+        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 ren <source> <dest>', '36', use_color)}",
+        f"  {_style('cdx rmv <name>', '36', use_color)}",
+        f"  {_style('cdx status', '36', use_color)}",
+    ]
+    return "\n".join(lines)

package/src/config.py

@@ -0,0 +1,8 @@
+import os
+from pathlib import Path
+
+
+def get_cdx_home(env=None):
+    if env is None:
+        env = os.environ
+    return env.get("CDX_HOME", str(Path.home() / ".cdx"))

package/src/errors.py

@@ -0,0 +1,4 @@
+class CdxError(Exception):
+    def __init__(self, message, exit_code=1):
+        super().__init__(message)
+        self.exit_code = exit_code

package/src/health.py

@@ -0,0 +1,125 @@
+import json
+import os
+import shutil
+import tempfile
+from urllib.parse import quote, unquote
+
+from .cli_render import _pad_table, _style
+
+
+def _encode(name):
+    return quote(name, safe="")
+
+
+def _state_file_path(base_dir, name):
+    return os.path.join(base_dir, "state", f"{_encode(name)}.json")
+
+
+def _profiles_dir(base_dir):
+    return os.path.join(base_dir, "profiles")
+
+
+def _issue(status, code, message, detail=None, repairable=False):
+    return {
+        "status": status,
+        "code": code,
+        "message": message,
+        "detail": detail,
+        "repairable": repairable,
+    }
+
+
+def collect_health_report(service, base_dir, env=None):
+    env = env or os.environ
+    issues = []
+
+    for command in ("codex", "claude"):
+        path = shutil.which(command, path=env.get("PATH"))
+        status = "OK" if path else "WARN"
+        issues.append(_issue(status, f"{command}_cli", f"{command} CLI {'found' if path else 'not found'}", path))
+
+    script_bin = env.get("CDX_SCRIPT_BIN", "script")
+    script_path = shutil.which(script_bin, path=env.get("PATH"))
+    issues.append(_issue(
+        "OK" if script_path else "WARN",
+        "script_cli",
+        f"{script_bin} CLI {'found' if script_path else 'not found; Codex will launch without transcript fallback'}",
+        script_path,
+    ))
+
+    issues.append(_check_cdx_home(base_dir))
+    sessions = service["list_sessions"]()
+    session_names = {session["name"] for session in sessions}
+    for session in sessions:
+        name = session["name"]
+        root = session.get("sessionRoot") or service["get_session_root"](name)
+        if not os.path.isdir(root):
+            issues.append(_issue("FAIL", "missing_profile", f"session {name} profile is missing", root))
+        state_path = _state_file_path(base_dir, name)
+        if not os.path.isfile(state_path):
+            issues.append(_issue("FAIL", "missing_state", f"session {name} state file is missing", state_path, True))
+
+    issues.extend(_collect_profile_issues(base_dir, session_names))
+    return {"base_dir": base_dir, "issues": issues, "summary": summarize_health(issues)}
+
+
+def _check_cdx_home(base_dir):
+    try:
+        os.makedirs(base_dir, exist_ok=True)
+        fd, path = tempfile.mkstemp(prefix=".cdx-doctor.", dir=base_dir)
+        os.close(fd)
+        os.unlink(path)
+        return _issue("OK", "cdx_home_writable", "CDX_HOME is writable", base_dir)
+    except OSError as error:
+        return _issue("FAIL", "cdx_home_writable", "CDX_HOME is not writable", f"{base_dir}: {error}")
+
+
+def _collect_profile_issues(base_dir, session_names):
+    profile_dir = _profiles_dir(base_dir)
+    if not os.path.isdir(profile_dir):
+        return []
+    issues = []
+    encoded_session_names = {_encode(name) for name in session_names}
+    for entry in sorted(os.listdir(profile_dir)):
+        path = os.path.join(profile_dir, entry)
+        if not os.path.isdir(path):
+            continue
+        if entry.startswith(".") and ".remove." in entry:
+            issues.append(_issue("WARN", "quarantine_profile", f"pending quarantine profile: {entry}", path, True))
+            continue
+        if entry.startswith("."):
+            continue
+        if entry not in encoded_session_names:
+            issues.append(_issue("WARN", "orphan_profile", f"orphan profile: {unquote(entry)}", path, True))
+    return issues
+
+
+def summarize_health(issues):
+    return {
+        "ok": sum(1 for issue in issues if issue["status"] == "OK"),
+        "warn": sum(1 for issue in issues if issue["status"] == "WARN"),
+        "fail": sum(1 for issue in issues if issue["status"] == "FAIL"),
+        "repairable": sum(1 for issue in issues if issue.get("repairable")),
+    }
+
+
+def format_health_report(report, use_color=False):
+    rows = [["STATUS", "CHECK", "MESSAGE"]]
+    for issue in report["issues"]:
+        status = issue["status"]
+        style = "32" if status == "OK" else "33" if status == "WARN" else "31"
+        rows.append([_style(status, style, use_color), issue["code"], issue["message"]])
+    summary = report["summary"]
+    return "\n".join([
+        _pad_table(rows),
+        "",
+        _style(
+            f"Summary: {summary['ok']} OK, {summary['warn']} WARN, {summary['fail']} FAIL, {summary['repairable']} repairable.",
+            "1",
+            use_color,
+        ),
+    ])
+
+
+def health_json(report):
+    return json.dumps(report, indent=2)

package/src/notify.py

@@ -0,0 +1,138 @@
+import json
+import os
+import subprocess
+import time
+
+from .errors import CdxError
+from .status_view import _parse_reset_timestamp, _recommend_priority_sessions
+
+
+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
+    poll = 60
+    cleaned = []
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg in ("--json", "--once", "--at-reset", "--next-ready"):
+            i += 1
+            continue
+        if arg == "--poll":
+            if i + 1 >= len(args):
+                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+            try:
+                poll = max(1, int(args[i + 1]))
+            except ValueError as error:
+                raise CdxError("--poll must be a number of seconds") from error
+            i += 2
+            continue
+        if arg.startswith("-"):
+            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+        cleaned.append(arg)
+        i += 1
+    if at_reset == next_ready:
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+    if at_reset and len(cleaned) != 1:
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once]")
+    if next_ready and cleaned:
+        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once]")
+    return {
+        "name": cleaned[0] if cleaned else None,
+        "mode": "at-reset" if at_reset else "next-ready",
+        "poll": poll,
+        "once": once,
+        "json": json_flag,
+    }
+
+
+def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None):
+    notifier = notifier or send_desktop_notification
+    sleep_fn = sleep_fn or time.sleep
+    now_fn = now_fn or time.time
+    while True:
+        event = resolve_notify_event(service["get_status_rows"](), parsed, now_fn())
+        if event["ready"] or parsed["once"]:
+            if event["ready"]:
+                notifier(event["title"], event["message"])
+            return event
+        sleep_fn(parsed["poll"])
+
+
+def resolve_notify_event(rows, parsed, now_ts=None):
+    now_ts = time.time() if now_ts is None else now_ts
+    if parsed["mode"] == "next-ready":
+        priority = _recommend_priority_sessions(rows)
+        if not priority:
+            return _event(False, "cdx", "No session status available", None)
+        first = priority[0]
+        if _is_available(first):
+            return _event(True, "cdx", f"{first['session_name']} is ready", first["session_name"])
+        timestamp = _next_reset_timestamp(first)
+        if timestamp is not None and timestamp <= now_ts:
+            return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
+        return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
+
+    row = next((item for item in rows if item["session_name"] == parsed["name"]), None)
+    if not row:
+        raise CdxError(f"Unknown session: {parsed['name']}")
+    timestamp = _next_reset_timestamp(row)
+    if timestamp is None:
+        return _event(False, "cdx", f"No reset time known for {row['session_name']}", row["session_name"])
+    if timestamp <= now_ts:
+        return _event(True, "cdx", f"{row['session_name']} reset is due", row["session_name"], timestamp)
+    return _event(False, "cdx", f"Waiting for {row['session_name']} reset", row["session_name"], timestamp)
+
+
+def _is_available(row):
+    value = row.get("available_pct")
+    return value is not None and value > 0
+
+
+def _next_reset_timestamp(row):
+    values = [row.get("reset_5h_at"), row.get("reset_week_at"), row.get("reset_at")]
+    timestamps = [
+        timestamp
+        for timestamp in (_parse_reset_timestamp(value) for value in values)
+        if timestamp is not None
+    ]
+    if not timestamps:
+        return None
+    return min(timestamps)
+
+
+def _event(ready, title, message, session_name, target_timestamp=None):
+    return {
+        "ready": ready,
+        "title": title,
+        "message": message,
+        "session": session_name,
+        "target_timestamp": target_timestamp,
+    }
+
+
+def send_desktop_notification(title, message, spawn_sync=None, env=None):
+    spawn_sync = spawn_sync or subprocess.run
+    env = env or os.environ
+    if shutil_which("osascript", env):
+        script = f'display notification "{_escape_applescript(message)}" with title "{_escape_applescript(title)}"'
+        spawn_sync(["osascript", "-e", script], env=env, capture_output=True, text=True)
+
+
+def shutil_which(command, env):
+    import shutil
+    return shutil.which(command, path=env.get("PATH"))
+
+
+def _escape_applescript(value):
+    return str(value).replace("\\", "\\\\").replace('"', '\\"')
+
+
+def format_notify_event(event):
+    return event["message"]
+
+
+def notify_json(event):
+    return json.dumps(event, indent=2)