@marlinjai/email-mcp 1.8.1 → 1.9.0

package/dist/setup/wizard.js

@@ -1377,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",
@@ -1404,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
@@ -1433,6 +1432,62 @@ 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);
+  }
   /**
    * 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 +1648,7 @@ function buildGraphFilter(query) {
 }
 
 // src/providers/outlook/adapter.ts
-var OutlookAdapter = class {
+var OutlookAdapter = class _OutlookAdapter {
   providerType = ProviderType.Outlook;
   client = null;
   accountId = "";
@@ -1961,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,
@@ -1993,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();
@@ -3390,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(`