dkimkit 0.0.0-stage → 0.6.1

package/dist/src/hosted/api.js

@@ -0,0 +1,781 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { ApiError, apiErrorHint, ConfigError } from '../errors.js';
+import { isValidDomain, normalizeName } from '../records.js';
+import { AccountAuth, LogMailer, SESSION_TTL_MS } from './auth.js';
+import { BillingService, WebhookSignatureError } from './billing.js';
+import { EMAIL_PROVIDERS, isEmailProvider } from '../providers/email/factory.js';
+import { Vault } from './crypto.js';
+import { Site } from './site.js';
+import { iso, toPublicAccount, toPublicDomain, toPublicEstimate, toPublicEvent, toPublicUsage, toWidgetDomain } from './serialize.js';
+import { ConflictError, DomainService, NotFoundError, PlanLimitError, } from './service.js';
+import { openStore, utcDay } from './store.js';
+import { MAX_SESSION_SEC, WidgetService } from './widget.js';
+import { BackgroundRunner } from './worker.js';
+const MAX_BODY_BYTES = 64 * 1024;
+const STATUSES = ['pending', 'awaiting_dns', 'verifying', 'verified', 'conflict', 'failed'];
+class HttpError extends Error {
+    status;
+    type;
+    extra;
+    constructor(status, type, message, extra = {}) {
+        super(message);
+        this.status = status;
+        this.type = type;
+        this.extra = extra;
+    }
+}
+const invalid = (message) => new HttpError(400, 'invalid_request', message);
+const WEB_DIR = new URL('../../../web/', import.meta.url);
+export function loadWidgetAssets() {
+    return {
+        loader: readFileSync(new URL('widget.js', WEB_DIR), 'utf8'),
+        frame: readFileSync(new URL('widget-frame.html', WEB_DIR), 'utf8'),
+        dashboard: readFileSync(new URL('dashboard.html', WEB_DIR), 'utf8'),
+    };
+}
+const SESSION_COOKIE = 'dkimkit_session';
+// Sessions started before the rename keep working until they expire.
+const LEGACY_SESSION_COOKIE = 'sds_session';
+/** The request handler, separate from the listener so it can be mounted elsewhere. */
+export function createApiHandler(opts) {
+    const { service, widget, auth, billing } = opts;
+    const assets = opts.assets ?? loadWidgetAssets();
+    const now = opts.now ?? Date.now;
+    const log = opts.log ?? (() => { });
+    const limiter = new RateLimiter(opts.rateLimit?.perSecond ?? 10, opts.rateLimit?.burst ?? 30);
+    // Sign-in emails: a burst of 5 per client address, then one every 12 seconds.
+    const emailLimiter = new RateLimiter(1 / 12, 5);
+    const secureCookies = opts.publicUrl?.startsWith('https://') ?? false;
+    const requireAuth = () => {
+        if (!auth || !opts.publicUrl)
+            throw new HttpError(404, 'not_found', 'Self-serve accounts are not enabled on this server.');
+        return auth;
+    };
+    const requireBilling = () => {
+        if (!billing)
+            throw invalid('Billing is not enabled on this server.');
+        return billing;
+    };
+    const sessionCookie = (token, maxAgeSec, name = SESSION_COOKIE) => `${name}=${token}; HttpOnly; Path=/; SameSite=Lax; Max-Age=${maxAgeSec}${secureCookies ? '; Secure' : ''}`;
+    const readCookie = (req, name) => req.headers.cookie
+        ?.split(';')
+        .map((c) => c.trim().split('='))
+        .find(([k]) => k === name)?.[1];
+    const sessionToken = (req) => readCookie(req, SESSION_COOKIE) ?? readCookie(req, LEGACY_SESSION_COOKIE) ?? '';
+    const dashboardView = async (account) => ({
+        account: toPublicAccount(account),
+        email: account.email,
+        billing_enabled: Boolean(billing),
+        billing: billing ? toPublicEstimate(await billing.estimate(account)) : null,
+        usage: toPublicUsage(`${utcDay(now()).slice(0, 7)}-01`, utcDay(now()), await service.usage(account, `${utcDay(now()).slice(0, 7)}-01`, utcDay(now()), false), account),
+    });
+    const baseUrl = (req) => {
+        if (opts.publicUrl)
+            return opts.publicUrl.replace(/\/$/, '');
+        const proto = String(req.headers['x-forwarded-proto'] ?? 'http').split(',')[0].trim();
+        return `${proto}://${req.headers.host}`;
+    };
+    const sessionView = async (ctx) => {
+        const row = await widget.domainOf(ctx);
+        const host = row && row.status !== 'verified' ? await widget.hostOf(row.domain) : null;
+        return {
+            object: 'widget_session',
+            expires_at: iso(ctx.session.expiresAt),
+            app_name: ctx.account.name,
+            needs_domain: row === null,
+            domain: row && toWidgetDomain(row),
+            dns_host: host && { name: host.name, provider: host.provider },
+        };
+    };
+    const routes = [
+        ['GET', /^\/v1\/account$/, async ({ account }) => [200, toPublicAccount(account)]],
+        ['PATCH', /^\/v1\/account$/, async ({ account, body }) => [200, toPublicAccount(await service.updateAccount(account, parseAccountPatch(await body())))]],
+        ['POST', /^\/v1\/account\/rotate-api-key$/, async ({ account }) => [200, { object: 'api_key', api_key: await service.rotateApiKey(account) }]],
+        ['POST', /^\/v1\/account\/rotate-webhook-secret$/, async ({ account }) => [200, toPublicAccount(await service.rotateWebhookSecret(account))]],
+        ['GET', /^\/v1\/usage$/, async ({ account, query }) => {
+                const { from, to } = parseUsagePeriod(query, now());
+                const groupBy = query.get('group_by');
+                if (groupBy !== null && groupBy !== 'tenant')
+                    throw invalid('group_by must be "tenant".');
+                return [200, toPublicUsage(from, to, await service.usage(account, from, to, groupBy === 'tenant'), account)];
+            }],
+        ['POST', /^\/v1\/domains$/, async ({ account, body }) => [201, toPublicDomain(await service.createDomain(account, parseDomainInput(await body())))]],
+        ['GET', /^\/v1\/domains$/, async ({ account, query }) => {
+                const limit = query.has('limit') ? Number(query.get('limit')) : 20;
+                if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+                    throw invalid('limit must be an integer from 1 to 100.');
+                const status = query.get('status') ?? undefined;
+                if (status && !STATUSES.includes(status))
+                    throw invalid(`status must be one of: ${STATUSES.join(', ')}.`);
+                const page = await service.listDomains(account, {
+                    limit,
+                    tenantId: query.get('tenant_id') ?? undefined,
+                    status: status,
+                    after: query.get('starting_after') ?? undefined,
+                });
+                return [200, { object: 'list', data: page.domains.map(toPublicDomain), has_more: page.next !== null, next_cursor: page.next }];
+            }],
+        ['GET', /^\/v1\/domains\/([\w-]+)$/, async ({ account, params }) => [200, toPublicDomain(await service.getDomain(account, params[0]))]],
+        ['PATCH', /^\/v1\/domains\/([\w-]+)$/, async ({ account, params, body }) => [200, toPublicDomain(await service.updateDomain(account, params[0], parseDomainPatch(await body(), (await service.getDomain(account, params[0])).domain)))]],
+        ['DELETE', /^\/v1\/domains\/([\w-]+)$/, async ({ account, params, query }) => {
+                await service.deleteDomain(account, params[0], { remote: query.get('remote') === 'true' });
+                return [200, { id: params[0], object: 'domain', deleted: true }];
+            }],
+        ['POST', /^\/v1\/domains\/([\w-]+)\/verify$/, async ({ account, params }) => [202, toPublicDomain(await service.verifyNow(account, params[0]))]],
+        ['GET', /^\/v1\/domains\/([\w-]+)\/events$/, async ({ account, params }) => {
+                await service.getDomain(account, params[0]); // 404 unless it's this account's domain
+                return [200, { object: 'list', data: (await service.listEvents(params[0])).map(toPublicEvent) }];
+            }],
+        // Widget: sessions are minted server-side with the secret key...
+        ['POST', /^\/v1\/widget-sessions$/, async ({ req, account, body }) => {
+                const { session, token } = await widget.createSession(account, parseWidgetSession(await body()));
+                const base = baseUrl(req);
+                return [201, {
+                        object: 'widget_session',
+                        id: session.id,
+                        client_secret: token,
+                        domain_id: session.domainId,
+                        expires_at: iso(session.expiresAt),
+                        frame_url: `${base}/widget/frame?session=${token}`,
+                        script_url: `${base}/widget.js`,
+                    }];
+            }],
+        // ...and used from the browser with the session token.
+        ['GET', /^\/v1\/widget\/session$/, async (ctx) => [200, await sessionView(ctx)], 'session'],
+        ['POST', /^\/v1\/widget\/domain$/, async (ctx) => {
+                const body = await ctx.body();
+                rejectUnknown(body, ['domain']);
+                await widget.setDomain(ctx, optString(body, 'domain', 253) ?? '');
+                return [201, await sessionView(ctx)];
+            }, 'session'],
+        ['POST', /^\/v1\/widget\/connect$/, async (ctx) => {
+                const dns = parseDns(await ctx.body());
+                await widget.connect(ctx, dns.provider, dns.credentials);
+                return [200, await sessionView(ctx)];
+            }, 'session'],
+        ['POST', /^\/v1\/widget\/verify$/, async (ctx) => {
+                await widget.verify(ctx);
+                return [202, await sessionView(ctx)];
+            }, 'session'],
+        ['POST', /^\/v1\/widget\/resolve-conflicts$/, async (ctx) => {
+                await widget.resolveConflicts(ctx);
+                return [200, await sessionView(ctx)];
+            }, 'session'],
+        ['GET', /^\/widget\.js$/, async () => ({
+                status: 200,
+                headers: {
+                    'content-type': 'text/javascript; charset=utf-8',
+                    'cache-control': 'public, max-age=300',
+                    'access-control-allow-origin': '*',
+                    'x-content-type-options': 'nosniff',
+                },
+                body: assets.loader,
+            }), 'public'],
+        ['GET', /^\/widget\/frame$/, async ({ query }) => renderFrame(assets.frame, await widget.authenticate(query.get('session') ?? ''), query), 'public'],
+        // Public website: landing, pricing, docs, about, contact and legal pages.
+        ['GET', /^\/(pricing|about|contact|terms|privacy|refunds|docs(\/[\w-]*)?)?$/, async ({ req }) => {
+                const path = new URL(req.url ?? '/', 'http://localhost').pathname;
+                const page = opts.site?.render(path);
+                if (page)
+                    return page;
+                // Without a site, the root goes straight to the dashboard (if sign-up is on).
+                if (path === '/' && auth && opts.publicUrl)
+                    return { status: 302, headers: { location: '/dashboard' }, body: '' };
+                throw new HttpError(404, 'not_found', `No page at ${path}.`);
+            }, 'public'],
+        // Self-serve accounts: passwordless email links and the dashboard.
+        ['GET', /^\/(signup|login)$/, async () => {
+                requireAuth();
+                return { status: 302, headers: { location: '/dashboard' }, body: '' };
+            }, 'public'],
+        ['GET', /^\/dashboard$/, async () => {
+                requireAuth();
+                return renderDashboard(assets.dashboard, opts.site?.appName ?? 'DKIMkit');
+            }, 'public'],
+        ['POST', /^\/v1\/auth\/email-link$/, async ({ req, body }) => {
+                const accountAuth = requireAuth();
+                const retryAfter = emailLimiter.take(`ip:${req.socket.remoteAddress}`, now());
+                if (retryAfter > 0) {
+                    throw new HttpError(429, 'rate_limited', 'Too many sign-in emails. Please wait a minute and try again.');
+                }
+                const input = await body();
+                rejectUnknown(input, ['email', 'name']);
+                await accountAuth.requestLink(optString(input, 'email', 254) ?? '', optString(input, 'name', 100));
+                // Same response whether or not the account exists.
+                return [202, { ok: true }];
+            }, 'public'],
+        ['GET', /^\/auth\/callback$/, async ({ query }) => {
+                const accountAuth = requireAuth();
+                try {
+                    const { sessionToken, created } = await accountAuth.completeLink(query.get('token') ?? '');
+                    return {
+                        status: 303,
+                        headers: { location: created ? '/dashboard?welcome=1' : '/dashboard', 'set-cookie': sessionCookie(sessionToken, SESSION_TTL_MS / 1000), 'cache-control': 'no-store' },
+                        body: '',
+                    };
+                }
+                catch (err) {
+                    if (!(err instanceof ConfigError))
+                        throw err;
+                    return { status: 303, headers: { location: '/dashboard?link=expired', 'cache-control': 'no-store' }, body: '' };
+                }
+            }, 'public'],
+        ['GET', /^\/dashboard\/api\/me$/, async ({ account }) => [200, await dashboardView(account)], 'dashboard'],
+        ['POST', /^\/dashboard\/api\/logout$/, async ({ req }) => {
+                await requireAuth().logout(sessionToken(req));
+                const cleared = [sessionCookie('', 0), sessionCookie('', 0, LEGACY_SESSION_COOKIE)];
+                return { status: 200, headers: { 'set-cookie': cleared, 'content-type': 'application/json' }, body: '{"ok":true}' };
+            }, 'dashboard'],
+        ['POST', /^\/dashboard\/api\/api-key$/, async ({ account }) => [200, { object: 'api_key', api_key: await service.rotateApiKey(account) }], 'dashboard'],
+        ['PATCH', /^\/dashboard\/api\/account$/, async ({ account, body }) => {
+                const updated = await service.updateAccount(account, parseAccountPatch(await body()));
+                return [200, await dashboardView(updated)];
+            }, 'dashboard'],
+        ['POST', /^\/dashboard\/api\/checkout$/, async ({ account }) => [200, { url: await requireBilling().checkoutUrl(account) }], 'dashboard'],
+        ['POST', /^\/dashboard\/api\/portal$/, async ({ account }) => [200, { url: await requireBilling().portalUrl(account) }], 'dashboard'],
+        // Payment provider → us. Authenticated by the provider's signature over the raw body.
+        ['POST', /^\/billing\/webhook$/, async ({ req, rawBody }) => {
+                const result = await requireBilling().handleWebhook(await rawBody(), req.headers);
+                return [200, { received: true, result }];
+            }, 'public'],
+    ];
+    return async (req, res) => {
+        const started = now();
+        const requestId = typeof req.headers['x-request-id'] === 'string' ? req.headers['x-request-id'].slice(0, 64) : randomUUID();
+        res.setHeader('x-request-id', requestId);
+        let accountId;
+        let status = 500;
+        try {
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            if (req.method === 'GET' && url.pathname === '/healthz') {
+                status = 200;
+                return sendJson(res, 200, { ok: true });
+            }
+            const matching = routes.filter(([, re]) => re.test(url.pathname));
+            if (matching.length === 0)
+                throw new HttpError(404, 'not_found', `No route for ${url.pathname}.`);
+            const route = matching.find(([method]) => method === req.method);
+            if (!route)
+                throw new HttpError(405, 'method_not_allowed', `${req.method} is not supported here.`);
+            const [, re, handler, auth = 'account'] = route;
+            let account;
+            let session;
+            if (auth === 'dashboard') {
+                const accountAuth = requireAuth();
+                // Cookie-authenticated writes must come from our own pages (CSRF).
+                if (req.method !== 'GET' && req.headers.origin !== new URL(opts.publicUrl).origin) {
+                    throw new HttpError(403, 'forbidden', 'Cross-site request rejected.');
+                }
+                account = await accountAuth.sessionAccount(sessionToken(req));
+                if (!account)
+                    throw new HttpError(401, 'unauthorized', 'Please sign in.');
+                accountId = account.id;
+                const retryAfter = limiter.take(account.id, now());
+                if (retryAfter > 0)
+                    throw new HttpError(429, 'rate_limited', 'Too many requests.');
+            }
+            else if (auth !== 'public') {
+                const key = /^Bearer\s+(\S+)$/i.exec(req.headers.authorization ?? '')?.[1] ?? '';
+                if (auth === 'session') {
+                    const ctx = key.startsWith('wss_') ? await widget.authenticate(key) : undefined;
+                    if (!ctx)
+                        throw new HttpError(401, 'session_expired', 'This setup session has expired. Reload the page to start again.');
+                    ({ account, session } = ctx);
+                }
+                else {
+                    account = key && !key.startsWith('wss_') ? await service.authenticate(key) : undefined;
+                    if (!account)
+                        throw new HttpError(401, 'unauthorized', 'Missing or invalid API key. Send Authorization: Bearer <key>.');
+                }
+                accountId = account.id;
+                const retryAfter = limiter.take(session?.id ?? account.id, now());
+                if (retryAfter > 0) {
+                    res.setHeader('retry-after', String(Math.ceil(retryAfter / 1000)));
+                    throw new HttpError(429, 'rate_limited', 'Too many requests.');
+                }
+            }
+            const result = await handler({
+                req,
+                account: account,
+                session: session,
+                params: re.exec(url.pathname).slice(1),
+                query: url.searchParams,
+                body: () => readJsonObject(req),
+                rawBody: () => readRawBody(req),
+            });
+            if (Array.isArray(result)) {
+                status = result[0];
+                sendJson(res, result[0], result[1]);
+            }
+            else {
+                status = result.status;
+                res.writeHead(result.status, result.headers);
+                res.end(result.body);
+            }
+        }
+        catch (err) {
+            const e = toHttpError(err);
+            status = e.status;
+            if (e.status === 500)
+                log('error', 'request failed', { request_id: requestId, error: err instanceof Error ? err.stack : String(err) });
+            else if (e.status === 502)
+                log('warn', 'provider rejected request', { request_id: requestId, error: e.message });
+            sendJson(res, e.status, { error: { type: e.type, message: e.message, request_id: requestId, ...e.extra } });
+        }
+        finally {
+            log('info', 'request', { request_id: requestId, method: req.method, path: req.url?.split('?')[0], status, ms: now() - started, account_id: accountId });
+        }
+    };
+}
+function toHttpError(err) {
+    if (err instanceof HttpError)
+        return err;
+    if (err instanceof ConfigError)
+        return invalid(err.message);
+    if (err instanceof NotFoundError)
+        return new HttpError(404, 'not_found', err.message);
+    if (err instanceof PlanLimitError) {
+        return new HttpError(402, 'plan_limit_reached', err.message, { domain_limit: err.limit, ...(err.upgradeUrl ? { upgrade_url: err.upgradeUrl } : {}) });
+    }
+    if (err instanceof WebhookSignatureError)
+        return new HttpError(400, 'invalid_signature', err.message);
+    if (err instanceof ConflictError) {
+        return new HttpError(409, 'conflict', err.message, err.existingId ? { existing_id: err.existingId } : {});
+    }
+    if (err instanceof ApiError) {
+        return new HttpError(502, 'provider_error', err.message, {
+            provider: err.provider,
+            provider_status: err.status,
+            ...(apiErrorHint(err) ? { hint: apiErrorHint(err) } : {}),
+        });
+    }
+    return new HttpError(500, 'internal_error', 'Something went wrong on our side.');
+}
+// ---- input parsing ----
+const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+/** from/to as inclusive UTC days; defaults to the current calendar month so far. */
+export function parseUsagePeriod(query, now) {
+    const today = new Date(now).toISOString().slice(0, 10);
+    const from = query.get('from') ?? `${today.slice(0, 7)}-01`;
+    const to = query.get('to') ?? today;
+    for (const [name, day] of [['from', from], ['to', to]]) {
+        if (!DAY_RE.test(day) || Number.isNaN(Date.parse(`${day}T00:00:00Z`)) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day) {
+            throw invalid(`${name} must be a date like 2026-10-01.`);
+        }
+    }
+    if (from > to)
+        throw invalid('from must not be after to.');
+    if ((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86_400_000 > 366)
+        throw invalid('The period can be at most 366 days.');
+    return { from, to };
+}
+function rejectUnknown(body, allowed, prefix = '') {
+    const unknown = Object.keys(body).filter((k) => !allowed.includes(k));
+    if (unknown.length > 0)
+        throw invalid(`Unknown field${unknown.length > 1 ? 's' : ''}: ${unknown.map((k) => prefix + k).join(', ')}.`);
+}
+function optString(body, key, max, label = key) {
+    const v = body[key];
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'string' || v.length > max)
+        throw invalid(`${label} must be a string of at most ${max} characters.`);
+    return v.trim() || undefined;
+}
+function optBool(body, key, label = key) {
+    const v = body[key];
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== 'boolean')
+        throw invalid(`${label} must be true or false.`);
+    return v;
+}
+function asObject(v, label) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw invalid(`${label} must be an object.`);
+    return v;
+}
+function parseMetadata(v) {
+    const obj = asObject(v, 'metadata');
+    const entries = Object.entries(obj);
+    if (entries.length > 20)
+        throw invalid('metadata can have at most 20 keys.');
+    for (const [k, val] of entries) {
+        if (k.length > 40 || typeof val !== 'string' || val.length > 500) {
+            throw invalid('metadata keys must be at most 40 characters and values strings of at most 500.');
+        }
+    }
+    return obj;
+}
+/** Without a hostname, the email provider's default applies (e.g. parse.<domain>, or the domain itself for Mailgun). */
+function parseInbound(v, domain) {
+    if (v === null)
+        return null;
+    const obj = asObject(v, 'inbound');
+    rejectUnknown(obj, ['url', 'hostname', 'spam_check', 'send_raw'], 'inbound.');
+    const url = optString(obj, 'url', 2048, 'inbound.url');
+    if (!url || !/^https:\/\/\S+$/.test(url))
+        throw invalid('inbound.url must be an https:// URL.');
+    const given = optString(obj, 'hostname', 253, 'inbound.hostname');
+    const hostname = given === undefined ? undefined : normalizeName(given);
+    if (hostname !== undefined && (!isValidDomain(hostname) || !(hostname === domain || hostname.endsWith(`.${domain}`)))) {
+        throw invalid(`inbound.hostname must be ${domain} or a subdomain of it.`);
+    }
+    return { url, ...(hostname ? { hostname } : {}), spamCheck: optBool(obj, 'spam_check', 'inbound.spam_check') ?? false, sendRaw: optBool(obj, 'send_raw', 'inbound.send_raw') ?? false };
+}
+function parseDns(v) {
+    const obj = asObject(v, 'dns');
+    rejectUnknown(obj, ['provider', 'cloudflare_api_token', 'aws_access_key_id', 'aws_secret_access_key', 'aws_session_token', 'route53_hosted_zone_id'], 'dns.');
+    const provider = optString(obj, 'provider', 20, 'dns.provider');
+    if (!provider)
+        throw invalid('dns.provider is required.');
+    return {
+        provider,
+        credentials: {
+            cloudflareApiToken: optString(obj, 'cloudflare_api_token', 200, 'dns.cloudflare_api_token'),
+            awsAccessKeyId: optString(obj, 'aws_access_key_id', 128, 'dns.aws_access_key_id'),
+            awsSecretAccessKey: optString(obj, 'aws_secret_access_key', 128, 'dns.aws_secret_access_key'),
+            awsSessionToken: optString(obj, 'aws_session_token', 4096, 'dns.aws_session_token'),
+            route53HostedZoneId: optString(obj, 'route53_hosted_zone_id', 64, 'dns.route53_hosted_zone_id'),
+        },
+    };
+}
+export function parseDomainInput(body) {
+    rejectUnknown(body, ['domain', 'subdomain', 'tenant_id', 'metadata', 'sendgrid_subuser', 'inbound', 'dns', 'overwrite']);
+    const domain = normalizeName(optString(body, 'domain', 253) ?? '');
+    if (!isValidDomain(domain))
+        throw invalid('domain must be a valid domain name, like example.com.');
+    const subdomain = optString(body, 'subdomain', 63);
+    if (subdomain && !/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/i.test(subdomain))
+        throw invalid('subdomain must be a single DNS label, like "em".');
+    const dns = body.dns === undefined ? { provider: 'manual', credentials: {} } : parseDns(body.dns);
+    return {
+        domain,
+        subdomain: subdomain?.toLowerCase() ?? null,
+        tenantId: optString(body, 'tenant_id', 128) ?? null,
+        metadata: body.metadata === undefined ? {} : parseMetadata(body.metadata),
+        sendgridSubuser: optString(body, 'sendgrid_subuser', 64) ?? null,
+        inbound: body.inbound === undefined ? null : parseInbound(body.inbound, domain),
+        dnsProvider: dns.provider,
+        dnsCredentials: dns.credentials,
+        overwrite: optBool(body, 'overwrite') ?? false,
+    };
+}
+function parseDomainPatch(body, domain) {
+    rejectUnknown(body, ['tenant_id', 'metadata', 'inbound', 'dns', 'overwrite']);
+    const patch = {};
+    if ('tenant_id' in body)
+        patch.tenantId = optString(body, 'tenant_id', 128) ?? null;
+    if (body.metadata !== undefined)
+        patch.metadata = parseMetadata(body.metadata);
+    if (body.inbound !== undefined)
+        patch.inbound = parseInbound(body.inbound, domain);
+    if (body.dns !== undefined) {
+        const dns = parseDns(body.dns);
+        patch.dnsProvider = dns.provider;
+        patch.dnsCredentials = Object.fromEntries(Object.entries(dns.credentials).filter(([, v]) => v !== undefined));
+    }
+    const overwrite = optBool(body, 'overwrite');
+    if (overwrite !== undefined)
+        patch.overwrite = overwrite;
+    return patch;
+}
+const EMAIL_CREDENTIAL_FIELDS = [
+    ['api_key', 'apiKey', 300],
+    ['account_token', 'accountToken', 200],
+    ['inbound_server_id', 'inboundServerId', 40],
+    ['region', 'region', 40],
+    ['access_key_id', 'accessKeyId', 128],
+    ['secret_access_key', 'secretAccessKey', 128],
+    ['session_token', 'sessionToken', 4096],
+];
+/** `email_provider: { provider: "postmark", account_token: "…" }`, etc. Fields left out keep their saved values. */
+function parseEmailProvider(v) {
+    const obj = asObject(v, 'email_provider');
+    rejectUnknown(obj, ['provider', ...EMAIL_CREDENTIAL_FIELDS.map(([f]) => f)], 'email_provider.');
+    const provider = optString(obj, 'provider', 20, 'email_provider.provider');
+    if (!provider || !isEmailProvider(provider))
+        throw invalid(`email_provider.provider must be one of: ${EMAIL_PROVIDERS.join(', ')}.`);
+    const credentials = {};
+    for (const [field, key, max] of EMAIL_CREDENTIAL_FIELDS) {
+        const value = optString(obj, field, max, `email_provider.${field}`);
+        if (value !== undefined)
+            credentials[key] = value;
+    }
+    return { provider, credentials };
+}
+function parseAccountPatch(body) {
+    rejectUnknown(body, ['name', 'webhook_url', 'sendgrid_api_key', 'email_provider', 'widget_origins']);
+    const patch = {};
+    const name = optString(body, 'name', 200);
+    if (name !== undefined)
+        patch.name = name;
+    if ('webhook_url' in body)
+        patch.webhookUrl = optString(body, 'webhook_url', 2048) ?? null;
+    const key = optString(body, 'sendgrid_api_key', 200);
+    if (key !== undefined)
+        patch.sendgridApiKey = key;
+    if (body.email_provider !== undefined)
+        patch.emailProvider = parseEmailProvider(body.email_provider);
+    if (body.widget_origins !== undefined)
+        patch.widgetOrigins = parseOrigins(body.widget_origins);
+    return patch;
+}
+const LOCAL_HOSTS = ['localhost', '127.0.0.1', '[::1]'];
+function parseOrigins(v) {
+    if (!Array.isArray(v) || v.length > 20)
+        throw invalid('widget_origins must be an array of at most 20 origins.');
+    return v.map((o) => {
+        const hint = `widget_origins entries must be origins like https://app.example.com (http:// only for localhost): ${String(o)}`;
+        if (typeof o !== 'string')
+            throw invalid(hint);
+        let url;
+        try {
+            url = new URL(o);
+        }
+        catch {
+            throw invalid(hint);
+        }
+        const secure = url.protocol === 'https:' || (url.protocol === 'http:' && LOCAL_HOSTS.includes(url.hostname));
+        if (!secure || url.origin !== o.replace(/\/$/, ''))
+            throw invalid(hint);
+        return url.origin;
+    });
+}
+function parseWidgetSession(body) {
+    rejectUnknown(body, ['domain_id', 'tenant_id', 'metadata', 'subdomain', 'sendgrid_subuser', 'inbound_url', 'expires_in']);
+    let expiresInSec;
+    if (body.expires_in !== undefined) {
+        expiresInSec = Number(body.expires_in);
+        if (!Number.isInteger(expiresInSec) || expiresInSec < 60 || expiresInSec > MAX_SESSION_SEC) {
+            throw invalid(`expires_in must be between 60 and ${MAX_SESSION_SEC} seconds.`);
+        }
+    }
+    const domainId = optString(body, 'domain_id', 64);
+    const tenantId = optString(body, 'tenant_id', 128);
+    if (domainId) {
+        if (Object.keys(body).some((k) => k !== 'domain_id' && k !== 'expires_in')) {
+            throw invalid('With domain_id, the domain\'s own settings apply; pass only domain_id and expires_in.');
+        }
+        return { domainId, expiresInSec };
+    }
+    if (!tenantId)
+        throw invalid('Pass domain_id for an existing domain, or tenant_id to let the user enter their domain.');
+    const inboundUrl = optString(body, 'inbound_url', 2048) ?? null;
+    if (inboundUrl && !/^https:\/\/\S+$/.test(inboundUrl))
+        throw invalid('inbound_url must be an https:// URL.');
+    const subdomain = optString(body, 'subdomain', 63)?.toLowerCase() ?? null;
+    if (subdomain && !/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain))
+        throw invalid('subdomain must be a single DNS label, like "em".');
+    return {
+        expiresInSec,
+        defaults: {
+            tenantId,
+            metadata: body.metadata === undefined ? {} : parseMetadata(body.metadata),
+            subdomain,
+            sendgridSubuser: optString(body, 'sendgrid_subuser', 64) ?? null,
+            inboundUrl,
+        },
+    };
+}
+// ---- widget frame ----
+const THEME_MODES = ['light', 'dark', 'auto'];
+/** The iframe page. Embeddable only by the account's widget origins, since users type credentials into it. */
+function renderFrame(template, ctx, query) {
+    const nonce = randomBytes(16).toString('base64');
+    const accent = query.get('accent') ?? '';
+    // Number(null) is 0, so an absent radius must not count as an explicit 0.
+    const radius = query.has('radius') ? Number(query.get('radius')) : NaN;
+    const config = {
+        allowedOrigins: ctx?.account.widgetOrigins ?? [],
+        valid: Boolean(ctx),
+        theme: {
+            accent: /^#[0-9a-f]{6}$/i.test(accent) ? accent : null,
+            // Light unless the host opts in: matching the host page matters more than the OS setting.
+            mode: THEME_MODES.includes(query.get('mode') ?? '') ? query.get('mode') : 'light',
+            radius: Number.isInteger(radius) && radius >= 0 && radius <= 24 ? radius : null,
+        },
+    };
+    const ancestors = ctx ? ctx.account.widgetOrigins.join(' ') : "'none'";
+    return {
+        status: ctx ? 200 : 401,
+        headers: {
+            'content-type': 'text/html; charset=utf-8',
+            'cache-control': 'no-store',
+            'referrer-policy': 'no-referrer',
+            'x-content-type-options': 'nosniff',
+            'content-security-policy': [
+                "default-src 'none'",
+                `script-src 'nonce-${nonce}'`,
+                "style-src 'unsafe-inline'",
+                "img-src 'self' data:",
+                "connect-src 'self'",
+                "base-uri 'none'",
+                "form-action 'none'",
+                `frame-ancestors ${ancestors}`,
+            ].join('; '),
+        },
+        body: template
+            .replaceAll('__NONCE__', nonce)
+            // A function replacement, so `$` sequences in the JSON are never treated as patterns.
+            .replace('__CONFIG__', () => JSON.stringify(config).replace(/</g, '\\u003c')),
+    };
+}
+/** The account dashboard (sign-in and billing). Never framed; scripts by nonce only. */
+function renderDashboard(template, appName) {
+    const nonce = randomBytes(16).toString('base64');
+    const name = appName.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'text/html; charset=utf-8',
+            'cache-control': 'no-store',
+            'referrer-policy': 'same-origin',
+            'x-content-type-options': 'nosniff',
+            'content-security-policy': [
+                "default-src 'none'",
+                `script-src 'nonce-${nonce}'`,
+                "style-src 'unsafe-inline'",
+                "img-src 'self' data:",
+                "connect-src 'self'",
+                "base-uri 'none'",
+                "form-action 'self'",
+                "frame-ancestors 'none'",
+            ].join('; '),
+        },
+        // Function replacements, so `$` in the name is never treated as a pattern.
+        body: template.replaceAll('__NONCE__', nonce).replaceAll('__APP_NAME__', () => name),
+    };
+}
+// ---- plumbing ----
+/** The exact request body, for signature verification. */
+async function readRawBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 1024 * 1024)
+            throw new HttpError(413, 'payload_too_large', 'Request body is too large.');
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function readJsonObject(req) {
+    if (!req.headers['content-type']?.startsWith('application/json')) {
+        throw new HttpError(415, 'unsupported_media_type', 'Send Content-Type: application/json.');
+    }
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES)
+            throw new HttpError(413, 'payload_too_large', 'Request body is too large.');
+        chunks.push(chunk);
+    }
+    let body;
+    try {
+        body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+    }
+    catch {
+        throw invalid('Request body is not valid JSON.');
+    }
+    return asObject(body, 'Request body');
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+/** Token bucket per account. Returns 0 when allowed, else ms until a token is available. */
+class RateLimiter {
+    perSecond;
+    burst;
+    buckets = new Map();
+    constructor(perSecond, burst) {
+        this.perSecond = perSecond;
+        this.burst = burst;
+    }
+    take(key, now) {
+        const bucket = this.buckets.get(key) ?? { tokens: this.burst, at: now };
+        bucket.tokens = Math.min(this.burst, bucket.tokens + ((now - bucket.at) / 1000) * this.perSecond);
+        bucket.at = now;
+        this.buckets.set(key, bucket);
+        if (bucket.tokens >= 1) {
+            bucket.tokens -= 1;
+            return 0;
+        }
+        return ((1 - bucket.tokens) / this.perSecond) * 1000;
+    }
+}
+export async function startHostedApi(opts) {
+    if ((opts.signup || opts.billing || opts.site) && !opts.publicUrl) {
+        throw new ConfigError('Sign-up, billing and the website need a public URL (PUBLIC_URL).');
+    }
+    const store = opts.store ?? (await openStore(opts.database ?? ':memory:'));
+    const publicUrl = opts.publicUrl?.replace(/\/$/, '');
+    const billing = opts.billing ? new BillingService(store, opts.billing, { publicUrl: publicUrl, now: opts.now, log: opts.log }) : undefined;
+    const service = new DomainService({
+        store,
+        vault: new Vault(opts.encryptionKey),
+        providers: opts.providers,
+        lookup: opts.lookup,
+        now: opts.now,
+        allowPrivateWebhooks: opts.allowPrivateWebhooks,
+        planCap: billing?.planCap,
+        log: opts.log,
+    });
+    const auth = opts.signup
+        ? new AccountAuth(store, service, opts.signup.mailer ?? new LogMailer(opts.log ?? (() => { })), {
+            publicUrl: publicUrl,
+            appName: opts.signup.appName ?? opts.site?.appName,
+            now: opts.now,
+        })
+        : undefined;
+    const site = opts.site
+        ? new Site({
+            ...opts.site,
+            publicUrl: publicUrl,
+            signupEnabled: Boolean(auth),
+            plan: billing && { freeDomains: billing.freeDomains, unitAmount: billing.unitAmount, currency: billing.currency, provider: billing.provider.name },
+        })
+        : undefined;
+    const runner = new BackgroundRunner(service, store, {
+        ...opts.runner,
+        now: opts.now,
+        fetch: opts.fetch,
+        allowPrivateWebhooks: opts.allowPrivateWebhooks,
+        billing,
+        log: opts.log,
+    });
+    const widget = new WidgetService(service, store, { now: opts.now, detectHost: opts.detectHost });
+    const handler = createApiHandler({ service, widget, auth, billing, site, publicUrl, rateLimit: opts.rateLimit, now: opts.now, log: opts.log });
+    const server = createServer((req, res) => void handler(req, res));
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port ?? 8080, opts.host ?? '0.0.0.0', () => resolve());
+    });
+    if (opts.workers !== false)
+        runner.start();
+    const { port } = server.address();
+    return {
+        url: `http://${opts.host === '0.0.0.0' || !opts.host ? '127.0.0.1' : opts.host}:${port}`,
+        port,
+        server,
+        store,
+        service,
+        runner,
+        billing,
+        auth,
+        site,
+        async close() {
+            await new Promise((resolve) => {
+                server.close(() => resolve());
+                server.closeIdleConnections();
+            });
+            await runner.stop();
+            await store.close();
+        },
+    };
+}
+//# sourceMappingURL=api.js.map