@ggui-ai/mcp-server 0.1.0-rc.1

package/dist/email-login.js

@@ -0,0 +1,254 @@
+import { randomBytes } from 'node:crypto';
+import { formatUserSessionCookieHeader } from './user-session-auth.js';
+import { createConsoleLogger } from './logger.js';
+/**
+ * Public route paths. Operators may override via
+ * `EmailLoginRoutesOptions.{startPath,verifyPath,configPath}` for
+ * test or sub-mount scenarios.
+ */
+export const DEFAULT_EMAIL_LOGIN_START_PATH = '/ggui/email-login/start';
+export const DEFAULT_EMAIL_LOGIN_VERIFY_PATH = '/ggui/email-login/verify';
+export const DEFAULT_EMAIL_LOGIN_CONFIG_PATH = '/ggui/email-login/config';
+const TOKEN_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_NEXT_PATH = '/settings';
+/**
+ * Fallback sender that logs every "sent" email to the configured
+ * logger at info level. The verify URL appears in the logs so an
+ * operator running `ggui serve` locally can copy/paste it without
+ * setting up real email infrastructure. Production deploys MUST
+ * swap this for a real sender — the fallback is a developer-mode
+ * convenience, not a security control.
+ *
+ * @public
+ */
+export class ConsoleEmailSender {
+    logger;
+    constructor(logger) {
+        this.logger = logger ?? createConsoleLogger({ component: 'email-console-sender' });
+    }
+    async send(message) {
+        this.logger.info('email_console_sender', {
+            to: message.to,
+            from: message.from ?? '<default>',
+            subject: message.subject,
+            text: message.text,
+        });
+    }
+}
+/**
+ * Default in-memory store. Loses tokens on process restart (which
+ * is acceptable — pending magic links expire in 15 min anyway, and
+ * a restart is itself a "request a new link" prompt to the user).
+ *
+ * @public
+ */
+export class InMemoryMagicLinkStore {
+    records = new Map();
+    async mintToken({ email, nextPath, ttlMs }) {
+        // 32 random bytes → 64 hex chars. Plenty of entropy; no need
+        // for the more compact base64url since hex copy/pastes cleaner
+        // out of email clients that try to "smarten" punctuation.
+        const token = randomBytes(32).toString('hex');
+        this.records.set(token, {
+            email,
+            nextPath,
+            expiresAt: Date.now() + ttlMs,
+        });
+        return token;
+    }
+    async consumeToken(token) {
+        const r = this.records.get(token);
+        if (!r)
+            return null;
+        // Single-use: delete BEFORE checking expiry so an expired but
+        // present token can't be reconsumed by a clock-rewind attacker.
+        this.records.delete(token);
+        if (Date.now() > r.expiresAt)
+            return null;
+        return { email: r.email, nextPath: r.nextPath };
+    }
+}
+const DEFAULT_SUBJECT = 'Sign in to ggui';
+const DEFAULT_BODY_TEXT = "Click the link below to sign in. It expires in 15 minutes.\n\n" +
+    '{verifyUrl}\n\n' +
+    "If you didn't request this, you can safely ignore this email.";
+const DEFAULT_BODY_HTML = '<p>Click the link below to sign in. It expires in 15 minutes.</p>' +
+    '<p><a href="{verifyUrl}">{verifyUrl}</a></p>' +
+    "<p style=\"color:#888\">If you didn't request this, you can safely ignore this email.</p>";
+/**
+ * Loose RFC 5322 subset — `local@host.tld`. Doesn't reject every
+ * weird-but-legal address (no IDN, no quoted locals), just rules
+ * out obviously-broken input early. The downstream SMTP/HTTP
+ * sender is the authoritative validator.
+ */
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/**
+ * Mount `POST /start`, `GET /verify`, `GET /config`. Idempotent
+ * across multiple calls (later mount wins for the same path).
+ *
+ * @public
+ */
+export function mountEmailLoginRoutes(app, opts) {
+    const startPath = opts.startPath ?? DEFAULT_EMAIL_LOGIN_START_PATH;
+    const verifyPath = opts.verifyPath ?? DEFAULT_EMAIL_LOGIN_VERIFY_PATH;
+    const configPath = opts.configPath ?? DEFAULT_EMAIL_LOGIN_CONFIG_PATH;
+    const store = opts.store ?? new InMemoryMagicLinkStore();
+    const subject = opts.subject ?? DEFAULT_SUBJECT;
+    const bodyText = opts.bodyText ?? DEFAULT_BODY_TEXT;
+    const bodyHtml = opts.bodyHtml ?? DEFAULT_BODY_HTML;
+    const auditSink = opts.auditSink;
+    const emitAudit = async (entry, auditLogger) => {
+        if (!auditSink)
+            return;
+        try {
+            await auditSink.record({ at: Date.now(), ...entry });
+        }
+        catch (err) {
+            auditLogger.warn('audit_emit_failed', {
+                action: entry.action,
+                error: String(err),
+            });
+        }
+    };
+    // --- GET /ggui/email-login/config ---
+    // Public + cheap. /login fetches this to know whether to render
+    // the email form. No secrets here — just a presence boolean.
+    app.get(configPath, (_req, res) => {
+        res.status(200).json({ enabled: true });
+    });
+    // --- POST /ggui/email-login/start ---
+    // Body: { email: string, next?: string }. Always 200 (avoid
+    // email enumeration — see route docstring for why).
+    app.post(startPath, async (req, res) => {
+        const reqLogger = opts.logger.child({ route: 'POST ' + startPath });
+        const body = typeof req.body === 'object' && req.body !== null
+            ? req.body
+            : {};
+        const rawEmail = typeof body['email'] === 'string' ? body['email'] : '';
+        const email = rawEmail.trim().toLowerCase();
+        if (!EMAIL_RE.test(email) || email.length > 254) {
+            // 254 = RFC 5321 max length. Reject malformed up-front — this
+            // is "user typo" not "attacker probe", so 400 is honest.
+            reqLogger.warn('email_login_invalid_email', {});
+            res.status(400).json({
+                error: {
+                    code: 'invalid_email',
+                    message: 'Provide a valid email address.',
+                },
+            });
+            return;
+        }
+        const nextRaw = typeof body['next'] === 'string' ? body['next'] : undefined;
+        const nextPath = sanitizeNextPath(nextRaw) ?? DEFAULT_NEXT_PATH;
+        const token = await store.mintToken({
+            email,
+            nextPath,
+            ttlMs: TOKEN_TTL_MS,
+        });
+        const verifyUrl = `${trimTrailingSlash(opts.publicBaseUrl)}${verifyPath}` +
+            `?token=${encodeURIComponent(token)}`;
+        try {
+            await opts.sender.send({
+                to: email,
+                from: opts.fromAddress,
+                subject,
+                text: bodyText.replace(/\{verifyUrl\}/g, verifyUrl),
+                html: bodyHtml.replace(/\{verifyUrl\}/g, verifyUrl),
+            });
+            reqLogger.info('email_login_sent', { email });
+            await emitAudit({
+                action: 'auth.email.start',
+                actor: { kind: 'anonymous' },
+                metadata: { email },
+            }, reqLogger);
+        }
+        catch (err) {
+            // Sender failures we log + audit, but we still 200 to the
+            // caller — same enumeration concern. The user's "I never got
+            // an email" is the discovery path; ops finds it in logs.
+            reqLogger.warn('email_login_send_failed', {
+                email,
+                error: String(err),
+            });
+            await emitAudit({
+                action: 'auth.email.failure',
+                actor: { kind: 'anonymous' },
+                metadata: { email, reason: 'send_failed', detail: String(err) },
+            }, reqLogger);
+        }
+        res.status(200).json({ ok: true });
+    });
+    // --- GET /ggui/email-login/verify?token=... ---
+    app.get(verifyPath, async (req, res) => {
+        const reqLogger = opts.logger.child({ route: 'GET ' + verifyPath });
+        const tokenRaw = req.query['token'];
+        const token = typeof tokenRaw === 'string' ? tokenRaw : '';
+        if (!token) {
+            reqLogger.warn('email_login_verify_missing_token', {});
+            res.status(400).send('Missing token. Open your email and click the link again.');
+            return;
+        }
+        const consumed = await store.consumeToken(token);
+        if (!consumed) {
+            reqLogger.warn('email_login_verify_invalid', {});
+            await emitAudit({
+                action: 'auth.email.failure',
+                actor: { kind: 'anonymous' },
+                metadata: { reason: 'invalid_or_expired_token' },
+            }, reqLogger);
+            res
+                .status(403)
+                .send('This sign-in link is invalid or has expired. ' +
+                'Request a new link from /login.');
+            return;
+        }
+        if (!opts.auth.registerToken) {
+            reqLogger.warn('email_login_register_token_unsupported', {});
+            res.status(501).json({
+                error: {
+                    code: 'not_supported',
+                    message: 'AuthAdapter has no registerToken — email login requires a token-registering adapter.',
+                },
+            });
+            return;
+        }
+        const userId = `email:${consumed.email}`;
+        const bearer = `ggui_user_${randomBytes(24).toString('hex')}`;
+        opts.auth.registerToken(bearer, {
+            identity: { kind: 'user', userId, roles: [] },
+            source: 'email',
+            metadata: { email: consumed.email },
+        });
+        const sessionCookie = formatUserSessionCookieHeader({
+            bearer,
+            ...(opts.ttlSec !== undefined ? { ttlSec: opts.ttlSec } : {}),
+            ...(opts.secure !== undefined ? { secure: opts.secure } : {}),
+        });
+        res.setHeader('Set-Cookie', sessionCookie);
+        reqLogger.info('email_login_success', { userId });
+        await emitAudit({
+            action: 'auth.email.success',
+            actor: { kind: 'user', id: userId },
+            metadata: { email: consumed.email },
+        }, reqLogger);
+        res.redirect(302, consumed.nextPath);
+    });
+}
+/**
+ * Reject open-redirects: only same-origin RELATIVE paths starting
+ * with `/` (and NOT `//` which the URL parser treats as protocol-
+ * relative). Returns null when the input fails validation so the
+ * caller can pick the default.
+ */
+function sanitizeNextPath(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    if (!raw.startsWith('/'))
+        return null;
+    if (raw.startsWith('//'))
+        return null;
+    return raw;
+}
+function trimTrailingSlash(s) {
+    return s.endsWith('/') ? s.slice(0, -1) : s;
+}

package/dist/email-resend.d.ts

@@ -0,0 +1,29 @@
+import type { EmailMessage, EmailSender } from './email-login.js';
+import type { Logger } from './logger.js';
+/**
+ * @public
+ */
+export interface ResendEmailSenderOptions {
+    /**
+     * Resend API key, format `re_...`. Mint at
+     * https://resend.com/api-keys. Required.
+     */
+    readonly apiKey: string;
+    /**
+     * Optional logger. Defaults to a component-bound console logger.
+     * Receives one `email_resend_sent` event per successful send and
+     * one `email_resend_failed` event per failure (with `errorCode`
+     * + `errorMessage` from the SDK response).
+     */
+    readonly logger?: Logger;
+}
+/**
+ * @public
+ */
+export declare class ResendEmailSender implements EmailSender {
+    private readonly client;
+    private readonly logger;
+    constructor(opts: ResendEmailSenderOptions);
+    send(message: EmailMessage): Promise<void>;
+}
+//# sourceMappingURL=email-resend.d.ts.map

package/dist/email-resend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-resend.d.ts","sourceRoot":"","sources":["../src/email-resend.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,IAAI,EAAE,wBAAwB;IAMpC,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAiCjD"}

package/dist/email-resend.js

@@ -0,0 +1,71 @@
+/**
+ * Resend-backed `EmailSender`.
+ *
+ * Wraps the `resend` SDK (https://resend.com) into the same
+ * `EmailSender` interface as `ConsoleEmailSender` — drop-in
+ * replacement: construct it, pass it to `createGguiServer({emailLogin: {sender, …}})`.
+ *
+ * The OSS CLI auto-constructs this when `GGUI_EMAIL_SENDER=resend` and
+ * `RESEND_API_KEY` are set in the environment. Programmatic embedders
+ * import it directly:
+ *
+ * ```ts
+ * import { ResendEmailSender, createGguiServer } from '@ggui-ai/mcp-server';
+ *
+ * const server = createGguiServer({
+ *   emailLogin: {
+ *     sender: new ResendEmailSender({ apiKey: process.env.RESEND_API_KEY! }),
+ *     fromAddress: 'Acme <noreply@acme.com>',
+ *   },
+ *   // ...
+ * });
+ * ```
+ *
+ * Note: Resend requires the `from` address's domain to be verified
+ * in the Resend dashboard. Pass an unverified domain and `send()`
+ * will reject — the adapter surfaces the SDK error verbatim, no
+ * silent swallow. See https://resend.com/docs/dashboard/domains/introduction.
+ */
+import { Resend } from 'resend';
+import { createConsoleLogger } from './logger.js';
+/**
+ * @public
+ */
+export class ResendEmailSender {
+    client;
+    logger;
+    constructor(opts) {
+        this.client = new Resend(opts.apiKey);
+        this.logger =
+            opts.logger ?? createConsoleLogger({ component: 'email-resend-sender' });
+    }
+    async send(message) {
+        if (!message.from) {
+            // Resend requires an explicit `from`. Defer the surface error
+            // to the caller — `mountEmailLoginRoutes` always supplies one
+            // from `fromAddress`, so this branch is operator-config error.
+            throw new Error('ResendEmailSender: `from` address required (set `emailLogin.fromAddress` on createGguiServer).');
+        }
+        const { data, error } = await this.client.emails.send({
+            from: message.from,
+            to: message.to,
+            subject: message.subject,
+            text: message.text,
+            ...(message.html ? { html: message.html } : {}),
+        });
+        if (error) {
+            this.logger.warn('email_resend_failed', {
+                to: message.to,
+                from: message.from,
+                errorName: error.name,
+                errorMessage: error.message,
+            });
+            throw new Error(`ResendEmailSender.send failed: ${error.name}: ${error.message}`);
+        }
+        this.logger.info('email_resend_sent', {
+            to: message.to,
+            from: message.from,
+            messageId: data?.id,
+        });
+    }
+}

package/dist/email-sender-from-env.d.ts

@@ -0,0 +1,34 @@
+import type { EmailSender } from './email-login.js';
+import type { Logger } from './logger.js';
+/**
+ * @public
+ */
+export type EmailSenderKind = 'console' | 'resend' | 'smtp';
+/**
+ * @public
+ */
+export type EmailSenderSelection = {
+    kind: 'ok';
+    sender: EmailSender;
+    senderKind: EmailSenderKind;
+    /** Operator-supplied `GGUI_EMAIL_FROM`, if set. CLI uses this to override the default `fromAddress`. */
+    fromAddress?: string;
+} | {
+    kind: 'error';
+    senderKind: EmailSenderKind;
+    reason: string;
+};
+/**
+ * @public
+ */
+export interface SelectEmailSenderOptions {
+    /** Process env. Defaults to `process.env`. */
+    readonly env?: NodeJS.ProcessEnv;
+    /** Optional logger threaded into the constructed sender. */
+    readonly logger?: Logger;
+}
+/**
+ * @public
+ */
+export declare function selectEmailSenderFromEnv(opts?: SelectEmailSenderOptions): EmailSenderSelection;
+//# sourceMappingURL=email-sender-from-env.d.ts.map

package/dist/email-sender-from-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-sender-from-env.d.ts","sourceRoot":"","sources":["../src/email-sender-from-env.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IACE,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,eAAe,CAAC;IAC5B,wGAAwG;IACxG,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,eAAe,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACjC,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,GAAE,wBAA6B,GAClC,oBAAoB,CA0FtB"}

package/dist/email-sender-from-env.js

@@ -0,0 +1,112 @@
+/**
+ * Env-driven `EmailSender` selector. Lets `ggui serve` (or any
+ * embedder reading from process.env) pick between the three built-in
+ * senders without hardcoding branches.
+ *
+ * Env contract:
+ *
+ *   - `GGUI_EMAIL_SENDER`        — `console` | `resend` | `smtp` (default: `console`)
+ *   - `GGUI_EMAIL_FROM`          — overrides the default `fromAddress` (returned alongside the sender)
+ *   - `RESEND_API_KEY`           — required when `GGUI_EMAIL_SENDER=resend`
+ *   - `SMTP_URL`                 — connection string, e.g. `smtps://user:pass@host:465`
+ *   - `SMTP_HOST` / `SMTP_PORT`  — discrete config (alternative to `SMTP_URL`)
+ *   - `SMTP_USER` / `SMTP_PASS`  — auth (used with `SMTP_HOST`)
+ *   - `SMTP_SECURE`              — `'true'`/`'false'` to override the auto-derive
+ *
+ * Misconfiguration (e.g. `GGUI_EMAIL_SENDER=resend` without
+ * `RESEND_API_KEY`) returns `{ kind: 'error', reason }` so the CLI
+ * can log + fall back to console rather than crashing the boot.
+ *
+ * @public
+ */
+import { ConsoleEmailSender } from './email-login.js';
+import { ResendEmailSender } from './email-resend.js';
+import { SmtpEmailSender } from './email-smtp.js';
+/**
+ * @public
+ */
+export function selectEmailSenderFromEnv(opts = {}) {
+    const env = opts.env ?? process.env;
+    const raw = env.GGUI_EMAIL_SENDER?.trim().toLowerCase() ?? 'console';
+    const fromAddress = env.GGUI_EMAIL_FROM?.trim() || undefined;
+    if (raw !== 'console' && raw !== 'resend' && raw !== 'smtp') {
+        return {
+            kind: 'error',
+            senderKind: 'console',
+            reason: `GGUI_EMAIL_SENDER='${raw}' is not one of console|resend|smtp`,
+        };
+    }
+    const senderKind = raw;
+    if (senderKind === 'console') {
+        const result = {
+            kind: 'ok',
+            sender: new ConsoleEmailSender(opts.logger),
+            senderKind,
+        };
+        return fromAddress ? { ...result, fromAddress } : result;
+    }
+    if (senderKind === 'resend') {
+        const apiKey = env.RESEND_API_KEY?.trim();
+        if (!apiKey) {
+            return {
+                kind: 'error',
+                senderKind,
+                reason: 'GGUI_EMAIL_SENDER=resend but RESEND_API_KEY is not set',
+            };
+        }
+        const result = {
+            kind: 'ok',
+            sender: new ResendEmailSender({
+                apiKey,
+                ...(opts.logger ? { logger: opts.logger } : {}),
+            }),
+            senderKind,
+        };
+        return fromAddress ? { ...result, fromAddress } : result;
+    }
+    // smtp
+    const url = env.SMTP_URL?.trim();
+    const host = env.SMTP_HOST?.trim();
+    if (!url && !host) {
+        return {
+            kind: 'error',
+            senderKind,
+            reason: 'GGUI_EMAIL_SENDER=smtp but neither SMTP_URL nor SMTP_HOST is set',
+        };
+    }
+    const portRaw = env.SMTP_PORT?.trim();
+    const port = portRaw ? Number(portRaw) : undefined;
+    if (portRaw && (Number.isNaN(port) || port <= 0 || port > 65535)) {
+        return {
+            kind: 'error',
+            senderKind,
+            reason: `SMTP_PORT='${portRaw}' is not a valid port number`,
+        };
+    }
+    const secureRaw = env.SMTP_SECURE?.trim().toLowerCase();
+    const secure = secureRaw === 'true' ? true : secureRaw === 'false' ? false : undefined;
+    try {
+        const sender = new SmtpEmailSender({
+            ...(url ? { url } : {}),
+            ...(host ? { host } : {}),
+            ...(port !== undefined ? { port } : {}),
+            ...(secure !== undefined ? { secure } : {}),
+            ...(env.SMTP_USER ? { user: env.SMTP_USER } : {}),
+            ...(env.SMTP_PASS ? { pass: env.SMTP_PASS } : {}),
+            ...(opts.logger ? { logger: opts.logger } : {}),
+        });
+        const result = {
+            kind: 'ok',
+            sender,
+            senderKind,
+        };
+        return fromAddress ? { ...result, fromAddress } : result;
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            senderKind,
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}

package/dist/email-smtp.d.ts

@@ -0,0 +1,42 @@
+import type { EmailMessage, EmailSender } from './email-login.js';
+import type { Logger } from './logger.js';
+/**
+ * @public
+ */
+export interface SmtpEmailSenderOptions {
+    /**
+     * SMTP connection URL, e.g. `smtps://user:pass@host:465` or
+     * `smtp://user:pass@host:587`. Convenient for env-driven config.
+     * Mutually exclusive with the discrete `host`/`port`/etc. fields.
+     */
+    readonly url?: string;
+    /** SMTP server hostname. Required if `url` is omitted. */
+    readonly host?: string;
+    /** SMTP server port. Common: 465 (TLS), 587 (STARTTLS), 25 (plaintext). */
+    readonly port?: number;
+    /**
+     * Whether to use a fully-encrypted TLS socket (port 465). Set
+     * `false` for STARTTLS upgrade on 587. Defaults to `port === 465`.
+     */
+    readonly secure?: boolean;
+    /** SMTP auth username. */
+    readonly user?: string;
+    /** SMTP auth password. */
+    readonly pass?: string;
+    /**
+     * Optional logger. Defaults to a component-bound console logger.
+     * Emits one `email_smtp_sent` event per successful delivery; SMTP
+     * errors propagate via thrown exception (caller logs).
+     */
+    readonly logger?: Logger;
+}
+/**
+ * @public
+ */
+export declare class SmtpEmailSender implements EmailSender {
+    private readonly transporter;
+    private readonly logger;
+    constructor(opts: SmtpEmailSenderOptions);
+    send(message: EmailMessage): Promise<void>;
+}
+//# sourceMappingURL=email-smtp.d.ts.map

package/dist/email-smtp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-smtp.d.ts","sourceRoot":"","sources":["../src/email-smtp.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,WAAW;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,IAAI,EAAE,sBAAsB;IA6BlC,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBjD"}

package/dist/email-smtp.js

@@ -0,0 +1,81 @@
+/**
+ * SMTP-backed `EmailSender` via nodemailer.
+ *
+ * Drop-in replacement for `ConsoleEmailSender` — works against any
+ * SMTP server: SES SMTP endpoint, Gmail App Password, Postmark SMTP,
+ * Mailgun, a self-hosted Postfix, etc. No vendor lock-in.
+ *
+ * The OSS CLI auto-constructs this when `GGUI_EMAIL_SENDER=smtp` and
+ * either `SMTP_URL` or the discrete `SMTP_HOST/SMTP_PORT/SMTP_USER/
+ * SMTP_PASS` set are present. Programmatic embedders pass options
+ * directly:
+ *
+ * ```ts
+ * import { SmtpEmailSender, createGguiServer } from '@ggui-ai/mcp-server';
+ *
+ * const server = createGguiServer({
+ *   emailLogin: {
+ *     sender: new SmtpEmailSender({
+ *       url: 'smtps://AKIA...:secret@email-smtp.us-east-1.amazonaws.com:465',
+ *     }),
+ *     fromAddress: 'Acme <noreply@acme.com>',
+ *   },
+ *   // ...
+ * });
+ * ```
+ *
+ * Either `url` OR `host` (with the rest of the discrete fields) is
+ * required. Passing both is a configuration error and throws at
+ * construction time.
+ */
+import nodemailer from 'nodemailer';
+import { createConsoleLogger } from './logger.js';
+/**
+ * @public
+ */
+export class SmtpEmailSender {
+    transporter;
+    logger;
+    constructor(opts) {
+        if (opts.url && opts.host) {
+            throw new Error('SmtpEmailSender: pass `url` OR `host` (with port/user/pass), not both.');
+        }
+        if (!opts.url && !opts.host) {
+            throw new Error('SmtpEmailSender: `url` or `host` is required (set SMTP_URL or SMTP_HOST in the environment).');
+        }
+        this.transporter = opts.url
+            ? nodemailer.createTransport(opts.url)
+            : nodemailer.createTransport({
+                host: opts.host,
+                ...(opts.port !== undefined ? { port: opts.port } : {}),
+                ...(opts.secure !== undefined
+                    ? { secure: opts.secure }
+                    : opts.port === 465
+                        ? { secure: true }
+                        : {}),
+                ...(opts.user || opts.pass
+                    ? { auth: { user: opts.user ?? '', pass: opts.pass ?? '' } }
+                    : {}),
+            });
+        this.logger =
+            opts.logger ?? createConsoleLogger({ component: 'email-smtp-sender' });
+    }
+    async send(message) {
+        if (!message.from) {
+            throw new Error('SmtpEmailSender: `from` address required (set `emailLogin.fromAddress` on createGguiServer).');
+        }
+        const info = await this.transporter.sendMail({
+            from: message.from,
+            to: message.to,
+            subject: message.subject,
+            text: message.text,
+            ...(message.html ? { html: message.html } : {}),
+        });
+        this.logger.info('email_smtp_sent', {
+            to: message.to,
+            from: message.from,
+            messageId: info.messageId,
+            response: info.response,
+        });
+    }
+}