toiljs 0.0.115 → 0.0.117

package/src/devserver/email/console.ts

@@ -1,348 +0,0 @@
-/**
- * DEV EMAIL EMULATOR: renders an outgoing email as an ASCII-drawn box in the
- * terminal so confirm / reset / 2FA flows are testable locally WITHOUT a real
- * inbox (the whole point of dev). It converts the HTML body to readable text WITH
- * terminal color + font styling (bold / italic / underline / colored text taken
- * from the HTML), lays it out under a left-barred box, and highlights the ACTION
- * (the one-time link, which carries its token in the `#token=` fragment and so is
- * directly clickable, or the numeric 2FA code). Dev-only; the production edge never
- * renders or logs token material.
- *
- * The box uses a LEFT bar plus full top/bottom rules (no right border), so colored
- * spans never break column alignment and long URLs stay on one unbroken, clickable
- * line. Styling is emitted only when the terminal supports color (a piped/CI run
- * gets clean plain text).
- */
-import pc from 'picocolors';
-
-import { type ParsedEmail } from './wire.js';
-
-const WIDTH = 68; // wrap column for body text (URLs are left un-wrapped)
-
-/** Decode the handful of HTML entities our built-in templates can emit. */
-function decodeEntities(s: string): string {
-    return s
-        .replace(/ /g, ' ')
-        .replace(/&/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#0*39;|&apos;/g, "'")
-        .replace(/&#x([0-9a-fA-F]+);/g, (_m, h: string) => String.fromCodePoint(parseInt(h, 16)))
-        .replace(/&#(\d+);/g, (_m, d: string) => String.fromCodePoint(parseInt(d, 10)));
-}
-
-/**
- * A plain-text (no color) rendering of an HTML email body: anchors become
- * `text (url)`, block elements become line breaks, remaining tags are stripped,
- * entities decoded, whitespace collapsed. Kept for the action-extraction fallback
- * and any caller that wants text without escape codes.
- */
-export function htmlToText(html: string): string {
-    let s = html;
-    // <a href="URL">TEXT</a> -> "TEXT (URL)" (or just URL when text == url / empty)
-    s = s.replace(
-        /<a\b[^>]*\bhref=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi,
-        (_m, href: string, inner: string) => {
-            const t = inner.replace(/<[^>]+>/g, '').trim();
-            return t.length > 0 && t !== href ? `${t} (${href})` : href;
-        },
-    );
-    s = s.replace(/<br\s*\/?>/gi, '\n');
-    s = s.replace(/<\/?(?:p|div|h[1-6]|li|tr|table|ul|ol|blockquote|section|header|footer)\b[^>]*>/gi, '\n');
-    s = s.replace(/<[^>]+>/g, '');
-    s = decodeEntities(s);
-    s = s.replace(/[ \t]+/g, ' ');
-    s = s
-        .split('\n')
-        .map((l) => l.trim())
-        .join('\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-    return s;
-}
-
-/** The actionable bit of an email: the first link, else a 4-8 digit code, else null. */
-export function emailAction(parsed: ParsedEmail): { kind: 'link' | 'code'; value: string } | null {
-    const body = parsed.body.length > 0 ? parsed.body : htmlToText(parsed.html);
-    const link = /https?:\/\/[^\s"'<>)]+/.exec(body);
-    if (link !== null) return { kind: 'link', value: link[0] };
-    const code = /\b(\d{4,8})\b/.exec(body);
-    if (code !== null) return { kind: 'code', value: code[1] };
-    return null;
-}
-
-// --- HTML -> STYLED terminal spans -----------------------------------------------------------------
-
-type Rgb = readonly [number, number, number];
-interface Style {
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    color?: Rgb;
-}
-interface Word {
-    readonly text: string;
-    readonly style: Style;
-    /** Whether whitespace separated this word from the previous one in the source
-     *  (so `<b>bob</b>,` renders as `bob,` not `bob ,`). */
-    readonly spaceBefore: boolean;
-}
-
-/** A small palette of CSS color names our templates (and most emails) use. */
-const NAMED: Record<string, Rgb> = {
-    black: [0, 0, 0], white: [235, 235, 235], red: [229, 57, 53], green: [67, 160, 71],
-    blue: [30, 136, 229], yellow: [253, 216, 53], orange: [251, 140, 0], purple: [142, 36, 170],
-    magenta: [216, 27, 96], pink: [233, 30, 99], cyan: [0, 172, 193], teal: [0, 137, 123],
-    indigo: [57, 73, 171], gray: [128, 128, 128], grey: [128, 128, 128], silver: [192, 192, 192],
-    gold: [255, 193, 7], brown: [121, 85, 72], navy: [26, 35, 126], lime: [124, 179, 66],
-};
-
-/** Parse a CSS color value (`#rgb`, `#rrggbb`, `rgb(...)`, or a named color) to RGB. */
-export function parseColor(value: string): Rgb | undefined {
-    const s = value.trim().toLowerCase();
-    const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(s);
-    if (hex !== null) {
-        const h = hex[1];
-        if (h.length === 3) {
-            return [parseInt(h[0] + h[0], 16), parseInt(h[1] + h[1], 16), parseInt(h[2] + h[2], 16)];
-        }
-        return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
-    }
-    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})/.exec(s);
-    if (rgb !== null) {
-        return [Math.min(255, +rgb[1]), Math.min(255, +rgb[2]), Math.min(255, +rgb[3])];
-    }
-    return NAMED[s];
-}
-
-/** The style delta a tag (name + raw attributes) contributes. */
-function styleFromTag(name: string, attrs: string): Style {
-    const d: Style = {};
-    if (name === 'b' || name === 'strong' || /^h[1-6]$/.test(name)) d.bold = true;
-    if (name === 'i' || name === 'em') d.italic = true;
-    if (name === 'u' || name === 'ins') d.underline = true;
-    if (name === 'a') {
-        d.underline = true;
-        d.color = NAMED.cyan; // links stand out
-    }
-    if (name === 'code' || name === 'kbd' || name === 'pre' || name === 'samp') d.color = NAMED.gray;
-    const styleAttr = /style\s*=\s*["']([^"']*)["']/i.exec(attrs);
-    if (styleAttr !== null) {
-        const css = styleAttr[1].toLowerCase();
-        const colorM = /(?:^|;)\s*color\s*:\s*([^;]+)/.exec(css);
-        if (colorM !== null) {
-            const c = parseColor(colorM[1]);
-            if (c !== undefined) d.color = c;
-        }
-        if (/font-weight\s*:\s*(?:bold|bolder|[6-9]00)/.test(css)) d.bold = true;
-        if (/font-style\s*:\s*italic/.test(css)) d.italic = true;
-        if (/text-decoration[^;]*:\s*[^;]*underline/.test(css)) d.underline = true;
-    }
-    if (name === 'font') {
-        const fc = /\bcolor\s*=\s*["']([^"']+)["']/i.exec(attrs);
-        if (fc !== null) {
-            const c = parseColor(fc[1]);
-            if (c !== undefined) d.color = c;
-        }
-    }
-    return d;
-}
-
-/** Flatten a style stack (last color / any true flag wins). */
-function compose(stack: readonly Style[]): Style {
-    const out: Style = {};
-    for (const s of stack) {
-        if (s.bold) out.bold = true;
-        if (s.italic) out.italic = true;
-        if (s.underline) out.underline = true;
-        if (s.color !== undefined) out.color = s.color;
-    }
-    return out;
-}
-
-const BLOCK = new Set([
-    'p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'tr', 'table', 'ul', 'ol',
-    'blockquote', 'section', 'header', 'footer', 'br', 'hr', 'article', 'main', 'nav', 'aside',
-]);
-
-/** Parse an HTML body into paragraphs (split on block elements) of styled words,
- *  preserving whether each word was space-separated from the previous one. */
-function htmlToParagraphs(html: string): Word[][] {
-    const paras: Word[][] = [];
-    let cur: Word[] = [];
-    let pendingSpace = false; // a space boundary carried across tag boundaries
-    const flush = (): void => {
-        if (cur.length > 0) {
-            paras.push(cur);
-            cur = [];
-        }
-        pendingSpace = false;
-    };
-    const stack: Style[] = [];
-    const hrefs: (string | null)[] = [];
-    const re = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:"[^"]*"|'[^']*'|[^>"'])*)>|([^<]+)/g;
-    let m: RegExpExecArray | null;
-    while ((m = re.exec(html)) !== null) {
-        const raw = m[4];
-        if (raw !== undefined) {
-            const norm = decodeEntities(raw).replace(/\s+/g, ' ').trim();
-            if (norm.length === 0) {
-                if (/\s/.test(raw)) pendingSpace = true;
-                continue;
-            }
-            const leading = /^\s/.test(raw) || pendingSpace;
-            const st = compose(stack);
-            const words = norm.split(' ');
-            for (let i = 0; i < words.length; i++) {
-                cur.push({ text: words[i], style: st, spaceBefore: cur.length > 0 && (i > 0 || leading) });
-            }
-            pendingSpace = /\s$/.test(raw);
-            continue;
-        }
-        const closing = m[1] === '/';
-        const name = m[2].toLowerCase();
-        const attrs = m[3] ?? '';
-        if (BLOCK.has(name)) {
-            flush();
-            if (/^h[1-6]$/.test(name)) {
-                if (closing) stack.pop();
-                else stack.push(styleFromTag(name, attrs));
-            }
-            continue;
-        }
-        if (closing) {
-            stack.pop();
-            if (name === 'a') {
-                const href = hrefs.pop();
-                if (href) {
-                    cur.push({
-                        text: `(${href})`,
-                        style: { ...compose(stack), color: NAMED.gray },
-                        spaceBefore: cur.length > 0,
-                    });
-                }
-            }
-        } else {
-            stack.push(styleFromTag(name, attrs));
-            if (name === 'a') {
-                const hm = /\bhref\s*=\s*["']([^"']+)["']/i.exec(attrs);
-                hrefs.push(hm !== null ? hm[1] : null);
-            }
-        }
-    }
-    flush();
-    return paras;
-}
-
-/** Apply a style to a string as terminal escapes (no-op when color is unsupported). */
-function paint(style: Style, s: string): string {
-    if (!pc.isColorSupported) return s;
-    let open = '';
-    if (style.bold) open += '\x1b[1m';
-    if (style.italic) open += '\x1b[3m';
-    if (style.underline) open += '\x1b[4m';
-    if (style.color !== undefined) open += `\x1b[38;2;${style.color[0]};${style.color[1]};${style.color[2]}m`;
-    return open === '' ? s : `${open}${s}\x1b[0m`;
-}
-
-/** Word-wrap styled words to `width` VISIBLE columns; over-long words (URLs) overflow.
- *  Honors each word's `spaceBefore` so attached punctuation is not pushed off. */
-function wrapWords(words: readonly Word[], width: number): Word[][] {
-    const lines: Word[][] = [];
-    let line: Word[] = [];
-    let len = 0;
-    for (const w of words) {
-        const sep = line.length > 0 && w.spaceBefore ? 1 : 0;
-        if (line.length > 0 && len + sep + w.text.length > width) {
-            lines.push(line);
-            line = [w];
-            len = w.text.length;
-        } else {
-            line.push(w);
-            len += sep + w.text.length;
-        }
-    }
-    if (line.length > 0) lines.push(line);
-    return lines;
-}
-
-/**
- * Render an HTML body to styled terminal lines (visible width <= `width`). Empty
- * strings mark blank separator lines between paragraphs. Exported for tests.
- */
-export function renderHtmlBody(html: string, width: number = WIDTH): string[] {
-    const paras = htmlToParagraphs(html);
-    const out: string[] = [];
-    for (let p = 0; p < paras.length; p++) {
-        if (p > 0) out.push(''); // one blank line between paragraphs
-        for (const line of wrapWords(paras[p], width)) {
-            out.push(
-                line.map((w, i) => (i > 0 && w.spaceBefore ? ' ' : '') + paint(w.style, w.text)).join(''),
-            );
-        }
-    }
-    return out;
-}
-
-/** Word-wrap PLAIN text (the fallback when there is no HTML body). */
-function wrap(text: string, width: number): string[] {
-    const out: string[] = [];
-    for (const para of text.split('\n')) {
-        if (para.length === 0) {
-            out.push('');
-            continue;
-        }
-        let line = '';
-        for (const word of para.split(' ')) {
-            if (line.length === 0) line = word;
-            else if (line.length + 1 + word.length <= width) line += ' ' + word;
-            else {
-                out.push(line);
-                line = word;
-            }
-        }
-        out.push(line);
-    }
-    return out;
-}
-
-/**
- * The full ASCII box for one dev email. `status` is a short label for the header
- * (e.g. `not sent, no provider`, `sent`, `deduped`). The body is rendered from the
- * HTML with color + font styling when present, else from the plain-text body.
- */
-export function renderEmailConsole(parsed: ParsedEmail, status: string): string {
-    const bar = pc.dim('  │ ');
-    const rule = (label: string): string => {
-        const head = label.length > 0 ? `─ ${label} ` : '─';
-        const fill = '─'.repeat(Math.max(0, WIDTH + 2 - head.length));
-        return pc.dim(`  ├${head}${fill}`);
-    };
-    const purpose = parsed.purpose.length > 0 ? ` · ${parsed.purpose}` : '';
-    const header = `─ ✉  ${pc.bold('Email')} ${pc.dim(`(dev${purpose} · ${status})`)} `;
-    const topFill = '─'.repeat(Math.max(0, WIDTH + 2 - `─ ✉  Email (dev${purpose} · ${status}) `.length));
-
-    const lines: string[] = [];
-    lines.push(pc.dim(`  ┌${header}${topFill}`));
-    lines.push(bar + pc.dim('To:      ') + parsed.to);
-    lines.push(bar + pc.dim('Subject: ') + parsed.subject);
-    lines.push(pc.dim('  │'));
-
-    const bodyLines =
-        parsed.html.length > 0 ? renderHtmlBody(parsed.html, WIDTH) : wrap(parsed.body, WIDTH);
-    for (const l of bodyLines) lines.push(l.length === 0 ? pc.dim('  │') : bar + l);
-
-    const action = emailAction(parsed);
-    if (action !== null) {
-        if (action.kind === 'link') {
-            lines.push(rule('🔗 click to continue'));
-            lines.push(bar + pc.cyan(pc.underline(action.value)));
-        } else {
-            lines.push(rule('🔢 code'));
-            lines.push(bar + pc.bold(pc.yellow(action.value)));
-        }
-    }
-    lines.push(pc.dim(`  └${'─'.repeat(WIDTH + 2)}`));
-    return lines.join('\n');
-}

package/src/devserver/email/index.ts

@@ -1,155 +0,0 @@
-/**
- * The dev / self-host email service — the full edge pipeline in Node, reusable
- * by the future self-host runtime (this folder has NO Vite/devserver coupling).
- *
- * Split for the sync-wasm constraint: `prepare()` is SYNCHRONOUS (parse +
- * validate + dedup + budget + per-recipient cap) and returns the terminal status
- * to hand the guest now; `deliver()` is ASYNC (the actual provider send). A
- * synchronous host (the dev server) fires `deliver()` and returns `Sent`
- * optimistically; an async-capable host (a future self-host) can `await deliver()`
- * for the true status.
- */
-import { loadEnvFiles } from '../config/dotenv.js';
-import { EmailCaps } from './caps.js';
-import { type ResolvedEmailConfig, resolveEmailConfig } from './config.js';
-import { type OutboundMessage, sendVia } from './providers.js';
-import { EmailStatus } from './status.js';
-import { validRecipient } from './validate.js';
-import { type ParsedEmail, parseEmailBlob } from './wire.js';
-
-import type { EmailBackendConfig } from 'toiljs/shared';
-
-export { EmailStatus } from './status.js';
-export type { ResolvedEmailConfig } from './config.js';
-
-export interface PrepareResult {
-    /** The status to return to the guest now. `Sent` means proceed to `deliver`. */
-    readonly status: EmailStatus;
-    /** The parsed message, present iff `status === Sent` (caller should deliver). */
-    readonly parsed: ParsedEmail | null;
-}
-
-export class NodeEmailService {
-    private readonly caps = new EmailCaps();
-    constructor(private readonly config: ResolvedEmailConfig) {}
-
-    /** The configured provider id (for the startup banner / logs). */
-    get providerLabel(): string {
-        return `${this.config.provider} (${this.config.from})`;
-    }
-
-    /**
-     * Synchronous pre-send: parse the wire blob, validate the recipient, then
-     * dedup + per-minute/day budget + per-recipient cap (all committing). Returns
-     * a terminal status (`BadRecipient` / `Deduped` / `Budget` / `RecipientCapped`),
-     * or `{ status: Sent, parsed }` meaning the caller should `deliver(parsed)`.
-     */
-    prepare(blob: Buffer, now: number = Date.now()): PrepareResult {
-        const parsed = parseEmailBlob(blob);
-        if (parsed === null || !validRecipient(parsed.to)) {
-            return { status: EmailStatus.BadRecipient, parsed: null };
-        }
-        if (this.caps.isDuplicate(parsed.to, parsed.purpose, now)) {
-            return { status: EmailStatus.Deduped, parsed: null };
-        }
-        if (!this.caps.budgetOk(this.config.maxPerMin, this.config.maxPerDay, now)) {
-            return { status: EmailStatus.Budget, parsed: null };
-        }
-        if (!this.caps.recipientOk(parsed.to, this.config.maxPerRecipientPerHour, now)) {
-            return { status: EmailStatus.RecipientCapped, parsed: null };
-        }
-        return { status: EmailStatus.Sent, parsed };
-    }
-
-    /** Actually send via the configured provider; resolves to the real status. */
-    deliver(parsed: ParsedEmail): Promise<EmailStatus> {
-        const msg: OutboundMessage = {
-            from: this.config.from,
-            to: parsed.to,
-            subject: parsed.subject,
-            body: parsed.body,
-            html: parsed.html,
-        };
-        return sendVia(this.config, msg);
-    }
-}
-
-// --- Test-only capture seam ---------------------------------------------------
-
-/**
- * A message the dev email pipeline decided to send (a real provider send, or the
- * unconfigured stub), captured for TESTS ONLY. The built-in auth controller
- * delivers its one-time confirm/reset tokens via email, so an e2e test reads the
- * token straight out of the emitted link here. This is NOT a production path —
- * the edge never imports this module, and real sends are unchanged.
- */
-export interface SentEmail {
-    readonly to: string;
-    readonly subject: string;
-    /** Plain-text body (the confirm/reset link appears here and in `html`). */
-    readonly text: string;
-    readonly html: string;
-    /** Short non-PII tag the guest passed (e.g. `verify`, `reset`). */
-    readonly purpose: string;
-}
-
-/** Bounded ring of the most-recent dev sends (test seam). */
-export const __sentEmails: SentEmail[] = [];
-const SENT_EMAILS_MAX = 256;
-
-/**
- * Record one dev send into {@link __sentEmails}. Called at the exact point the
- * dev pipeline decides to send/stub, so it captures precisely the messages the
- * guest emitted (and nothing it dropped/deduped).
- */
-export function recordSentEmail(msg: ParsedEmail): void {
-    __sentEmails.push({
-        to: msg.to,
-        subject: msg.subject,
-        text: msg.body,
-        html: msg.html,
-        purpose: msg.purpose,
-    });
-    while (__sentEmails.length > SENT_EMAILS_MAX) __sentEmails.shift();
-}
-
-/** Clear the captured dev-send ring (tests call this between cases). */
-export function __clearSentEmails(): void {
-    __sentEmails.length = 0;
-}
-
-// --- Process-level singleton (one project per dev/self-host process) ----------
-
-let service: NodeEmailService | null = null;
-
-export interface EmailInitResult {
-    /** The service, or `null` when email is unconfigured / invalid. */
-    readonly service: NodeEmailService | null;
-    /** A note for the startup banner: the provider label, or a config warning. */
-    readonly note: string | null;
-}
-
-/**
- * Build the email service from the `toil.config.ts` `email` section + the
- * project's `.env.secrets` (`TOIL_EMAIL_*`, holding the API key) and install it
- * as the process singleton. Call once at startup. Returns a startup note.
- */
-export function initEmailService(
-    root: string,
-    cfgEmail: EmailBackendConfig | null | undefined,
-): EmailInitResult {
-    const reserved = loadEnvFiles(root).reserved;
-    const { config, warning } = resolveEmailConfig(cfgEmail, reserved);
-    service = config === null ? null : new NodeEmailService(config);
-    return { service, note: service === null ? warning : service.providerLabel };
-}
-
-/** The installed email service, or `null` when email is not configured. */
-export function getEmailService(): NodeEmailService | null {
-    return service;
-}
-
-/** Reset the singleton (tests). */
-export function resetEmailService(): void {
-    service = null;
-}

package/src/devserver/email/providers.ts

@@ -1,131 +0,0 @@
-/**
- * Provider transports for the dev / self-host mailer, mirroring the edge's
- * `mailer.rs`: Resend over `fetch` (`send_resend`) and SMTP over nodemailer
- * (`send_smtp`). Both retry transient failures with capped backoff; a permanent
- * rejection is terminal (`ProviderError`).
- *
- * nodemailer is imported lazily, so a Resend-only project never loads it.
- */
-import { EmailStatus } from './status.js';
-import type { ResolvedEmailConfig } from './config.js';
-
-const MAX_ATTEMPTS = 3;
-const BACKOFF_BASE_MS = 200;
-const POST_TIMEOUT_MS = 10_000;
-
-/** The concrete parts of one send (already validated + rendered). */
-export interface OutboundMessage {
-    readonly from: string;
-    readonly to: string;
-    readonly subject: string;
-    /** Plain-text body (may be empty when only `html` is set). */
-    readonly body: string;
-    /** Optional HTML body (empty = plain-text send). */
-    readonly html: string;
-}
-
-const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
-
-/**
- * Classify an HTTP status (or `null` for a transport failure): 2xx → `Sent`,
- * 4xx → terminal `ProviderError` (a bad address keeps being bad), else
- * (5xx / transport) → retry.
- */
-function classifyHttp(status: number | null): EmailStatus | 'retry' {
-    if (status !== null && status >= 200 && status < 300) return EmailStatus.Sent;
-    if (status !== null && status >= 400 && status < 500) return EmailStatus.ProviderError;
-    return 'retry';
-}
-
-/** Drive one Resend POST with retry. */
-export async function sendResend(
-    cfg: ResolvedEmailConfig,
-    msg: OutboundMessage,
-): Promise<EmailStatus> {
-    const payload: Record<string, unknown> = {
-        from: msg.from,
-        to: [msg.to],
-        subject: msg.subject,
-    };
-    if (msg.body.length > 0) payload.text = msg.body;
-    if (msg.html.length > 0) payload.html = msg.html;
-
-    let backoff = BACKOFF_BASE_MS;
-    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-        let status: number | null = null;
-        try {
-            const res = await fetch('https://api.resend.com/emails', {
-                method: 'POST',
-                headers: {
-                    authorization: `Bearer ${cfg.apiKey}`,
-                    'content-type': 'application/json',
-                },
-                body: JSON.stringify(payload),
-                signal: AbortSignal.timeout(POST_TIMEOUT_MS),
-            });
-            status = res.status;
-        } catch {
-            status = null; // transport error → retry
-        }
-        const verdict = classifyHttp(status);
-        if (verdict !== 'retry') return verdict;
-        if (attempt === MAX_ATTEMPTS) break;
-        await sleep(backoff);
-        backoff *= 2;
-    }
-    return EmailStatus.ProviderError;
-}
-
-/** Send one email over SMTP (nodemailer) with retry. */
-export async function sendSmtp(
-    cfg: ResolvedEmailConfig,
-    msg: OutboundMessage,
-): Promise<EmailStatus> {
-    const smtp = cfg.smtp;
-    if (smtp === undefined) return EmailStatus.ProviderError; // resolve() guarantees Some for smtp
-
-    let transporter: import('nodemailer').Transporter;
-    try {
-        const nodemailer = await import('nodemailer');
-        transporter = nodemailer.createTransport({
-            host: smtp.host,
-            port: smtp.port,
-            secure: smtp.port === 465, // 465 = implicit TLS; else STARTTLS
-            // Auth only when there is a credential; a local/auth-less relay takes none.
-            auth: cfg.apiKey.length > 0 ? { user: smtp.user, pass: cfg.apiKey } : undefined,
-            connectionTimeout: POST_TIMEOUT_MS,
-            greetingTimeout: POST_TIMEOUT_MS,
-        });
-    } catch {
-        // nodemailer not installed: SMTP unavailable.
-        return EmailStatus.ProviderError;
-    }
-
-    let backoff = BACKOFF_BASE_MS;
-    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-        try {
-            await transporter.sendMail({
-                from: msg.from,
-                to: msg.to,
-                subject: msg.subject,
-                text: msg.body.length > 0 ? msg.body : undefined,
-                html: msg.html.length > 0 ? msg.html : undefined,
-            });
-            return EmailStatus.Sent;
-        } catch (e) {
-            // SMTP 5xx is a PERMANENT failure (bad auth / rejected recipient):
-            // terminal. 4xx / transport errors are transient: retry with backoff.
-            const code = (e as { responseCode?: number }).responseCode;
-            if (typeof code === 'number' && code >= 500) return EmailStatus.ProviderError;
-            if (attempt === MAX_ATTEMPTS) break;
-            await sleep(backoff);
-            backoff *= 2;
-        }
-    }
-    return EmailStatus.ProviderError;
-}
-
-/** Dispatch to the configured provider. */
-export function sendVia(cfg: ResolvedEmailConfig, msg: OutboundMessage): Promise<EmailStatus> {
-    return cfg.provider === 'resend' ? sendResend(cfg, msg) : sendSmtp(cfg, msg);
-}

package/src/devserver/email/status.ts

@@ -1,23 +0,0 @@
-/**
- * The `i32` status `env::email_send` returns to the guest. Byte-identical to the
- * edge's `EmailStatus` (toil-backend `host/email.rs`, `#[repr(i32)]`) and the
- * guest `EmailStatus` enum (`server/globals/email.ts`). `Sent` and `Deduped` are
- * success; the rest say why it was not delivered and whether a retry could help.
- */
-export enum EmailStatus {
-    Sent = 0,
-    /** No email config (or not enabled). */
-    Disabled = 1,
-    /** Per-process minute/day budget exhausted. Retriable later. */
-    Budget = 2,
-    /** Per-recipient hourly cap hit. Terminal for this recipient/window. */
-    RecipientCapped = 3,
-    /** An identical recent (recipient, purpose) send was collapsed. Treat as sent. */
-    Deduped = 4,
-    /** Saturated / queue full. Retriable; back off. */
-    TryLater = 5,
-    /** The recipient failed host-side validation (CRLF, multiple addresses, malformed). */
-    BadRecipient = 6,
-    /** The provider rejected the send, or transport failed after retries. Terminal. */
-    ProviderError = 7,
-}