@marlinjai/email-mcp 1.2.8 → 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) {
@@ -363,6 +366,7 @@ var FolderType = {
 };
 
 // src/providers/gmail/adapter.ts
+import { Readable } from "node:stream";
 import { google } from "googleapis";
 import { OAuth2Client as OAuth2Client2 } from "google-auth-library";
 
@@ -567,20 +571,32 @@ var GmailAdapter = class {
   async search(query) {
     const gmail = this.ensureConnected();
     const q = buildGmailQuery(query);
-    const params = {
-      userId: "me",
-      maxResults: query.limit || 20
-    };
-    if (q) params.q = q;
-    if (query.folder) params.labelIds = [query.folder];
-    const res = await gmail.users.messages.list(params);
-    const messages = res.data.messages || [];
-    if (messages.length === 0) return [];
+    const limit = query.limit || 20;
+    const offset = query.offset || 0;
+    const needed = offset + limit;
+    const ids = [];
+    let pageToken;
+    do {
+      const params = {
+        userId: "me",
+        maxResults: Math.min(500, needed - ids.length)
+      };
+      if (q) params.q = q;
+      if (query.folder) params.labelIds = [query.folder];
+      if (pageToken) params.pageToken = pageToken;
+      const res = await gmail.users.messages.list(params);
+      for (const msg of res.data.messages || []) {
+        if (msg.id) ids.push(msg.id);
+      }
+      pageToken = res.data.nextPageToken || void 0;
+    } while (pageToken && ids.length < needed);
+    const windowIds = ids.slice(offset, offset + limit);
+    if (windowIds.length === 0) return [];
     const emails = [];
-    for (const msg of messages) {
+    for (const id of windowIds) {
       const full = await gmail.users.messages.get({
         userId: "me",
-        id: msg.id,
+        id,
         format: "full"
       });
       emails.push(mapGmailMessage(full.data, this.accountId));
@@ -828,6 +844,40 @@ var GmailAdapter = class {
     }
     return result;
   }
+  async getRawMessage(emailId, _sourceFolder) {
+    const gmail = this.ensureConnected();
+    const res = await gmail.users.messages.get({
+      userId: "me",
+      id: emailId,
+      format: "raw"
+    });
+    return Buffer.from(res.data.raw || "", "base64url");
+  }
+  async appendRawMessage(raw, targetFolder, flags) {
+    const gmail = this.ensureConnected();
+    const labelIds = [];
+    labelIds.push(targetFolder ? await this.resolveLabelId(targetFolder) : "INBOX");
+    if (flags?.read === false) labelIds.push("UNREAD");
+    if (flags?.starred === true) labelIds.push("STARRED");
+    const res = await gmail.users.messages.insert({
+      userId: "me",
+      internalDateSource: "dateHeader",
+      requestBody: { labelIds },
+      media: { mimeType: "message/rfc822", body: Readable.from(raw) }
+    });
+    return { id: res.data.id || "" };
+  }
+  /** Resolve a Gmail label name or id to a label id (accepts either). */
+  async resolveLabelId(nameOrId) {
+    const gmail = this.ensureConnected();
+    const res = await gmail.users.labels.list({ userId: "me" });
+    const labels = res.data.labels || [];
+    const byId = labels.find((l) => l.id === nameOrId);
+    if (byId?.id) return byId.id;
+    const byName = labels.find((l) => (l.name || "").toLowerCase() === nameOrId.toLowerCase());
+    if (byName?.id) return byName.id;
+    return nameOrId;
+  }
   async addLabels(emailId, labels) {
     const gmail = this.ensureConnected();
     await gmail.users.messages.modify({
@@ -854,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}`);
@@ -1209,6 +1327,41 @@ var OutlookAdapter = class {
       destinationId
     });
   }
+  async getRawMessage(emailId, _sourceFolder) {
+    this.ensureClient();
+    const res = await fetch(
+      `https://graph.microsoft.com/v1.0/me/messages/${encodeURIComponent(emailId)}/$value`,
+      { headers: { Authorization: `Bearer ${this.accessToken}` } }
+    );
+    if (!res.ok) {
+      throw new Error(`Graph $value fetch failed for ${emailId}: HTTP ${res.status}`);
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  async appendRawMessage(raw, targetFolder, flags) {
+    this.ensureClient();
+    const endpoint = targetFolder ? `https://graph.microsoft.com/v1.0/me/mailFolders/${encodeURIComponent(await this.resolveFolder(targetFolder))}/messages` : "https://graph.microsoft.com/v1.0/me/messages";
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "text/plain"
+      },
+      body: raw.toString("base64")
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`Graph MIME import failed: HTTP ${res.status} ${detail.slice(0, 200)}`);
+    }
+    const data = await res.json().catch(() => ({}));
+    if (flags && data.id && (flags.read !== void 0 || flags.starred !== void 0)) {
+      try {
+        await this.markEmail(data.id, flags);
+      } catch {
+      }
+    }
+    return { id: data.id || "" };
+  }
   async deleteEmail(emailId, permanent, _sourceFolder) {
     const client = this.ensureClient();
     if (permanent) {
@@ -1338,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();
@@ -1887,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";
@@ -1931,6 +2188,32 @@ var ImapAdapter = class {
       lock.release();
     }
   }
+  async getRawMessage(emailId, sourceFolder) {
+    if (!this.client) throw new Error("Not connected");
+    const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
+    let lock;
+    try {
+      lock = await this.client.getMailboxLock(folder);
+    } catch (error) {
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
+    }
+    try {
+      const msg = await this.client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
+      if (!msg || !msg.source) throw new Error(`Email ${emailId} not found in "${folder}"`);
+      return msg.source;
+    } finally {
+      lock.release();
+    }
+  }
+  async appendRawMessage(raw, targetFolder, flags) {
+    if (!this.client) throw new Error("Not connected");
+    const folder = targetFolder ? await this.resolveFolder(targetFolder) : "INBOX";
+    const imapFlags = [];
+    if (flags?.read) imapFlags.push("\\Seen");
+    if (flags?.starred) imapFlags.push("\\Flagged");
+    const result = await this.client.append(folder, raw, imapFlags);
+    return { id: String(result?.uid ?? "") };
+  }
   async batchDelete(emailIds, permanent, sourceFolder) {
     if (!this.client) throw new Error("Not connected");
     const result = { succeeded: [], failed: [] };