@marlinjai/email-mcp 1.8.1 → 1.10.0

package/dist/setup/wizard.js

@@ -830,6 +830,14 @@ function extractAttachments(payload) {
   }
   return attachments;
 }
+function threadingHeaders(headers) {
+  const picked = {};
+  for (const name of ["Message-ID", "In-Reply-To", "References"]) {
+    const value = getHeader(headers, name);
+    if (value) picked[name.toLowerCase()] = value;
+  }
+  return Object.keys(picked).length > 0 ? picked : void 0;
+}
 function mapGmailMessage(message, accountId) {
   const headers = message.payload?.headers || [];
   const labelIds = message.labelIds || [];
@@ -864,6 +872,7 @@ function mapGmailMessage(message, accountId) {
     snippet: message.snippet,
     attachments,
     labels: labelIds,
+    headers: threadingHeaders(headers),
     flags: {
       read: !labelIds.includes("UNREAD"),
       starred: labelIds.includes("STARRED"),
@@ -1084,7 +1093,7 @@ var GmailAdapter = class {
     const raw = await this.buildRaw(params);
     const res = await gmail.users.messages.send({
       userId: "me",
-      requestBody: { raw }
+      requestBody: { raw, ...this.threadFor(params) }
     });
     return {
       id: res.data.id || "",
@@ -1097,19 +1106,41 @@ var GmailAdapter = class {
     const res = await gmail.users.drafts.create({
       userId: "me",
       requestBody: {
-        message: { raw }
+        message: { raw, ...this.threadFor(params) }
       }
     });
     return { id: res.data.id || "" };
   }
-  async updateDraft(draftId, params) {
+  /**
+   * drafts.update replaces the whole message, so a reply draft would fall out
+   * of its thread. When the caller names no thread, the thread and the reply
+   * headers of the stored draft are carried over into the new message.
+   */
+  async updateDraft(draftId, update) {
     const gmail = this.ensureConnected();
+    let params = update;
+    if (update.threadId === void 0) {
+      const existing = await gmail.users.drafts.get({
+        userId: "me",
+        id: draftId,
+        // Ids, labels and headers, no body. drafts.get has no way to ask for
+        // single headers (messages.get does), so all of them come back.
+        format: "metadata"
+      });
+      const message = existing.data.message;
+      const header = (name) => (message?.payload?.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || void 0;
+      const inReplyTo = update.inReplyTo ?? header("in-reply-to");
+      const references = update.references ?? header("references")?.split(/\s+/).filter(Boolean);
+      if (message?.threadId && inReplyTo) {
+        params = { ...update, threadId: message.threadId, inReplyTo, references: references?.length ? references : [inReplyTo] };
+      }
+    }
     const raw = await this.buildRaw(params);
     const res = await gmail.users.drafts.update({
       userId: "me",
       id: draftId,
       requestBody: {
-        message: { raw }
+        message: { raw, ...this.threadFor(params) }
       }
     });
     return { id: res.data.id || draftId };
@@ -1377,23 +1408,36 @@ var GmailAdapter = class {
       requestBody: { addLabelIds: ["SPAM"], removeLabelIds: ["INBOX"] }
     });
   }
-  async createBlockRule(rule) {
-    const gmail = this.ensureConnected();
+  filterCriteria(matchType, value) {
     const criteria = {};
-    switch (rule.matchType) {
+    switch (matchType) {
       case "senderDomain":
-        criteria.from = `@${rule.value}`;
+        criteria.from = `@${value}`;
         break;
       case "senderAddress":
-        criteria.from = rule.value;
+        criteria.from = value;
         break;
       case "subjectContains":
-        criteria.subject = rule.value;
+        criteria.subject = value;
         break;
       case "headerContains":
-        criteria.query = rule.value;
+        criteria.query = value;
         break;
     }
+    return criteria;
+  }
+  /** The reverse of filterCriteria, for listing. A best-effort reading of filters made elsewhere. */
+  readCriteria(criteria) {
+    if (typeof criteria?.from === "string" && criteria.from.startsWith("@")) {
+      return { matchType: "senderDomain", value: criteria.from.slice(1) };
+    }
+    if (criteria?.from) return { matchType: "senderAddress", value: criteria.from };
+    if (criteria?.subject) return { matchType: "subjectContains", value: criteria.subject };
+    return { matchType: "headerContains", value: criteria?.query || "" };
+  }
+  async createBlockRule(rule) {
+    const gmail = this.ensureConnected();
+    const criteria = this.filterCriteria(rule.matchType, rule.value);
     const action = rule.action === "delete" ? { addLabelIds: ["TRASH"] } : { removeLabelIds: ["INBOX"] };
     const res = await gmail.users.settings.filters.create({
       userId: "me",
@@ -1404,25 +1448,11 @@ var GmailAdapter = class {
   async listBlockRules() {
     const gmail = this.ensureConnected();
     const res = await gmail.users.settings.filters.list({ userId: "me" });
-    return (res.data.filter || []).map((f) => {
-      const criteria = f.criteria || {};
+    return (res.data.filter || []).filter((f) => !f.action?.forward).map((f) => {
       const addLabelIds = f.action?.addLabelIds || [];
-      let matchType = "headerContains";
-      let value = criteria.query || "";
-      if (typeof criteria.from === "string" && criteria.from.startsWith("@")) {
-        matchType = "senderDomain";
-        value = criteria.from.slice(1);
-      } else if (criteria.from) {
-        matchType = "senderAddress";
-        value = criteria.from;
-      } else if (criteria.subject) {
-        matchType = "subjectContains";
-        value = criteria.subject;
-      }
       return {
         id: f.id || "",
-        matchType,
-        value,
+        ...this.readCriteria(f.criteria),
         action: addLabelIds.includes("TRASH") ? "delete" : "moveToJunk",
         createdAt: ""
         // Gmail's filter API does not expose a creation timestamp
@@ -1433,6 +1463,72 @@ var GmailAdapter = class {
     const gmail = this.ensureConnected();
     await gmail.users.settings.filters.delete({ userId: "me", id: ruleId });
   }
+  /**
+   * Gmail only forwards to an address the user has added and confirmed under
+   * Settings, "Forwarding and POP/IMAP". Adding one through the API needs a
+   * scope this app does not request (gmail.settings.sharing), so a missing or
+   * unconfirmed address is answered with the manual step, before Gmail's own
+   * less helpful error.
+   */
+  async createForwardRule(rule) {
+    const gmail = this.ensureConnected();
+    const target = rule.forwardTo.trim().toLowerCase();
+    const addresses = await gmail.users.settings.forwardingAddresses.list({ userId: "me" });
+    const known = (addresses.data.forwardingAddresses || []).find(
+      (a) => (a.forwardingEmail || "").toLowerCase() === target
+    );
+    if (!known) {
+      throw new Error(
+        `${rule.forwardTo} is not a forwarding address of this Gmail account yet. Add it once in Gmail under Settings, "Forwarding and POP/IMAP", "Add a forwarding address", confirm the email Google sends to it, then run this again.`
+      );
+    }
+    if (known.verificationStatus !== "accepted") {
+      throw new Error(
+        `${rule.forwardTo} was added to this Gmail account but not confirmed yet. Open the confirmation email Google sent to that address, confirm it, then run this again.`
+      );
+    }
+    const existing = (await this.listForwardRules()).find(
+      (r) => r.matchType === rule.matchType && r.value.toLowerCase() === rule.value.toLowerCase() && r.forwardTo.toLowerCase() === target
+    );
+    if (existing) return { id: existing.id, alreadyExisted: true };
+    const action = { forward: known.forwardingEmail };
+    if (!rule.keepInInbox) action.removeLabelIds = ["INBOX"];
+    const res = await gmail.users.settings.filters.create({
+      userId: "me",
+      requestBody: { criteria: this.filterCriteria(rule.matchType, rule.value), action }
+    });
+    return { id: res.data.id || "" };
+  }
+  /** Every filter that forwards, including ones made by hand in Gmail. */
+  async listForwardRules() {
+    const gmail = this.ensureConnected();
+    const res = await gmail.users.settings.filters.list({ userId: "me" });
+    return (res.data.filter || []).filter((f) => f.action?.forward).map((f) => ({
+      id: f.id || "",
+      ...this.readCriteria(f.criteria),
+      forwardTo: f.action.forward,
+      keepInInbox: !(f.action.removeLabelIds || []).includes("INBOX"),
+      createdAt: ""
+      // Gmail's filter API does not expose a creation timestamp
+    }));
+  }
+  async deleteForwardRule(ruleId) {
+    const rules = await this.listForwardRules();
+    if (!rules.some((r) => r.id === ruleId)) {
+      throw new Error(`No forwarding rule with id ${ruleId} on this account. Use email_list_forward_rules to see the ids.`);
+    }
+    await this.deleteBlockRule(ruleId);
+  }
+  /**
+   * Gmail files a message into an existing thread only when the threadId
+   * comes with In-Reply-To and References headers and a subject (which has to
+   * match the thread's; the reply tool builds "Re: <original subject>"). A
+   * threadId without them is left out, and the message starts its own thread.
+   */
+  threadFor(params) {
+    const belongs = params.threadId && params.inReplyTo && params.references?.length && params.subject.trim();
+    return belongs ? { threadId: params.threadId } : {};
+  }
   /**
    * Builds the base64url `raw` payload Gmail expects for send, draft create and
    * draft update: a full MIME message with a text part, an HTML part when one
@@ -1593,7 +1689,36 @@ function buildGraphFilter(query) {
 }
 
 // src/providers/outlook/adapter.ts
-var OutlookAdapter = class {
+var toGraphAttachment = (att) => ({
+  "@odata.type": "#microsoft.graph.fileAttachment",
+  name: att.filename,
+  contentType: att.contentType,
+  contentBytes: att.content.toString("base64")
+});
+var OUTLOOK_MAX_ATTACHMENT_BYTES = 3 * 1024 * 1024;
+var OUTLOOK_MAX_REQUEST_BYTES = 4 * 1024 * 1024;
+var UPLOAD_SESSION_HINT = "Larger files need an upload session, which email-mcp does not implement for Outlook yet.";
+function megabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function assertOutlookAttachmentSizes(attachments) {
+  if (!attachments?.length) return;
+  const limit = megabytes(OUTLOOK_MAX_ATTACHMENT_BYTES);
+  for (const att of attachments) {
+    if (att.content.length > OUTLOOK_MAX_ATTACHMENT_BYTES) {
+      throw new Error(`Outlook accepts attachments up to ${limit} through email-mcp; ${att.filename} is ${megabytes(att.content.length)}. ${UPLOAD_SESSION_HINT}`);
+    }
+  }
+}
+function assertOutlookRequestSize(body) {
+  const bytes = Buffer.byteLength(JSON.stringify(body));
+  if (bytes > OUTLOOK_MAX_REQUEST_BYTES) {
+    throw new Error(
+      `Outlook accepts requests up to ${megabytes(OUTLOOK_MAX_REQUEST_BYTES)} through email-mcp; this message is ${megabytes(bytes)} once its attachments are base64-encoded. ${UPLOAD_SESSION_HINT}`
+    );
+  }
+}
+var OutlookAdapter = class _OutlookAdapter {
   providerType = ProviderType.Outlook;
   client = null;
   accountId = "";
@@ -1732,31 +1857,125 @@ var OutlookAdapter = class {
       meta: mapGraphAttachment(attachment)
     };
   }
+  /**
+   * Graph only threads a reply (conversationId, subject, quoted history)
+   * through the createReply flow: POST /me/messages and /me/sendMail always
+   * start a new conversation whatever In-Reply-To says. Build the reply draft,
+   * overlay our subject, body, recipients and attachments, and return its id.
+   * Note the body replaces Graph's pre-filled quoted history.
+   *
+   * Each attachment goes up in a request of its own, so the sizes are checked
+   * per file, and before createReply so that a file that is too big leaves no
+   * draft behind. A draft that cannot be filled is deleted again. (A draft
+   * whose send failed is kept, see `sendEmail`.)
+   */
+  async createReplyDraft(params, replyToId) {
+    const client = this.ensureClient();
+    assertOutlookAttachmentSizes(params.attachments);
+    const draft = await client.api(`/me/messages/${encodeURIComponent(replyToId)}/createReply`).post({});
+    try {
+      await this.fillReplyDraft(draft.id, params);
+    } catch (error) {
+      throw await this.discardDraft(draft.id, error);
+    }
+    return draft.id;
+  }
+  async fillReplyDraft(draftId, params) {
+    const client = this.ensureClient();
+    const toGraphRecipient = (c) => ({
+      emailAddress: { name: c.name, address: c.email }
+    });
+    const patch = {
+      // Always the caller's subject: Graph pre-fills its own "RE: ..." one.
+      subject: params.subject,
+      body: { contentType: params.body.html ? "html" : "text", content: params.body.html || params.body.text || "" }
+    };
+    if (params.to?.length) patch.toRecipients = params.to.map(toGraphRecipient);
+    if (params.cc !== void 0) patch.ccRecipients = params.cc.map(toGraphRecipient);
+    if (params.bcc !== void 0) patch.bccRecipients = params.bcc.map(toGraphRecipient);
+    await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(patch);
+    for (const att of params.attachments ?? []) {
+      await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post(toGraphAttachment(att));
+    }
+  }
+  /**
+   * Deletes a reply draft that could not be filled, so a failed reply leaves
+   * nothing half-built in Drafts. Returns the error to throw: the original
+   * one, or, when the delete fails as well, the original message with a note
+   * that the draft is still there.
+   */
+  async discardDraft(draftId, cause) {
+    try {
+      await this.ensureClient().api(`/me/messages/${encodeURIComponent(draftId)}`).delete();
+      return cause;
+    } catch (deleteError) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      return new Error(
+        `${message} (the reply draft ${draftId} could not be removed and was left in Drafts: ${deleteError?.message ?? deleteError})`,
+        { cause }
+      );
+    }
+  }
   async sendEmail(params) {
     const client = this.ensureClient();
+    if (params.replyToGraphId) {
+      const draftId = await this.createReplyDraft(params, params.replyToGraphId);
+      try {
+        await client.api(`/me/messages/${encodeURIComponent(draftId)}/send`).post({});
+      } catch (error) {
+        throw new Error(
+          `${error?.message ?? error} (the reply was saved as draft ${draftId} in Drafts and was not confirmed as sent; check Sent Items before sending it again)`,
+          { cause: error }
+        );
+      }
+      return { id: draftId };
+    }
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
     const payload = { message };
     if (params.attachments?.length) {
-      payload.message.attachments = params.attachments.map((att) => ({
-        "@odata.type": "#microsoft.graph.fileAttachment",
-        name: att.filename,
-        contentType: att.contentType,
-        contentBytes: att.content.toString("base64")
-      }));
+      payload.message.attachments = params.attachments.map(toGraphAttachment);
     }
+    assertOutlookRequestSize(payload);
     await client.api("/me/sendMail").post(payload);
     return { id: `sent-${Date.now()}` };
   }
   async createDraft(params) {
     const client = this.ensureClient();
+    if (params.replyToGraphId) {
+      return { id: await this.createReplyDraft(params, params.replyToGraphId) };
+    }
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
+    if (params.attachments?.length) {
+      message.attachments = params.attachments.map(toGraphAttachment);
+    }
+    assertOutlookRequestSize(message);
     const result = await client.api("/me/messages").post(message);
     return { id: result.id };
   }
   async updateDraft(draftId, params) {
     const client = this.ensureClient();
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
     await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(message);
+    if (params.attachments) {
+      const attachmentsPath = `/me/messages/${encodeURIComponent(draftId)}/attachments`;
+      const previousIds = [];
+      let page = await client.api(attachmentsPath).select("id").get();
+      for (; ; ) {
+        previousIds.push(...(page.value || []).map((att) => att.id));
+        const next = page["@odata.nextLink"];
+        if (!next) break;
+        page = await client.api(next).get();
+      }
+      for (const att of params.attachments) {
+        await client.api(attachmentsPath).post(toGraphAttachment(att));
+      }
+      for (const id of previousIds) {
+        await client.api(`${attachmentsPath}/${encodeURIComponent(id)}`).delete();
+      }
+    }
     return { id: draftId };
   }
   async listDrafts(limit, offset) {
@@ -1961,28 +2180,53 @@ var OutlookAdapter = class {
    * before this scope was added need to re-run the setup wizard to
    * re-consent — old tokens will 403 on this call until then.
    */
-  async createBlockRule(rule) {
-    const client = this.ensureClient();
+  ruleConditions(matchType, value) {
     const conditions = {};
-    switch (rule.matchType) {
+    switch (matchType) {
       case "senderDomain":
       case "senderAddress":
-        conditions.senderContains = [rule.value];
+        conditions.senderContains = [value];
         break;
       case "subjectContains":
-        conditions.subjectContains = [rule.value];
+        conditions.subjectContains = [value];
         break;
       case "headerContains":
-        conditions.headerContains = [rule.value];
+        conditions.headerContains = [value];
         break;
     }
+    return conditions;
+  }
+  // Graph doesn't tag which of our four matchTypes a rule came from:
+  // this reconstruction is a best-effort heuristic for listing/auditing,
+  // not a guaranteed round-trip of what was originally requested.
+  readConditions(conditions) {
+    if (conditions?.senderContains?.length) {
+      const value = conditions.senderContains[0];
+      return { matchType: value.includes("@") ? "senderAddress" : "senderDomain", value };
+    }
+    if (conditions?.subjectContains?.length) return { matchType: "subjectContains", value: conditions.subjectContains[0] };
+    if (conditions?.headerContains?.length) return { matchType: "headerContains", value: conditions.headerContains[0] };
+    return { matchType: "headerContains", value: "" };
+  }
+  /** Addresses a rule sends mail on to, whether by "forward" or "redirect". */
+  static forwardTargets(actions) {
+    return [...actions?.forwardTo || [], ...actions?.redirectTo || [], ...actions?.forwardAsAttachmentTo || []].map((r) => r?.emailAddress?.address).filter((a) => typeof a === "string" && a.length > 0);
+  }
+  async listMessageRules() {
+    const client = this.ensureClient();
+    const response = await client.api("/me/mailFolders/inbox/messageRules").get();
+    return response.value || [];
+  }
+  async createBlockRule(rule) {
+    const client = this.ensureClient();
+    const conditions = this.ruleConditions(rule.matchType, rule.value);
     const actions = { stopProcessingRules: true };
     if (rule.action === "delete") {
       actions.delete = true;
     } else {
       actions.moveToFolder = await this.resolveFolder("junkemail");
     }
-    const existing = await this.listBlockRules();
+    const existing = await this.listMessageRules();
     const result = await client.api("/me/mailFolders/inbox/messageRules").post({
       displayName: `email-mcp: ${rule.matchType} "${rule.value}"`.slice(0, 255),
       sequence: existing.length + 1,
@@ -1993,36 +2237,66 @@ var OutlookAdapter = class {
     return { id: result.id };
   }
   async listBlockRules() {
-    const client = this.ensureClient();
-    const response = await client.api("/me/mailFolders/inbox/messageRules").get();
-    return (response.value || []).map((r) => {
-      const conditions = r.conditions || {};
-      let matchType = "headerContains";
-      let value = "";
-      if (conditions.senderContains?.length) {
-        value = conditions.senderContains[0];
-        matchType = value.includes("@") ? "senderAddress" : "senderDomain";
-      } else if (conditions.subjectContains?.length) {
-        matchType = "subjectContains";
-        value = conditions.subjectContains[0];
-      } else if (conditions.headerContains?.length) {
-        matchType = "headerContains";
-        value = conditions.headerContains[0];
-      }
-      return {
-        id: r.id,
-        matchType,
-        value,
-        action: r.actions?.delete ? "delete" : "moveToJunk",
-        createdAt: ""
-        // Graph's messageRule resource has no creation timestamp field
-      };
-    });
+    return (await this.listMessageRules()).filter((r) => _OutlookAdapter.forwardTargets(r.actions).length === 0).map((r) => ({
+      id: r.id,
+      ...this.readConditions(r.conditions),
+      action: r.actions?.delete ? "delete" : "moveToJunk",
+      createdAt: ""
+      // Graph's messageRule resource has no creation timestamp field
+    }));
   }
   async deleteBlockRule(ruleId) {
     const client = this.ensureClient();
     await client.api(`/me/mailFolders/inbox/messageRules/${encodeURIComponent(ruleId)}`).delete();
   }
+  /**
+   * Outlook forwards to any address without a confirmation step, so the only
+   * check on the target is the allowlist in the tool layer. Needs the same
+   * MailboxSettings.ReadWrite scope as block rules.
+   */
+  async createForwardRule(rule) {
+    const client = this.ensureClient();
+    const forwardTo = rule.forwardTo.trim();
+    const target = forwardTo.toLowerCase();
+    const all = await this.listMessageRules();
+    const existing = all.find((r) => {
+      const read = this.readConditions(r.conditions);
+      const sameMatch = read.value.toLowerCase() === rule.value.toLowerCase() && (read.matchType === rule.matchType || read.matchType.startsWith("sender") && rule.matchType.startsWith("sender"));
+      return sameMatch && _OutlookAdapter.forwardTargets(r.actions).some((a) => a.toLowerCase() === target);
+    });
+    if (existing) return { id: existing.id, alreadyExisted: true };
+    const actions = { forwardTo: [{ emailAddress: { address: forwardTo } }] };
+    if (!rule.keepInInbox) {
+      actions.moveToFolder = await this.resolveFolder("archive");
+      actions.stopProcessingRules = true;
+    }
+    const result = await client.api("/me/mailFolders/inbox/messageRules").post({
+      displayName: `email-mcp: forward ${rule.matchType} "${rule.value}" to ${forwardTo}`.slice(0, 255),
+      sequence: all.length + 1,
+      isEnabled: true,
+      conditions: this.ruleConditions(rule.matchType, rule.value),
+      actions
+    });
+    return { id: result.id };
+  }
+  /** Every inbox rule that forwards or redirects, including ones made by hand in Outlook. */
+  async listForwardRules() {
+    return (await this.listMessageRules()).filter((r) => _OutlookAdapter.forwardTargets(r.actions).length > 0).map((r) => ({
+      id: r.id,
+      ...this.readConditions(r.conditions),
+      forwardTo: _OutlookAdapter.forwardTargets(r.actions).join(", "),
+      keepInInbox: !r.actions?.moveToFolder && !r.actions?.delete,
+      createdAt: ""
+      // Graph's messageRule resource has no creation timestamp field
+    }));
+  }
+  async deleteForwardRule(ruleId) {
+    const rules = await this.listForwardRules();
+    if (!rules.some((r) => r.id === ruleId)) {
+      throw new Error(`No forwarding rule with id ${ruleId} on this account. Use email_list_forward_rules to see the ids.`);
+    }
+    await this.deleteBlockRule(ruleId);
+  }
   async getCategories() {
     const client = this.ensureClient();
     const response = await client.api("/me/outlook/masterCategories").get();
@@ -2072,6 +2346,12 @@ function mapImapFolder(imapFolder) {
     unreadCount: imapFolder.status?.unseen
   };
 }
+function imapAttachmentId(att, index) {
+  return att.contentId || `att-${index}`;
+}
+function headerValue(line) {
+  return line.slice(line.indexOf(":") + 1).replace(/\r?\n[ \t]+/g, " ").trim();
+}
 function mapParsedEmail(parsed, folder, accountId, uid) {
   const mapContact = (addr) => ({
     name: addr.name || void 0,
@@ -2082,7 +2362,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
     return addrs.value.map(mapContact);
   };
   const attachments = (parsed.attachments || []).map((att, i) => ({
-    id: att.contentId || `att-${i}`,
+    id: imapAttachmentId(att, i),
     filename: att.filename || `attachment-${i}`,
     contentType: att.contentType || "application/octet-stream",
     size: att.size || 0
@@ -2111,7 +2391,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
       flagged: parsed.flags?.has("\\Flagged") || false,
       draft: parsed.flags?.has("\\Draft") || false
     },
-    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, h.line])) : void 0
+    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, headerValue(h.line)])) : void 0
   };
 }
 
@@ -2508,7 +2788,7 @@ var ImapAdapter = class {
   }
   async getEmail(id, folder) {
     const client = await this.ensureConnected();
-    const targetFolder = folder || "INBOX";
+    const targetFolder = folder ? await this.resolveFolder(folder) : "INBOX";
     let lock;
     try {
       lock = await client.getMailboxLock(targetFolder);
@@ -2527,13 +2807,20 @@ var ImapAdapter = class {
       lock.release();
     }
   }
-  async getThread(threadId) {
+  /**
+   * IMAP has no thread object: the thread is the set of messages in ONE
+   * folder whose Message-ID, References or In-Reply-To name `threadId`.
+   * Messages of the same conversation in other folders (the own replies in
+   * Sent, for example) are not part of the result.
+   */
+  async getThread(threadId, sourceFolder) {
     const client = await this.ensureConnected();
+    const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
     let lock;
     try {
-      lock = await client.getMailboxLock("INBOX");
+      lock = await client.getMailboxLock(folder);
     } catch (error) {
-      throw formatImapError(error, 'Failed to open folder "INBOX"');
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
     }
     try {
       const searchResult = await client.search(
@@ -2541,13 +2828,13 @@ var ImapAdapter = class {
         { uid: true }
       );
       const uids = Array.isArray(searchResult) ? searchResult : [];
-      if (uids.length === 0) throw new Error(`Thread ${threadId} not found`);
+      if (uids.length === 0) throw new Error(`Thread ${threadId} not found in "${folder}"`);
       const messages = [];
       for await (const msg of client.fetch(uids, { source: true, uid: true, flags: true })) {
         if (!msg.source) continue;
         const parsed = await simpleParser(msg.source);
         parsed.flags = msg.flags;
-        messages.push(mapParsedEmail(parsed, "INBOX", this.accountId, msg.uid));
+        messages.push(mapParsedEmail(parsed, folder, this.accountId, msg.uid));
       }
       const participantMap = /* @__PURE__ */ new Map();
       for (const msg of messages) {
@@ -2569,27 +2856,29 @@ var ImapAdapter = class {
       lock.release();
     }
   }
-  async getAttachment(emailId, attachmentId) {
+  async getAttachment(emailId, attachmentId, sourceFolder) {
     const client = await this.ensureConnected();
+    const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
     let lock;
     try {
-      lock = await client.getMailboxLock("INBOX");
+      lock = await client.getMailboxLock(folder);
     } catch (error) {
-      throw formatImapError(error, 'Failed to open folder "INBOX"');
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
     }
     try {
       const msg = await client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
-      if (!msg) throw new Error(`Email ${emailId} not found`);
+      if (!msg) throw new Error(`Email ${emailId} not found in "${folder}"`);
       if (!msg.source) throw new Error(`Email ${emailId} has no source`);
       const parsed = await simpleParser(msg.source);
-      const attachment = (parsed.attachments || []).find(
-        (att) => att.contentId === attachmentId || att.filename === attachmentId
-      );
-      if (!attachment) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+      const attachments = parsed.attachments || [];
+      let index = attachments.findIndex((att, i) => imapAttachmentId(att, i) === attachmentId);
+      if (index === -1) index = attachments.findIndex((att) => att.filename === attachmentId);
+      if (index === -1) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+      const attachment = attachments[index];
       return {
         data: attachment.content,
         meta: {
-          id: attachment.contentId || attachmentId,
+          id: imapAttachmentId(attachment, index),
           filename: attachment.filename || "attachment",
           contentType: attachment.contentType || "application/octet-stream",
           size: attachment.size || 0
@@ -2626,18 +2915,34 @@ var ImapAdapter = class {
    * Drafts folder, and IMAP messages are immutable once appended. This
    * deletes the old revision and appends a new one, so the returned `id`
    * is a NEW uid; the old id no longer resolves after this call.
+   *
+   * A reply draft keeps its place in the thread: when the caller passes no
+   * `inReplyTo`, the In-Reply-To and References headers of the old revision
+   * are copied into the new one.
    */
   async updateDraft(draftId, params, sourceFolder) {
     const client = await this.ensureConnected();
     const draftsFolder = sourceFolder ? await this.resolveFolder(sourceFolder) : await this.resolveFolder("Drafts");
-    const rawMessage = await this.buildDraftMessage(params);
     let lock;
     try {
       lock = await client.getMailboxLock(draftsFolder);
     } catch (error) {
       throw formatImapError(error, `Failed to open folder "${draftsFolder}"`);
     }
+    let rawMessage;
     try {
+      let next = params;
+      if (params.inReplyTo === void 0) {
+        const old = await client.fetchOne(String(draftId), { source: true, uid: true }, { uid: true });
+        if (old && old.source) {
+          const parsed = await simpleParser(old.source);
+          const references = [].concat(parsed.references ?? []);
+          if (parsed.inReplyTo) {
+            next = { ...params, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+          }
+        }
+      }
+      rawMessage = await this.buildDraftMessage(next);
       await client.messageDelete(draftId, { uid: true });
     } finally {
       lock.release();
@@ -2924,6 +3229,11 @@ var AccountManager = class {
       connected: this.providers.has(c.id)
     }));
   }
+  /** The account's own address, or undefined for an unknown account id. */
+  async getAccountEmail(accountId) {
+    const creds = this.credentials.get(accountId) ?? await this.store.get(accountId);
+    return creds?.email;
+  }
   async getProvider(accountId) {
     const existing = this.providers.get(accountId);
     if (existing) {
@@ -3390,6 +3700,9 @@ async function main() {
     addMore = await askConfirm("Would you like to add another email account?", false);
   }
   console.log("\nSetup complete! You can now use the email tools in Claude Code.");
+  console.log(
+    "\nemail-mcp is free and open source. Google requires a yearly independent security\naudit (675 US dollars) for the Gmail sign-in it ships. If email-mcp is useful to you,\nyou can help cover it: https://github.com/sponsors/marlinjai"
+  );
 }
 main().catch((err) => {
   console.error(`