@marlinjai/email-mcp 1.4.4 → 1.7.0

package/dist/index.js

@@ -35,18 +35,62 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/auth/credential-store.ts
 import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-function getMachineSeed() {
-  return `email-mcp:${os.hostname()}:${os.userInfo().username}`;
+function getStableMachineId() {
+  if (cachedMachineId !== void 0) return cachedMachineId;
+  cachedMachineId = computeStableMachineId();
+  return cachedMachineId;
 }
-function deriveKey(salt) {
-  return crypto.pbkdf2Sync(getMachineSeed(), salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
+function computeStableMachineId() {
+  try {
+    if (process.platform === "darwin") {
+      const out = execFileSync("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+        encoding: "utf-8"
+      });
+      const match = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      return match ? match[1] : null;
+    }
+    if (process.platform === "linux") {
+      for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        if (fs.existsSync(p)) {
+          const id = fs.readFileSync(p, "utf-8").trim();
+          if (id) return id;
+        }
+      }
+      return null;
+    }
+    if (process.platform === "win32") {
+      const out = execFileSync(
+        "reg",
+        ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"],
+        { encoding: "utf-8" }
+      );
+      const match = out.match(/MachineGuid\s+REG_SZ\s+([A-Za-z0-9-]+)/);
+      return match ? match[1] : null;
+    }
+  } catch {
+  }
+  return null;
 }
-function encrypt(plaintext) {
+function getSeedCandidates() {
+  const seeds = [];
+  const username = os.userInfo().username;
+  const envKey = process.env.EMAIL_MCP_KEY;
+  if (envKey) seeds.push(`email-mcp:env:${envKey}`);
+  const machineId = getStableMachineId();
+  if (machineId) seeds.push(`email-mcp:machine:${machineId}:${username}`);
+  seeds.push(`email-mcp:${os.hostname()}:${username}`);
+  return seeds;
+}
+function deriveKey(seed, salt) {
+  return crypto.pbkdf2Sync(seed, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
+}
+function encrypt(plaintext, seed) {
   const salt = crypto.randomBytes(SALT_LENGTH);
-  const key = deriveKey(salt);
+  const key = deriveKey(seed, salt);
   const iv = crypto.randomBytes(IV_LENGTH);
   const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
   let encrypted = cipher.update(plaintext, "utf-8", "hex");
@@ -59,16 +103,27 @@ function encrypt(plaintext) {
     data: encrypted
   });
 }
-function decrypt(ciphertext) {
+function decrypt(ciphertext, seeds) {
   const { salt, iv, authTag, data } = JSON.parse(ciphertext);
-  const key = deriveKey(Buffer.from(salt, "hex"));
-  const decipher = crypto.createDecipheriv(ALGORITHM, key, Buffer.from(iv, "hex"));
-  decipher.setAuthTag(Buffer.from(authTag, "hex"));
-  let decrypted = decipher.update(data, "hex", "utf-8");
-  decrypted += decipher.final("utf-8");
-  return decrypted;
-}
-var ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, PBKDF2_ITERATIONS, CredentialStore;
+  const saltBuf = Buffer.from(salt, "hex");
+  const ivBuf = Buffer.from(iv, "hex");
+  const authTagBuf = Buffer.from(authTag, "hex");
+  let lastError;
+  for (const seed of seeds) {
+    try {
+      const key = deriveKey(seed, saltBuf);
+      const decipher = crypto.createDecipheriv(ALGORITHM, key, ivBuf);
+      decipher.setAuthTag(authTagBuf);
+      let decrypted = decipher.update(data, "hex", "utf-8");
+      decrypted += decipher.final("utf-8");
+      return { plaintext: decrypted, seedUsed: seed };
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError ?? new Error("Unable to decrypt credentials");
+}
+var ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, PBKDF2_ITERATIONS, cachedMachineId, CredentialStore;
 var init_credential_store = __esm({
   "src/auth/credential-store.ts"() {
     "use strict";
@@ -91,12 +146,20 @@ var init_credential_store = __esm({
           return { accounts: {} };
         }
         const raw = fs.readFileSync(this.filePath, "utf-8");
-        const json2 = decrypt(raw);
-        return JSON.parse(json2);
+        const seeds = getSeedCandidates();
+        const { plaintext, seedUsed } = decrypt(raw, seeds);
+        const data = JSON.parse(plaintext);
+        if (seedUsed !== seeds[0]) {
+          try {
+            this.write(data);
+          } catch {
+          }
+        }
+        return data;
       }
       write(data) {
         const json2 = JSON.stringify(data);
-        const encrypted = encrypt(json2);
+        const encrypted = encrypt(json2, getSeedCandidates()[0]);
         fs.writeFileSync(this.filePath, encrypted, { mode: 384 });
       }
       async save(creds) {
@@ -3314,8 +3377,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input2 = path3;
+    function removeDotSegments(path4) {
+      let input2 = path4;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -3514,8 +3577,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path4, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6877,12 +6940,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs4, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs4[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -7119,11 +7182,12 @@ var init_adapter = __esm({
         const labels = res.data.labels || [];
         return labels.map(mapGmailLabel);
       }
-      async createFolder(name) {
+      async createFolder(name, parentPath) {
         const gmail = this.ensureConnected();
+        const fullName = parentPath ? `${parentPath}/${name}` : name;
         const res = await gmail.users.labels.create({
           userId: "me",
-          requestBody: { name }
+          requestBody: { name: fullName }
         });
         return mapGmailLabel(res.data);
       }
@@ -7240,6 +7304,18 @@ var init_adapter = __esm({
         });
         return { id: res.data.id || "" };
       }
+      async updateDraft(draftId, params) {
+        const gmail = this.ensureConnected();
+        const raw = this.buildRfc2822(params);
+        const res = await gmail.users.drafts.update({
+          userId: "me",
+          id: draftId,
+          requestBody: {
+            message: { raw }
+          }
+        });
+        return { id: res.data.id || draftId };
+      }
       async listDrafts(limit, _offset) {
         const gmail = this.ensureConnected();
         const res = await gmail.users.drafts.list({
@@ -7403,6 +7479,34 @@ var init_adapter = __esm({
         }
         return result;
       }
+      async batchLabel(emailIds, addLabels, removeLabels) {
+        const gmail = this.ensureConnected();
+        const result = { succeeded: [], failed: [] };
+        const addLabelIds = addLabels ?? [];
+        const removeLabelIds = removeLabels ?? [];
+        if (addLabelIds.length === 0 && removeLabelIds.length === 0) {
+          result.succeeded = [...emailIds];
+          return result;
+        }
+        try {
+          await gmail.users.messages.batchModify({
+            userId: "me",
+            requestBody: { ids: emailIds, addLabelIds, removeLabelIds }
+          });
+          result.succeeded = [...emailIds];
+        } catch (error48) {
+          for (const id of emailIds) {
+            try {
+              if (addLabelIds.length > 0) await this.addLabels(id, addLabelIds);
+              if (removeLabelIds.length > 0) await this.removeLabels(id, removeLabelIds);
+              result.succeeded.push(id);
+            } catch (e) {
+              result.failed.push({ id, error: e.message });
+            }
+          }
+        }
+        return result;
+      }
       async getRawMessage(emailId, _sourceFolder) {
         const gmail = this.ensureConnected();
         const res = await gmail.users.messages.get({
@@ -7563,18 +7667,37 @@ var init_adapter = __esm({
 // src/providers/gmail/auth.ts
 import { OAuth2Client as OAuth2Client2 } from "google-auth-library";
 import crypto2 from "node:crypto";
+function resolveScopeMode(explicit) {
+  if (explicit) return explicit;
+  return process.env.EMAIL_MCP_GMAIL_SCOPE?.toLowerCase() === "restricted" ? "restricted" : "full";
+}
 var GMAIL_SCOPES, GmailAuth;
 var init_auth = __esm({
   "src/providers/gmail/auth.ts"() {
     "use strict";
-    GMAIL_SCOPES = [
-      "https://mail.google.com/",
-      "https://www.googleapis.com/auth/gmail.modify",
-      // Mailbox content access (above) does NOT cover the Settings API —
-      // Google treats them as separate permission domains. Needed for
-      // users.settings.filters.* (email_create_block_rule/list/delete).
-      "https://www.googleapis.com/auth/gmail.settings.basic"
-    ];
+    GMAIL_SCOPES = {
+      full: [
+        // Gmail's maximum-permission scope. Superset of gmail.modify below;
+        // the only capability it adds is immediate, trash-bypassing permanent
+        // deletion (messages.delete / batchDelete with permanent: true).
+        "https://mail.google.com/",
+        "https://www.googleapis.com/auth/gmail.modify",
+        // Mailbox content access (above) does NOT cover the Settings API —
+        // Google treats them as separate permission domains. Needed for
+        // users.settings.filters.* (email_create_block_rule/list/delete).
+        "https://www.googleapis.com/auth/gmail.settings.basic"
+      ],
+      // Drops https://mail.google.com/ so an AI-triggered permanent delete
+      // can't happen: gmail.modify already covers every other read/write
+      // operation this server performs (read, send, label, archive, trash,
+      // drafts, filters). Choosing this mode means deleteEmail(..., permanent:
+      // true) and batchDelete(..., permanent: true) will fail with a Gmail API
+      // 403 instead of succeeding — everything else behaves identically.
+      restricted: [
+        "https://www.googleapis.com/auth/gmail.modify",
+        "https://www.googleapis.com/auth/gmail.settings.basic"
+      ]
+    };
     GmailAuth = class {
       clientId;
       clientSecret;
@@ -7584,13 +7707,13 @@ var init_auth = __esm({
         this.clientSecret = clientSecret;
         this.oauth2Client = new OAuth2Client2(clientId, clientSecret, redirectUri);
       }
-      getAuthUrl(redirectUri) {
+      getAuthUrl(redirectUri, scopeMode) {
         const codeVerifier = crypto2.randomBytes(32).toString("base64url");
         const codeChallenge = crypto2.createHash("sha256").update(codeVerifier).digest("base64url");
         this.oauth2Client = new OAuth2Client2(this.clientId, this.clientSecret, redirectUri);
         const url2 = this.oauth2Client.generateAuthUrl({
           access_type: "offline",
-          scope: GMAIL_SCOPES,
+          scope: GMAIL_SCOPES[resolveScopeMode(scopeMode)],
           prompt: "consent",
           code_challenge: codeChallenge,
           code_challenge_method: "S256"
@@ -7805,8 +7928,8 @@ var init_adapter2 = __esm({
           }
         });
         const originalApi = client.api.bind(client);
-        client.api = (path3) => {
-          return originalApi(path3).header("Prefer", 'IdType="ImmutableId"');
+        client.api = (path4) => {
+          return originalApi(path4).header("Prefer", 'IdType="ImmutableId"');
         };
         this.client = client;
       }
@@ -7947,6 +8070,12 @@ var init_adapter2 = __esm({
         const result = await client.api("/me/messages").post(message);
         return { id: result.id };
       }
+      async updateDraft(draftId, params) {
+        const client = this.ensureClient();
+        const message = this.buildGraphMessage(params);
+        await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(message);
+        return { id: draftId };
+      }
       async listDrafts(limit, offset) {
         const client = this.ensureClient();
         let request = client.api("/me/mailFolders/drafts/messages");
@@ -8499,6 +8628,7 @@ var init_adapter3 = __esm({
       accountId = "";
       email = "";
       passwordCreds = null;
+      connectingPromise = null;
       async connect(credentials) {
         if (!credentials.password) {
           throw new Error("IMAP adapter requires password credentials");
@@ -8506,23 +8636,87 @@ var init_adapter3 = __esm({
         this.accountId = credentials.id;
         this.email = credentials.email;
         this.passwordCreds = credentials.password;
-        this.client = new ImapFlow({
-          host: credentials.password.host,
-          port: credentials.password.port,
-          secure: credentials.password.tls,
-          auth: {
-            user: credentials.email,
-            pass: credentials.password.password
-          },
-          logger: false
-        });
-        await this.client.connect();
+        await this.ensureConnected();
       }
       async disconnect() {
         if (this.client) {
-          await this.client.logout();
+          try {
+            await this.client.logout();
+          } catch {
+          }
           this.client = null;
         }
+        this.passwordCreds = null;
+      }
+      /**
+       * Builds a fresh ImapFlow client from stored credentials and wires up
+       * close/error listeners so a dropped socket clears `this.client`, forcing
+       * the next `ensureConnected()` call to reconnect.
+       */
+      buildClient() {
+        if (!this.passwordCreds) {
+          throw new Error("Cannot build IMAP client without stored credentials");
+        }
+        const client = new ImapFlow({
+          host: this.passwordCreds.host,
+          port: this.passwordCreds.port,
+          secure: this.passwordCreds.tls,
+          auth: { user: this.email, pass: this.passwordCreds.password },
+          logger: false
+        });
+        const drop = () => {
+          if (this.client === client) this.client = null;
+        };
+        client.on("close", drop);
+        client.on("error", drop);
+        return client;
+      }
+      /**
+       * Returns true while the underlying ImapFlow socket is healthy.
+       * ImapFlow sets `usable=false` when the connection is closed, in the
+       * middle of logging out, or otherwise unsafe to issue commands on.
+       */
+      isClientUsable() {
+        return !!this.client && this.client.usable === true;
+      }
+      /**
+       * Guarantees a usable IMAP client and returns it. Reconnects transparently
+       * if the previous client was dropped (idle timeout, server-side disconnect,
+       * network flap). Concurrent callers share a single in-flight reconnect to
+       * avoid duplicate sessions.
+       *
+       * Callers should bind the result to a local `const client` and use that
+       * within the method instead of `this.client`, so a `'close'` event mid-call
+       * does not race the active operation.
+       */
+      async ensureConnected() {
+        if (this.connectingPromise) {
+          await this.connectingPromise;
+        }
+        if (!this.isClientUsable()) {
+          if (!this.passwordCreds) {
+            throw new Error("Not connected");
+          }
+          this.connectingPromise = (async () => {
+            if (this.client) {
+              try {
+                await this.client.logout();
+              } catch {
+              }
+              this.client = null;
+            }
+            const client = this.buildClient();
+            await client.connect();
+            this.client = client;
+          })().finally(() => {
+            this.connectingPromise = null;
+          });
+          await this.connectingPromise;
+        }
+        if (!this.client) {
+          throw new Error("IMAP client unavailable after reconnect attempt");
+        }
+        return this.client;
       }
       async testConnection() {
         try {
@@ -8533,14 +8727,14 @@ var init_adapter3 = __esm({
         }
       }
       async listFolders() {
-        if (!this.client) throw new Error("Not connected");
-        const imapFolders = await this.client.list();
+        const client = await this.ensureConnected();
+        const imapFolders = await client.list();
         return imapFolders.map(mapImapFolder);
       }
       async createFolder(name, parentPath) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const fullPath = parentPath ? `${parentPath}/${name}` : name;
-        const result = await this.client.mailboxCreate(fullPath);
+        const result = await client.mailboxCreate(fullPath);
         return {
           id: result.path,
           name: result.name || name,
@@ -8569,7 +8763,7 @@ var init_adapter3 = __esm({
        * and matching by name or special-use type.
        */
       async resolveFolder(folder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const FOLDER_ALIASES = {
           junk: ["Junk", "Spam", "Bulk Mail", "Junk E-mail", "Junk Email"],
           spam: ["Junk", "Spam", "Bulk Mail", "Junk E-mail", "Junk Email"],
@@ -8578,7 +8772,7 @@ var init_adapter3 = __esm({
           drafts: ["Drafts", "Draft"],
           archive: ["Archive", "All Mail"]
         };
-        const folders = await this.client.list();
+        const folders = await client.list();
         const lowerFolder = folder.toLowerCase();
         const exactMatch = folders.find(
           (f) => f.path === folder || f.path.toLowerCase() === lowerFolder
@@ -8616,7 +8810,7 @@ var init_adapter3 = __esm({
         return folder;
       }
       async search(query) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const requestedFolder = query.folder || "INBOX";
         let folder;
         try {
@@ -8625,17 +8819,25 @@ var init_adapter3 = __esm({
           folder = requestedFolder;
         }
         try {
-          await this.client.noop();
+          await client.noop();
         } catch {
         }
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
-          const mailboxExists = this.client.mailbox?.exists ?? 0;
+          let mailboxExists = client.mailbox?.exists ?? 0;
+          if (mailboxExists === 0) {
+            try {
+              const status = await client.status(folder, { messages: true });
+              mailboxExists = status?.messages ?? 0;
+            } catch {
+              mailboxExists = 0;
+            }
+          }
           if (mailboxExists === 0) {
             return [];
           }
@@ -8643,14 +8845,14 @@ var init_adapter3 = __esm({
           const hasCriteria = Object.keys(criteria).length > 0;
           let allUids = [];
           try {
-            const searchResult = await this.client.search(
+            const searchResult = await client.search(
               hasCriteria ? criteria : { all: true },
               { uid: true }
             );
             allUids = Array.isArray(searchResult) ? searchResult : [];
           } catch {
             try {
-              allUids = await this.collectUidsViaFetch(query);
+              allUids = await this.collectUidsViaFetch(client, query);
             } catch {
               return [];
             }
@@ -8658,7 +8860,7 @@ var init_adapter3 = __esm({
           const offset = query.offset || 0;
           const slicedUids = query.limit ? allUids.slice(offset, offset + query.limit) : allUids.slice(offset);
           if (slicedUids.length === 0) return [];
-          return await this.fetchEmails(slicedUids, folder, query.returnBody);
+          return await this.fetchEmails(client, slicedUids, folder, query.returnBody);
         } catch (error48) {
           throw formatImapError(error48, `Search failed in folder "${folder}"`);
         } finally {
@@ -8672,13 +8874,12 @@ var init_adapter3 = __esm({
        * 2. FETCH 1:N using mailbox.exists as explicit range
        * 3. Individual sequence number fetches (slowest but most resilient)
        */
-      async collectUidsViaFetch(query) {
-        if (!this.client) return [];
+      async collectUidsViaFetch(client, query) {
         const uids = [];
-        const exists = this.client.mailbox?.exists ?? 0;
+        const exists = client.mailbox?.exists ?? 0;
         const safeFetch = async (range) => {
           try {
-            const messages = await this.client.fetchAll(range, { uid: true, flags: true });
+            const messages = await client.fetchAll(range, { uid: true, flags: true });
             for (const msg of messages) {
               if (query.unreadOnly && msg.flags?.has("\\Seen")) continue;
               if (query.starredOnly && !msg.flags?.has("\\Flagged")) continue;
@@ -8698,7 +8899,7 @@ var init_adapter3 = __esm({
         const count = exists > 0 ? exists : 50;
         for (let seq = 1; seq <= count; seq++) {
           try {
-            const msgs = await this.client.fetchAll(String(seq), { uid: true, flags: true });
+            const msgs = await client.fetchAll(String(seq), { uid: true, flags: true });
             for (const msg of msgs) {
               if (query.unreadOnly && msg.flags?.has("\\Seen")) continue;
               if (query.starredOnly && !msg.flags?.has("\\Flagged")) continue;
@@ -8712,19 +8913,18 @@ var init_adapter3 = __esm({
       /**
        * Fetches email data for a set of UIDs, either with full body or lightweight headers.
        */
-      async fetchEmails(uids, folder, returnBody) {
-        if (!this.client) return [];
+      async fetchEmails(client, uids, folder, returnBody) {
         const emails = [];
         const fetchOpts = returnBody ? { source: true, uid: true, flags: true } : { envelope: true, uid: true, flags: true, bodyStructure: true };
         const uidRange = uids.join(",");
         let messages;
         try {
-          messages = await this.client.fetchAll(uidRange, fetchOpts, { uid: true });
+          messages = await client.fetchAll(uidRange, fetchOpts, { uid: true });
         } catch {
           messages = [];
           for (const uid of uids) {
             try {
-              const batch = await this.client.fetchAll(String(uid), fetchOpts, { uid: true });
+              const batch = await client.fetchAll(String(uid), fetchOpts, { uid: true });
               messages.push(...batch);
             } catch {
             }
@@ -8763,17 +8963,17 @@ var init_adapter3 = __esm({
         return emails;
       }
       async getEmail(id, folder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const targetFolder = folder || "INBOX";
         let lock;
         try {
-          lock = await this.client.getMailboxLock(targetFolder);
+          lock = await client.getMailboxLock(targetFolder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${targetFolder}"`);
         }
         try {
           const uid = parseInt(id, 10);
-          const msg = await this.client.fetchOne(String(uid), { source: true, uid: true, flags: true }, { uid: true });
+          const msg = await client.fetchOne(String(uid), { source: true, uid: true, flags: true }, { uid: true });
           if (!msg) throw new Error(`Email ${id} not found`);
           const parsed = await simpleParser(msg.source);
           parsed.flags = msg.flags;
@@ -8783,22 +8983,22 @@ var init_adapter3 = __esm({
         }
       }
       async getThread(threadId) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         let lock;
         try {
-          lock = await this.client.getMailboxLock("INBOX");
+          lock = await client.getMailboxLock("INBOX");
         } catch (error48) {
           throw formatImapError(error48, 'Failed to open folder "INBOX"');
         }
         try {
-          const searchResult = await this.client.search(
+          const searchResult = await client.search(
             { or: [{ header: { "message-id": threadId } }, { header: { references: threadId } }, { header: { "in-reply-to": threadId } }] },
             { uid: true }
           );
           const uids = Array.isArray(searchResult) ? searchResult : [];
           if (uids.length === 0) throw new Error(`Thread ${threadId} not found`);
           const messages = [];
-          for await (const msg of this.client.fetch(uids, { source: true, uid: true, flags: true })) {
+          for await (const msg of client.fetch(uids, { source: true, uid: true, flags: true })) {
             const parsed = await simpleParser(msg.source);
             parsed.flags = msg.flags;
             messages.push(mapParsedEmail(parsed, "INBOX", this.accountId, msg.uid));
@@ -8824,15 +9024,15 @@ var init_adapter3 = __esm({
         }
       }
       async getAttachment(emailId, attachmentId) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         let lock;
         try {
-          lock = await this.client.getMailboxLock("INBOX");
+          lock = await client.getMailboxLock("INBOX");
         } catch (error48) {
           throw formatImapError(error48, 'Failed to open folder "INBOX"');
         }
         try {
-          const msg = await this.client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
+          const msg = await client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
           if (!msg) throw new Error(`Email ${emailId} not found`);
           const parsed = await simpleParser(msg.source);
           const attachment = (parsed.attachments || []).find(
@@ -8858,8 +9058,7 @@ var init_adapter3 = __esm({
         const messageId = await sendViaSmtp(transport, this.email, params);
         return { id: messageId };
       }
-      async createDraft(params) {
-        if (!this.client) throw new Error("Not connected");
+      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(", ")}`);
@@ -8874,8 +9073,39 @@ var init_adapter3 = __esm({
         lines.push("Content-Type: text/plain; charset=utf-8");
         lines.push("");
         lines.push(params.body.text || "");
-        const rawMessage = lines.join("\r\n");
-        const result = await this.client.append("Drafts", rawMessage, ["\\Draft", "\\Seen"]);
+        return lines.join("\r\n");
+      }
+      async createDraft(params) {
+        const client = await this.ensureConnected();
+        const rawMessage = this.buildDraftRfc2822(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");
+        return { id: String(result.uid || result) };
+      }
+      /**
+       * IMAP has no in-place message update — a draft is just a message in the
+       * Drafts folder, and IMAP messages are immutable once appended. This
+       * deletes the old revision and appends a new one, so the returned `id`
+       * is a NEW uid; the old id no longer resolves after this call.
+       */
+      async updateDraft(draftId, params, sourceFolder) {
+        const client = await this.ensureConnected();
+        const draftsFolder = sourceFolder ? await this.resolveFolder(sourceFolder) : await this.resolveFolder("Drafts");
+        let lock;
+        try {
+          lock = await client.getMailboxLock(draftsFolder);
+        } catch (error48) {
+          throw formatImapError(error48, `Failed to open folder "${draftsFolder}"`);
+        }
+        try {
+          await client.messageDelete(draftId, { uid: true });
+        } 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) };
       }
       async listDrafts(limit, offset) {
@@ -8886,16 +9116,16 @@ var init_adapter3 = __esm({
         });
       }
       async moveEmail(emailId, targetFolder, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const folder = sourceFolder || "INBOX";
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
-          await this.client.messageMove(emailId, targetFolder, { uid: true });
+          await client.messageMove(emailId, targetFolder, { uid: true });
         } finally {
           lock.release();
         }
@@ -8925,44 +9155,44 @@ var init_adapter3 = __esm({
         }
       }
       async deleteEmail(emailId, permanent, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
         const trashFolder = await this.resolveFolder("Trash");
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           if (permanent || folder === trashFolder) {
-            await this.client.messageDelete(emailId, { uid: true });
+            await client.messageDelete(emailId, { uid: true });
           } else {
-            await this.client.messageMove(emailId, trashFolder, { uid: true });
+            await client.messageMove(emailId, trashFolder, { uid: true });
           }
         } finally {
           lock.release();
         }
       }
       async markEmail(emailId, flags, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const folder = sourceFolder || "INBOX";
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           if (flags.read === true) {
-            await this.client.messageFlagsAdd(emailId, ["\\Seen"], { uid: true });
+            await client.messageFlagsAdd(emailId, ["\\Seen"], { uid: true });
           } else if (flags.read === false) {
-            await this.client.messageFlagsRemove(emailId, ["\\Seen"], { uid: true });
+            await client.messageFlagsRemove(emailId, ["\\Seen"], { uid: true });
           }
           if (flags.starred === true || flags.flagged === true) {
-            await this.client.messageFlagsAdd(emailId, ["\\Flagged"], { uid: true });
+            await client.messageFlagsAdd(emailId, ["\\Flagged"], { uid: true });
           } else if (flags.starred === false || flags.flagged === false) {
-            await this.client.messageFlagsRemove(emailId, ["\\Flagged"], { uid: true });
+            await client.messageFlagsRemove(emailId, ["\\Flagged"], { uid: true });
           }
         } finally {
           lock.release();
@@ -8995,32 +9225,32 @@ var init_adapter3 = __esm({
         return { id: String(result?.uid ?? "") };
       }
       async batchDelete(emailIds, permanent, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const result = { succeeded: [], failed: [] };
         const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
         const trashFolder = await this.resolveFolder("Trash");
         const shouldPermanentDelete = permanent || folder === trashFolder;
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           const uidRange = emailIds.join(",");
           if (shouldPermanentDelete) {
-            await this.client.messageDelete(uidRange, { uid: true });
+            await client.messageDelete(uidRange, { uid: true });
           } else {
-            await this.client.messageMove(uidRange, trashFolder, { uid: true });
+            await client.messageMove(uidRange, trashFolder, { uid: true });
           }
           result.succeeded = [...emailIds];
         } catch (error48) {
           for (const id of emailIds) {
             try {
               if (shouldPermanentDelete) {
-                await this.client.messageDelete(id, { uid: true });
+                await client.messageDelete(id, { uid: true });
               } else {
-                await this.client.messageMove(id, trashFolder, { uid: true });
+                await client.messageMove(id, trashFolder, { uid: true });
               }
               result.succeeded.push(id);
             } catch (e) {
@@ -9033,23 +9263,23 @@ var init_adapter3 = __esm({
         return result;
       }
       async batchMove(emailIds, targetFolder, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const result = { succeeded: [], failed: [] };
         const folder = sourceFolder || "INBOX";
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           const uidRange = emailIds.join(",");
-          await this.client.messageMove(uidRange, targetFolder, { uid: true });
+          await client.messageMove(uidRange, targetFolder, { uid: true });
           result.succeeded = [...emailIds];
         } catch (error48) {
           for (const id of emailIds) {
             try {
-              await this.client.messageMove(id, targetFolder, { uid: true });
+              await client.messageMove(id, targetFolder, { uid: true });
               result.succeeded.push(id);
             } catch (e) {
               result.failed.push({ id, error: e.message });
@@ -9061,26 +9291,26 @@ var init_adapter3 = __esm({
         return result;
       }
       async batchMark(emailIds, flags, sourceFolder) {
-        if (!this.client) throw new Error("Not connected");
+        const client = await this.ensureConnected();
         const result = { succeeded: [], failed: [] };
         const folder = sourceFolder || "INBOX";
         let lock;
         try {
-          lock = await this.client.getMailboxLock(folder);
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           const uidRange = emailIds.join(",");
           if (flags.read === true) {
-            await this.client.messageFlagsAdd(uidRange, ["\\Seen"], { uid: true });
+            await client.messageFlagsAdd(uidRange, ["\\Seen"], { uid: true });
           } else if (flags.read === false) {
-            await this.client.messageFlagsRemove(uidRange, ["\\Seen"], { uid: true });
+            await client.messageFlagsRemove(uidRange, ["\\Seen"], { uid: true });
           }
           if (flags.starred === true || flags.flagged === true) {
-            await this.client.messageFlagsAdd(uidRange, ["\\Flagged"], { uid: true });
+            await client.messageFlagsAdd(uidRange, ["\\Flagged"], { uid: true });
           } else if (flags.starred === false || flags.flagged === false) {
-            await this.client.messageFlagsRemove(uidRange, ["\\Flagged"], { uid: true });
+            await client.messageFlagsRemove(uidRange, ["\\Flagged"], { uid: true });
           }
           result.succeeded = [...emailIds];
         } catch (error48) {
@@ -9133,9 +9363,9 @@ var GMAIL_CLIENT_ID, GMAIL_CLIENT_SECRET, OUTLOOK_CLIENT_ID;
 var init_oauth_config = __esm({
   "src/oauth-config.ts"() {
     "use strict";
-    GMAIL_CLIENT_ID = "1062266096576-lu2ukplhc3lcm0bvheml5i18urptdp4t.apps.googleusercontent.com";
-    GMAIL_CLIENT_SECRET = "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";
-    OUTLOOK_CLIENT_ID = "76d32225-ef10-4b49-951c-c80ae906595d";
+    GMAIL_CLIENT_ID = process.env.EMAIL_MCP_GMAIL_CLIENT_ID || "1062266096576-lu2ukplhc3lcm0bvheml5i18urptdp4t.apps.googleusercontent.com";
+    GMAIL_CLIENT_SECRET = process.env.EMAIL_MCP_GMAIL_CLIENT_SECRET || "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";
+    OUTLOOK_CLIENT_ID = process.env.EMAIL_MCP_OUTLOOK_CLIENT_ID || "76d32225-ef10-4b49-951c-c80ae906595d";
   }
 });
 
@@ -9541,14 +9771,30 @@ async function testAndSave(creds) {
 async function promptAccountName(defaultName) {
   return askText("Account name:", defaultName);
 }
-async function setupGmail() {
+async function setupGmail(scopeModeFlag) {
   console.log("\n--- Gmail Setup ---");
+  if (process.env.EMAIL_MCP_GMAIL_CLIENT_ID) {
+    console.log("Using your own Google OAuth Client ID (EMAIL_MCP_GMAIL_CLIENT_ID).");
+  }
   console.log("A browser window will open for Google authorization.\n");
+  let scopeMode = scopeModeFlag;
+  if (!scopeMode) {
+    scopeMode = await askChoice("Gmail permission scope:", [
+      {
+        name: "Full (default) \u2014 includes permanent delete, bypassing Trash",
+        value: "full"
+      },
+      {
+        name: "Restricted \u2014 read/send/label/archive/trash only, no permanent delete",
+        value: "restricted"
+      }
+    ]);
+  }
   const server = new OAuthCallbackServer();
   const port = await server.start();
   const redirectUri = `http://localhost:${port}/callback`;
   const gmailAuth = new GmailAuth(GMAIL_CLIENT_ID, GMAIL_CLIENT_SECRET, redirectUri);
-  const { url: url2, codeVerifier } = gmailAuth.getAuthUrl(redirectUri);
+  const { url: url2, codeVerifier } = gmailAuth.getAuthUrl(redirectUri, scopeMode);
   console.log("\nOpening browser for Google authorization...");
   console.log(`If the browser does not open, visit:
 ${url2}
@@ -9747,6 +9993,17 @@ async function main() {
     await removeAccount(id);
     return;
   }
+  const scopeIdx = args.indexOf("--scope");
+  let scopeModeFlag;
+  if (scopeIdx !== -1) {
+    const value = args[scopeIdx + 1];
+    if (value === "full" || value === "restricted") {
+      scopeModeFlag = value;
+    } else {
+      console.error("Usage: --scope <full|restricted>");
+      process.exit(1);
+    }
+  }
   console.log("@marlinjai/email-mcp Account Setup\n");
   let addMore = true;
   while (addMore) {
@@ -9758,7 +10015,7 @@ async function main() {
     ]);
     switch (provider) {
       case ProviderType.Gmail:
-        await setupGmail();
+        await setupGmail(scopeModeFlag);
         break;
       case ProviderType.Outlook:
         await setupOutlook();
@@ -10164,8 +10421,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10280,11 +10537,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -14207,10 +14464,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -14593,11 +14850,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -14780,7 +15037,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path3 = []) => {
+  const processError = (error49, path4 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -14790,7 +15047,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14822,8 +15079,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27229,13 +27486,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path4[0] === defsKey) {
+    const key = path4[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33068,9 +33325,28 @@ function registerAccountTools(server, accountManager) {
 }
 
 // src/tools/reading.ts
+import fs3 from "node:fs";
+import os3 from "node:os";
+import path3 from "node:path";
 function jsonResult2(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
+function getDownloadsBaseDir() {
+  return path3.resolve(
+    process.env.EMAIL_MCP_DOWNLOADS_DIR || path3.join(os3.homedir(), ".email-mcp", "downloads")
+  );
+}
+function resolveDownloadPath(outputPath) {
+  const baseDir = getDownloadsBaseDir();
+  const resolved = path3.resolve(baseDir, outputPath);
+  const relative = path3.relative(baseDir, resolved);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
+    throw new Error(
+      `outputPath must resolve inside ${baseDir} (set EMAIL_MCP_DOWNLOADS_DIR to change the base directory)`
+    );
+  }
+  return resolved;
+}
 function stripBodies(emails) {
   return emails.map((email3) => ({
     ...email3,
@@ -33195,6 +33471,33 @@ function registerReadingTools(server, accountManager) {
       }
     }
   );
+  server.tool(
+    "email_save_attachment",
+    `Download an email attachment and save it directly to disk, returning metadata only (no base64 in the response) \u2014 avoids paying the token cost of round-tripping large attachments through the calling model. outputPath is relative to a fixed downloads directory (${getDownloadsBaseDir()}, override with EMAIL_MCP_DOWNLOADS_DIR) and cannot escape it.`,
+    {
+      accountId: external_exports3.string(),
+      emailId: external_exports3.string(),
+      attachmentId: external_exports3.string(),
+      outputPath: external_exports3.string().describe("Relative file path (within the downloads directory) to save the attachment as")
+    },
+    async (args) => {
+      try {
+        const absPath = resolveDownloadPath(args.outputPath);
+        const provider = await accountManager.getProvider(args.accountId);
+        const { data, meta: meta3 } = await provider.getAttachment(args.emailId, args.attachmentId);
+        fs3.mkdirSync(path3.dirname(absPath), { recursive: true });
+        fs3.writeFileSync(absPath, Buffer.from(data));
+        return jsonResult2({
+          path: absPath,
+          bytes: data.length,
+          filename: meta3.filename,
+          mimeType: meta3.contentType
+        });
+      } catch (error48) {
+        return jsonResult2({ error: error48.message });
+      }
+    }
+  );
 }
 
 // src/tools/sending.ts
@@ -33356,6 +33659,32 @@ function registerSendingTools(server, accountManager) {
       }
     }
   );
+  server.tool(
+    "email_draft_update",
+    "Update an existing email draft in place (to/subject/body). On Gmail and Outlook the draft id is unchanged. On iCloud/generic IMAP there is no in-place update \u2014 the old draft is deleted and a new one appended \u2014 so the returned id is a NEW id and the old one no longer resolves; always use the id this call returns, not the one you passed in.",
+    {
+      accountId: external_exports3.string(),
+      draftId: external_exports3.string(),
+      to: external_exports3.array(ContactSchema),
+      subject: external_exports3.string(),
+      body: BodySchema,
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when the draft is not in the default Drafts folder)")
+    },
+    async (args) => {
+      try {
+        const provider = await accountManager.getProvider(args.accountId);
+        const params = {
+          to: args.to,
+          subject: args.subject,
+          body: args.body
+        };
+        const result = await provider.updateDraft(args.draftId, params, args.sourceFolder);
+        return jsonResult3(result);
+      } catch (error48) {
+        return jsonResult3({ error: error48.message });
+      }
+    }
+  );
   server.tool(
     "email_draft_list",
     "List email drafts",
@@ -33543,6 +33872,45 @@ function registerOrganizingTools(server, accountManager) {
       }
     }
   );
+  server.tool(
+    "email_batch_label",
+    "Add or remove labels on multiple emails at once (Gmail only). Much faster than individual email_label calls.",
+    {
+      accountId: external_exports3.string(),
+      emailIds: external_exports3.array(external_exports3.string()).min(1).describe("Array of email IDs to label"),
+      addLabels: external_exports3.array(external_exports3.string()).optional(),
+      removeLabels: external_exports3.array(external_exports3.string()).optional()
+    },
+    async (args) => {
+      try {
+        const provider = await accountManager.getProvider(args.accountId);
+        if (!provider.addLabels || !provider.removeLabels) {
+          return jsonResult4({
+            success: false,
+            error: "email_batch_label is only supported on Gmail accounts",
+            supportedProviders: ["gmail"]
+          });
+        }
+        if (provider.batchLabel) {
+          const result2 = await provider.batchLabel(args.emailIds, args.addLabels, args.removeLabels);
+          return jsonResult4({ success: true, ...result2 });
+        }
+        const result = { succeeded: [], failed: [] };
+        for (const id of args.emailIds) {
+          try {
+            if (args.addLabels && args.addLabels.length > 0) await provider.addLabels(id, args.addLabels);
+            if (args.removeLabels && args.removeLabels.length > 0) await provider.removeLabels(id, args.removeLabels);
+            result.succeeded.push(id);
+          } catch (e) {
+            result.failed.push({ id, error: e.message });
+          }
+        }
+        return jsonResult4({ success: true, ...result });
+      } catch (error48) {
+        return jsonResult4({ success: false, error: error48.message });
+      }
+    }
+  );
   server.tool(
     "email_transfer",
     "Move or copy emails BETWEEN accounts, preserving the original message intact (sender, date, threading) by transferring the raw MIME. Fetches each message from the source account and imports it into the target account. With deleteAfter=true the source copy is sent to trash only after a confirmed import, making this a safe cross-account move.",