@aidalinfo/email-mcp 0.2.0 → 0.3.0

package/README.md

@@ -16,8 +16,18 @@ Agent Hermes B ─┤
    │  X-Auth-Token (dedicated IAM application, TEM on one project)          ▲
    ▼                                                                        │ webhook (Topics and Events)
 Scaleway TEM  /transactional-email/v1alpha1/regions/{region}/…  ───────────┘
+              smtp.tem.scaleway.com:2465 (emails above the 2 MB of the API)
 ```
 
+**Two ways out.** The TEM API refuses any email above **2 MB** (attachments included, base64
+counted, not raisable); TEM over SMTP accepts **50 MB**. By default (`EMAIL_SEND_VIA=auto`) an email
+leaves through the API up to ~1.9 MB and through SMTP above, with the same credentials (SMTP user =
+project id, password = the secret key) — attachments then go up to **35 MB** in total. `api` keeps
+everything on the API (2 MB), `smtp` sends everything over SMTP. SMTP returns no TEM id:
+`email_status` with the `idempotency_key` finds them once TEM lists the email (by the message id of
+the SMTP reply, else by sender, subject and date), usually within a minute; webhook events of an
+SMTP send are kept from then on.
+
 Guarantees, all enforced server-side:
 
 - **The sender is configuration, not an argument.** `EMAIL_FROM` / `EMAIL_FROM_NAME` / `EMAIL_REPLY_TO`
@@ -56,8 +66,9 @@ Guarantees, all enforced server-side:
   key, client keys, source tokens, webhook secret, Authorization headers).
 - **Bounded reads:** `email_status` (own sends only, 10 emails per key, 5 last attempts, 20 events),
   `email_suppressions` (20 allowed addresses at most — no probing of arbitrary addresses).
-- **No raw API tool**: the server makes exactly four Scaleway calls (find the sender domain, create
-  an email, read an email, read the blocklist of one address).
+- **No raw API tool**: the server makes exactly five Scaleway API calls (find the sender domain,
+  create an email, read an email, list its own emails after an SMTP send, read the blocklist of one
+  address), plus the SMTP submission of emails above 2 MB.
 
 ## Tools
 
@@ -160,7 +171,9 @@ startup (fail-closed) instead of guessing.
 | `EMAIL_TEMPLATES_DIR` | | | `*.json` templates, loaded at startup |
 | `EMAIL_ATTACHMENT_SOURCES` | | | JSON `[{id, baseUrl (https), tokenEnv?, authScheme?, clients?}]` |
 | `EMAIL_ATTACHMENT_TYPES` | | pdf, png, jpeg, txt, csv | also docx, xlsx |
-| `EMAIL_MAX_ATTACHMENTS` / `EMAIL_MAX_ATTACHMENT_BYTES` | | 5 / 2 000 000 | caps 10 / 10 000 000 (total) |
+| `EMAIL_SEND_VIA` | | `auto` | `auto` (API ≤ 2 MB, SMTP above), `api`, `smtp` |
+| `EMAIL_SMTP_PORT` | | 2465 | 2465 / 465 (TLS), 2587 / 587 (STARTTLS) — Scaleway Instances block 465 and 587 by default |
+| `EMAIL_MAX_ATTACHMENTS` / `EMAIL_MAX_ATTACHMENT_BYTES` | | 5 / 35 000 000 (2 000 000 with `api`) | caps 10 / 35 000 000 (10 000 000 with `api`), total |
 | `EMAIL_MCP_TRANSPORT` | | `stdio` | `http` in the image |
 | `EMAIL_MCP_HOST` / `EMAIL_MCP_PORT` | | `127.0.0.1` / 8080 | `0.0.0.0` in the image |
 | `EMAIL_MCP_CLIENTS_FILE` or `EMAIL_MCP_CLIENTS` | HTTP | | clients JSON (below) |

package/deploy/compose.yaml

@@ -19,6 +19,9 @@ services:
       EMAIL_FROM: noreply@pulsemyit.fr
       EMAIL_FROM_NAME: ${EMAIL_FROM_NAME:-Pulse myIT}
       EMAIL_REGION: ${EMAIL_REGION:-fr-par}
+      # API up to 2 MB per email, SMTP (port 2465, outbound) above — see README
+      EMAIL_SEND_VIA: ${EMAIL_SEND_VIA:-auto}
+      EMAIL_SMTP_PORT: ${EMAIL_SMTP_PORT:-2465}
       # required, no default — the container exits with a clear message when one is missing
       SCW_SECRET_KEY: ${SCW_SECRET_KEY:?SCW_SECRET_KEY is required}
       EMAIL_PROJECT_ID: ${EMAIL_PROJECT_ID:?EMAIL_PROJECT_ID is required}

package/dist/attachments.js

@@ -17,7 +17,9 @@ export const DEFAULT_MAX_ATTACHMENTS = 5;
 export const HARD_MAX_ATTACHMENTS = 10;
 export const DEFAULT_MAX_ATTACHMENT_BYTES = 2_000_000;
 export const HARD_MAX_ATTACHMENT_BYTES = 10_000_000;
-export const FETCH_TIMEOUT_MS = 30_000;
+/** With SMTP (TEM: 50 MB per email): 35 MB of files, ~47 MB once base64-encoded, leaves room for the bodies. */
+export const SMTP_MAX_ATTACHMENT_BYTES = 35_000_000;
+export const FETCH_TIMEOUT_MS = 60_000;
 const SOURCE_ID_RE = /^[a-z0-9][a-z0-9-]{0,39}$/;
 /** Path segments starting with a letter or digit: no "..", no "/x", no "//", no query. */
 export const REF_RE = /^[A-Za-z0-9][A-Za-z0-9._~-]*(?:\/[A-Za-z0-9][A-Za-z0-9._~-]*)*$/;
@@ -26,7 +28,7 @@ const FILENAME_RE = /^[A-Za-z0-9][A-Za-z0-9 ._()-]{0,99}$/;
  * EMAIL_ATTACHMENT_SOURCES: JSON list of `{ "id", "baseUrl", "tokenEnv"?, "authScheme"?, "clients"? }`.
  * The token itself never sits in that JSON: `tokenEnv` names the env var holding it.
  */
-export function loadAttachmentConfig(env, warnings = []) {
+export function loadAttachmentConfig(env, warnings = [], sendVia = "api") {
     const raw = env.EMAIL_ATTACHMENT_SOURCES?.trim();
     const sources = [];
     if (raw) {
@@ -81,7 +83,9 @@ export function loadAttachmentConfig(env, warnings = []) {
         sources,
         types,
         maxCount: intIn(env.EMAIL_MAX_ATTACHMENTS?.trim() || undefined, "EMAIL_MAX_ATTACHMENTS", DEFAULT_MAX_ATTACHMENTS, HARD_MAX_ATTACHMENTS, warnings),
-        maxTotalBytes: intIn(env.EMAIL_MAX_ATTACHMENT_BYTES?.trim() || undefined, "EMAIL_MAX_ATTACHMENT_BYTES", DEFAULT_MAX_ATTACHMENT_BYTES, HARD_MAX_ATTACHMENT_BYTES, warnings),
+        maxTotalBytes: sendVia === "api"
+            ? intIn(env.EMAIL_MAX_ATTACHMENT_BYTES?.trim() || undefined, "EMAIL_MAX_ATTACHMENT_BYTES", DEFAULT_MAX_ATTACHMENT_BYTES, HARD_MAX_ATTACHMENT_BYTES, warnings)
+            : intIn(env.EMAIL_MAX_ATTACHMENT_BYTES?.trim() || undefined, "EMAIL_MAX_ATTACHMENT_BYTES", SMTP_MAX_ATTACHMENT_BYTES, SMTP_MAX_ATTACHMENT_BYTES, warnings),
     };
 }
 const refused = (m) => new EmailError("attachment_refused", `attachment_refused: ${m}`);

package/dist/config.js

@@ -45,6 +45,10 @@ export const DEFAULT_MAX_PER_HOUR = 20;
 export const HARD_MAX_PER_HOUR = 500;
 export const DEFAULT_MAX_PER_DAY = 200;
 export const HARD_MAX_PER_DAY = 5000;
+/** How a message leaves: the TEM API (2 MB max per email, not raisable), SMTP (50 MB), or the API up to its limit then SMTP. */
+export const SEND_VIA = ["auto", "api", "smtp"];
+/** Implicit TLS (465, 2465) or STARTTLS (587, 2587). 2465 and 2587 stay open on Scaleway Instances, which block 465 and 587 by default. */
+export const SMTP_PORTS = [2465, 465, 2587, 587];
 const get = (env, k) => env[k]?.trim() || undefined;
 export function intIn(raw, name, def, max, warnings) {
     if (raw === undefined)
@@ -93,6 +97,12 @@ export function loadConfig(env) {
     if (!allowlist.addresses.size && !allowlist.domains.size) {
         throw new Error("EMAIL_ALLOWED_RECIPIENTS is empty — list the addresses and/or @domains the agent may write to");
     }
+    const sendVia = (get(env, "EMAIL_SEND_VIA") ?? "auto");
+    if (!SEND_VIA.includes(sendVia))
+        throw new Error(`EMAIL_SEND_VIA must be one of ${SEND_VIA.join(", ")} (got "${sendVia}")`);
+    const smtpPort = Number(get(env, "EMAIL_SMTP_PORT") ?? SMTP_PORTS[0]);
+    if (!SMTP_PORTS.includes(smtpPort))
+        throw new Error(`EMAIL_SMTP_PORT must be one of ${SMTP_PORTS.join(", ")} (got "${get(env, "EMAIL_SMTP_PORT")}")`);
     return {
         secretKey,
         projectId: projectId.toLowerCase(),
@@ -103,6 +113,8 @@ export function loadConfig(env) {
         maxRecipients: intIn(get(env, "EMAIL_MAX_RECIPIENTS"), "EMAIL_MAX_RECIPIENTS", DEFAULT_MAX_RECIPIENTS, HARD_MAX_RECIPIENTS, warnings),
         maxPerHour: intIn(get(env, "EMAIL_MAX_PER_HOUR"), "EMAIL_MAX_PER_HOUR", DEFAULT_MAX_PER_HOUR, HARD_MAX_PER_HOUR, warnings),
         maxPerDay: intIn(get(env, "EMAIL_MAX_PER_DAY"), "EMAIL_MAX_PER_DAY", DEFAULT_MAX_PER_DAY, HARD_MAX_PER_DAY, warnings),
+        sendVia,
+        smtpPort,
         killSwitchFile: get(env, "EMAIL_KILL_SWITCH_FILE"),
         auditFile: get(env, "EMAIL_AUDIT_LOG_FILE"),
         stateDir: get(env, "EMAIL_STATE_DIR"),

package/dist/index.js

@@ -7,6 +7,7 @@ import { CLIENT_ID_RE, ClientRegistry, generateKey } from "./clients.js";
 import { loadConfig } from "./config.js";
 import { createHttpServer, loadHttpConfig } from "./http.js";
 import { redactor } from "./redact.js";
+import { SmtpClient } from "./smtp-client.js";
 import { TemClient } from "./tem-client.js";
 import { createService, localClient, registerTools, SERVER_INSTRUCTIONS } from "./tools.js";
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -30,15 +31,16 @@ async function main() {
         throw new Error(`EMAIL_MCP_TRANSPORT must be stdio or http (got "${mode}")`);
     const config = loadConfig(process.env);
     redactor.add(config.secretKey);
-    const attachments = loadAttachmentConfig(process.env, config.warnings);
+    const attachments = loadAttachmentConfig(process.env, config.warnings, config.sendVia);
     const tem = new TemClient(config.secretKey, config.projectId, config.region);
+    const smtp = config.sendVia === "api" ? undefined : new SmtpClient(config.projectId, config.secretKey, config.smtpPort);
     const a = config.allowlist;
-    const summary = `sender: ${config.from.email}, TEM ${config.region}, allowlist: ${a.addresses.size} address(es) + ${a.domains.size} domain(s), ` +
+    const summary = `sender: ${config.from.email}, TEM ${config.region} via ${config.sendVia === "auto" ? `API ≤ 2 MB, SMTP :${config.smtpPort} above` : config.sendVia === "smtp" ? `SMTP :${config.smtpPort}` : "API"}, allowlist: ${a.addresses.size} address(es) + ${a.domains.size} domain(s), ` +
         `${config.maxRecipients} recipients/email, ${config.maxPerHour}/hour, ${config.maxPerDay}/day, ` +
         `kill switch: ${config.killSwitchFile ?? "not configured"}, attachment sources: ${attachments.sources.length}, ` +
         `templates: ${config.templatesDir ?? "not configured"}, state: ${config.stateDir ?? "memory only"}`;
     if (mode === "stdio") {
-        const svc = createService(config, tem, { attachments });
+        const svc = createService(config, tem, { attachments, smtp });
         const server = new McpServer({ name: "email", version: pkg.version }, { instructions: SERVER_INSTRUCTIONS });
         registerTools(server, { ...svc, client: localClient(config) });
         for (const w of config.warnings)
@@ -52,7 +54,7 @@ async function main() {
     if (!config.stateDir)
         throw new Error("Missing required env var for HTTP: EMAIL_STATE_DIR (persistent volume for the send ledger)");
     const clients = new ClientRegistry({ file: http.clientsFile, inline: http.clientsInline }, config);
-    const svc = createService(config, tem, { attachments, multiClient: true, webhookConfigured: !!http.webhookSecret });
+    const svc = createService(config, tem, { attachments, smtp, multiClient: true, webhookConfigured: !!http.webhookSecret });
     const server = createHttpServer(svc, clients, http, pkg.version);
     for (const w of config.warnings)
         log(w);

package/dist/ledger.js

@@ -88,9 +88,19 @@ export class SendLedger {
         return r;
     }
     /** After the provider answered. Never throws: the email has left, a disk error must not hide it. */
-    settle(r, state, emailIds = []) {
+    settle(r, state, emailIds = [], smtp) {
         r.state = state;
         r.emailIds = emailIds;
+        r.smtp = smtp;
+        r.updatedAt = new Date(this.now()).toISOString();
+        for (const id of emailIds)
+            this.owners.set(id, r);
+        this.safePersist();
+    }
+    /** The TEM ids of an SMTP send, once TEM lists them. */
+    attach(r, emailIds) {
+        r.emailIds = emailIds;
+        delete r.smtp;
         r.updatedAt = new Date(this.now()).toISOString();
         for (const id of emailIds)
             this.owners.set(id, r);

package/dist/smtp-client.js

@@ -0,0 +1,70 @@
+import nodemailer from "nodemailer";
+import { EmailError } from "./errors.js";
+import { redactSecret } from "./tem-client.js";
+export const SMTP_HOST = "smtp.tem.scaleway.com";
+/** TEM refuses an email above 50 MB over SMTP, headers, bodies and encoded attachments included. */
+export const SMTP_MAX_EMAIL_BYTES = 50_000_000;
+export const SMTP_TIMEOUT_MS = 120_000;
+/** Stages before the message body leaves: a failure there means nothing was sent. */
+const BEFORE_DATA = new Set(["CONN", "GREETING", "EHLO", "HELO", "LHLO", "STARTTLS", "AUTH", "AUTH PLAIN", "AUTH LOGIN", "MAIL FROM", "RCPT TO"]);
+const NOT_CONNECTED = new Set(["ECONNECTION", "EDNS", "ETLS", "EAUTH", "EENVELOPE"]);
+/** Same outcome rules as the API: a refusal is certain, a cut after the body started is unknown. */
+export function smtpError(err, secret) {
+    const e = (err ?? {});
+    const detail = redactSecret(String(e.response ?? e.message ?? err), secret).slice(0, 300);
+    const code = e.responseCode;
+    if (e.code === "EAUTH" || code === 530 || code === 535) {
+        return new EmailError("permission_missing", `permission_missing: SMTP authentication refused — the API key needs Transactional Email permissions on the project (${detail})`, code);
+    }
+    if (code && code >= 400) {
+        if (code === 552)
+            return new EmailError("invalid_request", `invalid_request: TEM refused the email as too large over SMTP (${detail})`, code);
+        if (code < 500)
+            return new EmailError("transient", `transient: SMTP send refused for now (${detail}) — retry later`, code);
+        return new EmailError("invalid_request", `invalid_request: TEM refused the email over SMTP (${detail})`, code);
+    }
+    if (NOT_CONNECTED.has(e.code ?? "") || BEFORE_DATA.has(e.command ?? "")) {
+        return new EmailError("transient", `transient: SMTP connection to ${SMTP_HOST} failed before sending (${detail})`);
+    }
+    return new EmailError("unknown_outcome", `unknown_outcome: the SMTP send was interrupted (${detail}) — the email may have been sent; check email_status and the TEM console before sending again`);
+}
+/** TEM over SMTP: user = project id, password = the same secret key as the API. */
+export class SmtpClient {
+    secretKey;
+    transport;
+    constructor(projectId, secretKey, port) {
+        this.secretKey = secretKey;
+        this.transport = nodemailer.createTransport({
+            host: SMTP_HOST,
+            port,
+            secure: port === 465 || port === 2465,
+            requireTLS: true,
+            auth: { user: projectId, pass: secretKey },
+            connectionTimeout: 30_000,
+            greetingTimeout: 30_000,
+            socketTimeout: SMTP_TIMEOUT_MS,
+            // contents come from the resolver only: never let the library read a path or a URL
+            disableFileAccess: true,
+            disableUrlAccess: true,
+        });
+    }
+    async send(m) {
+        try {
+            const info = await this.transport.sendMail({
+                from: m.from.name ? { name: m.from.name, address: m.from.email } : m.from.email,
+                replyTo: m.replyTo,
+                to: m.to,
+                cc: m.cc.length ? m.cc : undefined,
+                subject: m.subject,
+                text: m.text,
+                html: m.html,
+                attachments: m.attachments.map((a) => ({ filename: a.name, contentType: a.type, content: a.content })),
+            });
+            const list = (v) => (Array.isArray(v) ? v.map((x) => String(typeof x === "object" && x && "address" in x ? x.address : x).toLowerCase()) : []);
+            return { response: String(info.response ?? ""), accepted: list(info.accepted), rejected: list(info.rejected) };
+        }
+        catch (err) {
+            throw smtpError(err, this.secretKey);
+        }
+    }
+}

package/dist/tem-client.js

@@ -73,6 +73,15 @@ export class TemClient {
     async getEmail(id) {
         return this.call("GET", `${this.base}/emails/${encodeURIComponent(id)}`, "get email");
     }
+    async listEmails(q) {
+        const qs = new URLSearchParams({ project_id: this.projectId, mail_from: q.mailFrom, since: q.since, page_size: "100" });
+        if (q.messageId)
+            qs.set("message_id", q.messageId);
+        if (q.subject)
+            qs.set("subject", q.subject);
+        const res = await this.call("GET", `${this.base}/emails?${qs}`, "list emails");
+        return (res.emails ?? []).filter((e) => e.project_id === this.projectId);
+    }
     async listBlocklists(domainId, email) {
         const qs = new URLSearchParams({ domain_id: domainId, email, page_size: "20" });
         const res = await this.call("GET", `${this.base}/blocklists?${qs}`, "list TEM blocklists");

package/dist/tools.js

@@ -9,10 +9,13 @@ import { Quotas } from "./quota.js";
 import { IDEMPOTENCY_KEY_RE, SendLedger } from "./ledger.js";
 import { HARD_VARIABLE_LENGTH, TemplateCatalog } from "./templates.js";
 import { AttachmentResolver, DEFAULT_MAX_ATTACHMENT_BYTES, DEFAULT_MAX_ATTACHMENTS, HARD_MAX_ATTACHMENTS } from "./attachments.js";
+import { SMTP_MAX_EMAIL_BYTES } from "./smtp-client.js";
 export const MAX_SUBJECT = 200;
 export const MAX_TEXT = 100_000;
 export const MAX_HTML = 200_000;
 export const MAX_SUPPRESSION_LOOKUPS = 20;
+/** TEM refuses an email above 2 MB through its API (not raisable); kept a little under for the JSON envelope. */
+export const API_MAX_EMAIL_BYTES = 1_900_000;
 /** Above this, the preview shows the start of the HTML only (the digest still covers all of it). */
 const PREVIEW_HTML = 20_000;
 export const SERVER_INSTRUCTIONS = "Sends email from ONE fixed sender (set by the operator, not by you) to an allowlist of recipients, through Scaleway Transactional Email. " +
@@ -29,6 +32,7 @@ export function createService(config, tem, opts = {}) {
     return {
         config,
         tem,
+        smtp: opts.smtp,
         confirmations: new Confirmations(),
         audit: new AuditLogger(config.auditFile),
         quotas: new Quotas(config),
@@ -51,7 +55,7 @@ const fence = (s) => {
     return `${ticks}\n${s}\n${ticks}`;
 };
 const allowedFor = (ctx, address) => isAllowed(ctx.config.allowlist, address) && (!ctx.client.allowlist || isAllowed(ctx.client.allowlist, address));
-/** Validates the arguments into the exact message that will be sent. Throws on any guard. */
+/** Validates the arguments into the exact message that will be sent, and how it will leave. Throws on any guard. */
 export async function buildMessage(ctx, a) {
     const { config } = ctx;
     if (!IDEMPOTENCY_KEY_RE.test(a.idempotency_key ?? "")) {
@@ -109,20 +113,34 @@ export async function buildMessage(ctx, a) {
     if (html !== undefined && html.length > MAX_HTML)
         throw new EmailError("invalid_request", `invalid_request: HTML body longer than ${MAX_HTML} characters`);
     const files = await ctx.attachments.resolve(ctx.client.id, a.attachments ?? []);
-    return {
-        msg: {
-            from: config.from,
-            replyTo: config.replyTo,
-            to,
-            cc,
-            subject,
-            text: body,
-            html,
-            template,
-            attachments: files.map(({ name, type, size, sha256 }) => ({ name, type, size, sha256 })),
-        },
-        files,
+    const msg = {
+        from: config.from,
+        replyTo: config.replyTo,
+        to,
+        cc,
+        subject,
+        text: body,
+        html,
+        template,
+        attachments: files.map(({ name, type, size, sha256 }) => ({ name, type, size, sha256 })),
     };
+    return { msg, files, via: viaFor(ctx, msg) };
+}
+/** The TEM API up to its 2 MB, SMTP above (EMAIL_SEND_VIA=auto), or the one transport the operator chose. */
+function viaFor(ctx, msg) {
+    const size = estimatedSize(msg);
+    const mode = ctx.config.sendVia;
+    if (mode === "api" || (mode === "auto" && size <= API_MAX_EMAIL_BYTES)) {
+        if (size > API_MAX_EMAIL_BYTES) {
+            throw new EmailError("invalid_request", `invalid_request: about ${size} bytes once encoded, above the ${API_MAX_EMAIL_BYTES}-byte limit of the TEM API (EMAIL_SEND_VIA=api) — lighten the attachments, or let the operator enable SMTP (EMAIL_SEND_VIA=auto)`);
+        }
+        return "api";
+    }
+    if (!ctx.smtp)
+        throw new EmailError("capability_unavailable", "capability_unavailable: this email needs SMTP (above the 2 MB of the TEM API) and SMTP is not configured");
+    if (size > SMTP_MAX_EMAIL_BYTES)
+        throw new EmailError("invalid_request", `invalid_request: about ${size} bytes once encoded, above the ${SMTP_MAX_EMAIL_BYTES}-byte limit of TEM over SMTP`);
+    return "smtp";
 }
 function header(m) {
     const from = m.from.name ? `${m.from.name} <${m.from.email}>` : m.from.email;
@@ -191,7 +209,8 @@ export async function previewEmail(ctx, a) {
     let msg;
     let messageDigest;
     try {
-        msg = (await buildMessage(ctx, a)).msg;
+        let via;
+        ({ msg, via } = await buildMessage(ctx, a));
         messageDigest = digest(msg);
         const prior = ctx.ledger.find(ctx.client.id, a.idempotency_key);
         if (prior)
@@ -212,6 +231,7 @@ export async function previewEmail(ctx, a) {
                 recipients: msg.to.length + msg.cc.length,
                 format: msg.html === undefined ? "text" : "text + html",
                 estimatedBytes: estimatedSize(msg),
+                transport: via === "smtp" ? "TEM over SMTP (above the 2 MB of the API)" : "TEM API",
                 messageDigest: `sha256:${messageDigest}`,
                 policy: { recipientsAllowed: true, senderDomain: domain.status, killSwitch: "inactive" },
                 quotaLeft: { client: q.client, server: q.global },
@@ -250,19 +270,35 @@ export async function sendEmail(ctx, a) {
             throw killSwitchError(ctx);
         const record = ctx.ledger.begin(ctx.client.id, a.idempotency_key, messageDigest);
         const release = ctx.quotas.reserve(ctx.client.id);
-        let emails;
+        let emails = [];
+        let smtp;
+        // TEM lists the email after it arrived: look from a little before, for clock skew
+        const since = new Date(Date.now() - 5 * 60_000).toISOString();
         try {
-            emails = await ctx.tem.createEmail({
-                from: msg.from,
-                to: msg.to.map((email) => ({ email })),
-                cc: msg.cc.map((email) => ({ email })),
-                subject: msg.subject,
-                text: msg.text,
-                html: msg.html,
-                project_id: config.projectId,
-                additional_headers: msg.replyTo ? [{ key: "Reply-To", value: msg.replyTo }] : undefined,
-                attachments: built.files.length ? built.files.map((f) => ({ name: f.name, type: f.type, content: f.content.toString("base64") })) : undefined,
-            });
+            if (built.via === "smtp") {
+                smtp = await ctx.smtp.send({
+                    from: msg.from,
+                    replyTo: msg.replyTo,
+                    to: msg.to,
+                    cc: msg.cc,
+                    subject: msg.subject,
+                    text: msg.text,
+                    html: msg.html,
+                    attachments: built.files.map((f) => ({ name: f.name, type: f.type, content: f.content })),
+                });
+            }
+            else
+                emails = await ctx.tem.createEmail({
+                    from: msg.from,
+                    to: msg.to.map((email) => ({ email })),
+                    cc: msg.cc.map((email) => ({ email })),
+                    subject: msg.subject,
+                    text: msg.text,
+                    html: msg.html,
+                    project_id: config.projectId,
+                    additional_headers: msg.replyTo ? [{ key: "Reply-To", value: msg.replyTo }] : undefined,
+                    attachments: built.files.length ? built.files.map((f) => ({ name: f.name, type: f.type, content: f.content.toString("base64") })) : undefined,
+                });
         }
         catch (err) {
             // a send that may have left keeps its quota slot and burns its key
@@ -274,10 +310,18 @@ export async function sendEmail(ctx, a) {
             }
             throw err;
         }
+        const q = ctx.quotas.remaining(ctx.client.id, ctx.client);
+        if (smtp) {
+            const recipients = smtp.accepted.length ? smtp.accepted : [...msg.to, ...msg.cc];
+            ctx.ledger.settle(record, "sent", [], { since, subject: msg.subject, recipients, messageId: UUID_IN.exec(smtp.response)?.[0].toLowerCase() });
+            ctx.audit.log({ ...auditBase(ctx, tool, a), ...auditMsg(msg, messageDigest), result: "sent", via: "smtp", smtpResponse: smtp.response.slice(0, 200), rejected: smtp.rejected.length ? smtp.rejected : undefined });
+            return text(`# email_send — accepted by Scaleway TEM over SMTP\n\n${fence(header(msg))}\n\n` +
+                json({ accepted: smtp.accepted, rejected: smtp.rejected.length ? smtp.rejected : undefined, smtpResponse: smtp.response.slice(0, 200) }) +
+                `\n\nSMTP does not return TEM email ids: follow delivery with email_status (idempotency_key), which finds them once TEM lists the email (usually within a minute). Quota left: ${q.client.hour} this hour, ${q.client.day} today.`);
+        }
         const ids = emails.map((e) => e.id);
         ctx.ledger.settle(record, "sent", ids);
         ctx.audit.log({ ...auditBase(ctx, tool, a), ...auditMsg(msg, messageDigest), result: "sent", temEmailIds: ids });
-        const q = ctx.quotas.remaining(ctx.client.id, ctx.client);
         return text(`# email_send — accepted by Scaleway TEM\n\n${fence(header(msg))}\n\n` +
             json(emails.map((e) => ({ id: e.id, rcptTo: e.rcpt_to, rcptType: e.rcpt_type, status: e.status }))) +
             `\n\nDelivery is asynchronous: follow it with email_status (emailId or idempotency_key). Quota left: ${q.client.hour} this hour, ${q.client.day} today.`);
@@ -290,6 +334,30 @@ export async function sendEmail(ctx, a) {
     }
 }
 const addressOf = (s) => (/<([^>]+)>/.exec(s)?.[1] ?? s).trim().toLowerCase();
+const UUID_IN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+/**
+ * SMTP does not return the TEM ids: look the email up by the TEM message id of the SMTP reply, or by
+ * sender, subject and date, one email per recipient, the oldest not already owned by another send.
+ * Nothing is attached until every recipient is listed.
+ */
+async function findSmtpIds(ctx, r) {
+    const s = r.smtp;
+    const from = ctx.config.from.email;
+    let list = s.messageId ? await ctx.tem.listEmails({ messageId: s.messageId, mailFrom: from, since: s.since }) : [];
+    if (!list.length)
+        list = await ctx.tem.listEmails({ mailFrom: from, subject: s.subject, since: s.since });
+    const candidates = list
+        .filter((e) => addressOf(e.mail_from ?? "") === from && e.subject === s.subject && !ctx.ledger.ownerOf(e.id))
+        .sort((x, y) => (x.created_at ?? "").localeCompare(y.created_at ?? ""));
+    const ids = [];
+    for (const rcpt of s.recipients) {
+        const e = candidates.find((c) => addressOf(c.rcpt_to ?? "") === rcpt && !ids.includes(c.id));
+        if (!e)
+            return;
+        ids.push(e.id);
+    }
+    ctx.ledger.attach(r, ids);
+}
 async function statusOf(ctx, id) {
     const e = await ctx.tem.getEmail(id);
     // only this server's own sends: the project may also carry other applications' mail
@@ -318,6 +386,12 @@ export async function emailStatus(ctx, a) {
             const r = ctx.ledger.find(ctx.client.id, a.idempotency_key);
             if (!r)
                 throw new EmailError("not_found", "not_found: no send with this idempotency_key for this client (kept 30 days)");
+            if (r.smtp && r.state === "sent") {
+                await findSmtpIds(ctx, r);
+                if (r.smtp) {
+                    return text(json({ idempotencyKey: r.key, state: r.state, transport: "smtp", createdAt: r.createdAt, emails: [], note: "accepted over SMTP; TEM does not list this email yet — ask again in a minute" }));
+                }
+            }
             const emails = [];
             for (const id of r.emailIds.slice(0, 10))
                 emails.push(await statusOf(ctx, id).catch((err) => ({ id, error: toEmailError(err).message })));
@@ -400,7 +474,12 @@ export async function emailConfig(ctx) {
         sender: c.from.name ? `${c.from.name} <${c.from.email}>` : c.from.email,
         replyTo: c.replyTo,
         domain,
-        provider: { name: "Scaleway Transactional Email", region: c.region },
+        provider: {
+            name: "Scaleway Transactional Email",
+            region: c.region,
+            sendVia: c.sendVia === "auto" ? (ctx.smtp ? "API up to 2 MB, SMTP above" : "API") : c.sendVia === "smtp" ? "SMTP" : "API",
+            maxEmailBytes: c.sendVia === "api" || !ctx.smtp ? API_MAX_EMAIL_BYTES : SMTP_MAX_EMAIL_BYTES,
+        },
         allowedRecipients: cl.allowlist ? { server: fmt(c.allowlist), client: fmt(cl.allowlist), rule: "a recipient must be in both" } : fmt(c.allowlist),
         limits: {
             maxRecipientsPerEmail: c.maxRecipients,

package/docs/exploitation.md

@@ -131,5 +131,10 @@ d'authentification sont journalisés (`tool: "http"`, `errorCode: "unauthorized"
 
 - Quotas en mémoire : un redémarrage les remet à zéro (le registre empêche toujours les doublons).
 - Une seule instance : le registre est un fichier local, pas de réplication.
-- Pièces jointes : jointes au message (pas de lien de téléchargement temporaire), 2 Mo au total
-  par défaut, à ajuster à la limite de taille de TEM.
+- Pièces jointes : jointes au message (pas de lien de téléchargement temporaire). L'API TEM refuse
+  tout e-mail de plus de 2 Mo (non augmentable) : au-delà, le serveur passe par le SMTP de TEM
+  (`EMAIL_SEND_VIA=auto`, port sortant 2465 à ouvrir), limité à 50 Mo par e-mail, soit 35 Mo de
+  pièces jointes par défaut. Avec `EMAIL_SEND_VIA=api`, la limite reste 2 Mo.
+- Envois SMTP : pas d'identifiant TEM au moment de l'envoi. `email_status` (par
+  `idempotency_key`) les retrouve quand TEM liste l'e-mail ; les événements webhook reçus avant
+  ne sont pas rattachés.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aidalinfo/email-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Outbound email MCP server over Scaleway Transactional Email (TEM) — stdio or central Streamable HTTP with per-client Bearer keys, fixed sender, recipient allowlist, preview then confirmed idempotent sends, quotas, kill switch, versioned templates, controlled attachments, delivery webhook and audit",
   "type": "module",
   "main": "dist/index.js",
@@ -44,11 +44,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0",
+    "nodemailer": "^10.5.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@jest/globals": "^30.3.0",
     "@types/node": "^26.6.5",
+    "@types/nodemailer": "^8.0.2",
     "jest": "^30.3.0",
     "ts-jest": "^29.4.6",
     "typescript": "^5.7.0"