@marlinjai/email-mcp 1.10.0 → 1.10.1

package/README.md

@@ -141,7 +141,7 @@ npx -y -p @marlinjai/email-mcp@latest email-mcp-setup
 
 ### Sending & Drafts (6)
 
-`email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` take an optional `attachments` list. Each entry is either `{ path }` (a file in the attachments folder, see below) or `{ content, filename }` (base64), with an optional `contentType` (inferred from the extension otherwise). The total is capped at 25 MB; Outlook accepts up to 3 MB per message through this server. On `email_draft_update` a list replaces the draft's files and an empty list removes them.
+`email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` take an optional `attachments` list. Each entry is either `{ path }` (a file in the attachments folder, see below) or `{ content, filename }` (base64), with an optional `contentType` (inferred from the extension otherwise). The total is capped at 25 MB; Outlook accepts up to 3 MB per message through this server. On `email_draft_update` a list replaces the draft's files, an empty list removes them, and no list keeps the files the draft has.
 
 Replies stay in their thread: `email_reply` sends inside the original conversation on Gmail and Outlook (and sets the `In-Reply-To` and `References` headers everywhere), `email_draft_create` with `inReplyToEmailId` saves a reply draft in that thread, and `email_draft_update` keeps a reply draft there.
 

package/dist/index.js

@@ -7386,27 +7386,39 @@ var init_adapter = __esm({
         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);
@@ -7803,6 +7815,41 @@ var init_adapter = __esm({
         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
@@ -9548,7 +9595,11 @@ var init_adapter3 = __esm({
        *
        * 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();
@@ -9562,13 +9613,28 @@ var init_adapter3 = __esm({
         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 };
               }
             }
           }
@@ -34492,7 +34558,7 @@ function registerSendingTools(server, accountManager) {
       subject: external_exports3.string(),
       body: BodySchema,
       attachments: AttachmentsSchema.describe(
-        "Files to attach. When given, they replace the draft's current attachments; an empty list removes them all. When omitted, Outlook keeps the existing files but Gmail and IMAP drop them (those providers rewrite the whole message), so pass them again to keep them."
+        "Files to attach. When given, they replace the draft's current attachments; an empty list removes them all. When omitted, the draft keeps the files it has."
       ),
       sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when the draft is not in the default Drafts folder)")
     },
@@ -35156,7 +35222,7 @@ function registerForwardingTools(server, accountManager) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "1.10.0";
+var SERVER_VERSION = "1.10.1";
 async function createServer(accountManager) {
   const mgr = accountManager ?? new AccountManager();
   const server = new McpServer({