@marlinjai/email-mcp 1.8.0 → 1.9.0

package/dist/setup/wizard.js

@@ -892,6 +892,53 @@ function buildGmailQuery(query) {
   return parts.join(" ");
 }
 
+// src/providers/mime.ts
+import MailComposer from "nodemailer/lib/mail-composer/index.js";
+import { convert } from "html-to-text";
+function htmlToText(html) {
+  return convert(html, {
+    wordwrap: false,
+    selectors: [
+      { selector: "img", format: "skip" },
+      { selector: "a", options: { hideLinkHrefIfSameAsText: true } }
+    ]
+  }).trim();
+}
+function normalizeBody(body) {
+  const html = body.html ? body.html : void 0;
+  if (body.text) return { text: body.text, html };
+  if (html) return { text: htmlToText(html), html };
+  return { text: "" };
+}
+function toAddress(contact) {
+  return contact.name ? { name: contact.name, address: contact.email } : contact.email;
+}
+function toAddressList(contacts) {
+  return contacts?.length ? contacts.map(toAddress) : void 0;
+}
+async function buildMimeMessage(from, params) {
+  const { text, html } = normalizeBody(params.body);
+  const mail = {
+    from,
+    to: toAddressList(params.to),
+    cc: toAddressList(params.cc),
+    bcc: toAddressList(params.bcc),
+    subject: params.subject,
+    text,
+    html,
+    inReplyTo: params.inReplyTo,
+    references: params.references?.length ? params.references : void 0,
+    attachments: params.attachments?.map((a) => ({
+      filename: a.filename,
+      content: a.content,
+      contentType: a.contentType
+    }))
+  };
+  const node = new MailComposer(mail).compile();
+  node.keepBcc = true;
+  return node.build();
+}
+
 // src/providers/gmail/adapter.ts
 var GmailAdapter = class {
   providerType = ProviderType.Gmail;
@@ -1034,7 +1081,7 @@ var GmailAdapter = class {
   }
   async sendEmail(params) {
     const gmail = this.ensureConnected();
-    const raw = this.buildRfc2822(params);
+    const raw = await this.buildRaw(params);
     const res = await gmail.users.messages.send({
       userId: "me",
       requestBody: { raw }
@@ -1046,7 +1093,7 @@ var GmailAdapter = class {
   }
   async createDraft(params) {
     const gmail = this.ensureConnected();
-    const raw = this.buildRfc2822(params);
+    const raw = await this.buildRaw(params);
     const res = await gmail.users.drafts.create({
       userId: "me",
       requestBody: {
@@ -1057,7 +1104,7 @@ var GmailAdapter = class {
   }
   async updateDraft(draftId, params) {
     const gmail = this.ensureConnected();
-    const raw = this.buildRfc2822(params);
+    const raw = await this.buildRaw(params);
     const res = await gmail.users.drafts.update({
       userId: "me",
       id: draftId,
@@ -1330,23 +1377,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",
@@ -1357,25 +1417,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
@@ -1386,30 +1432,71 @@ var GmailAdapter = class {
     const gmail = this.ensureConnected();
     await gmail.users.settings.filters.delete({ userId: "me", id: ruleId });
   }
-  buildRfc2822(params) {
-    const lines = [];
-    lines.push(`From: ${this.email}`);
-    lines.push(
-      `To: ${params.to.map((c) => c.name ? `"${c.name}" <${c.email}>` : c.email).join(", ")}`
+  /**
+   * 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 (params.cc?.length) {
-      lines.push(`Cc: ${params.cc.map((c) => c.email).join(", ")}`);
-    }
-    if (params.bcc?.length) {
-      lines.push(`Bcc: ${params.bcc.map((c) => c.email).join(", ")}`);
+    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.`
+      );
     }
-    lines.push(`Subject: ${params.subject}`);
-    if (params.inReplyTo) {
-      lines.push(`In-Reply-To: ${params.inReplyTo}`);
+    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.`
+      );
     }
-    if (params.references?.length) {
-      lines.push(`References: ${params.references.join(" ")}`);
+    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.`);
     }
-    lines.push("MIME-Version: 1.0");
-    lines.push("Content-Type: text/plain; charset=UTF-8");
-    lines.push("");
-    lines.push(params.body.text || params.body.html || "");
-    return Buffer.from(lines.join("\r\n")).toString("base64url");
+    await this.deleteBlockRule(ruleId);
+  }
+  /**
+   * 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
+   * was given (or a text part derived from HTML-only input), encoded headers
+   * and any attachments. See `buildMimeMessage`.
+   */
+  async buildRaw(params) {
+    const message = await buildMimeMessage(this.email, params);
+    return message.toString("base64url");
   }
 };
 
@@ -1561,7 +1648,7 @@ function buildGraphFilter(query) {
 }
 
 // src/providers/outlook/adapter.ts
-var OutlookAdapter = class {
+var OutlookAdapter = class _OutlookAdapter {
   providerType = ProviderType.Outlook;
   client = null;
   accountId = "";
@@ -1929,28 +2016,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,
@@ -1961,36 +2073,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();
@@ -2094,14 +2236,15 @@ function createSmtpTransport(email, creds) {
   });
 }
 async function sendViaSmtp(transport, from, params) {
+  const { text, html } = normalizeBody(params.body);
   const result = await transport.sendMail({
     from,
-    to: params.to.map((c) => c.name ? `"${c.name}" <${c.email}>` : c.email).join(", "),
-    cc: params.cc?.map((c) => c.email).join(", "),
-    bcc: params.bcc?.map((c) => c.email).join(", "),
+    to: params.to.map(toAddress),
+    cc: params.cc?.length ? params.cc.map(toAddress) : void 0,
+    bcc: params.bcc?.length ? params.bcc.map(toAddress) : void 0,
     subject: params.subject,
-    text: params.body.text,
-    html: params.body.html,
+    text,
+    html,
     inReplyTo: params.inReplyTo,
     references: params.references?.join(" "),
     attachments: params.attachments?.map((a) => ({
@@ -2572,26 +2715,17 @@ var ImapAdapter = class {
     const messageId = await sendViaSmtp(transport, this.email, params);
     return { id: messageId };
   }
-  buildDraftRfc2822(params) {
-    const lines = [];
-    lines.push(`From: ${this.email}`);
-    lines.push(`To: ${params.to.map((c) => c.name ? `"${c.name}" <${c.email}>` : c.email).join(", ")}`);
-    if (params.cc?.length) {
-      lines.push(`Cc: ${params.cc.map((c) => c.email).join(", ")}`);
-    }
-    lines.push(`Subject: ${params.subject}`);
-    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toUTCString()}`);
-    if (params.inReplyTo) lines.push(`In-Reply-To: ${params.inReplyTo}`);
-    if (params.references?.length) lines.push(`References: ${params.references.join(" ")}`);
-    lines.push("MIME-Version: 1.0");
-    lines.push("Content-Type: text/plain; charset=utf-8");
-    lines.push("");
-    lines.push(params.body.text || "");
-    return lines.join("\r\n");
+  /**
+   * Builds the full MIME message a draft is stored as: text and HTML parts,
+   * Bcc kept so the draft remembers its recipients, encoded headers and any
+   * attachments. See `buildMimeMessage`.
+   */
+  buildDraftMessage(params) {
+    return buildMimeMessage(this.email, params);
   }
   async createDraft(params) {
     const client = await this.ensureConnected();
-    const rawMessage = this.buildDraftRfc2822(params);
+    const rawMessage = await this.buildDraftMessage(params);
     const draftsFolder = await this.resolveFolder("Drafts");
     const result = await client.append(draftsFolder, rawMessage, ["\\Draft", "\\Seen"]);
     if (!result) throw new Error("Failed to append draft");
@@ -2606,6 +2740,7 @@ var ImapAdapter = class {
   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);
@@ -2617,7 +2752,6 @@ var ImapAdapter = class {
     } finally {
       lock.release();
     }
-    const rawMessage = this.buildDraftRfc2822(params);
     const result = await client.append(draftsFolder, rawMessage, ["\\Draft", "\\Seen"]);
     if (!result) throw new Error("Failed to append updated draft");
     return { id: String(result.uid || result) };
@@ -3366,6 +3500,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(`