@cogitator-ai/channels 0.16.0 → 0.18.0

package/dist/channels/email/channel.js

@@ -0,0 +1,701 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { htmlToText, markdownToHtml } from '../../formatters/html.js';
+import { markdownToPlainText } from '../../formatters/plain-text.js';
+import { allowsSender, domainOf, headerOf, isAddress, normalizeAddress } from './address.js';
+import { secretsEqual, verifyMailgunSignature } from './auth.js';
+import { EmailDependencyError } from './errors.js';
+import { ImapInbox } from './imap.js';
+import { loadPostalMime, parseRawEmail } from './mime.js';
+import { readFormFields } from './multipart.js';
+import { bodyText, isForm, mailgunFormEmail, mailgunJsonEmail, postmarkEmail, requestHeader, sendgridEmail, } from './providers.js';
+import { stripQuotedReply } from './reply.js';
+/** The header the channel puts on every mail it sends, and skips mail that carries it. */
+export const EMAIL_LOOP_HEADER = 'X-Cogitator';
+/** The largest webhook body the channel's own server takes by default, in bytes. */
+export const EMAIL_DEFAULT_MAX_BODY = 10 * 1024 * 1024;
+/** The largest attachment handed to the agent by default, in bytes. */
+export const EMAIL_DEFAULT_MAX_ATTACHMENT = 10 * 1024 * 1024;
+/** How old a Mailgun signature may be by default, in seconds. */
+export const MAILGUN_DEFAULT_MAX_AGE = 300;
+const MAX_TRACKED = 1000;
+const MAX_REFERENCES = 20;
+/** The most Mailgun signatures remembered against replays, however many came in the window. */
+const MAX_SIGNATURES = 100_000;
+/**
+ * How long a webhook request waits for the gateway to take its mail, in ms. A gateway that queues
+ * takes it at once, and one that answers before it returns is answered `200` after this long.
+ */
+const HANDOVER_TIMEOUT = 5000;
+const AUTOMATED_SENDER = /^(mailer-daemon|postmaster|no-?reply|do-?not-?reply|bounces?)([+-.].*)?@/i;
+async function loadNodemailer() {
+    try {
+        const module = (await import('nodemailer'));
+        return 'createTransport' in module ? module : module.default;
+    }
+    catch (error) {
+        throw new EmailDependencyError('nodemailer', 'to send email over SMTP', { cause: error });
+    }
+}
+/** Resolves with `fallback` when `promise` takes longer than `ms`. */
+function within(promise, ms, fallback) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function forgetOldest(collection) {
+    while (collection.size > MAX_TRACKED) {
+        const oldest = collection.keys().next().value;
+        if (oldest === undefined)
+            return;
+        collection.delete(oldest);
+    }
+}
+/** `subject` as a reply's subject: with one `Re: `, whatever prefix it had. */
+export function replySubject(subject) {
+    const base = subject.replace(/^(\s*(re|aw|sv|antw|ответ|отв)\s*(\[\d+\])?\s*:\s*)+/i, '').trim();
+    return base ? `Re: ${base}` : 'Re:';
+}
+/** The references of a reply: the first and the latest ids, since a long chain is cut. */
+function trimReferences(ids) {
+    const unique = [...new Set(ids)];
+    if (unique.length <= MAX_REFERENCES)
+        return unique;
+    return [unique[0], ...unique.slice(unique.length - (MAX_REFERENCES - 1))];
+}
+/** Whether the mail is an automatic one: an auto-reply, a bounce, a list or bulk mailing. */
+export function isAutomatedEmail(email) {
+    const header = (name) => headerOf(email.headers, name)?.trim().toLowerCase();
+    const autoSubmitted = header('auto-submitted');
+    if (autoSubmitted && autoSubmitted !== 'no')
+        return true;
+    const precedence = header('precedence');
+    if (precedence && /^(bulk|junk|list|auto_reply)/.test(precedence))
+        return true;
+    if (header('x-autoreply') || header('x-autorespond') || header('x-autogenerated'))
+        return true;
+    if (header('x-failed-recipients'))
+        return true;
+    if (header('content-type')?.startsWith('multipart/report'))
+        return true;
+    if (header('return-path') === '<>')
+        return true;
+    return !!email.from && AUTOMATED_SENDER.test(email.from.address);
+}
+class BodyTooLarge extends Error {
+}
+function readBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > limit) {
+                reject(new BodyTooLarge('Webhook body too large'));
+                req.pause();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+/**
+ * An email channel: an agent answers mail, in the thread of each mail. Mail comes from a mailbox
+ * over IMAP (`imapflow` and `postal-mime`), or from the inbound webhook of Mailgun, Postmark or
+ * SendGrid, and answers go out over SMTP (`nodemailer`) or any transport given, with
+ * `In-Reply-To` and `References` set, so mail clients keep them in the thread.
+ *
+ * A sender is a conversation partner: `channelId` and `userId` are the sender's address in lower
+ * case, and `topicId` is the thread's first `Message-ID`, so each email thread is a conversation
+ * of its own. Answers are Markdown, sent as HTML with a plain text alternative, and cannot be
+ * edited. Mail from the bot itself, mail that carries the `X-Cogitator` header the channel puts
+ * on what it sends, auto-replies, bounces and bulk mail are never answered.
+ */
+export class EmailChannel {
+    type = 'email';
+    editable = false;
+    nativeMarkdown = true;
+    maxMessageChars = Infinity;
+    config;
+    address;
+    ownAddresses;
+    owners;
+    handler = null;
+    /** Mail handed to the gateway whose handler has not resolved yet, by `Message-ID` */
+    inFlight = new Set();
+    /** Mail of `inFlight` the gateway handed back while it was being taken */
+    refused = new Set();
+    handled = new Set();
+    /** Mailgun signatures seen, with their timestamps, against replays */
+    signatures = new Map();
+    /** The IMAP UID of each mail taken from the mailbox, by `Message-ID`, to mark it unread again */
+    uids = new Map();
+    threads = new Map();
+    /** The latest mail of each thread, by `address|root` */
+    latest = new Map();
+    transport;
+    inbox;
+    server;
+    running = false;
+    stopped = false;
+    constructor(config) {
+        const address = normalizeAddress(config.address ?? '');
+        if (!isAddress(address)) {
+            throw new Error(`[email] "${config.address}" is not an email address: set address`);
+        }
+        if (!config.smtp)
+            throw new Error('[email] smtp is required: answers are sent with it');
+        const webhook = config.webhook;
+        if (webhook?.provider === 'mailgun' && !webhook.signingKey) {
+            throw new Error('[email] webhook.signingKey is required: Mailgun signs requests with it');
+        }
+        if (webhook &&
+            webhook.provider !== 'mailgun' &&
+            !webhook.token &&
+            !(webhook.basicAuth?.username && webhook.basicAuth.password)) {
+            throw new Error(`[email] ${webhook.provider} does not sign its webhook: set webhook.basicAuth or webhook.token`);
+        }
+        if (config.imap && config.senderAuth === 'required' && !config.trustedAuthservIds?.length) {
+            throw new Error("[email] senderAuth 'required' over IMAP needs trustedAuthservIds: the Authentication-Results of the receiving server, such as mx.google.com, are the only ones a sender cannot forge");
+        }
+        this.config = config;
+        this.address = address;
+        this.ownAddresses = new Set([address, ...(config.aliases ?? []).map(normalizeAddress)]);
+        this.owners = new Set((config.owners ?? []).map(normalizeAddress));
+    }
+    onMessage(handler) {
+        this.handler = handler;
+    }
+    async start() {
+        if (this.running)
+            return;
+        if (!this.config.allowFrom?.length) {
+            console.warn('[email] No allowFrom set: the bot answers nobody. List the addresses or domains it answers, or "*" for everyone');
+        }
+        else if (this.config.allowFrom.includes('*') && this.config.senderAuth === 'off') {
+            console.warn('[email] allowFrom is "*" and senderAuth is off: anyone can write to the agent, also as someone else');
+        }
+        if (!this.config.imap && !this.config.webhook) {
+            console.warn('[email] Neither imap nor webhook is set: the channel only sends mail');
+        }
+        if (this.config.imap &&
+            this.config.senderAuth !== 'off' &&
+            !this.config.trustedAuthservIds?.length) {
+            console.warn(`[email] No trustedAuthservIds: mail read over IMAP has no sender authentication, so a forged From passes${this.owners.size > 0 ? ' and mail from the owners is dropped' : ''}. Set them to the authserv-id the receiving server writes in Authentication-Results, such as mx.google.com`);
+        }
+        this.running = true;
+        this.stopped = false;
+        try {
+            if (this.config.imap)
+                await loadPostalMime();
+            if (!('transport' in this.config.smtp))
+                await this.transportOf();
+            const webhook = this.config.webhook;
+            if (webhook?.port !== undefined) {
+                await this.listen(webhook.port, webhook.path ?? '/email/webhook', webhook.host);
+            }
+            if (this.config.imap) {
+                this.inbox = new ImapInbox(this.config.imap, (raw, uid) => parseRawEmail(raw, this.parseOptions()).then((email) => ({
+                    email: { ...email, raw: { uid, email: email.raw } },
+                    uid,
+                })), async ({ email, uid }) => (await this.accept(email, uid)) !== 'refused');
+                await this.inbox.start();
+            }
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+    }
+    async stop() {
+        this.running = false;
+        this.stopped = true;
+        const server = this.server;
+        this.server = undefined;
+        const inbox = this.inbox;
+        this.inbox = undefined;
+        await Promise.all([
+            inbox?.stop(),
+            server &&
+                new Promise((resolve) => {
+                    server.closeAllConnections();
+                    server.close(() => resolve());
+                }),
+        ]);
+        const transport = this.transport;
+        this.transport = undefined;
+        if (transport)
+            (await transport.catch(() => undefined))?.close?.();
+    }
+    /** Looks for unread mail over IMAP now, besides IDLE and the poll timer. */
+    async poll() {
+        await this.inbox?.sync();
+    }
+    /**
+     * Takes back a mail the gateway does not answer because it stops. One it refuses while it is
+     * being handed over stays unread in the mailbox, and its webhook request is answered `503`, so
+     * the provider sends it again. One it dropped after taking it is marked unread again, so the
+     * next start reads it once more, or, when a webhook brought it, only logged.
+     */
+    async redeliver(msg) {
+        if (this.inFlight.has(msg.id)) {
+            this.refused.add(msg.id);
+            return;
+        }
+        const uid = this.uids.get(msg.id);
+        if (uid === undefined || !this.inbox) {
+            console.warn(`[email] The mail ${msg.id} from ${msg.channelId} was dropped unanswered`);
+            return;
+        }
+        this.handled.delete(msg.id.toLowerCase());
+        this.uids.delete(msg.id);
+        await this.inbox.unsee(uid);
+    }
+    /**
+     * Answers a provider's inbound webhook request: checks its signature or secret, reads the
+     * mail, answers at once and hands the mail to the agent after. Mount it in any HTTP server
+     * with the raw body unparsed. It works before `start()` too and answers `503` once stopped.
+     */
+    async handleWebhook(request) {
+        const webhook = this.config.webhook;
+        if (this.stopped)
+            return { status: 503, body: 'The channel is stopped' };
+        if (!webhook)
+            return { status: 404, body: 'The webhook is not configured' };
+        if (request.method !== 'POST')
+            return { status: 405, body: 'Method not allowed' };
+        const raw = request.rawBody ?? '';
+        const contentType = requestHeader(request.headers, 'content-type') ?? '';
+        if (webhook.provider !== 'mailgun' && !this.authorized(webhook, request)) {
+            return { status: 401, body: 'Unauthorized' };
+        }
+        let email;
+        let replayKey;
+        try {
+            if (webhook.provider === 'mailgun') {
+                const verified = await this.mailgunEmail(webhook, request, raw, contentType);
+                if ('status' in verified)
+                    return verified;
+                ({ email, replayKey } = verified);
+            }
+            else if (webhook.provider === 'postmark') {
+                email = postmarkEmail(JSON.parse(bodyText(raw)), this.parseOptions());
+            }
+            else {
+                if (!isForm(contentType))
+                    return { status: 415, body: 'Expected multipart/form-data' };
+                email = await sendgridEmail(readFormFields(raw, contentType), this.parseOptions());
+            }
+        }
+        catch (error) {
+            if (error instanceof EmailDependencyError) {
+                console.error(`[email] ${error.message}`);
+                return { status: 500, body: 'Could not read the message' };
+            }
+            return { status: 400, body: 'Invalid payload' };
+        }
+        const accepted = this.accept(email).catch((error) => {
+            console.error('[email] Webhook mail failed:', error);
+            return 'taken';
+        });
+        const pending = Symbol('pending');
+        const handedOver = await within(accepted, HANDOVER_TIMEOUT, pending);
+        if (handedOver === 'refused') {
+            if (replayKey !== undefined)
+                this.signatures.delete(replayKey);
+            return { status: 503, body: 'Not taken now, send it again later' };
+        }
+        if (handedOver === pending) {
+            void accepted.then((late) => {
+                if (late === 'refused') {
+                    console.warn(`[email] The mail ${email.messageId ?? ''} from ${email.from?.address ?? 'unknown'} was dropped unanswered after its webhook was answered, so the provider will not send it again`);
+                }
+            });
+        }
+        return { status: 200, body: 'OK' };
+    }
+    /**
+     * A Node request listener that answers webhook requests on any path it is mounted at. Bodies
+     * over `webhook.maxBody` (10 MB by default) are refused with `413`.
+     */
+    webhookListener() {
+        const limit = this.config.webhook?.maxBody ?? EMAIL_DEFAULT_MAX_BODY;
+        return (req, res) => {
+            let query = {};
+            try {
+                query = Object.fromEntries(new URL(req.url ?? '/', 'http://localhost').searchParams);
+            }
+            catch {
+                res.writeHead(400, { 'content-type': 'text/plain' }).end('Bad request');
+                return;
+            }
+            readBody(req, limit)
+                .then((rawBody) => this.handleWebhook({ method: req.method ?? 'GET', query, headers: req.headers, rawBody }))
+                .then((response) => res.writeHead(response.status, { 'content-type': 'text/plain' }).end(response.body))
+                .catch((error) => {
+                if (error instanceof BodyTooLarge) {
+                    res.writeHead(413, { 'content-type': 'text/plain', connection: 'close' });
+                    res.end('Payload too large');
+                    return;
+                }
+                console.error('[email] Webhook request failed:', error);
+                if (!res.headersSent)
+                    res.writeHead(500);
+                res.end();
+            });
+        };
+    }
+    /**
+     * Sends `text` to the address `channelId`. With a `replyTo` of a mail the channel saw, or the
+     * `topicId` of a thread, it answers in that thread (`Re:` subject, `In-Reply-To`,
+     * `References`), and otherwise it starts a new one. Resolves with the new mail's `Message-ID`.
+     */
+    async sendText(channelId, text, options) {
+        if (!text.trim())
+            throw new Error('[email] Nothing to send');
+        return this.send(channelId, this.bodies(text, options?.format), options);
+    }
+    editText() {
+        return Promise.reject(new Error('[email] Sent email cannot be edited'));
+    }
+    /**
+     * Sends a file as an attachment, its caption as the text, in the thread as `sendText` does.
+     * A file needs a `buffer` or an `http(s)` url, which nodemailer downloads.
+     */
+    async sendFile(channelId, file, options) {
+        const filename = file.filename ?? (file.type === 'image' ? 'image' : 'file');
+        let attachment;
+        if (file.buffer) {
+            attachment = { filename, content: Buffer.from(file.buffer), contentType: file.mimeType };
+        }
+        else if (file.url && /^https?:\/\//i.test(file.url)) {
+            attachment = { filename, href: file.url, contentType: file.mimeType };
+        }
+        else {
+            throw new Error('[email] A file needs a buffer or an http(s) url');
+        }
+        const caption = file.caption?.trim() ? file.caption : filename;
+        return this.send(channelId, { ...this.bodies(caption, options?.format), attachment }, options);
+    }
+    async sendTyping() { }
+    parseOptions() {
+        return {
+            maxAttachmentBytes: this.config.maxAttachmentBytes ?? EMAIL_DEFAULT_MAX_ATTACHMENT,
+            ...(this.config.trustedAuthservIds && {
+                trustedAuthservIds: this.config.trustedAuthservIds,
+            }),
+        };
+    }
+    authorized(webhook, request) {
+        if (webhook.token) {
+            const given = request.query?.token ?? requestHeader(request.headers, 'x-webhook-token') ?? undefined;
+            if (given !== undefined && secretsEqual(given, webhook.token))
+                return true;
+        }
+        const credentials = webhook.basicAuth;
+        const authorization = requestHeader(request.headers, 'authorization');
+        if (credentials && authorization?.toLowerCase().startsWith('basic ')) {
+            const decoded = Buffer.from(authorization.slice(6).trim(), 'base64').toString('utf-8');
+            return secretsEqual(decoded, `${credentials.username}:${credentials.password}`);
+        }
+        return false;
+    }
+    /**
+     * Checks a Mailgun request's signature, age and token, and reads its mail. The signature is
+     * checked before the mail is read: a form is only split into its fields first, where the
+     * signature is.
+     */
+    async mailgunEmail(webhook, request, raw, contentType) {
+        let timestamp;
+        let token;
+        let signature;
+        let fields;
+        if (isForm(contentType)) {
+            fields = readFormFields(raw, contentType);
+            timestamp = fields.text('timestamp');
+            token = fields.text('token');
+            signature = fields.text('signature');
+        }
+        else {
+            timestamp = requestHeader(request.headers, 'x-mailgun-timestamp');
+            signature = requestHeader(request.headers, 'x-mailgun-signature');
+            token = raw;
+        }
+        if (!timestamp ||
+            !signature ||
+            token === undefined ||
+            !verifyMailgunSignature(timestamp, token, signature, webhook.signingKey)) {
+            return { status: 401, body: 'Invalid signature' };
+        }
+        const maxAge = webhook.maxAge ?? MAILGUN_DEFAULT_MAX_AGE;
+        const now = Date.now() / 1000;
+        const sent = Number(timestamp);
+        if (!Number.isFinite(sent) || Math.abs(now - sent) > maxAge) {
+            return { status: 401, body: 'Stale signature' };
+        }
+        const replayKey = signature.toLowerCase();
+        if (this.signatures.has(replayKey))
+            return { status: 200, body: 'Already received' };
+        this.rememberSignature(replayKey, sent, now - maxAge);
+        try {
+            const email = fields
+                ? await mailgunFormEmail(fields, this.parseOptions())
+                : await mailgunJsonEmail(JSON.parse(bodyText(raw)), this.parseOptions());
+            return { email, replayKey };
+        }
+        catch (error) {
+            this.signatures.delete(replayKey);
+            throw error;
+        }
+    }
+    /**
+     * Remembers a signature for as long as its timestamp is within the replay window: older ones
+     * are refused as stale anyway. Past `MAX_SIGNATURES` the oldest are forgotten.
+     */
+    rememberSignature(key, sent, oldestValid) {
+        for (const [seen, at] of this.signatures) {
+            if (at >= oldestValid && this.signatures.size < MAX_SIGNATURES)
+                break;
+            this.signatures.delete(seen);
+        }
+        this.signatures.set(key, sent);
+    }
+    /** Whether the mail may reach the agent: by its sender, its kind and its authentication. */
+    admits(email, sender) {
+        if (this.ownAddresses.has(sender))
+            return false;
+        if (headerOf(email.headers, EMAIL_LOOP_HEADER) !== undefined)
+            return false;
+        if (isAutomatedEmail(email))
+            return false;
+        const policy = this.config.senderAuth ?? 'when-reported';
+        if (policy !== 'off') {
+            if (email.authentication === 'fail')
+                return false;
+            if (policy === 'required' && email.authentication !== 'pass')
+                return false;
+        }
+        if (this.owners.has(sender))
+            return policy === 'off' || email.authentication === 'pass';
+        return allowsSender(this.config.allowFrom ?? [], sender);
+    }
+    /**
+     * The text the agent reads: the new text of the mail, starting with the subject on a thread's
+     * first mail. A command (`/status`) stays first, so the gateway still sees it, and a mail
+     * with only a command as its subject is that command.
+     */
+    textOf(email) {
+        const body = stripQuotedReply(email.text?.trim() ? email.text : email.html ? htmlToText(email.html) : '');
+        const subject = email.subject.trim();
+        if (!body && subject.startsWith('/'))
+            return subject;
+        const starts = !email.inReplyTo && email.references.length === 0;
+        if (!starts || !subject || this.config.includeSubject === false || body.startsWith('/')) {
+            return body;
+        }
+        return `Subject: ${subject}${body ? `\n\n${body}` : ''}`;
+    }
+    /**
+     * Hands an inbound mail to the agent when it is one to answer. Resolves `refused` when the
+     * gateway did not take it, so it may come again.
+     */
+    async accept(email, uid) {
+        if (!this.handler || !email.from)
+            return 'skipped';
+        const sender = email.from.address;
+        if (!this.admits(email, sender))
+            return 'skipped';
+        const messageId = email.messageId ?? this.fallbackId(email, sender);
+        const dedupeKey = messageId.toLowerCase();
+        if (this.handled.has(dedupeKey))
+            return 'skipped';
+        const text = this.textOf(email);
+        if (!text && email.attachments.length === 0)
+            return 'skipped';
+        this.handled.add(dedupeKey);
+        forgetOldest(this.handled);
+        const parent = email.inReplyTo ?? email.references[email.references.length - 1];
+        const root = (parent && this.threads.get(parent)?.root) ??
+            email.references[0] ??
+            email.inReplyTo ??
+            messageId;
+        this.remember(sender, messageId, {
+            subject: email.subject,
+            references: trimReferences([
+                ...(email.references.length ? email.references : email.inReplyTo ? [email.inReplyTo] : []),
+                messageId,
+            ]),
+            root,
+        });
+        const message = {
+            id: messageId,
+            channelType: this.type,
+            channelId: sender,
+            userId: sender,
+            ...(email.from.name && { userName: email.from.name }),
+            text,
+            ...(email.attachments.length > 0 && { attachments: email.attachments }),
+            ...(email.inReplyTo && { replyTo: email.inReplyTo }),
+            topicId: root,
+            raw: email.raw,
+        };
+        if (uid !== undefined) {
+            this.uids.set(messageId, uid);
+            forgetOldest(this.uids);
+        }
+        this.inFlight.add(messageId);
+        try {
+            await this.handler(message);
+        }
+        catch (error) {
+            console.error('[email] Message handler error:', error);
+        }
+        finally {
+            this.inFlight.delete(messageId);
+        }
+        if (!this.refused.delete(messageId))
+            return 'taken';
+        this.handled.delete(dedupeKey);
+        this.uids.delete(messageId);
+        return 'refused';
+    }
+    fallbackId(email, sender) {
+        const digest = createHash('sha256')
+            .update([
+            sender,
+            headerOf(email.headers, 'date') ?? '',
+            email.subject,
+            email.text ?? email.html ?? '',
+        ].join('\n'))
+            .digest('hex')
+            .slice(0, 32);
+        return `<${digest}@cogitator.invalid>`;
+    }
+    remember(address, messageId, entry) {
+        this.threads.delete(messageId);
+        this.threads.set(messageId, entry);
+        forgetOldest(this.threads);
+        const key = `${address}|${entry.root}`;
+        this.latest.delete(key);
+        this.latest.set(key, messageId);
+        forgetOldest(this.latest);
+    }
+    /** The thread a mail to `to` goes in: the mail it answers, or the latest of its topic. */
+    threadOf(to, options) {
+        const replyTo = options?.replyTo;
+        const answered = replyTo ? this.threads.get(replyTo) : undefined;
+        if (replyTo && answered)
+            return { inReplyTo: replyTo, entry: answered, root: answered.root };
+        const topic = options?.topicId;
+        if (topic) {
+            const latest = this.latest.get(`${to}|${topic}`);
+            const entry = latest ? this.threads.get(latest) : undefined;
+            if (latest && entry)
+                return { inReplyTo: latest, entry, root: topic };
+            return { inReplyTo: replyTo ?? topic, root: topic };
+        }
+        return replyTo ? { inReplyTo: replyTo, root: replyTo } : {};
+    }
+    bodies(text, format) {
+        if (format === 'plain')
+            return { text };
+        if (format === 'html')
+            return { text: htmlToText(text), html: text };
+        return { text: markdownToPlainText(text), html: markdownToHtml(text) };
+    }
+    async send(channelId, content, options) {
+        const to = normalizeAddress(channelId);
+        if (!isAddress(to)) {
+            throw new Error(`[email] Unknown channel id "${channelId}": use the recipient's address`);
+        }
+        const thread = this.threadOf(to, options);
+        const ownSubject = this.config.subject || `Message from ${this.config.name ?? this.address}`;
+        const baseSubject = thread.entry?.subject || ownSubject;
+        const subject = thread.entry ? replySubject(baseSubject) : baseSubject;
+        const references = thread.inReplyTo
+            ? trimReferences([...(thread.entry?.references ?? []), thread.inReplyTo])
+            : [];
+        const messageId = `<${randomUUID()}@${domainOf(this.address)}>`;
+        const transport = await this.transportOf();
+        await transport.sendMail({
+            from: this.config.name ? { name: this.config.name, address: this.address } : this.address,
+            to,
+            subject,
+            text: content.text,
+            ...(content.html && { html: content.html }),
+            messageId,
+            ...(thread.inReplyTo && { inReplyTo: thread.inReplyTo, references }),
+            headers: {
+                [EMAIL_LOOP_HEADER]: 'email',
+                'Auto-Submitted': thread.inReplyTo ? 'auto-replied' : 'auto-generated',
+            },
+            ...(content.attachment && { attachments: [content.attachment] }),
+        });
+        this.remember(to, messageId, {
+            subject: thread.entry?.subject || baseSubject,
+            references: trimReferences([...references, messageId]),
+            root: thread.root ?? messageId,
+        });
+        return messageId;
+    }
+    transportOf() {
+        const smtp = this.config.smtp;
+        if ('transport' in smtp)
+            return Promise.resolve(smtp.transport);
+        this.transport ??= loadNodemailer()
+            .then((nodemailer) => {
+            const secure = smtp.secure ?? smtp.port === 465;
+            return nodemailer.createTransport({
+                host: smtp.host,
+                port: smtp.port ?? (secure ? 465 : 587),
+                secure,
+                ...(smtp.auth && { auth: smtp.auth }),
+                ...smtp.options,
+            });
+        })
+            .catch((error) => {
+            this.transport = undefined;
+            throw error;
+        });
+        return this.transport;
+    }
+    listen(port, path, host) {
+        const listener = this.webhookListener();
+        const server = createServer((req, res) => {
+            let pathname;
+            try {
+                pathname = new URL(req.url ?? '/', 'http://localhost').pathname;
+            }
+            catch {
+                res.writeHead(400, { 'content-type': 'text/plain' }).end('Bad request');
+                return;
+            }
+            if (pathname !== path) {
+                res.writeHead(404).end();
+                return;
+            }
+            listener(req, res);
+        });
+        this.server = server;
+        return new Promise((resolve, reject) => {
+            const failed = (error) => {
+                this.server = undefined;
+                reject(error);
+            };
+            server.once('error', failed);
+            server.listen(port, host, () => {
+                server.off('error', failed);
+                resolve();
+            });
+        });
+    }
+}
+/** An email channel that answers mail in its thread. */
+export function emailChannel(config) {
+    return new EmailChannel(config);
+}
+//# sourceMappingURL=channel.js.map