@marlinjai/email-mcp 1.3.0 → 1.4.1

package/dist/setup/wizard.js

@@ -4,7 +4,101 @@
 // src/setup/wizard.ts
 import crypto3 from "node:crypto";
 import { exec } from "node:child_process";
-import inquirer from "inquirer";
+
+// src/setup/prompts.ts
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+var CTRL_C = "";
+var CTRL_D = "";
+var BACKSPACE = "\x7F";
+var sharedInterface = null;
+function getInterface() {
+  if (!sharedInterface) {
+    sharedInterface = readline.createInterface({ input, output });
+  }
+  return sharedInterface;
+}
+function closePrompts() {
+  sharedInterface?.close();
+  sharedInterface = null;
+}
+async function askText(message, defaultValue) {
+  const rl = getInterface();
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const answer = await rl.question(`${message}${suffix} `);
+  const trimmed = answer.trim();
+  return trimmed.length > 0 ? trimmed : defaultValue ?? "";
+}
+async function askValidated(message, defaultValue, validate) {
+  for (; ; ) {
+    const value = await askText(message, defaultValue);
+    const result = validate(value);
+    if (result === true) return value;
+    console.log(`  ${result}`);
+  }
+}
+async function askConfirm(message, defaultValue = false) {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const answer = await askText(`${message} (${suffix})`);
+  if (!answer) return defaultValue;
+  return /^y/i.test(answer);
+}
+async function askChoice(message, choices) {
+  console.log(message);
+  choices.forEach((c, i) => console.log(`  ${i + 1}) ${c.name}`));
+  for (; ; ) {
+    const answer = await askText("Enter a number:");
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < choices.length) return choices[idx].value;
+    console.log(`  Please enter a number between 1 and ${choices.length}.`);
+  }
+}
+function askPassword(message) {
+  return new Promise((resolve) => {
+    output.write(`${message} `);
+    if (!input.isTTY || typeof input.setRawMode !== "function") {
+      const rl = getInterface();
+      rl.question("").then(resolve);
+      return;
+    }
+    let value = "";
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    const cleanup = () => {
+      input.setRawMode(false);
+      input.pause();
+      input.removeListener("data", onData);
+    };
+    const onData = (char) => {
+      switch (char) {
+        case "\n":
+        case "\r":
+        case CTRL_D:
+          cleanup();
+          output.write("\n");
+          resolve(value);
+          break;
+        case CTRL_C:
+          cleanup();
+          output.write("\n");
+          process.exit(130);
+          break;
+        case BACKSPACE:
+        case "\b":
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            output.write("\b \b");
+          }
+          break;
+        default:
+          value += char;
+          output.write("*");
+      }
+    };
+    input.on("data", onData);
+  });
+}
 
 // src/auth/credential-store.ts
 import crypto from "node:crypto";
@@ -264,7 +358,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 +998,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 +1585,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 +2214,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";
@@ -2352,15 +2621,7 @@ async function testAndSave(creds) {
   }
 }
 async function promptAccountName(defaultName) {
-  const { name } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "name",
-      message: "Account name:",
-      default: defaultName
-    }
-  ]);
-  return name;
+  return askText("Account name:", defaultName);
 }
 async function setupGmail() {
   console.log("\n--- Gmail Setup ---");
@@ -2452,30 +2713,25 @@ async function setupICloud() {
   console.log(
     "You need an app-specific password for iCloud Mail.\nGenerate one at https://appleid.apple.com/account/manage\n(Sign In & Security > App-Specific Passwords)\n"
   );
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "email",
-      message: "iCloud email address:",
-      validate: (v) => v.includes("@") || "Enter a valid email address"
-    },
-    {
-      type: "password",
-      name: "password",
-      message: "App-specific password:",
-      mask: "*",
-      validate: (v) => v.trim().length > 0 || "Password is required"
-    }
-  ]);
+  const email = await askValidated(
+    "iCloud email address:",
+    void 0,
+    (v) => v.includes("@") || "Enter a valid email address"
+  );
+  let password = await askPassword("App-specific password:");
+  while (password.trim().length === 0) {
+    console.log("  Password is required");
+    password = await askPassword("App-specific password:");
+  }
   const name = await promptAccountName("iCloud");
   const id = crypto3.randomUUID();
   const creds = {
     id,
     name,
     provider: ProviderType.ICloud,
-    email: answers.email.trim(),
+    email: email.trim(),
     password: {
-      password: answers.password,
+      password,
       host: "imap.mail.me.com",
       port: 993,
       tls: true,
@@ -2487,72 +2743,26 @@ async function setupICloud() {
 }
 async function setupIMAP() {
   console.log("\n--- Generic IMAP Setup ---\n");
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "email",
-      message: "Email address:",
-      validate: (v) => v.includes("@") || "Enter a valid email address"
-    },
-    {
-      type: "input",
-      name: "host",
-      message: "IMAP host:",
-      validate: (v) => v.trim().length > 0 || "Host is required"
-    },
-    {
-      type: "input",
-      name: "port",
-      message: "IMAP port:",
-      default: "993",
-      validate: (v) => {
-        const n = parseInt(v, 10);
-        return n > 0 && n <= 65535 || "Enter a valid port number (1-65535)";
-      }
-    },
-    {
-      type: "confirm",
-      name: "tls",
-      message: "Use TLS?",
-      default: true
-    },
-    {
-      type: "password",
-      name: "password",
-      message: "Password:",
-      mask: "*",
-      validate: (v) => v.trim().length > 0 || "Password is required"
-    },
-    {
-      type: "confirm",
-      name: "configureSmtp",
-      message: "Configure SMTP (for sending)?",
-      default: false
-    }
-  ]);
+  const portValidator = (v) => {
+    const n = parseInt(v, 10);
+    return n > 0 && n <= 65535 || "Enter a valid port number (1-65535)";
+  };
+  const email = await askValidated("Email address:", void 0, (v) => v.includes("@") || "Enter a valid email address");
+  const host = await askValidated("IMAP host:", void 0, (v) => v.trim().length > 0 || "Host is required");
+  const portStr = await askValidated("IMAP port:", "993", portValidator);
+  const tls = await askConfirm("Use TLS?", true);
+  let password = await askPassword("Password:");
+  while (password.trim().length === 0) {
+    console.log("  Password is required");
+    password = await askPassword("Password:");
+  }
+  const configureSmtp = await askConfirm("Configure SMTP (for sending)?", false);
   let smtpHost;
   let smtpPort;
-  if (answers.configureSmtp) {
-    const smtp = await inquirer.prompt([
-      {
-        type: "input",
-        name: "smtpHost",
-        message: "SMTP host:",
-        validate: (v) => v.trim().length > 0 || "SMTP host is required"
-      },
-      {
-        type: "input",
-        name: "smtpPort",
-        message: "SMTP port:",
-        default: "587",
-        validate: (v) => {
-          const n = parseInt(v, 10);
-          return n > 0 && n <= 65535 || "Enter a valid port number (1-65535)";
-        }
-      }
-    ]);
-    smtpHost = smtp.smtpHost.trim();
-    smtpPort = parseInt(smtp.smtpPort, 10);
+  if (configureSmtp) {
+    smtpHost = await askValidated("SMTP host:", void 0, (v) => v.trim().length > 0 || "SMTP host is required");
+    const smtpPortStr = await askValidated("SMTP port:", "587", portValidator);
+    smtpPort = parseInt(smtpPortStr, 10);
   }
   const name = await promptAccountName("IMAP");
   const id = crypto3.randomUUID();
@@ -2560,12 +2770,12 @@ async function setupIMAP() {
     id,
     name,
     provider: ProviderType.IMAP,
-    email: answers.email.trim(),
+    email: email.trim(),
     password: {
-      password: answers.password,
-      host: answers.host.trim(),
-      port: parseInt(answers.port, 10),
-      tls: answers.tls,
+      password,
+      host: host.trim(),
+      port: parseInt(portStr, 10),
+      tls,
       smtpHost,
       smtpPort
     }
@@ -2595,14 +2805,7 @@ async function removeAccount(id) {
     console.error(`Account not found: ${id}`);
     process.exit(1);
   }
-  const { confirm } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirm",
-      message: `Remove account "${acct.name}" (${acct.email})?`,
-      default: false
-    }
-  ]);
+  const confirm = await askConfirm(`Remove account "${acct.name}" (${acct.email})?`, false);
   if (confirm) {
     await store.remove(id);
     console.log(`Account "${acct.name}" removed.`);
@@ -2629,18 +2832,11 @@ async function main() {
   console.log("@marlinjai/email-mcp Account Setup\n");
   let addMore = true;
   while (addMore) {
-    const { provider } = await inquirer.prompt([
-      {
-        type: "rawlist",
-        name: "provider",
-        message: "Select provider:",
-        choices: [
-          { name: "Gmail", value: "gmail" },
-          { name: "Outlook", value: "outlook" },
-          { name: "iCloud", value: "icloud" },
-          { name: "Other IMAP", value: "imap" }
-        ]
-      }
+    const provider = await askChoice("Select provider:", [
+      { name: "Gmail", value: "gmail" },
+      { name: "Outlook", value: "outlook" },
+      { name: "iCloud", value: "icloud" },
+      { name: "Other IMAP", value: "imap" }
     ]);
     switch (provider) {
       case ProviderType.Gmail:
@@ -2659,15 +2855,7 @@ async function main() {
         console.error(`Unknown provider: ${provider}`);
         process.exit(1);
     }
-    const { another } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "another",
-        message: "Would you like to add another email account?",
-        default: false
-      }
-    ]);
-    addMore = another;
+    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.");
 }
@@ -2675,5 +2863,5 @@ main().catch((err) => {
   console.error(`
 Setup failed: ${err.message}`);
   process.exit(1);
-});
+}).finally(closePrompts);
 //# sourceMappingURL=wizard.js.map