mxctl 0.3.0__py3-none-any.whl

mxctl/commands/mail/setup.py

@@ -0,0 +1,362 @@
+"""Setup wizard for first-time configuration: init."""
+
+import os
+import re
+import sys
+import termios
+import tty
+
+from mxctl import __version__
+from mxctl.config import (  # noqa: F401 — CONFIG_DIR imported for test monkeypatching
+    CONFIG_DIR,
+    CONFIG_FILE,
+    FIELD_SEPARATOR,
+    _save_json,
+    get_config,
+)
+from mxctl.util.applescript import run
+from mxctl.util.formatting import format_output
+
+# ANSI helpers
+_G = "\x1b[1;32m"   # bold green
+_C = "\x1b[1;36m"   # bold cyan
+_D = "\x1b[90m"     # dim gray
+_B = "\x1b[1m"      # bold
+_R = "\x1b[0m"      # reset
+_W = "\x1b[1;37m"   # bold white
+
+_BANNER = f"""{_C}
+                    _   _
+                   | | | |
+ _ __ _____  ___| |_| |
+| '_ ` _ \\ \\/ / __| __| |
+| | | | | |>  < (__| |_| |
+|_| |_| |_/_/\\_\\___|\\__|_|{_R}
+
+  {_B}Apple Mail from your terminal{_R} {_D}— v{__version__}{_R}
+  {_D}─────────────────────────────────────────{_R}
+"""
+
+# Styled key hints for the hint bar
+_K_ARROWS = f"{_D}↑/↓{_R}"
+_K_SPACE  = f"{_G}[Space]{_R}"
+_K_ENTER  = f"{_W}[Enter]{_R}"
+_K_CANCEL = f"{_D}Ctrl+C cancel{_R}"
+
+_HINT_RADIO    = f"  {_K_ARROWS} navigate   {_K_SPACE} select   {_K_ENTER} confirm   {_K_CANCEL}"
+_HINT_CHECKBOX = f"  {_K_ARROWS} navigate   {_K_SPACE} toggle   {_K_ENTER} confirm   {_K_CANCEL}"
+
+
+def _is_interactive() -> bool:
+    """True when running in a real terminal (not a pipe or test)."""
+    if os.environ.get("CI") or os.environ.get("MY_CLI_NON_INTERACTIVE"):
+        return False
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _radio_select(prompt: str, options: list[str]) -> int:
+    """Arrow-key single-select.  Returns chosen index.
+    Raises KeyboardInterrupt on Ctrl+C.
+    """
+    current = 0
+    n = len(options)
+
+    def _render(first: bool = False) -> None:
+        # In raw mode \n doesn't imply \r — always use \r\n explicitly.
+        w = sys.stdout.write
+        if not first:
+            w(f"\r\x1b[{n + 1}A\x1b[J")
+        w(f"{_B}{prompt}{_R}\r\n")
+        for i, opt in enumerate(options):
+            if i == current:
+                w(f"  {_G}(●) {opt}{_R}\r\n")
+            else:
+                w(f"  ( ) {opt}\r\n")
+        w(_HINT_RADIO)
+        sys.stdout.flush()
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    tty.setraw(fd)
+    try:
+        _render(first=True)
+        while True:
+            ch = os.read(fd, 1)
+            if ch == b"\x1b":
+                seq = os.read(fd, 2)
+                if seq == b"[A":
+                    current = (current - 1) % n
+                elif seq == b"[B":
+                    current = (current + 1) % n
+            elif ch in (b"\r", b"\n", b" "):
+                break
+            elif ch == b"\x03":
+                raise KeyboardInterrupt
+            _render()
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+    sys.stdout.write(f"\r\x1b[{n + 1}A\x1b[J")
+    print(f"{_B}{prompt}{_R}  {_G}{options[current]}{_R}")
+    return current
+
+
+def _checkbox_select(prompt: str, options: list[str]) -> list[int]:
+    """Arrow-key multi-select with Space to toggle.
+    Returns sorted list of selected indices.
+    Raises KeyboardInterrupt on Ctrl+C.
+    """
+    current = 0
+    selected: set[int] = set()
+    n = len(options)
+
+    def _render(first: bool = False) -> None:
+        # In raw mode \n doesn't imply \r — always use \r\n explicitly.
+        w = sys.stdout.write
+        if not first:
+            w(f"\r\x1b[{n + 1}A\x1b[J")
+        w(f"{_B}{prompt}{_R}\r\n")
+        for i, opt in enumerate(options):
+            box = f"{_G}[x]{_R}" if i in selected else "[ ]"
+            if i == current:
+                w(f"  {_G}{box} {opt}{_R}\r\n")
+            else:
+                w(f"  {box} {opt}\r\n")
+        w(_HINT_CHECKBOX)
+        sys.stdout.flush()
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    tty.setraw(fd)
+    try:
+        _render(first=True)
+        while True:
+            ch = os.read(fd, 1)
+            if ch == b"\x1b":
+                seq = os.read(fd, 2)
+                if seq == b"[A":
+                    current = (current - 1) % n
+                elif seq == b"[B":
+                    current = (current + 1) % n
+            elif ch == b" ":
+                selected.symmetric_difference_update({current})
+            elif ch in (b"\r", b"\n"):
+                break
+            elif ch == b"\x03":
+                raise KeyboardInterrupt
+            _render()
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+    result = sorted(selected)
+    sys.stdout.write(f"\r\x1b[{n + 1}A\x1b[J")
+    if result:
+        names = ", ".join(options[i] for i in result)
+        print(f"{_B}{prompt}{_R}  {_G}{names}{_R}")
+    else:
+        print(f"{_B}{prompt}{_R}  {_D}(none){_R}")
+    return result
+
+
+def _step_header(step: int, total: int, title: str, hint: str) -> None:
+    """Print a step header with number, title, and context hint."""
+    print(f"\n  {_C}Step {step}/{total}{_R} {_D}·{_R} {_B}{title}{_R}")
+    print(f"  {_D}{hint}{_R}\n")
+
+
+def cmd_init(args) -> None:
+    """Interactive setup wizard to configure mxctl."""
+    print(_BANNER)
+
+    # Check for existing config
+    if os.path.isfile(CONFIG_FILE):
+        existing = get_config()
+        default_acct = existing.get("mail", {}).get("default_account") or existing.get("default_account", "")
+        print(f"  {_D}Existing config found. Default account:{_R} {_B}{default_acct or '(none)'}{_R}")
+        try:
+            answer = input(f"  Reconfigure? [{_B}y{_R}/{_B}N{_R}]: ").strip().lower()
+        except KeyboardInterrupt:
+            print(f"\n  {_D}Setup cancelled.{_R}")
+            return
+        except EOFError:
+            answer = "n"
+        if answer != "y":
+            print(f"  {_D}Keeping existing configuration.{_R}")
+            if getattr(args, "json", False):
+                format_output(args, "", json_data=existing)
+            return
+
+    # Detect accounts via AppleScript
+    script = f"""
+tell application "Mail"
+    set output to ""
+    repeat with acct in (every account)
+        set acctName to name of acct
+        set acctEmail to user name of acct
+        set acctEnabled to enabled of acct
+        set output to output & acctName & "{FIELD_SEPARATOR}" & acctEmail & "{FIELD_SEPARATOR}" & acctEnabled & linefeed
+    end repeat
+    return output
+end tell
+"""
+    result = run(script)
+
+    if not result.strip():
+        print(f"  {_G}!{_R} No mail accounts found. Make sure Mail.app is configured.")
+        return
+
+    # Parse accounts
+    accounts = []
+    for line in result.strip().split("\n"):
+        if not line.strip():
+            continue
+        parts = line.split(FIELD_SEPARATOR)
+        if len(parts) >= 3:
+            name, email, enabled_str = parts[0], parts[1], parts[2]
+            accounts.append({
+                "name": name,
+                "email": email,
+                "enabled": enabled_str.strip().lower() == "true",
+            })
+
+    enabled_accounts = [a for a in accounts if a["enabled"]]
+
+    if not enabled_accounts:
+        print(f"  {_G}!{_R} No enabled mail accounts found.")
+        return
+
+    total_steps = 3
+
+    # --- Step 1: Select primary account ---
+    _step_header(1, total_steps, "Default Account",
+                 "Which account should commands use when you don't specify -a?")
+
+    if len(enabled_accounts) == 1:
+        chosen = enabled_accounts[0]
+        print(f"  {_G}Auto-selected:{_R} {chosen['name']} ({chosen['email']})")
+    elif _is_interactive():
+        try:
+            opts = [f"{a['name']} ({a['email']})" for a in enabled_accounts]
+            idx = _radio_select("  Select primary account:", opts)
+            chosen = enabled_accounts[idx]
+        except KeyboardInterrupt:
+            print(f"\n  {_D}Setup cancelled.{_R}")
+            return
+    else:
+        # Non-interactive fallback (tests, pipes)
+        print("  Available mail accounts:")
+        for i, acct in enumerate(enabled_accounts, start=1):
+            print(f"    {i}. {acct['name']} ({acct['email']})")
+        while True:
+            try:
+                raw = input(f"\n  Select primary account [1-{len(enabled_accounts)}]: ").strip()
+            except KeyboardInterrupt:
+                print(f"\n  {_D}Setup cancelled.{_R}")
+                return
+            except EOFError:
+                raw = "1"
+            if raw.isdigit() and 1 <= int(raw) <= len(enabled_accounts):
+                chosen = enabled_accounts[int(raw) - 1]
+                break
+            print(f"  Please enter a number between 1 and {len(enabled_accounts)}.")
+
+    # --- Step 2: Select Gmail accounts ---
+    _step_header(2, total_steps, "Gmail Accounts",
+                 "Gmail uses different mailbox names ([Gmail]/Spam instead of Junk).")
+
+    gmail_accounts: list[str] = []
+    if len(enabled_accounts) == 1:
+        try:
+            ans = input(f"  Is '{enabled_accounts[0]['name']}' a Gmail account? [y/N]: ").strip().lower()
+        except (KeyboardInterrupt, EOFError):
+            ans = "n"
+        if ans == "y":
+            gmail_accounts = [enabled_accounts[0]["name"]]
+    elif _is_interactive():
+        try:
+            opts = [f"{a['name']} ({a['email']})" for a in enabled_accounts]
+            indices = _checkbox_select("  Select your Gmail accounts:", opts)
+            gmail_accounts = [enabled_accounts[i]["name"] for i in indices]
+        except KeyboardInterrupt:
+            print(f"\n  {_D}Setup cancelled.{_R}")
+            return
+    else:
+        # Non-interactive fallback
+        print("  Enter numbers separated by commas, or press Enter to skip.")
+        for i, acct in enumerate(enabled_accounts, start=1):
+            print(f"    {i}. {acct['name']} ({acct['email']})")
+        try:
+            raw_gmail = input("  Gmail accounts: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            raw_gmail = ""
+        if raw_gmail:
+            for part in raw_gmail.split(","):
+                part = part.strip()
+                if part.isdigit() and 1 <= int(part) <= len(enabled_accounts):
+                    gmail_accounts.append(enabled_accounts[int(part) - 1]["name"])
+
+    if gmail_accounts:
+        print(f"  {_D}Mailbox names will auto-translate for: {', '.join(gmail_accounts)}{_R}")
+
+    # --- Step 3: Todoist API token ---
+    _step_header(3, total_steps, "Todoist Integration",
+                 "Turn emails into tasks with `mxctl to-todoist`.")
+    print(f"  {_D}Get your token: Todoist Settings > Integrations > Developer{_R}")
+
+    todoist_token = ""
+    try:
+        raw_token = input(f"\n  API token {_D}(Enter to skip){_R}: ").strip()
+    except KeyboardInterrupt:
+        print(f"\n  {_D}Setup cancelled.{_R}")
+        return
+    except EOFError:
+        raw_token = ""
+    if raw_token:
+        if not re.match(r'^[a-f0-9]{40}$', raw_token):
+            print(f"  {_D}Warning: Doesn't match expected format (40 hex chars). Saving anyway.{_R}")
+        todoist_token = raw_token
+
+    # Build and write config
+    config: dict = {
+        "mail": {
+            "default_account": chosen["name"],
+        }
+    }
+    if gmail_accounts:
+        config["mail"]["gmail_accounts"] = gmail_accounts
+    if todoist_token:
+        config["todoist_api_token"] = todoist_token
+
+    _save_json(CONFIG_FILE, config)
+
+    # Success output
+    summary_parts = [f"{chosen['name']}"]
+    if gmail_accounts:
+        summary_parts.append(f"Gmail: {len(gmail_accounts)} account{'s' if len(gmail_accounts) != 1 else ''}")
+    if todoist_token:
+        summary_parts.append("Todoist: connected")
+
+    success_text = (
+        f"\n  {_G}Setup complete!{_R}\n\n"
+        f"  {_D}Config saved to {CONFIG_FILE}{_R}\n"
+        f"  {_B}{' · '.join(summary_parts)}{_R}\n"
+        f"\n  {_B}Get started:{_R}\n"
+        f"    {_G}mxctl inbox{_R}       {_D}Unread counts across all accounts{_R}\n"
+        f"    {_G}mxctl summary{_R}     {_D}AI-concise one-liner per unread{_R}\n"
+        f"    {_G}mxctl triage{_R}      {_D}Unread grouped by urgency{_R}\n"
+        f"    {_G}mxctl --help{_R}      {_D}See all 49 commands{_R}\n"
+    )
+
+    if getattr(args, "json", False):
+        redacted = dict(config)
+        if "todoist_api_token" in redacted:
+            redacted = {**redacted, "todoist_api_token": "****"}
+        format_output(args, success_text, json_data=redacted)
+    else:
+        print(success_text)
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("init", help="Setup wizard for first-time configuration")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_init)

mxctl/commands/mail/system.py

@@ -0,0 +1,202 @@
+"""System mail commands: check, headers, rules."""
+
+from mxctl.config import (
+    DEFAULT_MAILBOX,
+    FIELD_SEPARATOR,
+    resolve_account,
+)
+from mxctl.util.applescript import escape, run, validate_msg_id
+from mxctl.util.formatting import die, format_output, truncate
+from mxctl.util.mail_helpers import parse_email_headers
+
+# ---------------------------------------------------------------------------
+# check — trigger mail fetch
+# ---------------------------------------------------------------------------
+
+def cmd_check(args) -> None:
+    """Trigger Mail.app to check for new mail."""
+    script = """
+    tell application "Mail"
+        check for new mail
+        return "ok"
+    end tell
+    """
+    run(script)
+    format_output(args, "Mail check triggered.", json_data={"status": "checked"})
+
+
+# ---------------------------------------------------------------------------
+# headers
+# ---------------------------------------------------------------------------
+
+def cmd_headers(args) -> None:
+    """Show email headers with authentication details."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+    mailbox = getattr(args, "mailbox", None) or DEFAULT_MAILBOX
+    message_id = validate_msg_id(args.id)
+
+    acct_escaped = escape(account)
+    mb_escaped = escape(mailbox)
+
+    script = f"""
+    tell application "Mail"
+        set mb to mailbox "{mb_escaped}" of account "{acct_escaped}"
+        set theMsg to first message of mb whose id is {message_id}
+        return all headers of theMsg
+    end tell
+    """
+
+    result = run(script)
+    raw = getattr(args, "raw", False)
+
+    if raw:
+        print(result)
+        return
+
+    # Parse all headers
+    headers = parse_email_headers(result)
+
+    # Extract useful info
+    from_addr = headers.get("From", "?")
+    to_addr = headers.get("To", "?")
+    subject = headers.get("Subject", "?")
+    date = headers.get("Date", "?")
+    msg_id = headers.get("Message-Id") or headers.get("Message-ID", "?")
+    reply_to = headers.get("Reply-To", "")
+    in_reply_to = headers.get("In-Reply-To", "")
+    list_unsubscribe = headers.get("List-Unsubscribe", "")
+
+    # Authentication summary
+    auth_results = headers.get("Authentication-Results", "")
+    if isinstance(auth_results, list):
+        auth_results = " | ".join(auth_results)
+    spf = "?"
+    dkim = "?"
+    dmarc = "?"
+    if "spf=pass" in auth_results:
+        spf = "pass"
+    elif "spf=fail" in auth_results:
+        spf = "FAIL"
+    elif "spf=softfail" in auth_results:
+        spf = "softfail"
+    if "dkim=pass" in auth_results:
+        dkim = "pass"
+    elif "dkim=fail" in auth_results:
+        dkim = "FAIL"
+    if "dmarc=pass" in auth_results:
+        dmarc = "pass"
+    elif "dmarc=fail" in auth_results:
+        dmarc = "FAIL"
+
+    # Count hops
+    received = headers.get("Received", [])
+    if isinstance(received, str):
+        received = [received]
+    hops = len(received)
+
+    # Return path (bounce address)
+    return_path = headers.get("Return-Path", "")
+
+    text = f"From: {from_addr}\nTo: {to_addr}\nSubject: {subject}\nDate: {date}\nMessage-ID: {msg_id}"
+    if reply_to:
+        text += f"\nReply-To: {reply_to}"
+    if in_reply_to:
+        text += f"\nIn-Reply-To: {in_reply_to}"
+    if return_path:
+        text += f"\nReturn-Path: {return_path}"
+    text += f"\n\nAuth: SPF={spf}  DKIM={dkim}  DMARC={dmarc}"
+    text += f"\nHops: {hops}"
+    if list_unsubscribe:
+        text += f"\nUnsubscribe: {truncate(list_unsubscribe, 80)}"
+    format_output(args, text, json_data=headers)
+
+
+# ---------------------------------------------------------------------------
+# rules — list/enable/disable/apply mail rules
+# ---------------------------------------------------------------------------
+
+def cmd_rules(args) -> None:
+    """List or manage mail rules."""
+    action = getattr(args, "action", None)
+    rule_name = getattr(args, "rule_name", None)
+    if action == "enable" and rule_name:
+        _toggle_rule(args, rule_name, True)
+    elif action == "disable" and rule_name:
+        _toggle_rule(args, rule_name, False)
+    else:
+        _list_rules(args)
+
+
+def _list_rules(args) -> None:
+    script = f"""
+    tell application "Mail"
+        set output to ""
+        repeat with r in (every rule)
+            set rName to name of r
+            set rEnabled to enabled of r
+            set output to output & rName & "{FIELD_SEPARATOR}" & rEnabled & linefeed
+        end repeat
+        return output
+    end tell
+    """
+    result = run(script)
+    if not result.strip():
+        format_output(args, "No mail rules found.")
+        return
+
+    rules = []
+    for line in result.strip().split("\n"):
+        if not line.strip():
+            continue
+        parts = line.split(FIELD_SEPARATOR)
+        if len(parts) >= 2:
+            rules.append({"name": parts[0], "enabled": parts[1].lower() == "true"})
+
+    text = "Mail Rules:"
+    for rule in rules:
+        status = "ON" if rule["enabled"] else "OFF"
+        text += f"\n  [{status}] {rule['name']}"
+    format_output(args, text, json_data=rules)
+
+
+def _toggle_rule(args, name: str, enabled: bool) -> None:
+    name_escaped = escape(name)
+    val = "true" if enabled else "false"
+    script = f"""
+    tell application "Mail"
+        set r to first rule whose name is "{name_escaped}"
+        set enabled of r to {val}
+        return name of r
+    end tell
+    """
+    result = run(script)
+    word = "enabled" if enabled else "disabled"
+    format_output(args, f"Rule '{result}' {word}.", json_data={"rule": result, "status": word})
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+def register(subparsers) -> None:
+    """Register system mail subcommands."""
+    p = subparsers.add_parser("check", help="Trigger fetch for new mail")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_check)
+
+    p = subparsers.add_parser("headers", help="Email header summary (auth, hops, reply-to)")
+    p.add_argument("id", type=int, help="Message ID")
+    p.add_argument("-a", "--account", help="Mail account name")
+    p.add_argument("-m", "--mailbox", help="Mailbox name (default: INBOX)")
+    p.add_argument("--raw", action="store_true", help="Show full raw headers instead of summary")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_headers)
+
+    p = subparsers.add_parser("rules", help="List/manage mail rules")
+    p.add_argument("action", nargs="?", choices=["enable", "disable"], help="Action to perform")
+    p.add_argument("rule_name", nargs="?", help="Rule name")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_rules)
+