@marlinjai/email-mcp 1.9.0 → 1.10.0

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,41 @@ 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 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.
+   */
+  async updateDraft(draftId, update) {
     const gmail = this.ensureConnected();
+    let params = update;
+    if (update.threadId === void 0) {
+      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"
+      });
+      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] };
+      }
+    }
     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 +1519,16 @@ 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 } : {};
+  }
   /**
    * 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 +1689,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 +1857,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 +2346,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 +2362,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 +2391,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 +2788,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 +2807,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 +2828,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 +2856,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 +2915,34 @@ 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.
    */
   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;
+      if (params.inReplyTo === void 0) {
+        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 };
+          }
+        }
+      }
+      rawMessage = await this.buildDraftMessage(next);
       await client.messageDelete(draftId, { uid: true });
     } finally {
       lock.release();
@@ -3034,6 +3229,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) {