@marlinjai/email-mcp 1.3.0 → 1.4.0

package/dist/setup/wizard.js

@@ -264,7 +264,10 @@ function createFileCachePlugin(cacheFilePath) {
 }
 var OutlookAuth = class _OutlookAuth {
   static AUTHORITY = "https://login.microsoftonline.com/consumers";
-  static SCOPES = ["Mail.ReadWrite", "Mail.Send", "offline_access"];
+  // MailboxSettings.ReadWrite is required for the messageRules API (block
+  // rules) — confirmed by Microsoft's own docs to be supported for personal
+  // Microsoft accounts (not just work/school), not just Mail.ReadWrite/Send.
+  static SCOPES = ["Mail.ReadWrite", "Mail.Send", "MailboxSettings.ReadWrite", "offline_access"];
   pca;
   cryptoProvider;
   constructor(clientId, cacheFilePath) {
@@ -901,6 +904,74 @@ var GmailAdapter = class {
       messageCount: label.messagesTotal ?? 0
     }));
   }
+  /**
+   * Trains Gmail's own spam filter — the same signal the "Report spam" UI
+   * button sends (add SPAM, drop INBOX). Not an abuse report to Google.
+   */
+  async reportSpam(emailId, _sourceFolder) {
+    const gmail = this.ensureConnected();
+    await gmail.users.messages.modify({
+      userId: "me",
+      id: emailId,
+      requestBody: { addLabelIds: ["SPAM"], removeLabelIds: ["INBOX"] }
+    });
+  }
+  async createBlockRule(rule) {
+    const gmail = this.ensureConnected();
+    const criteria = {};
+    switch (rule.matchType) {
+      case "senderDomain":
+        criteria.from = `@${rule.value}`;
+        break;
+      case "senderAddress":
+        criteria.from = rule.value;
+        break;
+      case "subjectContains":
+        criteria.subject = rule.value;
+        break;
+      case "headerContains":
+        criteria.query = rule.value;
+        break;
+    }
+    const action = rule.action === "delete" ? { addLabelIds: ["TRASH"] } : { addLabelIds: ["SPAM"], removeLabelIds: ["INBOX"] };
+    const res = await gmail.users.settings.filters.create({
+      userId: "me",
+      requestBody: { criteria, action }
+    });
+    return { id: res.data.id || "" };
+  }
+  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 || {};
+      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,
+        action: addLabelIds.includes("TRASH") ? "delete" : "moveToJunk",
+        createdAt: ""
+        // Gmail's filter API does not expose a creation timestamp
+      };
+    });
+  }
+  async deleteBlockRule(ruleId) {
+    const gmail = this.ensureConnected();
+    await gmail.users.settings.filters.delete({ userId: "me", id: ruleId });
+  }
   buildRfc2822(params) {
     const lines = [];
     lines.push(`From: ${this.email}`);
@@ -1420,6 +1491,86 @@ var OutlookAdapter = class {
     }
     return result;
   }
+  /**
+   * Trains Outlook's own spam filter — the same signal "Report Junk" sends
+   * in the UI (move to the Junk Email well-known folder). Not an abuse
+   * report to Microsoft's security team.
+   */
+  async reportSpam(emailId, _sourceFolder) {
+    const client = this.ensureClient();
+    await client.api(`/me/messages/${encodeURIComponent(emailId)}/move`).post({
+      destinationId: "junkemail"
+    });
+  }
+  /**
+   * Requires the `MailboxSettings.ReadWrite` delegated scope, confirmed by
+   * Microsoft's own docs to be supported for personal Microsoft accounts
+   * (outlook.com/hotmail), not just work/school. Accounts authenticated
+   * 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();
+    const conditions = {};
+    switch (rule.matchType) {
+      case "senderDomain":
+      case "senderAddress":
+        conditions.senderContains = [rule.value];
+        break;
+      case "subjectContains":
+        conditions.subjectContains = [rule.value];
+        break;
+      case "headerContains":
+        conditions.headerContains = [rule.value];
+        break;
+    }
+    const actions = { stopProcessingRules: true };
+    if (rule.action === "delete") {
+      actions.delete = true;
+    } else {
+      actions.moveToFolder = await this.resolveFolder("junkemail");
+    }
+    const existing = await this.listBlockRules();
+    const result = await client.api("/me/mailFolders/inbox/messageRules").post({
+      displayName: `email-mcp: ${rule.matchType} "${rule.value}"`.slice(0, 255),
+      sequence: existing.length + 1,
+      isEnabled: true,
+      conditions,
+      actions
+    });
+    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
+      };
+    });
+  }
+  async deleteBlockRule(ruleId) {
+    const client = this.ensureClient();
+    await client.api(`/me/mailFolders/inbox/messageRules/${encodeURIComponent(ruleId)}`).delete();
+  }
   async getCategories() {
     const client = this.ensureClient();
     const response = await client.api("/me/outlook/masterCategories").get();
@@ -1969,6 +2120,30 @@ var ImapAdapter = class {
       lock.release();
     }
   }
+  /**
+   * Best-effort only: generic IMAP has no server-side ML classifier to
+   * train, so this just moves the message to the account's Junk-typed
+   * folder (via the same alias resolution `deleteEmail` uses for Trash).
+   * No standing block-rule mechanism exists across IMAP servers (Sieve
+   * exists on some but isn't universal), so `createBlockRule` is
+   * intentionally left unimplemented for this provider.
+   */
+  async reportSpam(emailId, sourceFolder) {
+    if (!this.client) throw new Error("Not connected");
+    const folder = sourceFolder || "INBOX";
+    const junkFolder = await this.resolveFolder("junk");
+    let lock;
+    try {
+      lock = await this.client.getMailboxLock(folder);
+    } catch (error) {
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
+    }
+    try {
+      await this.client.messageMove(emailId, junkFolder, { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
   async deleteEmail(emailId, permanent, sourceFolder) {
     if (!this.client) throw new Error("Not connected");
     const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";