@marlinjai/email-mcp 1.10.0 → 1.11.0

package/dist/setup/wizard.js

@@ -922,6 +922,17 @@ function normalizeBody(body) {
 function toAddress(contact) {
   return contact.name ? { name: contact.name, address: contact.email } : contact.email;
 }
+var PROVIDER_LABELS = /* @__PURE__ */ new Set(["gmail", "outlook", "icloud", "imap"]);
+function fromAddress(email, displayName, accountName) {
+  const own = displayName?.trim();
+  if (own) return { name: own, address: email };
+  const fallback = accountName?.trim();
+  const label = (name) => PROVIDER_LABELS.has(name) || name === email.toLowerCase() || name === email.toLowerCase().split("@")[0];
+  if (fallback && !label(fallback.toLowerCase())) {
+    return { name: fallback, address: email };
+  }
+  return email;
+}
 function toAddressList(contacts) {
   return contacts?.length ? contacts.map(toAddress) : void 0;
 }
@@ -954,12 +965,14 @@ var GmailAdapter = class {
   gmail = null;
   accountId = "";
   email = "";
+  accountName = "";
   async connect(credentials) {
     if (!credentials.oauth) {
       throw new Error("Gmail adapter requires OAuth credentials");
     }
     this.accountId = credentials.id;
     this.email = credentials.email;
+    this.accountName = credentials.name;
     const auth = new OAuth2Client2();
     auth.setCredentials({
       access_token: credentials.oauth.access_token,
@@ -1112,27 +1125,39 @@ var GmailAdapter = class {
     return { id: res.data.id || "" };
   }
   /**
-   * drafts.update replaces the whole message, so a reply draft would fall out
-   * of its thread. When the caller names no thread, the thread and the reply
-   * headers of the stored draft are carried over into the new message.
+   * drafts.update replaces the whole message, so what the caller does not
+   * name would be lost: a reply draft would fall out of its thread and a
+   * draft's files would be dropped. So when the caller names no thread, the
+   * thread and the reply headers of the stored draft are carried over, and
+   * when the caller names no attachments, the stored draft's files are. A
+   * given list (an empty one included) replaces the files.
    */
   async updateDraft(draftId, update) {
     const gmail = this.ensureConnected();
     let params = update;
-    if (update.threadId === void 0) {
+    const keepThread = update.threadId === void 0;
+    const keepFiles = update.attachments === void 0;
+    if (keepThread || keepFiles) {
       const existing = await gmail.users.drafts.get({
         userId: "me",
         id: draftId,
-        // Ids, labels and headers, no body. drafts.get has no way to ask for
-        // single headers (messages.get does), so all of them come back.
-        format: "metadata"
+        // 'metadata' is ids, labels and headers, no body (drafts.get has no
+        // way to ask for single headers, so all of them come back). The parts
+        // that list the files only come with 'full'.
+        format: keepFiles ? "full" : "metadata"
       });
       const message = existing.data.message;
-      const header = (name) => (message?.payload?.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || void 0;
-      const inReplyTo = update.inReplyTo ?? header("in-reply-to");
-      const references = update.references ?? header("references")?.split(/\s+/).filter(Boolean);
-      if (message?.threadId && inReplyTo) {
-        params = { ...update, threadId: message.threadId, inReplyTo, references: references?.length ? references : [inReplyTo] };
+      if (keepThread) {
+        const header = (name) => (message?.payload?.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || void 0;
+        const inReplyTo = update.inReplyTo ?? header("in-reply-to");
+        const references = update.references ?? header("references")?.split(/\s+/).filter(Boolean);
+        if (message?.threadId && inReplyTo) {
+          params = { ...params, threadId: message.threadId, inReplyTo, references: references?.length ? references : [inReplyTo] };
+        }
+      }
+      if (keepFiles && message?.id) {
+        const stored = await this.storedAttachments(message.id, message.payload);
+        if (stored.length) params = { ...params, attachments: stored };
       }
     }
     const raw = await this.buildRaw(params);
@@ -1145,6 +1170,43 @@ var GmailAdapter = class {
     });
     return { id: res.data.id || draftId };
   }
+  /**
+   * The signature Gmail's own editor would add: the one of the send-as
+   * address the From header names (`this.email`, see buildRaw), or the
+   * default send-as when that address is not listed. Read on every call, so
+   * a signature changed in Gmail's settings applies to the next mail.
+   */
+  async getSignature() {
+    const entries = await this.sendAsList();
+    const entry = this.ownSendAs(entries) || entries.find((e) => e.isDefault);
+    if (!entry) throw new Error(`Gmail lists no send-as address for ${this.email}`);
+    const html = (entry.signature || "").trim();
+    return { sendAs: entry.sendAsEmail || this.email, html: html || null };
+  }
+  async sendAsList() {
+    const gmail = this.ensureConnected();
+    const res = await gmail.users.settings.sendAs.list({ userId: "me" });
+    return res.data.sendAs || [];
+  }
+  ownSendAs(entries) {
+    const own = this.email.toLowerCase();
+    return entries.find((e) => (e.sendAsEmail || "").toLowerCase() === own);
+  }
+  /**
+   * The From header: the account's address with the display name Gmail
+   * keeps for it as a send-as address. When the settings cannot be read the
+   * mail still goes out, named after the account (see `fromAddress`); the
+   * signature outcome in the tool result already reports that failure.
+   */
+  async from() {
+    let displayName;
+    try {
+      displayName = this.ownSendAs(await this.sendAsList())?.displayName || void 0;
+    } catch {
+      displayName = void 0;
+    }
+    return fromAddress(this.email, displayName, this.accountName);
+  }
   async listDrafts(limit, _offset) {
     const gmail = this.ensureConnected();
     const res = await gmail.users.drafts.list({
@@ -1529,6 +1591,41 @@ var GmailAdapter = class {
     const belongs = params.threadId && params.inReplyTo && params.references?.length && params.subject.trim();
     return belongs ? { threadId: params.threadId } : {};
   }
+  /**
+   * The files of a stored message, with their bytes: every part that has a
+   * file name, at any depth. Large files are referenced by an attachment id
+   * and fetched; small ones can come inline in the part. A fetch that fails
+   * is not swallowed: a draft update built on it would drop that file.
+   */
+  async storedAttachments(messageId, payload) {
+    const gmail = this.ensureConnected();
+    const files = [];
+    const html = (extractBody(payload).html || "").toLowerCase();
+    const visit = async (part) => {
+      if (!part) return;
+      const partHeader = (name) => (part.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || "";
+      const contentId = partHeader("content-id").trim().replace(/^<|>$/g, "").toLowerCase();
+      const embedded = /^\s*inline/i.test(partHeader("content-disposition")) && contentId !== "" && html.includes(`cid:${contentId}`);
+      if (part.filename && !embedded) {
+        let data = part.body?.data;
+        if (!data && part.body?.attachmentId) {
+          const res = await gmail.users.messages.attachments.get({ userId: "me", messageId, id: part.body.attachmentId });
+          data = res.data.data;
+        }
+        if (data === void 0 || data === null) {
+          throw new Error(`Could not read the draft's attachment ${part.filename}; the draft was not changed.`);
+        }
+        files.push({
+          filename: part.filename,
+          content: Buffer.from(data, "base64url"),
+          contentType: part.mimeType || "application/octet-stream"
+        });
+      }
+      for (const child of part.parts || []) await visit(child);
+    };
+    await visit(payload);
+    return files;
+  }
   /**
    * 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
@@ -1536,7 +1633,7 @@ var GmailAdapter = class {
    * and any attachments. See `buildMimeMessage`.
    */
   async buildRaw(params) {
-    const message = await buildMimeMessage(this.email, params);
+    const message = await buildMimeMessage(await this.from(), params);
     return message.toString("base64url");
   }
 };
@@ -2451,6 +2548,7 @@ var ImapAdapter = class {
   client = null;
   accountId = "";
   email = "";
+  accountName = "";
   passwordCreds = null;
   connectingPromise = null;
   async connect(credentials) {
@@ -2459,6 +2557,7 @@ var ImapAdapter = class {
     }
     this.accountId = credentials.id;
     this.email = credentials.email;
+    this.accountName = credentials.name;
     this.passwordCreds = credentials.password;
     await this.ensureConnected();
   }
@@ -2891,7 +2990,7 @@ var ImapAdapter = class {
   async sendEmail(params) {
     if (!this.passwordCreds) throw new Error("No credentials available");
     const transport = createSmtpTransport(this.email, this.passwordCreds);
-    const messageId = await sendViaSmtp(transport, this.email, params);
+    const messageId = await sendViaSmtp(transport, this.from(), params);
     return { id: messageId };
   }
   /**
@@ -2900,7 +2999,12 @@ var ImapAdapter = class {
    * attachments. See `buildMimeMessage`.
    */
   buildDraftMessage(params) {
-    return buildMimeMessage(this.email, params);
+    return buildMimeMessage(this.from(), params);
+  }
+  /** IMAP keeps no display name on the server, so the account's name is the
+   *  only one there is (see `fromAddress`). */
+  from() {
+    return fromAddress(this.email, void 0, this.accountName);
   }
   async createDraft(params) {
     const client = await this.ensureConnected();
@@ -2918,7 +3022,11 @@ var ImapAdapter = class {
    *
    * A reply draft keeps its place in the thread: when the caller passes no
    * `inReplyTo`, the In-Reply-To and References headers of the old revision
-   * are copied into the new one.
+   * are copied into the new one. The same goes for files: when the caller
+   * passes no `attachments`, the old revision's attachments are copied over
+   * (a given list, an empty one included, replaces them). Images embedded in
+   * the old HTML body are not files and are not copied: the new body replaces
+   * the old one.
    */
   async updateDraft(draftId, params, sourceFolder) {
     const client = await this.ensureConnected();
@@ -2932,13 +3040,28 @@ var ImapAdapter = class {
     let rawMessage;
     try {
       let next = params;
-      if (params.inReplyTo === void 0) {
+      const keepThread = params.inReplyTo === void 0;
+      const keepFiles = params.attachments === void 0;
+      if (keepThread || keepFiles) {
         const old = await client.fetchOne(String(draftId), { source: true, uid: true }, { uid: true });
         if (old && old.source) {
           const parsed = await simpleParser(old.source);
-          const references = [].concat(parsed.references ?? []);
-          if (parsed.inReplyTo) {
-            next = { ...params, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+          if (keepThread && parsed.inReplyTo) {
+            const references = [].concat(parsed.references ?? []);
+            next = { ...next, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+          }
+          if (keepFiles) {
+            const html = (parsed.html || "").toLowerCase();
+            const files = (parsed.attachments || []).filter((att) => {
+              if (!att.related) return true;
+              const cid = String(att.cid || att.contentId || "").replace(/^<|>$/g, "").toLowerCase();
+              return !cid || !html.includes(`cid:${cid}`);
+            }).map((att, i) => ({
+              filename: att.filename || `attachment-${i + 1}`,
+              content: att.content,
+              contentType: att.contentType || "application/octet-stream"
+            }));
+            if (files.length) next = { ...next, attachments: files };
           }
         }
       }