@marlinjai/email-mcp 1.9.0 → 1.10.1

package/dist/setup/wizard.js

@@ -830,6 +830,14 @@ function extractAttachments(payload) {
   }
   return attachments;
 }
+function threadingHeaders(headers) {
+  const picked = {};
+  for (const name of ["Message-ID", "In-Reply-To", "References"]) {
+    const value = getHeader(headers, name);
+    if (value) picked[name.toLowerCase()] = value;
+  }
+  return Object.keys(picked).length > 0 ? picked : void 0;
+}
 function mapGmailMessage(message, accountId) {
   const headers = message.payload?.headers || [];
   const labelIds = message.labelIds || [];
@@ -864,6 +872,7 @@ function mapGmailMessage(message, accountId) {
     snippet: message.snippet,
     attachments,
     labels: labelIds,
+    headers: threadingHeaders(headers),
     flags: {
       read: !labelIds.includes("UNREAD"),
       starred: labelIds.includes("STARRED"),
@@ -1084,7 +1093,7 @@ var GmailAdapter = class {
     const raw = await this.buildRaw(params);
     const res = await gmail.users.messages.send({
       userId: "me",
-      requestBody: { raw }
+      requestBody: { raw, ...this.threadFor(params) }
     });
     return {
       id: res.data.id || "",
@@ -1097,19 +1106,53 @@ var GmailAdapter = class {
     const res = await gmail.users.drafts.create({
       userId: "me",
       requestBody: {
-        message: { raw }
+        message: { raw, ...this.threadFor(params) }
       }
     });
     return { id: res.data.id || "" };
   }
-  async updateDraft(draftId, params) {
+  /**
+   * 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;
+    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,
+        // '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;
+      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);
     const res = await gmail.users.drafts.update({
       userId: "me",
       id: draftId,
       requestBody: {
-        message: { raw }
+        message: { raw, ...this.threadFor(params) }
       }
     });
     return { id: res.data.id || draftId };
@@ -1488,6 +1531,51 @@ var GmailAdapter = class {
     }
     await this.deleteBlockRule(ruleId);
   }
+  /**
+   * Gmail files a message into an existing thread only when the threadId
+   * comes with In-Reply-To and References headers and a subject (which has to
+   * match the thread's; the reply tool builds "Re: <original subject>"). A
+   * threadId without them is left out, and the message starts its own thread.
+   */
+  threadFor(params) {
+    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
@@ -1648,6 +1736,35 @@ function buildGraphFilter(query) {
 }
 
 // src/providers/outlook/adapter.ts
+var toGraphAttachment = (att) => ({
+  "@odata.type": "#microsoft.graph.fileAttachment",
+  name: att.filename,
+  contentType: att.contentType,
+  contentBytes: att.content.toString("base64")
+});
+var OUTLOOK_MAX_ATTACHMENT_BYTES = 3 * 1024 * 1024;
+var OUTLOOK_MAX_REQUEST_BYTES = 4 * 1024 * 1024;
+var UPLOAD_SESSION_HINT = "Larger files need an upload session, which email-mcp does not implement for Outlook yet.";
+function megabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function assertOutlookAttachmentSizes(attachments) {
+  if (!attachments?.length) return;
+  const limit = megabytes(OUTLOOK_MAX_ATTACHMENT_BYTES);
+  for (const att of attachments) {
+    if (att.content.length > OUTLOOK_MAX_ATTACHMENT_BYTES) {
+      throw new Error(`Outlook accepts attachments up to ${limit} through email-mcp; ${att.filename} is ${megabytes(att.content.length)}. ${UPLOAD_SESSION_HINT}`);
+    }
+  }
+}
+function assertOutlookRequestSize(body) {
+  const bytes = Buffer.byteLength(JSON.stringify(body));
+  if (bytes > OUTLOOK_MAX_REQUEST_BYTES) {
+    throw new Error(
+      `Outlook accepts requests up to ${megabytes(OUTLOOK_MAX_REQUEST_BYTES)} through email-mcp; this message is ${megabytes(bytes)} once its attachments are base64-encoded. ${UPLOAD_SESSION_HINT}`
+    );
+  }
+}
 var OutlookAdapter = class _OutlookAdapter {
   providerType = ProviderType.Outlook;
   client = null;
@@ -1787,31 +1904,125 @@ var OutlookAdapter = class _OutlookAdapter {
       meta: mapGraphAttachment(attachment)
     };
   }
+  /**
+   * Graph only threads a reply (conversationId, subject, quoted history)
+   * through the createReply flow: POST /me/messages and /me/sendMail always
+   * start a new conversation whatever In-Reply-To says. Build the reply draft,
+   * overlay our subject, body, recipients and attachments, and return its id.
+   * Note the body replaces Graph's pre-filled quoted history.
+   *
+   * Each attachment goes up in a request of its own, so the sizes are checked
+   * per file, and before createReply so that a file that is too big leaves no
+   * draft behind. A draft that cannot be filled is deleted again. (A draft
+   * whose send failed is kept, see `sendEmail`.)
+   */
+  async createReplyDraft(params, replyToId) {
+    const client = this.ensureClient();
+    assertOutlookAttachmentSizes(params.attachments);
+    const draft = await client.api(`/me/messages/${encodeURIComponent(replyToId)}/createReply`).post({});
+    try {
+      await this.fillReplyDraft(draft.id, params);
+    } catch (error) {
+      throw await this.discardDraft(draft.id, error);
+    }
+    return draft.id;
+  }
+  async fillReplyDraft(draftId, params) {
+    const client = this.ensureClient();
+    const toGraphRecipient = (c) => ({
+      emailAddress: { name: c.name, address: c.email }
+    });
+    const patch = {
+      // Always the caller's subject: Graph pre-fills its own "RE: ..." one.
+      subject: params.subject,
+      body: { contentType: params.body.html ? "html" : "text", content: params.body.html || params.body.text || "" }
+    };
+    if (params.to?.length) patch.toRecipients = params.to.map(toGraphRecipient);
+    if (params.cc !== void 0) patch.ccRecipients = params.cc.map(toGraphRecipient);
+    if (params.bcc !== void 0) patch.bccRecipients = params.bcc.map(toGraphRecipient);
+    await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(patch);
+    for (const att of params.attachments ?? []) {
+      await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post(toGraphAttachment(att));
+    }
+  }
+  /**
+   * Deletes a reply draft that could not be filled, so a failed reply leaves
+   * nothing half-built in Drafts. Returns the error to throw: the original
+   * one, or, when the delete fails as well, the original message with a note
+   * that the draft is still there.
+   */
+  async discardDraft(draftId, cause) {
+    try {
+      await this.ensureClient().api(`/me/messages/${encodeURIComponent(draftId)}`).delete();
+      return cause;
+    } catch (deleteError) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      return new Error(
+        `${message} (the reply draft ${draftId} could not be removed and was left in Drafts: ${deleteError?.message ?? deleteError})`,
+        { cause }
+      );
+    }
+  }
   async sendEmail(params) {
     const client = this.ensureClient();
+    if (params.replyToGraphId) {
+      const draftId = await this.createReplyDraft(params, params.replyToGraphId);
+      try {
+        await client.api(`/me/messages/${encodeURIComponent(draftId)}/send`).post({});
+      } catch (error) {
+        throw new Error(
+          `${error?.message ?? error} (the reply was saved as draft ${draftId} in Drafts and was not confirmed as sent; check Sent Items before sending it again)`,
+          { cause: error }
+        );
+      }
+      return { id: draftId };
+    }
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
     const payload = { message };
     if (params.attachments?.length) {
-      payload.message.attachments = params.attachments.map((att) => ({
-        "@odata.type": "#microsoft.graph.fileAttachment",
-        name: att.filename,
-        contentType: att.contentType,
-        contentBytes: att.content.toString("base64")
-      }));
+      payload.message.attachments = params.attachments.map(toGraphAttachment);
     }
+    assertOutlookRequestSize(payload);
     await client.api("/me/sendMail").post(payload);
     return { id: `sent-${Date.now()}` };
   }
   async createDraft(params) {
     const client = this.ensureClient();
+    if (params.replyToGraphId) {
+      return { id: await this.createReplyDraft(params, params.replyToGraphId) };
+    }
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
+    if (params.attachments?.length) {
+      message.attachments = params.attachments.map(toGraphAttachment);
+    }
+    assertOutlookRequestSize(message);
     const result = await client.api("/me/messages").post(message);
     return { id: result.id };
   }
   async updateDraft(draftId, params) {
     const client = this.ensureClient();
+    assertOutlookAttachmentSizes(params.attachments);
     const message = this.buildGraphMessage(params);
     await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(message);
+    if (params.attachments) {
+      const attachmentsPath = `/me/messages/${encodeURIComponent(draftId)}/attachments`;
+      const previousIds = [];
+      let page = await client.api(attachmentsPath).select("id").get();
+      for (; ; ) {
+        previousIds.push(...(page.value || []).map((att) => att.id));
+        const next = page["@odata.nextLink"];
+        if (!next) break;
+        page = await client.api(next).get();
+      }
+      for (const att of params.attachments) {
+        await client.api(attachmentsPath).post(toGraphAttachment(att));
+      }
+      for (const id of previousIds) {
+        await client.api(`${attachmentsPath}/${encodeURIComponent(id)}`).delete();
+      }
+    }
     return { id: draftId };
   }
   async listDrafts(limit, offset) {
@@ -2182,6 +2393,12 @@ function mapImapFolder(imapFolder) {
     unreadCount: imapFolder.status?.unseen
   };
 }
+function imapAttachmentId(att, index) {
+  return att.contentId || `att-${index}`;
+}
+function headerValue(line) {
+  return line.slice(line.indexOf(":") + 1).replace(/\r?\n[ \t]+/g, " ").trim();
+}
 function mapParsedEmail(parsed, folder, accountId, uid) {
   const mapContact = (addr) => ({
     name: addr.name || void 0,
@@ -2192,7 +2409,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
     return addrs.value.map(mapContact);
   };
   const attachments = (parsed.attachments || []).map((att, i) => ({
-    id: att.contentId || `att-${i}`,
+    id: imapAttachmentId(att, i),
     filename: att.filename || `attachment-${i}`,
     contentType: att.contentType || "application/octet-stream",
     size: att.size || 0
@@ -2221,7 +2438,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
       flagged: parsed.flags?.has("\\Flagged") || false,
       draft: parsed.flags?.has("\\Draft") || false
     },
-    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, h.line])) : void 0
+    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, headerValue(h.line)])) : void 0
   };
 }
 
@@ -2618,7 +2835,7 @@ var ImapAdapter = class {
   }
   async getEmail(id, folder) {
     const client = await this.ensureConnected();
-    const targetFolder = folder || "INBOX";
+    const targetFolder = folder ? await this.resolveFolder(folder) : "INBOX";
     let lock;
     try {
       lock = await client.getMailboxLock(targetFolder);
@@ -2637,13 +2854,20 @@ var ImapAdapter = class {
       lock.release();
     }
   }
-  async getThread(threadId) {
+  /**
+   * IMAP has no thread object: the thread is the set of messages in ONE
+   * folder whose Message-ID, References or In-Reply-To name `threadId`.
+   * Messages of the same conversation in other folders (the own replies in
+   * Sent, for example) are not part of the result.
+   */
+  async getThread(threadId, sourceFolder) {
     const client = await this.ensureConnected();
+    const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
     let lock;
     try {
-      lock = await client.getMailboxLock("INBOX");
+      lock = await client.getMailboxLock(folder);
     } catch (error) {
-      throw formatImapError(error, 'Failed to open folder "INBOX"');
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
     }
     try {
       const searchResult = await client.search(
@@ -2651,13 +2875,13 @@ var ImapAdapter = class {
         { uid: true }
       );
       const uids = Array.isArray(searchResult) ? searchResult : [];
-      if (uids.length === 0) throw new Error(`Thread ${threadId} not found`);
+      if (uids.length === 0) throw new Error(`Thread ${threadId} not found in "${folder}"`);
       const messages = [];
       for await (const msg of client.fetch(uids, { source: true, uid: true, flags: true })) {
         if (!msg.source) continue;
         const parsed = await simpleParser(msg.source);
         parsed.flags = msg.flags;
-        messages.push(mapParsedEmail(parsed, "INBOX", this.accountId, msg.uid));
+        messages.push(mapParsedEmail(parsed, folder, this.accountId, msg.uid));
       }
       const participantMap = /* @__PURE__ */ new Map();
       for (const msg of messages) {
@@ -2679,27 +2903,29 @@ var ImapAdapter = class {
       lock.release();
     }
   }
-  async getAttachment(emailId, attachmentId) {
+  async getAttachment(emailId, attachmentId, sourceFolder) {
     const client = await this.ensureConnected();
+    const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
     let lock;
     try {
-      lock = await client.getMailboxLock("INBOX");
+      lock = await client.getMailboxLock(folder);
     } catch (error) {
-      throw formatImapError(error, 'Failed to open folder "INBOX"');
+      throw formatImapError(error, `Failed to open folder "${folder}"`);
     }
     try {
       const msg = await client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
-      if (!msg) throw new Error(`Email ${emailId} not found`);
+      if (!msg) throw new Error(`Email ${emailId} not found in "${folder}"`);
       if (!msg.source) throw new Error(`Email ${emailId} has no source`);
       const parsed = await simpleParser(msg.source);
-      const attachment = (parsed.attachments || []).find(
-        (att) => att.contentId === attachmentId || att.filename === attachmentId
-      );
-      if (!attachment) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+      const attachments = parsed.attachments || [];
+      let index = attachments.findIndex((att, i) => imapAttachmentId(att, i) === attachmentId);
+      if (index === -1) index = attachments.findIndex((att) => att.filename === attachmentId);
+      if (index === -1) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+      const attachment = attachments[index];
       return {
         data: attachment.content,
         meta: {
-          id: attachment.contentId || attachmentId,
+          id: imapAttachmentId(attachment, index),
           filename: attachment.filename || "attachment",
           contentType: attachment.contentType || "application/octet-stream",
           size: attachment.size || 0
@@ -2736,18 +2962,53 @@ var ImapAdapter = class {
    * 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.
+   *
+   * 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. 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();
     const draftsFolder = sourceFolder ? await this.resolveFolder(sourceFolder) : await this.resolveFolder("Drafts");
-    const rawMessage = await this.buildDraftMessage(params);
     let lock;
     try {
       lock = await client.getMailboxLock(draftsFolder);
     } catch (error) {
       throw formatImapError(error, `Failed to open folder "${draftsFolder}"`);
     }
+    let rawMessage;
     try {
+      let next = params;
+      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);
+          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 };
+          }
+        }
+      }
+      rawMessage = await this.buildDraftMessage(next);
       await client.messageDelete(draftId, { uid: true });
     } finally {
       lock.release();
@@ -3034,6 +3295,11 @@ var AccountManager = class {
       connected: this.providers.has(c.id)
     }));
   }
+  /** The account's own address, or undefined for an unknown account id. */
+  async getAccountEmail(accountId) {
+    const creds = this.credentials.get(accountId) ?? await this.store.get(accountId);
+    return creds?.email;
+  }
   async getProvider(accountId) {
     const existing = this.providers.get(accountId);
     if (existing) {