mxctl 0.3.0__py3-none-any.whl

mxctl/commands/mail/templates.py

@@ -0,0 +1,145 @@
+"""Email templates management."""
+
+import json
+import os
+
+from mxctl.config import CONFIG_DIR, TEMPLATES_FILE, file_lock
+from mxctl.util.formatting import die, format_output
+
+
+def _load_templates() -> dict:
+    """Load templates from disk."""
+    if os.path.isfile(TEMPLATES_FILE):
+        with file_lock(TEMPLATES_FILE), open(TEMPLATES_FILE) as f:
+            try:
+                return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                return {}
+    return {}
+
+
+def _save_templates(templates: dict) -> None:
+    """Save templates to disk."""
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with file_lock(TEMPLATES_FILE), open(TEMPLATES_FILE, "w") as f:
+        json.dump(templates, f, indent=2)
+    os.chmod(TEMPLATES_FILE, 0o600)
+
+
+def cmd_templates_list(args) -> None:
+    """List all saved templates."""
+    templates = _load_templates()
+
+    if not templates:
+        format_output(args, "No templates saved.")
+        return
+
+    # Build JSON data
+    template_list = [
+        {"name": name, "subject": data.get("subject", ""), "body": data.get("body", "")}
+        for name, data in templates.items()
+    ]
+
+    # Build text output
+    text = "Email Templates:"
+    for name, data in templates.items():
+        subject = data.get("subject", "")
+        body = data.get("body", "")
+        text += f"\n\n{name}:"
+        text += f"\n  Subject: {subject}"
+        text += f"\n  Body: {body[:80]}{'...' if len(body) > 80 else ''}"
+
+    format_output(args, text, json_data=template_list)
+
+
+def cmd_templates_create(args) -> None:
+    """Create or update a template."""
+    name = args.name
+    templates = _load_templates()
+
+    # Check if interactive or flag-based
+    if args.subject is None or args.body is None:
+        # Interactive mode
+        print(f"Creating template '{name}'")
+        print("Enter subject (use {{original_subject}} as placeholder):")
+        subject = input("> ").strip()
+        print("Enter body:")
+        body = input("> ").strip()
+    else:
+        subject = args.subject
+        body = args.body
+
+    templates[name] = {"subject": subject, "body": body}
+    _save_templates(templates)
+
+    data = {"name": name, "subject": subject, "body": body}
+    text = f"Template '{name}' saved successfully!\n\nSubject: {subject}\nBody: {body}"
+    format_output(args, text, json_data=data)
+
+
+def cmd_templates_show(args) -> None:
+    """Show a specific template."""
+    name = args.name
+    templates = _load_templates()
+
+    if name not in templates:
+        die(f"Template '{name}' not found. Use 'mxctl templates list' to see available templates.")
+
+    template = templates[name]
+    subject = template.get("subject", "")
+    body = template.get("body", "")
+
+    data = {"name": name, "subject": subject, "body": body}
+    text = f"Template: {name}\n\nSubject: {subject}\n\nBody:\n{body}"
+    format_output(args, text, json_data=data)
+
+
+def cmd_templates_delete(args) -> None:
+    """Delete a template."""
+    name = args.name
+    templates = _load_templates()
+
+    if name not in templates:
+        die(f"Template '{name}' not found.")
+
+    del templates[name]
+    _save_templates(templates)
+
+    data = {"name": name, "deleted": True}
+    text = f"Template '{name}' deleted successfully."
+    format_output(args, text, json_data=data)
+
+
+def register(subparsers) -> None:
+    """Register email templates subcommands."""
+    # Create templates subcommand group
+    templates_parser = subparsers.add_parser("templates", help="Manage email templates")
+    templates_sub = templates_parser.add_subparsers(dest="templates_command")
+
+    # list
+    p = templates_sub.add_parser("list", help="List all saved templates")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_templates_list)
+
+    # create
+    p = templates_sub.add_parser("create", help="Create or update a template")
+    p.add_argument("name", help="Template name")
+    p.add_argument("--subject", help="Template subject (use {original_subject} as placeholder)")
+    p.add_argument("--body", help="Template body")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_templates_create)
+
+    # show
+    p = templates_sub.add_parser("show", help="Show a specific template")
+    p.add_argument("name", help="Template name")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_templates_show)
+
+    # delete
+    p = templates_sub.add_parser("delete", help="Delete a template")
+    p.add_argument("name", help="Template name")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_templates_delete)
+
+    # If `mxctl templates` is run with no subcommand, show help
+    templates_parser.set_defaults(func=lambda _: templates_parser.print_help())

mxctl/commands/mail/todoist_integration.py

@@ -0,0 +1,145 @@
+"""Todoist integration: create tasks from emails."""
+
+import json
+import ssl
+import urllib.error
+import urllib.request
+
+from mxctl.config import (
+    APPLESCRIPT_TIMEOUT_SHORT,
+    FIELD_SEPARATOR,
+    get_config,
+)
+from mxctl.util.applescript import run, validate_msg_id
+from mxctl.util.formatting import die, format_output
+from mxctl.util.mail_helpers import resolve_message_context
+
+# ---------------------------------------------------------------------------
+# to-todoist — create a Todoist task from an email
+# ---------------------------------------------------------------------------
+
+def cmd_to_todoist(args) -> None:
+    """Create a Todoist task from an email."""
+    account, mailbox, acct_escaped, mb_escaped = resolve_message_context(args)
+    message_id = validate_msg_id(args.id)
+    project = getattr(args, "project", None)
+    priority = getattr(args, "priority", 1)
+    due = getattr(args, "due", None)
+
+    # Get Todoist API token from config
+    cfg = get_config()
+    token = cfg.get("todoist_api_token")
+    if not token:
+        die("Todoist API token not configured. Add 'todoist_api_token' to ~/.config/mxctl/config.json")
+    # Validate token format before making any network calls (prevents silent hangs
+    # caused by malformed auth headers or non-string token values)
+    if not isinstance(token, str) or not token.strip():
+        die("Todoist API token is invalid. Check 'todoist_api_token' in ~/.config/mxctl/config.json")
+
+    ssl_context = ssl.create_default_context(cafile="/etc/ssl/cert.pem")
+
+    # Read the email via AppleScript
+    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}
+        set msgSubject to subject of theMsg
+        set msgSender to sender of theMsg
+        set msgDate to date received of theMsg
+        return msgSubject & "{FIELD_SEPARATOR}" & msgSender & "{FIELD_SEPARATOR}" & (msgDate as text)
+    end tell
+    """
+
+    result = run(script, timeout=APPLESCRIPT_TIMEOUT_SHORT)
+    parts = result.split(FIELD_SEPARATOR)
+    if len(parts) < 3:
+        die(f"Failed to read message {message_id}.")
+
+    subject, sender, date = parts[0], parts[1], parts[2]
+
+    # Resolve project name to ID if provided
+    project_id = None
+    if project:
+        projects_req = urllib.request.Request(
+            "https://api.todoist.com/api/v1/projects",
+            headers={"Authorization": f"Bearer {token}"},
+            method="GET",
+        )
+        try:
+            with urllib.request.urlopen(projects_req, context=ssl_context, timeout=APPLESCRIPT_TIMEOUT_SHORT) as resp:
+                projects_data = json.loads(resp.read().decode("utf-8"))
+            # API v1 returns paginated {"results": [...], "next_cursor": ...}
+            projects = projects_data.get("results", projects_data) if isinstance(projects_data, dict) else projects_data
+            match = next((p for p in projects if p.get("name", "").lower() == project.lower()), None)
+            if match is None:
+                die(f"Todoist project '{project}' not found. Check the name and try again.")
+            project_id = match["id"]
+        except (ssl.SSLError, ssl.CertificateError):
+            die("SSL certificate error. Try running: /usr/bin/python3 /Applications/Python*/Install\\ Certificates.command")
+        except urllib.error.HTTPError as e:
+            die(f"Todoist API error resolving project ({e.code}): {e.read().decode('utf-8')}")
+        except urllib.error.URLError as e:
+            die(f"Network error resolving project: {e.reason}")
+        except TimeoutError:
+            die(f"Todoist API timed out resolving project (>{APPLESCRIPT_TIMEOUT_SHORT}s). Check your network or try again.")
+
+    # Build Todoist task payload
+    task_data = {
+        "content": subject,
+        "description": f"From: {sender}\nDate: {date}\nMessage ID: {message_id}",
+        "priority": priority,
+    }
+    if project_id:
+        task_data["project_id"] = project_id
+    if due:
+        task_data["due_string"] = due
+
+    # Make request to Todoist API
+    url = "https://api.todoist.com/api/v1/tasks"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+    }
+    req = urllib.request.Request(
+        url,
+        data=json.dumps(task_data).encode("utf-8"),
+        headers=headers,
+        method="POST"
+    )
+
+    try:
+        with urllib.request.urlopen(req, context=ssl_context, timeout=APPLESCRIPT_TIMEOUT_SHORT) as response:
+            response_data = json.loads(response.read().decode("utf-8"))
+            task_url = response_data.get("url")
+
+            text = f"Created Todoist task: {subject}"
+            if task_url:
+                text += f"\nURL: {task_url}"
+
+            format_output(args, text, json_data=response_data)
+    except (ssl.SSLError, ssl.CertificateError):
+        die("SSL certificate error. Try running: /usr/bin/python3 /Applications/Python*/Install\\ Certificates.command")
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode("utf-8")
+        die(f"Todoist API error ({e.code}): {error_body}")
+    except urllib.error.URLError as e:
+        die(f"Network error: {e.reason}")
+    except TimeoutError:
+        die(f"Todoist API timed out creating task (>{APPLESCRIPT_TIMEOUT_SHORT}s). Check your network or try again.")
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+def register(subparsers) -> None:
+    # to-todoist
+    p = subparsers.add_parser("to-todoist", help="Create Todoist task from email")
+    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("--project", help="Todoist project name (resolves to project ID via API; task goes to Inbox if omitted)")
+    p.add_argument("--priority", type=int, choices=[1, 2, 3, 4], default=1, help="Priority (1-4, 4=highest)")
+    p.add_argument("--due", help="Due date (natural language, e.g. 'tomorrow')")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_to_todoist)

mxctl/commands/mail/undo.py

@@ -0,0 +1,323 @@
+"""Batch operation undo: undo, undo --list."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime
+
+from mxctl.config import (
+    APPLESCRIPT_TIMEOUT_LONG,
+    CONFIG_DIR,
+    UNDO_LOG_FILE,
+    file_lock,
+)
+from mxctl.util.applescript import escape, run
+from mxctl.util.formatting import die, format_output
+
+MAX_UNDO_OPERATIONS = 10
+UNDO_MAX_AGE_MINUTES = 30
+
+
+def _entry_age_minutes(entry: dict) -> float | None:
+    """Return the age of an undo entry in minutes, or None if timestamp is missing/invalid."""
+    ts = entry.get("timestamp")
+    if not ts:
+        return None
+    try:
+        entry_time = datetime.fromisoformat(ts)
+        return (datetime.now() - entry_time).total_seconds() / 60
+    except (ValueError, TypeError):
+        return None
+
+
+def _is_fresh(entry: dict) -> bool:
+    """Return True if the undo entry is younger than UNDO_MAX_AGE_MINUTES."""
+    age = _entry_age_minutes(entry)
+    if age is None:
+        return False
+    return age < UNDO_MAX_AGE_MINUTES
+
+
+def _load_undo_log(include_stale: bool = False) -> list[dict]:
+    """Load undo log from disk.
+
+    By default, only returns entries younger than UNDO_MAX_AGE_MINUTES.
+    Pass include_stale=True to load all entries regardless of age.
+    """
+    if not os.path.isfile(UNDO_LOG_FILE):
+        return []
+    with file_lock(UNDO_LOG_FILE), open(UNDO_LOG_FILE) as f:
+        try:
+            raw = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return []
+    if include_stale:
+        return list(raw)
+    return [entry for entry in raw if _is_fresh(entry)]
+
+
+def _save_undo_log(operations: list[dict]) -> None:
+    """Save undo log to disk, keeping only the last MAX_UNDO_OPERATIONS."""
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    # Keep only the most recent operations
+    trimmed = operations[-MAX_UNDO_OPERATIONS:]
+    with file_lock(UNDO_LOG_FILE), open(UNDO_LOG_FILE, "w") as f:
+        json.dump(trimmed, f, indent=2)
+
+
+def log_batch_operation(
+    operation_type: str,
+    account: str,
+    message_ids: list[int],
+    source_mailbox: str | None = None,
+    dest_mailbox: str | None = None,
+    sender: str | None = None,
+    older_than_days: int | None = None,
+) -> None:
+    """Log a batch operation for potential undo."""
+    operations = _load_undo_log()
+    operations.append({
+        "timestamp": datetime.now().isoformat(),
+        "operation": operation_type,
+        "account": account,
+        "message_ids": message_ids,
+        "source_mailbox": source_mailbox,
+        "dest_mailbox": dest_mailbox,
+        "sender": sender,
+        "older_than_days": older_than_days,
+    })
+    _save_undo_log(operations)
+
+
+def log_fence_operation(operation_type: str) -> None:
+    """Log a fence sentinel for operations that cannot be undone (e.g. batch-read, batch-flag).
+
+    This claims the undo slot so that a subsequent `mxctl undo` does not silently
+    skip past these operations and accidentally undo an earlier undoable entry.
+    """
+    operations = _load_undo_log(include_stale=True)
+    operations.append({
+        "type": "fence",
+        "operation": operation_type,
+        "timestamp": datetime.now().isoformat(),
+    })
+    _save_undo_log(operations)
+
+
+def cmd_undo_list(args) -> None:
+    """List recent undoable operations."""
+    operations = _load_undo_log()
+    if not operations:
+        format_output(args, "No recent batch operations to undo.",
+                      json_data={"operations": []})
+        return
+
+    # Build text output
+    text = f"Recent batch operations ({len(operations)}):"
+    for i, op in enumerate(reversed(operations), 1):
+        is_fence = op.get("type") == "fence"
+        prefix = "[no undo] " if is_fence else ""
+        ts = op.get("timestamp", "")
+        text += f"\n  {i}. {prefix}{op['operation']} — {ts}"
+        if not is_fence:
+            if op.get("sender"):
+                text += f" from {op['sender']}"
+            if op.get("source_mailbox"):
+                text += f" from {op['source_mailbox']}"
+            if op.get("dest_mailbox"):
+                text += f" to {op['dest_mailbox']}"
+            if op.get("older_than_days"):
+                text += f" (older than {op['older_than_days']} days)"
+            text += f" ({len(op.get('message_ids', []))} messages)"
+
+    format_output(args, text, json_data={"operations": list(reversed(operations))})
+
+
+def cmd_undo(args) -> None:
+    """Undo the most recent batch operation."""
+    force = getattr(args, "force", False)
+
+    # Load all entries (including stale) so we can give a helpful message when
+    # there ARE entries but they're older than the freshness window.
+    all_ops = _load_undo_log(include_stale=True)
+    fresh_ops = [op for op in all_ops if _is_fresh(op)]
+
+    if not all_ops:
+        die("No recent batch operations to undo.")
+
+    if not fresh_ops and not force:
+        # There are entries but they're all stale — tell the user.
+        most_recent = all_ops[-1]
+        age = _entry_age_minutes(most_recent)
+        age_str = f"{int(age)} minutes ago" if age is not None else "unknown time ago"
+        die(
+            f"Nothing recent to undo (most recent operation was {age_str}). "
+            f"Run `mxctl undo --list` to see older operations and use "
+            f"`mxctl undo --force` to run them."
+        )
+
+    operations = fresh_ops if not force else all_ops
+    if not operations:
+        die("No batch operations to undo.")
+
+    # Pop the most recent operation — do NOT write the log yet;
+    # only commit removal after the restore work succeeds.
+    last_op = operations.pop()
+
+    # Fence sentinel: operation was run but cannot be undone.
+    if last_op.get("type") == "fence":
+        op_name = last_op.get("operation", "unknown")
+        if not force:
+            die(
+                f"The most recent operation ({op_name}) cannot be undone. "
+                f"Use `mxctl undo --list` to see older undoable operations, "
+                f"or `mxctl undo --force` to skip to the next undoable entry."
+            )
+        # --force: pop the fence and continue to the next entry
+        if not operations:
+            die("No undoable operations remain after skipping the fence.")
+        last_op = operations.pop()
+
+    operation_type = last_op["operation"]
+    account = last_op["account"]
+    message_ids = last_op.get("message_ids", [])
+
+    if not message_ids:
+        die(f"No message IDs recorded for operation '{operation_type}'. Cannot undo.")
+
+    acct_escaped = escape(account)
+
+    try:
+        if operation_type == "batch-move":
+            # Reverse move: move messages back from dest
+            # Note: batch-move can pull from multiple source mailboxes, so we move back to INBOX as default
+            dest_mailbox = last_op.get("dest_mailbox")
+            if not dest_mailbox:
+                die("Incomplete operation data. Cannot undo batch-move.")
+
+            # Move messages back from dest to INBOX (safest default since source could be multiple mailboxes)
+            dest_escaped = escape(dest_mailbox)
+            inbox_escaped = escape("INBOX")
+
+            # Build AppleScript to move messages back
+            # We'll iterate through message_ids and try to move them
+            id_list = ", ".join(str(mid) for mid in message_ids)
+
+            script = f"""
+            tell application "Mail"
+                set acct to account "{acct_escaped}"
+                set destMb to mailbox "{dest_escaped}" of acct
+                set inboxMb to mailbox "{inbox_escaped}" of acct
+                set movedCount to 0
+                set targetIds to {{{id_list}}}
+                repeat with targetId in targetIds
+                    try
+                        set msgs to (every message of destMb whose id is targetId)
+                        if (count of msgs) > 0 then
+                            set m to item 1 of msgs
+                            move m to inboxMb
+                            set movedCount to movedCount + 1
+                        end if
+                    end try
+                end repeat
+                return movedCount
+            end tell
+            """
+
+            result = run(script, timeout=APPLESCRIPT_TIMEOUT_LONG)
+            moved = int(result) if result.isdigit() else 0
+            sender = last_op.get("sender", "unknown sender")
+            _save_undo_log(operations)  # commit removal only on success
+            total = len(message_ids)
+            if moved == 0:
+                msg = f"Nothing to restore (0 of {total} messages found — they may have already been moved or deleted)."
+            else:
+                msg = f"Undid batch-move: moved {moved}/{total} messages from '{sender}' back to INBOX from '{dest_mailbox}'."
+            format_output(args, msg,
+                          json_data={
+                              "operation": "undo-batch-move",
+                              "account": account,
+                              "from_mailbox": dest_mailbox,
+                              "to_mailbox": "INBOX",
+                              "sender": sender,
+                              "restored": moved,
+                              "total": len(message_ids),
+                          })
+
+        elif operation_type == "batch-delete":
+            # Reverse delete: move messages from Trash back to source_mailbox (or INBOX if unknown)
+            source_mailbox = last_op.get("source_mailbox")
+            restore_mailbox = source_mailbox if source_mailbox else "INBOX"
+            restore_note = None if source_mailbox else "Original mailbox unknown; restored to INBOX."
+
+            trash_escaped = escape("Trash")
+            restore_escaped = escape(restore_mailbox)
+
+            id_list = ", ".join(str(mid) for mid in message_ids)
+
+            script = f"""
+            tell application "Mail"
+                set acct to account "{acct_escaped}"
+                set trashMb to mailbox "{trash_escaped}" of acct
+                set restoreMb to mailbox "{restore_escaped}" of acct
+                set movedCount to 0
+                set targetIds to {{{id_list}}}
+                repeat with targetId in targetIds
+                    try
+                        set msgs to (every message of trashMb whose id is targetId)
+                        if (count of msgs) > 0 then
+                            set m to item 1 of msgs
+                            move m to restoreMb
+                            set movedCount to movedCount + 1
+                        end if
+                    end try
+                end repeat
+                return movedCount
+            end tell
+            """
+
+            result = run(script, timeout=APPLESCRIPT_TIMEOUT_LONG)
+            moved = int(result) if result.isdigit() else 0
+            sender = last_op.get("sender", "unknown sender")
+            total = len(message_ids)
+            if moved == 0:
+                msg = f"Nothing to restore (0 of {total} messages found — they may have already been moved or deleted)."
+            else:
+                msg = f"Undid batch-delete: moved {moved}/{total} messages from Trash back to '{restore_mailbox}'."
+            if restore_note and moved > 0:
+                msg += f" Note: {restore_note}"
+            json_result = {
+                "operation": "undo-batch-delete",
+                "account": account,
+                "from_mailbox": "Trash",
+                "to_mailbox": restore_mailbox,
+                "sender": sender,
+                "restored": moved,
+                "total": len(message_ids),
+            }
+            if restore_note:
+                json_result["note"] = restore_note
+            _save_undo_log(operations)  # commit removal only on success
+            format_output(args, msg, json_data=json_result)
+
+        else:
+            die(f"Unknown operation type '{operation_type}'. Cannot undo.")
+
+    except (Exception, KeyboardInterrupt):
+        operations.append(last_op)
+        _save_undo_log(operations)  # put it back
+        raise
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+def register(subparsers) -> None:
+    """Register undo mail subcommands."""
+    p = subparsers.add_parser("undo", help="Undo most recent batch operation")
+    p.add_argument("--list", action="store_true", dest="list_operations", help="List recent undoable operations")
+    p.add_argument("--force", action="store_true", help="Bypass the 30-minute freshness check")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=lambda args: cmd_undo_list(args) if args.list_operations else cmd_undo(args))