@marlinjai/email-mcp 1.10.1 → 1.11.0

package/README.md

@@ -143,6 +143,12 @@ npx -y -p @marlinjai/email-mcp@latest email-mcp-setup
 
 `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.
 
+**Gmail adds your signature, like Gmail's own editor.** The Gmail API never appends one, so `email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` read the signature of the send-as address the mail goes out from (Gmail settings, read on every call, so a changed signature applies at once) and add it in Gmail's own markup (`gmail_signature`), above any quoted history, plus a plain-text rendering in the text part. A text-only body gains an HTML part for it, as the signature's logo and links only exist as HTML. A body that already holds a signature (a `gmail_signature` block, or a `-- ` line in text) is left alone, so passing a draft's body back to `email_draft_update` never stacks a second one. `signature: false` turns it off for one call. Each of these tools returns a `signature` field saying what happened: `added`, `already_present`, `disabled`, `none_configured`, `unsupported`, or `skipped` with the reason (for example a missing permission); a failed read never blocks the mail or draft.
+
+**Outlook, iCloud and IMAP add no signature.** Microsoft Graph has no signature API for Outlook.com accounts (signatures live in the Outlook clients, out of reach for a server), and an IMAP or iCloud server keeps no signature at all. The tools report `unsupported` there instead of inventing one; put the signature in the body when the mail needs it. A signature stored in email-mcp's own account settings was considered and left out on purpose: it would be a second copy that drifts from the one in the mail client, which is exactly how old mail ends up with an outdated signature.
+
+**From names you.** The From header carries a display name, not just the address: on Gmail the send-as display name from Gmail's settings, otherwise the account's name in email-mcp (unless that is only a label: a provider name such as "Gmail" or "iCloud", or the address's local part such as "founder"). Gmail often keeps no display name for an account's primary address (its web editor then uses the Google profile name, which this server cannot read); set one under Settings, Accounts, "Send mail as", edit info, and the tools use it. This also holds for a draft sent later from another mail program, which keeps the draft's From. Outlook sets From itself.
+
 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.
 
 **Forwarding the original message's attachments is opt-in.** `email_forward` sends the text of the original; its files go along only with `includeOriginalAttachments: true`, so one call does not pass files the assistant never looked at on to another address. Forwarded files count against the 25 MB cap together with added ones.

package/dist/index.js

@@ -7181,6 +7181,16 @@ function normalizeBody(body) {
 function toAddress(contact) {
   return contact.name ? { name: contact.name, address: contact.email } : contact.email;
 }
+function fromAddress(email3, displayName, accountName) {
+  const own = displayName?.trim();
+  if (own) return { name: own, address: email3 };
+  const fallback = accountName?.trim();
+  const label = (name) => PROVIDER_LABELS.has(name) || name === email3.toLowerCase() || name === email3.toLowerCase().split("@")[0];
+  if (fallback && !label(fallback.toLowerCase())) {
+    return { name: fallback, address: email3 };
+  }
+  return email3;
+}
 function toAddressList(contacts) {
   return contacts?.length ? contacts.map(toAddress) : void 0;
 }
@@ -7206,9 +7216,11 @@ async function buildMimeMessage(from, params) {
   node.keepBcc = true;
   return node.build();
 }
+var PROVIDER_LABELS;
 var init_mime = __esm({
   "src/providers/mime.ts"() {
     "use strict";
+    PROVIDER_LABELS = /* @__PURE__ */ new Set(["gmail", "outlook", "icloud", "imap"]);
   }
 });
 
@@ -7228,12 +7240,14 @@ var init_adapter = __esm({
       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 OAuth2Client();
         auth.setCredentials({
           access_token: credentials.oauth.access_token,
@@ -7431,6 +7445,43 @@ var init_adapter = __esm({
         });
         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({
@@ -7857,7 +7908,7 @@ var init_adapter = __esm({
        * 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");
       }
     };
@@ -9128,6 +9179,7 @@ var init_adapter3 = __esm({
       client = null;
       accountId = "";
       email = "";
+      accountName = "";
       passwordCreds = null;
       connectingPromise = null;
       async connect(credentials) {
@@ -9136,6 +9188,7 @@ var init_adapter3 = __esm({
         }
         this.accountId = credentials.id;
         this.email = credentials.email;
+        this.accountName = credentials.name;
         this.passwordCreds = credentials.password;
         await this.ensureConnected();
       }
@@ -9568,7 +9621,7 @@ var init_adapter3 = __esm({
       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 };
       }
       /**
@@ -9577,7 +9630,12 @@ var init_adapter3 = __esm({
        * 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();
@@ -34312,6 +34370,78 @@ function assertAttachmentTotal(totalBytes) {
   }
 }
 
+// src/tools/signature.ts
+init_mime();
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function textToHtml(text) {
+  return `<div dir="ltr">${escapeHtml(text).replace(/\r?\n/g, "<br>")}</div>`;
+}
+var TEXT_DELIMITER = /^-- \r?$/m;
+var HTML_QUOTE = /<(?:div|blockquote)\b[^>]*\bclass="[^"]*\bgmail_quote/i;
+var TEXT_QUOTE = /^(?:-{10} Forwarded message -{10}|On .+ wrote:)\s*$/m;
+function hasSignature(body) {
+  return /\bgmail_signature\b/.test(body.html ?? "") || TEXT_DELIMITER.test(body.text ?? "");
+}
+function renderSignature(signatureHtml) {
+  return {
+    html: `<span class="gmail_signature_prefix">-- </span><br><div dir="ltr" class="gmail_signature" data-smartmail="gmail_signature">${signatureHtml}</div>`,
+    text: `-- 
+${htmlToText(signatureHtml)}`
+  };
+}
+function insertBefore(content, quote, block, separator) {
+  const match = quote.exec(content);
+  const at = match ? match.index : content.length;
+  const before = content.slice(0, at).replace(/\s+$/, "");
+  const after = content.slice(at);
+  return [before, block, after].filter(Boolean).join(separator);
+}
+function withSignature(body, signatureHtml) {
+  const signature = renderSignature(signatureHtml);
+  const html = body.html ?? (body.text ? textToHtml(body.text) : "");
+  const text = body.text ?? (body.html ? htmlToText(body.html) : "");
+  return {
+    html: insertBefore(html, HTML_QUOTE, `<div>${signature.html}</div>`, "<br>"),
+    text: insertBefore(text, TEXT_QUOTE, signature.text, "\n\n")
+  };
+}
+function unsupportedReason(provider) {
+  if (provider === "outlook") {
+    return "Outlook: Microsoft Graph has no signature API for Outlook.com accounts, so no signature was added. Put it in the body if the mail needs one.";
+  }
+  return `${provider === "icloud" ? "iCloud" : "IMAP"}: the server keeps no signature a client can read, so no signature was added. Put it in the body if the mail needs one.`;
+}
+async function resolveSignature(provider, body, enabled) {
+  if (enabled === false) return { body, signature: { status: "disabled" } };
+  if (hasSignature(body)) return { body, signature: { status: "already_present" } };
+  if (!provider.getSignature) {
+    return { body, signature: { status: "unsupported", reason: unsupportedReason(provider.providerType) } };
+  }
+  let found;
+  try {
+    found = await provider.getSignature();
+  } catch (error48) {
+    const message = error48?.message || String(error48);
+    return {
+      body,
+      signature: { status: "skipped", reason: `The signature could not be read, so none was added: ${message}` }
+    };
+  }
+  if (!found.html) {
+    return {
+      body,
+      signature: {
+        status: "none_configured",
+        sendAs: found.sendAs,
+        reason: `${found.sendAs} has no signature in Gmail's settings.`
+      }
+    };
+  }
+  return { body: withSignature(body, found.html), signature: { status: "added", sendAs: found.sendAs } };
+}
+
 // src/tools/sending.ts
 var ContactSchema = external_exports3.object({
   email: external_exports3.string(),
@@ -34321,6 +34451,9 @@ var BodySchema = external_exports3.object({
   text: external_exports3.string().optional(),
   html: external_exports3.string().optional()
 });
+var SignatureSchema = external_exports3.boolean().optional().describe(
+  "Add the account's signature (default true). Gmail: the signature of the send-as address the mail goes out from, read from Gmail's settings, in Gmail's own markup above any quoted history; a body that already holds one is left alone. Outlook.com, iCloud and IMAP have no signature a client can read, so nothing is added there. The result's `signature` field says what happened"
+);
 function jsonResult3(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
 }
@@ -34360,21 +34493,24 @@ function registerSendingTools(server, accountManager) {
       bcc: external_exports3.array(ContactSchema).optional(),
       subject: external_exports3.string(),
       body: BodySchema,
-      attachments: AttachmentsSchema
+      attachments: AttachmentsSchema,
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           cc: args.cc,
           bcc: args.bcc,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34393,7 +34529,8 @@ function registerSendingTools(server, accountManager) {
       cc: external_exports3.array(ContactSchema).optional().describe("Cc recipients. Replaces any Cc carried over by replyAll"),
       bcc: external_exports3.array(ContactSchema).optional(),
       additionalRecipients: external_exports3.array(ContactSchema).optional().describe("Extra To recipients added to the default or given To (deduplicated by address)"),
-      attachments: AttachmentsSchema
+      attachments: AttachmentsSchema,
+      signature: SignatureSchema
     },
     async (args) => {
       try {
@@ -34421,17 +34558,19 @@ function registerSendingTools(server, accountManager) {
         }
         if (args.cc !== void 0) cc = args.cc;
         if (args.replyAll) ({ to, cc } = withoutDuplicates(to, cc));
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to,
           cc,
           bcc: args.bcc,
           subject,
-          body: args.body,
+          body,
           ...replyThreading(original),
-          attachments: resolveAttachments(args.attachments)
+          attachments
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34449,12 +34588,14 @@ function registerSendingTools(server, accountManager) {
       body: BodySchema.optional(),
       attachments: AttachmentsSchema.describe("Files to attach to the forward. Total size, together with forwarded original attachments, is capped at 25 MB"),
       includeOriginalAttachments: external_exports3.boolean().optional().describe("Also forward the original message's attachments (default false). Leave it off unless the user asked for the files to go along"),
-      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)")
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)"),
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
         const original = await provider.getEmail(args.emailId, args.sourceFolder);
+        const { body: note, signature } = await resolveSignature(provider, args.body ?? {}, args.signature);
         const subject = original.subject.startsWith("Fwd: ") ? original.subject : `Fwd: ${original.subject}`;
         const forwardHeader = [
           "---------- Forwarded message ----------",
@@ -34464,7 +34605,7 @@ function registerSendingTools(server, accountManager) {
           `To: ${original.to.map((c) => c.name ? `${c.name} <${c.email}>` : c.email).join(", ")}`,
           ""
         ].join("\n");
-        const additionalText = args.body?.text ?? "";
+        const additionalText = note.text ?? "";
         const originalText = original.body.text ?? "";
         const forwardedText = [
           additionalText,
@@ -34473,19 +34614,22 @@ function registerSendingTools(server, accountManager) {
           originalText
         ].join("");
         let forwardedHtml;
-        if (original.body.html || args.body?.html) {
-          const additionalHtml = args.body?.html ?? "";
-          const originalHtml = original.body.html ?? "";
+        if (original.body.html || note.html) {
+          const additionalHtml = note.html ?? "";
+          const originalHtml = original.body.html ?? textToHtml(original.body.text ?? "");
+          const contact = (c) => escapeHtml(c.name ? `${c.name} <${c.email}>` : c.email);
           forwardedHtml = [
             additionalHtml,
             "<br/><hr/>",
+            '<div class="gmail_quote">',
             `<b>---------- Forwarded message ----------</b><br/>`,
-            `From: ${original.from.name ? `${original.from.name} &lt;${original.from.email}&gt;` : original.from.email}<br/>`,
-            `Date: ${original.date}<br/>`,
-            `Subject: ${original.subject}<br/>`,
-            `To: ${original.to.map((c) => c.name ? `${c.name} &lt;${c.email}&gt;` : c.email).join(", ")}<br/>`,
+            `From: ${contact(original.from)}<br/>`,
+            `Date: ${escapeHtml(original.date)}<br/>`,
+            `Subject: ${escapeHtml(original.subject)}<br/>`,
+            `To: ${original.to.map(contact).join(", ")}<br/>`,
             "<br/>",
-            originalHtml
+            originalHtml,
+            "</div>"
           ].join("");
         }
         const extra = resolveAttachments(args.attachments) ?? [];
@@ -34511,7 +34655,7 @@ function registerSendingTools(server, accountManager) {
           attachments: attachments.length ? attachments : void 0
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34527,22 +34671,24 @@ function registerSendingTools(server, accountManager) {
       body: BodySchema,
       attachments: AttachmentsSchema,
       inReplyToEmailId: external_exports3.string().optional().describe("Id of the email this draft replies to. The draft joins that thread (Gmail threadId, Outlook createReply, In-Reply-To/References headers elsewhere)"),
-      inReplyToSourceFolder: external_exports3.string().optional().describe("Folder of the email named in inReplyToEmailId (required for IMAP/iCloud when that email is not in INBOX). The draft itself is saved to Drafts")
+      inReplyToSourceFolder: external_exports3.string().optional().describe("Folder of the email named in inReplyToEmailId (required for IMAP/iCloud when that email is not in INBOX). The draft itself is saved to Drafts"),
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const threading = args.inReplyToEmailId ? replyThreading(await provider.getEmail(args.inReplyToEmailId, args.inReplyToSourceFolder)) : {};
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments,
+          ...threading
         };
-        if (args.inReplyToEmailId) {
-          Object.assign(params, replyThreading(await provider.getEmail(args.inReplyToEmailId, args.inReplyToSourceFolder)));
-        }
         const result = await provider.createDraft(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34560,19 +34706,24 @@ function registerSendingTools(server, accountManager) {
       attachments: AttachmentsSchema.describe(
         "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)")
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when the draft is not in the default Drafts folder)"),
+      signature: SignatureSchema.describe(
+        "Add the account's signature (default true), as on email_draft_create. The body given here replaces the draft's body, so the signature is added to it once; a body that already holds one (passed back from the draft) is left alone, so repeated updates never stack a second one"
+      )
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments
         };
         const result = await provider.updateDraft(args.draftId, params, args.sourceFolder);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -35222,7 +35373,7 @@ function registerForwardingTools(server, accountManager) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "1.10.1";
+var SERVER_VERSION = "1.11.0";
 async function createServer(accountManager) {
   const mgr = accountManager ?? new AccountManager();
   const server = new McpServer({