@marlinjai/email-mcp 1.10.0 → 1.10.1

package/dist/setup/wizard.js

@@ -1112,27 +1112,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);
@@ -1529,6 +1541,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
@@ -2918,7 +2965,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 +2983,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 };
           }
         }
       }