mailmate 0.2.0 → 1.1.0

data/lib/mailmate/cli/modify.rb

@@ -69,9 +69,10 @@ module Mailmate
           o.banner = <<~BANNER
             Usage: mm-modify <id> <action> [args...] [<action> [args...]]...
 
-            <id> can be either a local eml-id (e.g. 183715) or an RFC Message-ID
-            (with or without angle brackets, e.g. <abc@example.com>). Quote the
-            Message-ID in your shell so the < > aren't interpreted as redirection.
+            <id> can be a local eml-id (e.g. 183715), an RFC Message-ID (with or
+            without angle brackets, e.g. <abc@example.com>), or a message://%3C...%3E
+            URL. Quote the Message-ID in your shell so the < > aren't interpreted as
+            redirection.
 
             Selects the message in MailMate (via the `mid:` URL) and runs one or
             more AppleScript key-binding selectors against the now-selected message.
@@ -86,7 +87,13 @@ module Mailmate
               untag <name>                  Remove IMAP keyword <name>
               clear-tags                    Remove all keywords
               archive                       Move to the archive mailbox
-              move <mailbox-uuid>           Move to a specific mailbox (use UUID from MailMate)
+              move <mailbox>                Move to a specific mailbox. Bare names like 'Archive'
+                                            or 'Folder/Sub' resolve within the same account and
+                                            take a fast path (direct .eml rename — no UI, no
+                                            focus theft). Mailbox UUIDs and cross-account moves
+                                            fall back to the AppleScript driver. Chained with
+                                            other actions: tag/flag/etc. run first at the
+                                            original location, the rename happens last.
               junk / not-junk               Mark as junk / not junk
               mute                          Toggle mute state
               delete                        Delete (move to trash)
@@ -135,6 +142,117 @@ module Mailmate
       end
 
       def drive(eml_id, message_id, actions, opts)
+        # Fast-path moves apply ONLY when every requested action is a move.
+        # When the chain includes any non-move action (tag, flag, archive, …)
+        # we're paying for MailMate's UI anyway, so we let MailMate handle the
+        # move in-UI alongside the rest. Why this beats reordering moves to
+        # the end of the chain:
+        #
+        # - The marginal cost of one extra AppleScript `moveToMailbox:` call
+        #   is small next to the UI activation we're already eating.
+        # - MailMate sees the move it just made — no #source-index staleness
+        #   inside the same invocation or for follow-ups.
+        # - Simpler mental model: pure-move = silent + fast; mixed = all-UI.
+        fast_moves, other = actions.partition { |name, _, _| name == "move" }
+
+        if other.empty? && !fast_moves.empty?
+          current_path = Mailmate::EmlLookup.path_for(eml_id)
+          fast_moves.each do |_name, selector, args|
+            new_path = try_fast_move(eml_id, current_path, args.first, opts)
+            if new_path
+              current_path = new_path
+            else
+              # Fast-path declined for this one move (cross-account, target
+              # not found, perm error, …) — single UI-driven move as fallback.
+              drive_via_applescript(eml_id, message_id, [["move", selector, args]], opts)
+            end
+          end
+        else
+          # Mixed chain (or pure non-move chain): everything goes through the
+          # AppleScript driver in the user-supplied order.
+          drive_via_applescript(eml_id, message_id, actions, opts)
+        end
+      end
+
+      # Returns the new path on success (or in dry-run, the path we *would*
+      # have moved to). Returns nil if the caller should fall back to the
+      # AppleScript driver for this action (cross-account, unknown target,
+      # permission error, …).
+      def try_fast_move(eml_id, current_path, target_spec, opts)
+        return nil if current_path.nil?
+        account_dir = account_dir_for(current_path)
+        return nil if account_dir.nil?
+
+        dest_messages = find_target_in_account(account_dir, target_spec)
+        return nil if dest_messages.nil?
+
+        dest_path = File.join(dest_messages, "#{eml_id}.eml")
+        if dest_path == current_path
+          $stdout.puts "move (fast): #{eml_id}.eml is already in #{target_spec} — no-op"
+          return dest_path
+        end
+
+        if opts[:dry_run]
+          $stdout.puts "move (fast, dry-run): would rename"
+          $stdout.puts "  from: #{current_path}"
+          $stdout.puts "  to:   #{dest_path}"
+          return dest_path
+        end
+
+        File.rename(current_path, dest_path)
+        # The #source index still points at the old location until MailMate
+        # rescans; bust it so any subsequent path_for in this process re-reads
+        # (and eventually picks up MailMate's refreshed value).
+        Mailmate::IndexReader.reset!("#source") if defined?(Mailmate::IndexReader)
+        $stdout.puts "move (fast): renamed #{eml_id}.eml → #{relative_to_imap_root(dest_messages)}"
+        dest_path
+      rescue Errno::EACCES, Errno::EXDEV, Errno::ENOENT, Errno::EEXIST => e
+        warn "move (fast): rename failed (#{e.class}: #{e.message}); falling back to AppleScript"
+        nil
+      end
+
+      # The account directory is the first path segment under imap_root.
+      def account_dir_for(path)
+        imap_root = Mailmate.config.imap_root
+        return nil unless path.start_with?("#{imap_root}/")
+        rel = path.sub("#{imap_root}/", "")
+        first = rel.split("/", 2).first
+        return nil if first.nil? || first.empty?
+        File.join(imap_root, first)
+      end
+
+      # Resolve `target_spec` to a `.../Messages` directory within `account_dir`.
+      # Returns nil if not found unambiguously in the same account — caller
+      # should then fall back to AppleScript (which can handle cross-account
+      # moves, UUIDs, special mailboxes, etc.).
+      def find_target_in_account(account_dir, target_spec)
+        spec = target_spec.to_s.sub(%r{/Messages\z}, "").sub(/\.mailbox\z/, "")
+        return nil if spec.empty?
+
+        # 1. Exact relative path under the account, each segment .mailbox-suffixed.
+        nested = spec.split("/").map { |s| "#{s}.mailbox" }.join("/")
+        cand = File.join(account_dir, nested, "Messages")
+        return cand if File.directory?(cand)
+
+        # 2. Bare-name match anywhere inside the account.
+        matches = Dir.glob(File.join(account_dir, "**", "#{spec}.mailbox", "Messages"))
+                     .select { |p| File.directory?(p) }
+        case matches.size
+        when 0 then nil
+        when 1 then matches.first
+        else
+          warn "move (fast): ambiguous target '#{spec}' in account; matches:"
+          matches.each { |m| warn "  #{m}" }
+          nil
+        end
+      end
+
+      def relative_to_imap_root(path)
+        root = Mailmate.config.imap_root
+        path.start_with?("#{root}/") ? path.sub("#{root}/", "") : path
+      end
+
+      def drive_via_applescript(eml_id, message_id, actions, opts)
         driver  = Mailmate::AppleScriptDriver.new(dry_run: opts[:dry_run])
         mid_url = Mailmate::MidUrl.for(message_id)
 

data/lib/mailmate/cli/open.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Mailmate
+  module CLI
+    # `mmopen` — open one MailMate message in the MailMate UI by handing the
+    # `mid:` URL to macOS's `open`. Read-side (doesn't change message state),
+    # but activates MailMate's window and brings it forward.
+    #
+    # Accepts any of the six id forms `EmlLookup.resolve_id` understands —
+    # eml-id, RFC Message-ID with or without angle brackets, message://… URL,
+    # or mid:… URL.
+    # @api private
+    module Open
+      extend self
+
+      def run(argv)
+        opts = parse_options(argv)
+        input = argv.first
+        return usage_error("missing <id>") if input.nil? || input.empty?
+
+        eml_id = Mailmate::EmlLookup.resolve_id(input)
+        if eml_id.nil? || eml_id.zero?
+          warn "mmopen: not found: #{input.inspect} (couldn't resolve as eml-id or Message-ID)"
+          return 1
+        end
+
+        path = Mailmate::EmlLookup.path_for(eml_id)
+        unless path
+          warn "mmopen: not found: #{eml_id}.eml"
+          return 1
+        end
+
+        message_id = Mailmate::HeaderReader.message_id(path)
+        unless message_id
+          warn "mmopen: could not find Message-ID in #{path}"
+          return 1
+        end
+
+        url = Mailmate::MidUrl.for(message_id)
+        if opts[:print_only]
+          $stdout.puts url
+          return 0
+        end
+
+        system("/usr/bin/open", url)
+        $?.exitstatus
+      end
+
+      def parse_options(argv)
+        opts = { print_only: false }
+        OptionParser.new do |o|
+          o.banner = "Usage: mmopen <id> [--print]"
+          o.separator ""
+          o.separator "Open a MailMate message in MailMate's UI. <id> can be a local"
+          o.separator "eml-id, an RFC Message-ID (with or without angle brackets), or"
+          o.separator "a message://… or mid:… URL."
+          o.on("--print", "Print the mid: URL instead of opening it (for piping)") { opts[:print_only] = true }
+        end.parse!(argv)
+        opts
+      end
+
+      def usage_error(msg)
+        warn "mmopen: #{msg}"
+        warn "Usage: mmopen <id> [--print]"
+        2
+      end
+    end
+  end
+end