mxctl 0.3.0__py3-none-any.whl

mxctl/commands/mail/batch.py

@@ -0,0 +1,402 @@
+"""Batch mail operations: batch-read, batch-flag, batch-move, batch-delete."""
+
+import sys
+from datetime import datetime, timedelta
+
+from mxctl.commands.mail.undo import log_batch_operation, log_fence_operation
+from mxctl.config import (
+    APPLESCRIPT_TIMEOUT_LONG,
+    DEFAULT_MAILBOX,
+    resolve_account,
+)
+from mxctl.util.applescript import escape, run
+from mxctl.util.dates import to_applescript_date
+from mxctl.util.formatting import die, format_output
+from mxctl.util.mail_helpers import resolve_mailbox
+
+# ---------------------------------------------------------------------------
+# batch-read — mark all as read in a mailbox
+# ---------------------------------------------------------------------------
+
+def cmd_batch_read(args) -> None:
+    """Mark all messages as read in a mailbox."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+    mailbox = getattr(args, "mailbox", None) or DEFAULT_MAILBOX
+    limit = getattr(args, "limit", None) or 25
+
+    acct_escaped = escape(account)
+    mb_escaped = escape(mailbox)
+
+    script = f"""
+    tell application "Mail"
+        set mb to mailbox "{mb_escaped}" of account "{acct_escaped}"
+        set unreadMsgs to (every message of mb whose read status is false)
+        set ct to count of unreadMsgs
+        set cap to {limit}
+        if ct < cap then set cap to ct
+        repeat with i from 1 to cap
+            set m to item i of unreadMsgs
+            set read status of m to true
+        end repeat
+        return cap
+    end tell
+    """
+
+    result = run(script)
+    count = int(result) if result.isdigit() else 0
+    log_fence_operation("batch-read")
+    format_output(args, f"Marked {count} messages as read in {mailbox} [{account}] (limit: {limit}).",
+                  json_data={"mailbox": mailbox, "account": account, "marked_read": count, "limit": limit})
+    print(f"Note: batch-read operations are not tracked in undo history. Use --limit N to cap scope (current: {limit} messages).", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# batch-flag — flag all from a sender
+# ---------------------------------------------------------------------------
+
+def cmd_batch_flag(args) -> None:
+    """Flag all messages from a specific sender."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+    sender = getattr(args, "from_sender", None)
+    if not sender:
+        die("--from-sender is required.")
+    limit = getattr(args, "limit", None) or 25
+
+    acct_escaped = escape(account)
+    sender_escaped = escape(sender)
+
+    script = f"""
+    tell application "Mail"
+        set output to 0
+        repeat with mbox in (mailboxes of account "{acct_escaped}")
+            if output >= {limit} then exit repeat
+            set msgs to (every message of mbox whose sender contains "{sender_escaped}")
+            repeat with m in msgs
+                if output >= {limit} then exit repeat
+                set flagged status of m to true
+                set output to output + 1
+            end repeat
+        end repeat
+        return output
+    end tell
+    """
+
+    result = run(script)
+    count = int(result) if result.isdigit() else 0
+    log_fence_operation("batch-flag")
+    format_output(args, f"Flagged {count} messages from '{sender}' in account '{account}' (limit: {limit}).",
+                  json_data={"sender": sender, "account": account, "flagged": count, "limit": limit})
+    print(f"Note: batch-flag operations are not tracked in undo history. Use --limit N to cap scope (current: {limit} messages).", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# batch-move — move all messages from a sender to a folder
+# ---------------------------------------------------------------------------
+
+def cmd_batch_move(args) -> None:
+    """Move all messages from a sender to a mailbox."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+    sender = getattr(args, "from_sender", None)
+    if not sender:
+        die("--from-sender is required.")
+    dest_mailbox = getattr(args, "to_mailbox", None)
+    if not dest_mailbox:
+        die("--to-mailbox is required.")
+    dest_mailbox = resolve_mailbox(account, dest_mailbox)
+
+    dry_run = getattr(args, "dry_run", False)
+    limit = getattr(args, "limit", None)
+
+    acct_escaped = escape(account)
+    sender_escaped = escape(sender)
+    dest_escaped = escape(dest_mailbox)
+
+    # First, count matching messages
+    count_script = f"""
+    tell application "Mail"
+        set output to 0
+        repeat with mbox in (mailboxes of account "{acct_escaped}")
+            set msgs to (every message of mbox whose sender contains "{sender_escaped}")
+            set output to output + (count of msgs)
+        end repeat
+        return output
+    end tell
+    """
+
+    count_result = run(count_script)
+    total_count = int(count_result) if count_result.isdigit() else 0
+
+    if total_count == 0:
+        format_output(args, f"No messages found from sender '{sender}'.",
+                      json_data={"sender": sender, "account": account, "moved": 0})
+        return
+
+    if dry_run:
+        effective_count = min(total_count, limit) if limit else total_count
+        format_output(args, f"Dry run: Would move {effective_count} messages from '{sender}' to '{dest_mailbox}'.",
+                      json_data={"sender": sender, "to_mailbox": dest_mailbox, "account": account, "would_move": effective_count, "total_matching": total_count, "dry_run": True})
+        return
+
+    # Actually move the messages and collect their IDs for undo logging
+    limit_clause = f"if moveCount >= {limit} then exit repeat" if limit else ""
+
+    move_script = f"""
+    tell application "Mail"
+        set destMb to mailbox "{dest_escaped}" of account "{acct_escaped}"
+        set moveCount to 0
+        set movedIds to {{}}
+        repeat with mbox in (mailboxes of account "{acct_escaped}")
+            {limit_clause}
+            set sourceMbName to name of mbox
+            set msgs to (every message of mbox whose sender contains "{sender_escaped}")
+            repeat with m in msgs
+                {limit_clause}
+                try
+                    set msgId to id of m
+                    move m to destMb
+                    set end of movedIds to msgId
+                    set moveCount to moveCount + 1
+                end try
+            end repeat
+        end repeat
+        set output to (moveCount as text)
+        repeat with msgId in movedIds
+            set output to output & linefeed & (msgId as text)
+        end repeat
+        return output
+    end tell
+    """
+
+    result = run(move_script, timeout=APPLESCRIPT_TIMEOUT_LONG)
+    lines = result.strip().split("\n")
+    moved = int(lines[0]) if lines and lines[0].isdigit() else 0
+    message_ids = [int(line) for line in lines[1:] if line.isdigit()]
+
+    # Log the operation for undo
+    if moved > 0:
+        # We don't track source mailbox per-message, so we'll use None
+        # The undo will move from dest back to the original location
+        log_batch_operation(
+            operation_type="batch-move",
+            account=account,
+            message_ids=message_ids,
+            source_mailbox=None,  # Multiple source mailboxes possible
+            dest_mailbox=dest_mailbox,
+            sender=sender,
+        )
+
+    format_output(args, f"Moved {moved} messages from '{sender}' to '{dest_mailbox}'.",
+                  json_data={"sender": sender, "to_mailbox": dest_mailbox, "account": account, "moved": moved})
+
+
+# ---------------------------------------------------------------------------
+# batch-delete — delete messages by sender and/or age from a mailbox
+# ---------------------------------------------------------------------------
+
+def cmd_batch_delete(args) -> None:
+    """Delete messages matching sender and/or age filters."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+
+    mailbox = getattr(args, "mailbox", None)
+    older_than_days = getattr(args, "older_than", None)
+    sender = getattr(args, "from_sender", None)
+    dry_run = getattr(args, "dry_run", False)
+    force = getattr(args, "force", False)
+    limit = getattr(args, "limit", None)
+
+    if older_than_days is None and sender is None:
+        die("Specify --older-than <days>, --from-sender <email>, or both.")
+
+    # --older-than without --from-sender still requires --mailbox for safety
+    if older_than_days is not None and sender is None and not mailbox:
+        die("--mailbox is required when using --older-than without --from-sender.")
+
+    if mailbox:
+        mailbox = resolve_mailbox(account, mailbox)
+
+    acct_escaped = escape(account)
+
+    # Build AppleScript whose-clause
+    where_parts = []
+    if older_than_days is not None:
+        cutoff_dt = datetime.now() - timedelta(days=older_than_days)
+        cutoff_applescript = to_applescript_date(cutoff_dt)
+        where_parts.append(f'date received < date "{cutoff_applescript}"')
+    if sender:
+        sender_escaped = escape(sender)
+        where_parts.append(f'sender contains "{sender_escaped}"')
+    where_clause = " and ".join(where_parts)
+
+    # Human-readable descriptions for output
+    scope_desc = f"'{mailbox}'" if mailbox else "all mailboxes"
+    filter_parts = []
+    if sender:
+        filter_parts.append(f"from '{sender}'")
+    if older_than_days is not None:
+        filter_parts.append(f"older than {older_than_days} days")
+    filter_desc = " and ".join(filter_parts)
+
+    # Count matching messages
+    if mailbox:
+        mb_escaped = escape(mailbox)
+        count_script = f"""
+        tell application "Mail"
+            set mb to mailbox "{mb_escaped}" of account "{acct_escaped}"
+            set targetMsgs to (every message of mb whose {where_clause})
+            return count of targetMsgs
+        end tell
+        """
+    else:
+        count_script = f"""
+        tell application "Mail"
+            set total to 0
+            repeat with mbox in (mailboxes of account "{acct_escaped}")
+                set targetMsgs to (every message of mbox whose {where_clause})
+                set total to total + (count of targetMsgs)
+            end repeat
+            return total
+        end tell
+        """
+
+    count_result = run(count_script)
+    total_count = int(count_result) if count_result.isdigit() else 0
+
+    if total_count == 0:
+        format_output(args, f"No messages found {filter_desc} in {scope_desc}.",
+                      json_data={"account": account, "mailbox": mailbox, "sender": sender,
+                                 "older_than_days": older_than_days, "deleted": 0})
+        return
+
+    if dry_run:
+        effective_count = min(total_count, limit) if limit else total_count
+        format_output(args, f"Dry run: Would delete {effective_count} messages {filter_desc} from {scope_desc}.",
+                      json_data={"account": account, "mailbox": mailbox, "sender": sender,
+                                 "older_than_days": older_than_days, "would_delete": effective_count, "total_matching": total_count, "dry_run": True})
+        return
+
+    if not force:
+        die(f"This will delete {total_count} messages {filter_desc} from {scope_desc}. Use --force to confirm.")
+
+    # Build delete script
+    # Use "repeat with m in list" (not indexed) so deletions don't shift remaining references.
+    # Wrap each delete in try/end try so a single failure (e.g. Gmail All Mail quirk) doesn't
+    # abort the whole batch — failures are silently skipped and the count reflects actual deletes.
+    limit_check = f"if deleteCount >= {limit} then exit repeat" if limit else ""
+    if mailbox:
+        mb_escaped = escape(mailbox)
+        delete_script = f"""
+        tell application "Mail"
+            set mb to mailbox "{mb_escaped}" of account "{acct_escaped}"
+            set targetMsgs to (every message of mb whose {where_clause})
+            set deleteCount to 0
+            set deletedIds to {{}}
+            repeat with m in targetMsgs
+                {limit_check}
+                try
+                    set msgId to id of m
+                    delete m
+                    set end of deletedIds to msgId
+                    set deleteCount to deleteCount + 1
+                end try
+            end repeat
+            set output to (deleteCount as text)
+            repeat with msgId in deletedIds
+                set output to output & linefeed & (msgId as text)
+            end repeat
+            return output
+        end tell
+        """
+    else:
+        delete_script = f"""
+        tell application "Mail"
+            set deleteCount to 0
+            set deletedIds to {{}}
+            repeat with mbox in (mailboxes of account "{acct_escaped}")
+                {limit_check}
+                set targetMsgs to (every message of mbox whose {where_clause})
+                repeat with m in targetMsgs
+                    {limit_check}
+                    try
+                        set msgId to id of m
+                        delete m
+                        set end of deletedIds to msgId
+                        set deleteCount to deleteCount + 1
+                    end try
+                end repeat
+            end repeat
+            set output to (deleteCount as text)
+            repeat with msgId in deletedIds
+                set output to output & linefeed & (msgId as text)
+            end repeat
+            return output
+        end tell
+        """
+
+    result = run(delete_script, timeout=APPLESCRIPT_TIMEOUT_LONG)
+    lines = result.strip().split("\n")
+    deleted = int(lines[0]) if lines and lines[0].isdigit() else 0
+    message_ids = [int(line) for line in lines[1:] if line.isdigit()]
+
+    if deleted > 0:
+        log_batch_operation(
+            operation_type="batch-delete",
+            account=account,
+            message_ids=message_ids,
+            source_mailbox=mailbox,
+            dest_mailbox=None,
+            sender=sender,
+            older_than_days=older_than_days,
+        )
+
+    format_output(args, f"Deleted {deleted} messages {filter_desc} from {scope_desc}.",
+                  json_data={"account": account, "mailbox": mailbox, "sender": sender,
+                             "older_than_days": older_than_days, "deleted": deleted})
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+def register(subparsers) -> None:
+    """Register batch mail subcommands."""
+    p = subparsers.add_parser("batch-read", help="Mark messages as read in a mailbox")
+    p.add_argument("-a", "--account", help="Mail account name")
+    p.add_argument("-m", "--mailbox", help="Mailbox name (default: INBOX)")
+    p.add_argument("--limit", type=int, default=25, help="Maximum number of messages to mark read (default: 25)")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_batch_read)
+
+    p = subparsers.add_parser("batch-flag", help="Flag messages from a sender")
+    p.add_argument("--from-sender", required=True, help="Sender email to match")
+    p.add_argument("-a", "--account", help="Mail account name")
+    p.add_argument("--limit", type=int, default=25, help="Maximum number of messages to flag (default: 25)")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_batch_flag)
+
+    p = subparsers.add_parser("batch-move", help="Move all messages from a sender to a mailbox")
+    p.add_argument("--from-sender", required=True, help="Sender email to match")
+    p.add_argument("--to-mailbox", required=True, help="Destination mailbox")
+    p.add_argument("-a", "--account", help="Mail account name")
+    p.add_argument("--dry-run", action="store_true", help="Show what would be moved without moving")
+    p.add_argument("--limit", type=int, help="Maximum number of messages to move")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_batch_move)
+
+    p = subparsers.add_parser("batch-delete", help="Delete messages by sender and/or age")
+    p.add_argument("--from-sender", help="Delete messages from this sender (across all mailboxes, or use -m to scope)")
+    p.add_argument("--older-than", type=int, help="Delete messages older than N days (requires -m when used alone)")
+    p.add_argument("-m", "--mailbox", help="Scope to a specific mailbox (required when using --older-than alone)")
+    p.add_argument("-a", "--account", help="Mail account name")
+    p.add_argument("--dry-run", action="store_true", help="Show what would be deleted without deleting")
+    p.add_argument("--limit", type=int, help="Maximum number of messages to delete")
+    p.add_argument("--force", action="store_true", help="Skip confirmation prompt")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_batch_delete)

mxctl/commands/mail/compose.py

@@ -0,0 +1,133 @@
+"""Draft creation command."""
+
+import json
+import os
+
+from mxctl.config import TEMPLATES_FILE, file_lock, resolve_account
+from mxctl.util.applescript import escape, run
+from mxctl.util.formatting import die, format_output
+
+
+def cmd_draft(args) -> None:
+    """Create a draft email for manual review and sending."""
+    account = resolve_account(getattr(args, "account", None))
+    if not account:
+        die("Account required. Use -a ACCOUNT.")
+
+    to_addr = args.to
+    subject = args.subject
+    body = args.body
+    cc = getattr(args, "cc", None)
+    bcc = getattr(args, "bcc", None)
+
+    # Handle template loading
+    template_name = getattr(args, "template", None)
+    if template_name:
+        if os.path.isfile(TEMPLATES_FILE):
+            with file_lock(TEMPLATES_FILE), open(TEMPLATES_FILE) as f:
+                try:
+                    templates = json.load(f)
+                except (json.JSONDecodeError, OSError):
+                    die("Templates file is corrupt. Run 'mxctl templates list' to diagnose.")
+            if template_name not in templates:
+                die(f"Template '{template_name}' not found. Use 'mxctl templates list' to see available templates.")
+            template = templates[template_name]
+            # Apply template, allowing flag overrides
+            if not subject:
+                subject = template.get("subject", "")
+            if not body:
+                body = template.get("body", "")
+        else:
+            die("No templates file found. Create templates with 'mxctl templates create'.")
+
+    # Validate that we have subject and body
+    if not subject:
+        die("Subject required. Use --subject or --template.")
+    if not body:
+        die("Body required. Use --body or --template.")
+
+    acct_escaped = escape(account)
+    subject_escaped = escape(subject)
+    body_escaped = escape(body)
+
+    to_commands = []
+    for addr in to_addr.split(","):
+        addr = addr.strip()
+        if addr:
+            to_commands.append(
+                f'make new to recipient at end of to recipients with properties {{address:"{escape(addr)}"}}'
+            )
+
+    cc_commands = []
+    if cc:
+        for addr in cc.split(","):
+            addr = addr.strip()
+            if addr:
+                cc_commands.append(
+                    f'make new cc recipient at end of cc recipients with properties {{address:"{escape(addr)}"}}'
+                )
+
+    bcc_commands = []
+    if bcc:
+        for addr in bcc.split(","):
+            addr = addr.strip()
+            if addr:
+                bcc_commands.append(
+                    f'make new bcc recipient at end of bcc recipients with properties {{address:"{escape(addr)}"}}'
+                )
+
+    all_recipient_commands = "\n        ".join(to_commands + cc_commands + bcc_commands)
+
+    script = f"""
+    tell application "Mail"
+        set emailAddrs to get (email addresses of account "{acct_escaped}")
+        if class of emailAddrs is list then
+            set senderEmail to item 1 of emailAddrs
+        else
+            set senderEmail to emailAddrs
+        end if
+        set newMsg to make new outgoing message with properties {{subject:"{subject_escaped}", content:"{body_escaped}", visible:true}}
+        tell newMsg
+            set sender to senderEmail
+            {all_recipient_commands}
+        end tell
+        return "draft created"
+    end tell
+    """
+
+    run(script)
+
+    data = {
+        "status": "draft_created",
+        "to": to_addr,
+        "subject": subject,
+        "account": account,
+    }
+    if cc:
+        data["cc"] = cc
+    if bcc:
+        data["bcc"] = bcc
+
+    text = f"Draft created successfully!\n\nTo: {to_addr}"
+    if cc:
+        text += f"\nCC: {cc}"
+    if bcc:
+        text += f"\nBCC: {bcc}"
+    text += f"\nSubject: {subject}"
+    text += "\n\nThe draft is open in Mail.app for review. You must manually click Send."
+
+    format_output(args, text, json_data=data)
+
+
+def register(subparsers) -> None:
+    """Register email composition subcommands."""
+    p = subparsers.add_parser("draft", help="Create a draft email (does NOT send)")
+    p.add_argument("--to", required=True, help="Recipient email(s), comma-separated")
+    p.add_argument("--subject", help="Email subject (or use --template)")
+    p.add_argument("--body", help="Email body (plain text, or use --template)")
+    p.add_argument("--template", help="Load subject/body from template (flags override template values)")
+    p.add_argument("--cc", help="CC recipient(s), comma-separated")
+    p.add_argument("--bcc", help="BCC recipient(s), comma-separated")
+    p.add_argument("-a", "--account", help="Mail account to send from")
+    p.add_argument("--json", action="store_true", help="Output as JSON")
+    p.set_defaults(func=cmd_draft)