mailmate 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b986acdac48e1c98c6cc80ae0cc1686af00161a5de3cc17b0946ea09c43b17e1
-  data.tar.gz: 6867d4736f7c4118ea775c60b108a36dc76a5234312b20a36cb5c60070233712
+  metadata.gz: b2e41c1bf66c9a41c75d683f9e7edcfa2d6ac5982f6a54c2d3cc4b2cbb5c36a8
+  data.tar.gz: 378d1b75d3485de7cf5285e8b12f4fa0ebd7b144b9ebe4a5d4322f6a5d592726
 SHA512:
-  metadata.gz: 45d6fc1c66f4549fdf14a899bdba83d1b7d0510b5a20e9469e75f44d92e8b5285bd4cba548a2524d9561831cd34ee64cf3fe3239829afe8b4dc19aa27e4cdbda
-  data.tar.gz: 7b88d5bb8668614368c969d0e6ba10f14a444594b4fe55fdf6dc14bf536e35b29c8845818bff44b65f880c4c5a724d551b245c23c4f3ee56d78247043da1af9c
+  metadata.gz: 710617dc65666c1eec32f4a6d1e7c4ac15c3aab6ce295548d59edaefacd86863ed2b716246bceb250dd9f7f67c4e3a54701366a3c4c65a6b69321b6df3024587
+  data.tar.gz: a54ee5f4a6cf7ff02c35f6239ab63e805404db1610fa470358ac382bf4870b1fb8176a0990e5a01a24195275e6c603fe44b2d124b9c6829765f222872f874a10

data/README.md

@@ -1,6 +1,6 @@
 # mailmate
 
-Ruby toolkit for [MailMate](https://freron.com) on macOS — a smart-mailbox filter engine, on-disk index readers, and CLI tools (`mmsearch`, `mmmessage`, `mmopen`, `mm-mailboxes`, `mmtags`, `mm-modify`, `mm-send`, `mmdiscover`) for searching, reading, modifying, and sending mail.
+Ruby toolkit for [MailMate](https://freron.com) on macOS — a smart-mailbox filter engine, on-disk index readers, and CLI tools (`mmsearch`, `mmmessage`, `mmopen`, `mm-mailboxes`, `mmtags`, `mm-modify`, `mm-send`, `mm-draft`, `mmdiscover`) for searching, reading, modifying, and sending mail.
 
 **Requires macOS with MailMate installed.** The library code (filter parser, evaluator) works anywhere, but the integration with MailMate itself — AppleScript, on-disk index reads, the `emate` binary — is macOS-only by way of MailMate being macOS-only.
 
@@ -25,6 +25,40 @@ mmsearch 'd 2026-05'
 mmsearch 'f acme' 'id flags subject from' --limit 20 --no-align
 ```
 
+**Quicksearch syntax.** The search-string is a list of specs combined with **AND** (`or`/parens not yet supported). Wrap multi-word terms in `"double quotes"`.
+
+| Modifier | Scope |
+|---|---|
+| _bare term_ | From/To/Cc/Subject **or body** contains (the UI quicksearch default). `--headers-only` skips the body scan. |
+| `f <term>` | From contains. |
+| `t <term>` | To/Cc (recipients) contains. |
+| `c <term>` | Cc contains. |
+| `s <term>` | Subject contains. |
+| `a <term>` | Any address header contains. |
+| `b <term>` | Body (plain text) contains. |
+| `m <term>` | Common headers OR body. |
+| `d <date>` | Received date: `Y`, `Y-M`, `Y-M-D`, or relative `1d`/`2w`/`3m`/`1y`. |
+| `T <tag>` | Tags / IMAP keywords (`K` is a synonym). |
+| `!<value>` | Negate, e.g. `f !smith` = From does NOT contain smith. |
+
+The `--mailbox` argument accepts an account, an `account/path`, a bare mailbox name matched across accounts, or a **smart-mailbox name** (e.g. `Medium`, `Whisper`, `Personal Inbox`) whose filter is ANDed into the search.
+
+**Output fields.** Default columns are `flags date time direction party subject`. Prefix a field list with `+` to add to the defaults; a bare list replaces them (`id` is always the first column).
+
+| Field | What it shows |
+|---|---|
+| `id` | The `.eml` body-part ID (always emitted first). |
+| `path` | Absolute file path. |
+| `mailbox` | `<account>/<mailbox>` relative to the IMAP root. |
+| `from`, `to`, `cc`, `bcc`, `reply-to` | Address headers (joined with `; `). |
+| `subject` | Decoded subject. |
+| `date` / `time` | `YYYY-MM-DD` / `HH:MM` (sender's timezone). |
+| `message-id` | The `Message-ID` header. |
+| `direction` | `→` outbound, `←` inbound (rendered as `dir`). |
+| `party` | The other party — recipient(s) if outbound, sender if inbound. |
+| `flags` | Two chars: position 1 archive-state (`A` archived / `P` primary), position 2 read-state (`R` read / `U` unread) — e.g. `AR`, `PU`. |
+| `read` / `archive` | Standalone versions of the two `flags` positions. |
+
 ### `mmmessage` — read one message
 
 ```bash
@@ -146,12 +180,49 @@ EOF
 mm-send -t friend@example.com -s "Photos" /path/to/photo1.jpg /path/to/photo2.jpg <<<"See attached."
 ```
 
+#### Replies and threading
+
+MailMate auto-generates the outgoing `Message-ID` for every send — never the caller's job. `In-Reply-To` and `References` are pure pass-through: whatever you set via `--header` ships verbatim, and **what you don't set is absent**. A reply with a `Re: …` subject but no threading headers shows up as a brand-new conversation in modern mail clients (they thread on headers, not subjects).
+
+To make a reply land in-thread, pass both headers:
+
+```bash
+mm-send -f you@x -t them@y -s "Re: foo" \
+  --header "In-Reply-To: <parent-message-id@domain>" \
+  --header "References: <root-mid> <parent-mid>" \
+  --send-now <<<"body"
+```
+
+Construct `References` as the source message's `References` header (if any) with the source's `Message-ID` appended. If the source is itself a thread root with no `References`, just use its `Message-ID` alone.
+
+The same passthrough applies to the `mailmate-mcp` `send` tool — see the `from`, `in_reply_to`, and `references` fields.
+
+### `mm-draft` — compose without sending
+
+`mm-draft` is identical to `mm-send` in every way except one: it **never sends**. It refuses the `--send-now` flag with a nonzero exit, so a "compose this but don't send it" instruction can't be silently defeated by passing the flag that flips `emate mailto` from draft-pause to send. Without `--send-now` the two commands already behave identically (open a draft window in MailMate and wait) — `mm-draft` just removes the ability to send at all.
+
+```bash
+# Opens a draft in MailMate; never sends.
+echo "Quick **markdown** body." | mm-draft -t friend@example.com -s "Hello"
+
+# Threading headers and attachments work exactly as in mm-send.
+mm-draft -f you@x -t them@y -s "Re: foo" \
+  --header "In-Reply-To: <parent-message-id@domain>" \
+  --header "References: <root-mid> <parent-mid>" <<<"body"
+
+# Passing --send-now is refused (exit 2):
+mm-draft -t friend@example.com -s "nope" --send-now <<<"body"
+# → mm-draft: refusing --send-now — mm-draft only ever creates drafts. Use mm-send to send.
+```
+
+Reach for `mm-draft` (or the `mailmate-mcp` `draft` tool) whenever the instruction is "write/compose but don't send" — it's the unambiguous, can't-misfire choice. The `draft` MCP tool mirrors `send` minus the `send_now` field.
+
 ### Why the names
 
 The `mm` prefix is for tab completion: typing `mm<tab>` in a shell lists every command in the toolkit. The dash matters:
 
 - **`mm<name>`** (no dash) — **read** operations. `mmsearch`, `mmmessage`, `mmopen`, `mmtags`, `mmdiscover` observe MailMate's on-disk state without changing it. (`mmopen` activates MailMate's UI but doesn't modify any message.)
-- **`mm-<name>`** (with dash) — **write** operations. `mm-modify`, `mm-send` change state (or send mail). `mm-mailboxes` is an exception: read-only, but uses the dash to keep `mmm<tab>` free for the daily-driver `mmmessage`. Typing `mm-<tab>` filters to the write-leaning commands.
+- **`mm-<name>`** (with dash) — **write** operations. `mm-modify`, `mm-send`, `mm-draft` change state (or compose/send mail). `mm-mailboxes` is an exception: read-only, but uses the dash to keep `mmm<tab>` free for the daily-driver `mmmessage`. Typing `mm-<tab>` filters to the write-leaning commands. (`mm-draft` only ever opens a draft — it never sends.)
 
 ## Limitations
 
@@ -278,6 +349,7 @@ Restart Claude Desktop after any change to server code or config.
 | `mmtags` | List user tags applied to messages (with counts) or defined in Preferences. |
 | `mm-modify` | Mark read/flag/tag/archive a message via AppleScript; same-account `move` uses a fast `.eml`-rename path with no UI takeover. |
 | `mm-send` | Send mail through `emate` with a markdown body on stdin. |
+| `mm-draft` | Like `mm-send`, but only ever opens a draft — refuses `--send-now` (exit 2). |
 | `mmdiscover` | First-run bootstrap; (re-)writes the user config from MailMate's plists. |
 
 Each command takes `--help` for usage. Tab-completion: `mm<tab>` lists every command; `mms<tab>` → `mmsearch`; `mmm<tab>` → `mmmessage`; `mm-<tab>` lists the write-side commands.

data/exe/mm-draft

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mailmate"
+require "mailmate/cli/draft"
+
+exit Mailmate::CLI::Draft.run(ARGV)

data/lib/mailmate/cli/draft.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "mailmate/cli/send"
+
+module Mailmate
+  module CLI
+    # `mm-draft` — identical to `mm-send` but guaranteed never to actually
+    # send. It refuses `--send-now` with a nonzero exit, so a "compose this
+    # but don't send it" instruction can't be silently defeated by the flag
+    # that flips `emate mailto` from draft-pause to send. Without `--send-now`
+    # both commands behave identically (open a draft window in MailMate); the
+    # only difference is that mm-draft *cannot* be talked into sending.
+    # @api private
+    module Draft
+      extend self
+
+      NOTE = <<~NOTE
+        mm-draft — same as `mm-send`, but it only ever opens a draft and refuses
+        `--send-now`. Use `mm-send` when you actually want to send. All other
+        flags pass through to `emate mailto` exactly as in mm-send (its help
+        follows below).
+
+      NOTE
+
+      # Returns the exit status. Refuses `--send-now` (exit 2); otherwise
+      # delegates verbatim to `Mailmate::CLI::Send`.
+      def run(argv)
+        if argv.include?("--send-now")
+          warn "mm-draft: refusing --send-now — mm-draft only ever creates drafts. Use mm-send to send."
+          return 2
+        end
+        warn NOTE if argv.include?("--help") || argv.include?("-h")
+        Send.run(argv)
+      end
+    end
+  end
+end

data/lib/mailmate/cli/message.rb

@@ -89,6 +89,8 @@ module Mailmate
         $stdout.puts "subject:    #{mail.subject}"
         $stdout.puts "date:       #{Mailmate.localize(mail.date)&.iso8601}"
         $stdout.puts "message-id: #{mail.message_id}"
+        thread_id = Mailmate::Attributes.thread_id_for(mail)
+        $stdout.puts "thread-id:  #{thread_id}" if thread_id
         if mail.attachments.any?
           $stdout.puts "attachments:"
           mail.attachments.each do |a|

data/lib/mailmate/cli/modify.rb

@@ -256,6 +256,13 @@ module Mailmate
         driver  = Mailmate::AppleScriptDriver.new(dry_run: opts[:dry_run])
         mid_url = Mailmate::MidUrl.for(message_id)
 
+        # Opening the `mid:` URL displays the message in a viewer, which
+        # causes MailMate to mark it `\Seen`. If the caller's action chain
+        # neither sets nor clears the read state, snapshot it first and
+        # restore after the open so this side-effect doesn't silently
+        # change read state. Skip in dry-run — no real open happens.
+        preserve_unread = should_preserve_unread?(eml_id, actions, opts)
+
         windows_before = driver.window_ids
         driver.open_url(mid_url)
         # Active wait: poll for the new viewer window instead of sleeping a
@@ -264,6 +271,15 @@ module Mailmate
         # the timeout for this wait rather than the sleep duration.
         new_windows = opts[:dry_run] ? [] : wait_for_new_window(driver, windows_before, timeout: opts[:settle])
 
+        # Restore unread BEFORE user actions: a subsequent move / archive /
+        # delete moves the message out of the viewer's selection, after
+        # which a `markAsUnread:` would land on whatever MailMate selected
+        # next (or be a silent no-op).
+        if preserve_unread
+          $stdout.puts "preserve-read-state: re-marking #{eml_id}.eml unread (opening the mid: URL marks it read)"
+          driver.perform("markAsUnread:")
+        end
+
         # Send each action's selector without sleeping between them.
         # AppleEvents queue per-app and process in order, so a subsequent
         # `close window id N` will execute only after `perform` is committed.
@@ -312,6 +328,17 @@ module Mailmate
         []
       end
 
+      # True iff we should re-mark the message unread after opening it.
+      # - Skip when any user action already touches read state (read/unread)
+      #   — the user's chain wins.
+      # - Skip in dry-run — no real open, so no real read-flip to undo.
+      # - Otherwise: read the index; preserve only if currently unread.
+      def should_preserve_unread?(eml_id, actions, opts)
+        return false if opts[:dry_run]
+        return false if actions.any? { |name, _, _| name == "read" || name == "unread" }
+        !current_flags(eml_id).include?("\\Seen")
+      end
+
       def current_flags(eml_id)
         # AppleScript actions write the index asynchronously — bust just the
         # #flags cache to pick up the latest values without throwing away

data/lib/mailmate/cli/send.rb

@@ -12,6 +12,35 @@ module Mailmate
 
       EMATE_PATH = "/Applications/MailMate.app/Contents/Resources/emate"
 
+      PREAMBLE = <<~PREAMBLE
+        mm-send — thin wrapper around `emate mailto` with `--markup markdown` enforced.
+        Body is read from stdin. All other flags pass through to emate (its help follows).
+
+        Replies and threading
+          MailMate auto-generates the outgoing Message-ID — never your job.
+          In-Reply-To and References are PURE PASS-THROUGH: whatever you set via
+          `--header` ships verbatim; what you don't set is absent (and recipients'
+          clients will see the message as a fresh thread, no matter how `Re:` the
+          subject looks). To make a reply land in-thread, pass both:
+
+            mm-send -f you@x -t them@y -s "Re: foo" \\
+              --header "In-Reply-To: <parent-message-id@domain>" \\
+              --header "References: <root-mid> <parent-mid>" \\
+              --send-now <<<"body"
+
+          References is constructed as the source message's References header (if
+          any) with the source's Message-ID appended. If the source is a thread
+          root with no References, just use its Message-ID alone.
+
+        Identity selection
+          `-f <address>` picks which of MailMate's configured identities sends.
+          Without `-f`, MailMate uses its default identity. See `mmdiscover` to
+          list available addresses.
+
+        ──────────────────────────── emate help follows ────────────────────────────
+
+      PREAMBLE
+
       # Returns the exit status of the spawned `emate` invocation. Uses
       # `system` (not `exec`) so the caller — and the test suite — can
       # actually observe the result.
@@ -21,6 +50,7 @@ module Mailmate
           warn "mm-send: emate not found at #{EMATE_PATH}. Is MailMate installed?"
           return 1
         end
+        warn PREAMBLE if argv.include?("--help") || argv.include?("-h")
         system(EMATE_PATH, "mailto", "--markup", "markdown", *argv)
         $?.exitstatus
       end

data/lib/mailmate/mcp.rb

@@ -8,6 +8,7 @@ require "mailmate/cli/search"
 require "mailmate/cli/message"
 require "mailmate/cli/modify"
 require "mailmate/cli/send"
+require "mailmate/cli/draft"
 require "mailmate/cli/open"
 require "mailmate/cli/mailboxes"
 require "mailmate/cli/tags"
@@ -17,7 +18,7 @@ require "mailmate/mid_url"
 
 module Mailmate
   # Stdio MCP server (JSON-RPC 2.0, line-delimited). Exposes the gem's CLIs —
-  # search, message, modify, send — plus a resolve_id helper that round-trips
+  # search, message, modify, send, draft — plus a resolve_id helper that round-trips
   # between local eml-id, RFC Message-ID, and the cross-machine message:// URL.
   #
   # In-process: each tool call runs the corresponding `Mailmate::CLI::*.run`
@@ -29,6 +30,46 @@ module Mailmate
     PROTOCOL_VERSION = "2024-11-05"
     SERVER_NAME      = "mailmate"
 
+    # Server-level guidance returned from `initialize`. This is the gem's
+    # operational doctrine — the things a caller must know to drive MailMate
+    # correctly that don't fit in a single tool's description. It travels with
+    # the gem so the MCP is self-sufficient (no companion skill required).
+    INSTRUCTIONS = <<~INSTRUCTIONS.strip
+      Read and act on MailMate's local mail store on macOS. `search`, `message`,
+      `resolve_id`, and `list_*` are read-only; `send`, `draft`, `modify`, and
+      `open` require MailMate to be running (they drive the app).
+
+      Composing (send / draft)
+      - Bodies are Markdown; MailMate renders them to HTML on the way out. For
+        that to reach recipients, MailMate → Preferences → Composer must have
+        "Preview: Display" = Always and "Replying/Forwarding HTML" = Always
+        embed — otherwise recipients get plain text. These are global, one-time
+        settings.
+      - Set `from` explicitly. When the To: address matches one of the user's
+        own accounts, MailMate may otherwise send from that account.
+      - Prefer `draft` over `send` whenever the user said "don't send" / "just
+        draft it" — `draft` physically cannot send, so it's the safe choice.
+        `send` also opens a draft and waits unless you pass `send_now: true`.
+      - Threading: set BOTH `in_reply_to` and `references`. A "Re:" subject
+        alone does not thread in modern clients. MailMate generates the
+        outgoing Message-ID itself.
+
+      Modifying (modify)
+      - Drives MailMate's UI via AppleScript: it briefly takes focus, calls are
+        serial per app, and each call costs a few seconds (flag/tag writes are
+        async). Batch multiple actions into ONE call rather than many.
+      - Opening a message marks it \\Seen; read state is auto-preserved unless
+        your action chain itself includes read/unread.
+      - A Message-ID can live in several mailboxes (Sent + Received copies,
+        Gmail label copies). When it does, the action may land on a different
+        copy than the id you targeted.
+
+      Identifiers
+      - Tools accept a local eml-id (an integer; per-machine, NOT portable) or
+        an RFC Message-ID (portable across machines). Use `resolve_id` to
+        convert between them and to mint a cross-machine message:// URL.
+    INSTRUCTIONS
+
     TOOLS = [
       {
         name: "search",
@@ -36,15 +77,31 @@ module Mailmate
           Search MailMate's .eml files using MailMate's quicksearch syntax.
           Returns column-aligned CSV. Same engine as the `mmsearch` CLI.
 
-          Common patterns:
+          Query = space-separated specs combined with AND (no or/parens yet).
+          Quote multi-word terms ("rent due"). Modifiers:
+            (bare term)  From/To/Cc/Subject OR body contains
+            f <t> From    t <t> To/Cc    c <t> Cc    s <t> Subject
+            a <t> any address header    b <t> body    m <t> headers OR body
+            d <date>  received: Y, Y-M, Y-M-D, or relative 1d/2w/3m/1y
+            T <tag>   tag / IMAP keyword (K is a synonym)
+            !<value>  negate, e.g. f !smith  (From does NOT contain smith)
+          The `mailbox` arg also accepts a smart-mailbox name (e.g. Medium,
+          Whisper, Personal Inbox) whose filter is ANDed into the search.
+
+          Examples:
             query="f medium d 7d"        from Medium in the last 7 days
-            query="T robot"              tagged "robot" (reads MailMate's #flags index)
+            query="T robot"              tagged "robot"
             query="s 'rent due' !draft"  subject has 'rent due', not 'draft'
-            query="d 2026-05"            received in May 2026
 
-          Fields default to: flags date time direction party subject
-          Prefix fields with "+" to add to defaults (e.g. "+tags +mailbox").
-          Bare fields list replaces defaults (id is always first).
+          Fields default to: flags date time direction party subject.
+          Prefix with "+" to add to the defaults ("+tags +mailbox"); a bare
+          list replaces them (id is always the first column). Meanings:
+            flags      2 chars — archive-state (A archived / P primary) then
+                       read-state (R read / U unread), e.g. AR, PU
+            direction  → outbound / ← inbound      party  the other party
+            read       R/U      archive  A/P       (standalone flag columns)
+          Other fields (from/to/cc/bcc/reply-to/subject/date/time/message-id/
+          path/mailbox) are the obvious header or location values.
         DESC
         inputSchema: {
           type: "object",
@@ -118,22 +175,45 @@ module Mailmate
       },
       {
         name: "send",
-        description: "Send mail via MailMate's `emate` (markdown body). Recipients and subject via fields; body is the markdown source.",
+        description: "Send mail via MailMate's `emate` (markdown body). Recipients and subject via fields; body is the markdown source. For replies, set `in_reply_to` and `references` so recipients' clients thread the message — without them a `Re:` subject alone is not enough. MailMate generates the outgoing Message-ID automatically.",
         inputSchema: {
           type: "object",
           properties: {
+            from: { type: "string", description: "Sender identity (one of MailMate's configured addresses; see mmdiscover). If omitted, MailMate uses its default identity." },
             to: { type: "string", description: "Recipient(s), comma-separated." },
             cc: { type: "string", description: "CC recipient(s), comma-separated." },
             bcc: { type: "string", description: "BCC recipient(s), comma-separated." },
             subject: { type: "string", description: "Subject line." },
             body: { type: "string", description: "Markdown body." },
             attachments: { type: "array", items: { type: "string" }, description: "Absolute paths to files to attach." },
+            in_reply_to: { type: "string", description: "Message-ID of the parent message (with or without angle brackets). Sets the In-Reply-To header on the outgoing message so recipients' clients thread it correctly." },
+            references: { type: "string", description: "Space-separated chain of Message-IDs (with angle brackets). Conventionally: parent's References header + parent's Message-ID. Required alongside in_reply_to for clean threading in deep chains." },
             send_now: { type: "boolean", description: "Send immediately (skip the Drafts pause)." },
           },
           required: %w[to subject body],
           additionalProperties: false,
         },
       },
+      {
+        name: "draft",
+        description: "Compose a draft via MailMate's `emate` (markdown body) — IDENTICAL to `send` but it never sends: the draft opens in MailMate and waits. There is no `send_now` option; use this whenever the instruction is 'write/compose but don't send'. For replies, set `in_reply_to` and `references` so the draft threads correctly. MailMate generates the outgoing Message-ID automatically.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            from: { type: "string", description: "Sender identity (one of MailMate's configured addresses; see mmdiscover). If omitted, MailMate uses its default identity." },
+            to: { type: "string", description: "Recipient(s), comma-separated." },
+            cc: { type: "string", description: "CC recipient(s), comma-separated." },
+            bcc: { type: "string", description: "BCC recipient(s), comma-separated." },
+            subject: { type: "string", description: "Subject line." },
+            body: { type: "string", description: "Markdown body." },
+            attachments: { type: "array", items: { type: "string" }, description: "Absolute paths to files to attach." },
+            in_reply_to: { type: "string", description: "Message-ID of the parent message (with or without angle brackets). Sets the In-Reply-To header so recipients' clients thread it correctly." },
+            references: { type: "string", description: "Space-separated chain of Message-IDs (with angle brackets). Conventionally: parent's References header + parent's Message-ID. Required alongside in_reply_to for clean threading in deep chains." },
+          },
+          required: %w[to subject body],
+          additionalProperties: false,
+        },
+      },
       {
         name: "open",
         description: "Open one MailMate message in MailMate's UI (activates the window). Accepts any of the id forms `resolve_id` takes. Read-side semantically, but does shift focus to MailMate.",
@@ -223,6 +303,7 @@ module Mailmate
           protocolVersion: PROTOCOL_VERSION,
           capabilities:    { tools: {} },
           serverInfo:      { name: SERVER_NAME, version: Mailmate::VERSION },
+          instructions:    INSTRUCTIONS,
         }))
       when "notifications/initialized", "notifications/cancelled"
         # notifications — no response
@@ -246,6 +327,7 @@ module Mailmate
       when "message"        then call_message(args)
       when "modify"         then call_modify(args)
       when "send"           then call_send(args)
+      when "draft"          then call_draft(args)
       when "open"           then call_open(args)
       when "list_mailboxes" then call_list_mailboxes(args)
       when "list_tags"      then call_list_tags(args)
@@ -289,14 +371,40 @@ module Mailmate
     end
 
     def call_send(args)
+      argv = compose_argv(args)
+      argv << "--send-now" if args["send_now"]
+      with_stdin(args["body"].to_s) { run_cli(Mailmate::CLI::Send, argv) }
+    end
+
+    # `draft` mirrors `send` but never sends — it has no send_now option and
+    # routes through CLI::Draft, which refuses `--send-now` outright.
+    def call_draft(args)
+      argv = compose_argv(args)
+      with_stdin(args["body"].to_s) { run_cli(Mailmate::CLI::Draft, argv) }
+    end
+
+    # Shared message-composition argv for both send and draft (everything bar
+    # the body, which is piped on stdin, and the send-only `--send-now`).
+    def compose_argv(args)
       argv = []
+      argv.push("-f", args["from"].to_s)    if args["from"]
       argv.push("-t", args["to"].to_s)      if args["to"]
       argv.push("-c", args["cc"].to_s)      if args["cc"]
       argv.push("-b", args["bcc"].to_s)     if args["bcc"]
       argv.push("-s", args["subject"].to_s) if args["subject"]
-      argv << "--send-now"                  if args["send_now"]
+      argv.push("--header", "In-Reply-To: #{bracket_mid(args["in_reply_to"])}") if args["in_reply_to"]
+      argv.push("--header", "References: #{args["references"]}")                if args["references"]
       Array(args["attachments"]).each { |p| argv << p.to_s }
-      with_stdin(args["body"].to_s) { run_cli(Mailmate::CLI::Send, argv) }
+      argv
+    end
+
+    # Wrap a bare Message-ID in `<…>` if it doesn't already have them. Both
+    # forms are valid input to the MCP for ergonomics; the header value
+    # going on the wire needs the brackets per RFC 5322.
+    def bracket_mid(id)
+      s = id.to_s.strip
+      return s if s.start_with?("<") && s.end_with?(">")
+      "<#{s}>"
     end
 
     def call_open(args)

data/lib/mailmate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mailmate
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mailmate
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Brian Murphy-Dye
@@ -94,6 +94,7 @@ email:
 - brian@murphydye.com
 executables:
 - mailmate-mcp
+- mm-draft
 - mm-mailboxes
 - mm-modify
 - mm-send
@@ -109,6 +110,7 @@ files:
 - README.md
 - config.yml.example
 - exe/mailmate-mcp
+- exe/mm-draft
 - exe/mm-mailboxes
 - exe/mm-modify
 - exe/mm-send
@@ -122,6 +124,7 @@ files:
 - lib/mailmate/ast.rb
 - lib/mailmate/attributes.rb
 - lib/mailmate/cli/discover.rb
+- lib/mailmate/cli/draft.rb
 - lib/mailmate/cli/mailboxes.rb
 - lib/mailmate/cli/message.rb
 - lib/mailmate/cli/modify.rb
@@ -166,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.12
 specification_version: 4
 summary: Ruby toolkit for MailMate on macOS — search, read, modify, send, and smart-mailbox
   evaluation