@dbx-tools/email 0.6.41 → 0.6.43

package/lib/src/auth/otp.js

@@ -0,0 +1,135 @@
+/**
+ * One-time-code store + session JWT for the email-OTP gate.
+ *
+ * Two pieces:
+ *
+ *   - **Code store** - a 6-digit code is generated with `crypto.randomInt` and
+ *     kept server-side as a SHA-256 hash with an expiry and an attempt counter
+ *     (never the plaintext, never in the JWT). `verifyCode` is constant-time on
+ *     the hash, enforces the TTL, and burns the code after too many attempts or
+ *     one success. In-memory `Map` keyed by lowercased email - fine for a
+ *     single-instance app behind a tunnel.
+ *   - **Session JWT** - on a correct code, `signSession` mints a short-lived
+ *     HS256 JWT (via `jose`) carrying only the email; `verifySession` validates
+ *     it. The signing key comes from `AUTH_JWT_SECRET`; when unset the gate
+ *     FAILS OPEN with an ephemeral per-process key (sessions reset on restart)
+ *     rather than refusing service - a Databricks App is already access-limited,
+ *     so an unset secret degrades to "sessions don't survive restarts", not
+ *     "nobody can log in".
+ *
+ * @module
+ */
+import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
+import { jwtVerify, SignJWT } from "jose";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("email:auth:otp");
+/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */
+const JWT_AUD = "dbx-tools-email-auth";
+/** SHA-256 hex of a value (for the stored code + a stable key comparison). */
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+/** Constant-time compare of two hex digests of equal length. */
+function safeEqualHex(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+}
+/** In-memory store of pending one-time codes, keyed by lowercased email. */
+export class CodeStore {
+    ttlMs;
+    maxAttempts;
+    codes = new Map();
+    constructor(ttlMs, maxAttempts) {
+        this.ttlMs = ttlMs;
+        this.maxAttempts = maxAttempts;
+    }
+    /**
+     * Generate, store (hashed), and RETURN a fresh 6-digit code for `email`. The
+     * caller emails the returned plaintext; only the hash is retained. Replaces
+     * any pending code for the address.
+     */
+    issue(email, now = Date.now()) {
+        const code = String(randomInt(0, 1_000_000)).padStart(6, "0");
+        this.codes.set(email.toLowerCase(), {
+            hash: sha256(code),
+            expiresAt: now + this.ttlMs,
+            attempts: 0,
+        });
+        return code;
+    }
+    /**
+     * Check `code` for `email`. Consumes the entry on success or when attempts are
+     * exhausted, so a code is single-use and can't be brute-forced past the cap.
+     */
+    verify(email, code, now = Date.now()) {
+        const key = email.toLowerCase();
+        const entry = this.codes.get(key);
+        if (!entry)
+            return "invalid";
+        if (now >= entry.expiresAt) {
+            this.codes.delete(key);
+            return "expired";
+        }
+        entry.attempts += 1;
+        if (safeEqualHex(entry.hash, sha256(code))) {
+            this.codes.delete(key);
+            return "ok";
+        }
+        if (entry.attempts >= this.maxAttempts) {
+            this.codes.delete(key);
+            return "too-many-attempts";
+        }
+        return "invalid";
+    }
+    /** Drop every pending code (tests). */
+    clear() {
+        this.codes.clear();
+    }
+}
+/**
+ * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an
+ * ephemeral per-process key (fail-open) and warns once. Memoized so every
+ * sign/verify in a process shares one key.
+ */
+let cachedKey;
+function signingKey() {
+    if (cachedKey)
+        return cachedKey;
+    const secret = process.env.AUTH_JWT_SECRET?.trim();
+    if (secret) {
+        cachedKey = new TextEncoder().encode(secret);
+    }
+    else {
+        logger.warn("AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart");
+        cachedKey = randomBytes(32);
+    }
+    return cachedKey;
+}
+/** Reset the memoized key (tests, or after changing the env in-process). */
+export function resetSigningKey() {
+    cachedKey = undefined;
+}
+/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */
+export async function signSession(email, ttlSeconds) {
+    return new SignJWT({ email })
+        .setProtectedHeader({ alg: "HS256" })
+        .setSubject(email)
+        .setAudience(JWT_AUD)
+        .setIssuedAt()
+        .setExpirationTime(`${ttlSeconds}s`)
+        .sign(signingKey());
+}
+/** Validate a session JWT, returning the email it was minted for, or `undefined`. */
+export async function verifySession(token) {
+    if (!token)
+        return undefined;
+    try {
+        const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });
+        return typeof payload.email === "string" ? payload.email : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"otp.js","sourceRoot":"","sources":["../../../src/auth/otp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One-time-code store + session JWT for the email-OTP gate.\n *\n * Two pieces:\n *\n *   - **Code store** - a 6-digit code is generated with `crypto.randomInt` and\n *     kept server-side as a SHA-256 hash with an expiry and an attempt counter\n *     (never the plaintext, never in the JWT). `verifyCode` is constant-time on\n *     the hash, enforces the TTL, and burns the code after too many attempts or\n *     one success. In-memory `Map` keyed by lowercased email - fine for a\n *     single-instance app behind a tunnel.\n *   - **Session JWT** - on a correct code, `signSession` mints a short-lived\n *     HS256 JWT (via `jose`) carrying only the email; `verifySession` validates\n *     it. The signing key comes from `AUTH_JWT_SECRET`; when unset the gate\n *     FAILS OPEN with an ephemeral per-process key (sessions reset on restart)\n *     rather than refusing service - a Databricks App is already access-limited,\n *     so an unset secret degrades to \"sessions don't survive restarts\", not\n *     \"nobody can log in\".\n *\n * @module\n */\n\nimport { createHash, randomBytes, randomInt, timingSafeEqual } from \"node:crypto\";\nimport { jwtVerify, SignJWT } from \"jose\";\nimport { log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"email:auth:otp\");\n\n/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */\nconst JWT_AUD = \"dbx-tools-email-auth\";\n\n/** SHA-256 hex of a value (for the stored code + a stable key comparison). */\nfunction sha256(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** Constant-time compare of two hex digests of equal length. */\nfunction safeEqualHex(a: string, b: string): boolean {\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(Buffer.from(a, \"hex\"), Buffer.from(b, \"hex\"));\n}\n\ninterface CodeEntry {\n  hash: string;\n  expiresAt: number;\n  attempts: number;\n}\n\n/** Result of {@link CodeStore.verify}. */\nexport type VerifyOutcome = \"ok\" | \"invalid\" | \"expired\" | \"too-many-attempts\";\n\n/** In-memory store of pending one-time codes, keyed by lowercased email. */\nexport class CodeStore {\n  private readonly codes = new Map<string, CodeEntry>();\n\n  constructor(\n    private readonly ttlMs: number,\n    private readonly maxAttempts: number,\n  ) {}\n\n  /**\n   * Generate, store (hashed), and RETURN a fresh 6-digit code for `email`. The\n   * caller emails the returned plaintext; only the hash is retained. Replaces\n   * any pending code for the address.\n   */\n  issue(email: string, now: number = Date.now()): string {\n    const code = String(randomInt(0, 1_000_000)).padStart(6, \"0\");\n    this.codes.set(email.toLowerCase(), {\n      hash: sha256(code),\n      expiresAt: now + this.ttlMs,\n      attempts: 0,\n    });\n    return code;\n  }\n\n  /**\n   * Check `code` for `email`. Consumes the entry on success or when attempts are\n   * exhausted, so a code is single-use and can't be brute-forced past the cap.\n   */\n  verify(email: string, code: string, now: number = Date.now()): VerifyOutcome {\n    const key = email.toLowerCase();\n    const entry = this.codes.get(key);\n    if (!entry) return \"invalid\";\n    if (now >= entry.expiresAt) {\n      this.codes.delete(key);\n      return \"expired\";\n    }\n    entry.attempts += 1;\n    if (safeEqualHex(entry.hash, sha256(code))) {\n      this.codes.delete(key);\n      return \"ok\";\n    }\n    if (entry.attempts >= this.maxAttempts) {\n      this.codes.delete(key);\n      return \"too-many-attempts\";\n    }\n    return \"invalid\";\n  }\n\n  /** Drop every pending code (tests). */\n  clear(): void {\n    this.codes.clear();\n  }\n}\n\n/**\n * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an\n * ephemeral per-process key (fail-open) and warns once. Memoized so every\n * sign/verify in a process shares one key.\n */\nlet cachedKey: Uint8Array | undefined;\nfunction signingKey(): Uint8Array {\n  if (cachedKey) return cachedKey;\n  const secret = process.env.AUTH_JWT_SECRET?.trim();\n  if (secret) {\n    cachedKey = new TextEncoder().encode(secret);\n  } else {\n    logger.warn(\n      \"AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart\",\n    );\n    cachedKey = randomBytes(32);\n  }\n  return cachedKey;\n}\n\n/** Reset the memoized key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  cachedKey = undefined;\n}\n\n/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */\nexport async function signSession(email: string, ttlSeconds: number): Promise<string> {\n  return new SignJWT({ email })\n    .setProtectedHeader({ alg: \"HS256\" })\n    .setSubject(email)\n    .setAudience(JWT_AUD)\n    .setIssuedAt()\n    .setExpirationTime(`${ttlSeconds}s`)\n    .sign(signingKey());\n}\n\n/** Validate a session JWT, returning the email it was minted for, or `undefined`. */\nexport async function verifySession(token: string | undefined): Promise<string | undefined> {\n  if (!token) return undefined;\n  try {\n    const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });\n    return typeof payload.email === \"string\" ? payload.email : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/lib/src/auth/rate-limit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A small in-memory fixed-window rate limiter for the email-OTP gate.
+ *
+ * Keyed by an arbitrary string (an email address or a client IP). Each key gets
+ * `max` hits per `windowMs`; the window resets on first use after it elapses.
+ * `hit()` returns whether the call is allowed and, when not, how many seconds
+ * until the window resets so a caller can surface a cooldown.
+ *
+ * In-memory is intentional and sufficient for a single-app-instance gate: an
+ * app behind a portr tunnel serves from one process. It is NOT a distributed
+ * limiter; a multi-replica deployment would need shared state. Entries are
+ * pruned lazily on access, so an idle key costs nothing after its window.
+ *
+ * @module
+ */
+/** A fixed-window rate limiter over string keys. */
+export declare class RateLimiter {
+    private readonly max;
+    private readonly windowMs;
+    private readonly windows;
+    constructor(max: number, windowMs: number);
+    /**
+     * Record a hit for `key`. Returns `{ allowed }`, plus `retryAfter` (seconds)
+     * when the limit is exceeded. A limit of `<= 0` disables limiting (always
+     * allowed), which lets a config turn it off without special-casing callers.
+     */
+    hit(key: string, now?: number): {
+        allowed: boolean;
+        retryAfter?: number;
+    };
+    /** Forget a key (e.g. clear a caller's window after a successful verify). */
+    reset(key: string): void;
+    /** Drop every window (tests). */
+    clear(): void;
+}

package/lib/src/auth/rate-limit.js

@@ -0,0 +1,53 @@
+/**
+ * A small in-memory fixed-window rate limiter for the email-OTP gate.
+ *
+ * Keyed by an arbitrary string (an email address or a client IP). Each key gets
+ * `max` hits per `windowMs`; the window resets on first use after it elapses.
+ * `hit()` returns whether the call is allowed and, when not, how many seconds
+ * until the window resets so a caller can surface a cooldown.
+ *
+ * In-memory is intentional and sufficient for a single-app-instance gate: an
+ * app behind a portr tunnel serves from one process. It is NOT a distributed
+ * limiter; a multi-replica deployment would need shared state. Entries are
+ * pruned lazily on access, so an idle key costs nothing after its window.
+ *
+ * @module
+ */
+/** A fixed-window rate limiter over string keys. */
+export class RateLimiter {
+    max;
+    windowMs;
+    windows = new Map();
+    constructor(max, windowMs) {
+        this.max = max;
+        this.windowMs = windowMs;
+    }
+    /**
+     * Record a hit for `key`. Returns `{ allowed }`, plus `retryAfter` (seconds)
+     * when the limit is exceeded. A limit of `<= 0` disables limiting (always
+     * allowed), which lets a config turn it off without special-casing callers.
+     */
+    hit(key, now = Date.now()) {
+        if (this.max <= 0)
+            return { allowed: true };
+        const existing = this.windows.get(key);
+        if (!existing || now >= existing.resetAt) {
+            this.windows.set(key, { count: 1, resetAt: now + this.windowMs });
+            return { allowed: true };
+        }
+        if (existing.count < this.max) {
+            existing.count += 1;
+            return { allowed: true };
+        }
+        return { allowed: false, retryAfter: Math.ceil((existing.resetAt - now) / 1000) };
+    }
+    /** Forget a key (e.g. clear a caller's window after a successful verify). */
+    reset(key) {
+        this.windows.delete(key);
+    }
+    /** Drop every window (tests). */
+    clear() {
+        this.windows.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/config.d.ts

@@ -81,6 +81,32 @@ export interface EmailPluginConfig extends BasePluginConfig {
      * `BrandContext`.
      */
     brand?: EmailBrand;
+    /**
+     * Optional email-OTP ACCESS GATE. When `enabled`, the plugin mounts a login
+     * flow (`/api/email/auth/*`) and gates every other route behind a session
+     * cookie - the front door for an app exposed publicly (e.g. through a portr
+     * tunnel that bypasses the Databricks OAuth proxy). Reuses this plugin's
+     * transport to email the code. Omit or `enabled: false` to leave the app open.
+     */
+    auth?: AuthConfig;
+}
+/** Email-OTP access-gate configuration (see {@link EmailPluginConfig.auth}). */
+export interface AuthConfig {
+    /** Turn the gate on. Falls back to `EMAIL_AUTH_ENABLED`. Default off. */
+    enabled?: boolean;
+    /**
+     * Who may request a code. Each entry is a domain shortcut (`databricks.com`
+     * or `@databricks.com`), a glob (`*.databricks.com`), or a `/regex/`. An
+     * EMPTY list allows nobody (fail closed). Falls back to `EMAIL_AUTH_ALLOW`
+     * (comma/space-separated).
+     */
+    allow?: string | string[];
+    /** Session lifetime (seconds). Falls back to `EMAIL_AUTH_SESSION_TTL`. Default 43200 (12h). */
+    sessionTtlSeconds?: number;
+    /** One-time-code lifetime (seconds). Falls back to `EMAIL_AUTH_CODE_TTL`. Default 600 (10m). */
+    codeTtlSeconds?: number;
+    /** Max verify attempts per issued code. Default 5. */
+    maxAttempts?: number;
 }
 /** Config shared by both resolved modes. */
 interface ResolvedSender {
@@ -121,6 +147,20 @@ export interface ResolvedFileConfig extends ResolvedSender {
 export type ResolvedEmailConfig = ResolvedSmtpConfig | ResolvedFileConfig;
 /** JSON Schema published on the manifest's `config.schema`. */
 export declare const EMAIL_CONFIG_SCHEMA: JSONSchema7;
+/** Resolved email-OTP gate config, with env fallbacks applied (or `undefined` when off). */
+export interface ResolvedAuthConfig {
+    readonly allow: string[];
+    readonly sessionTtlSeconds: number;
+    readonly codeTtlSeconds: number;
+    readonly maxAttempts: number;
+}
+/**
+ * Resolve {@link AuthConfig} against env, returning `undefined` when the gate is
+ * off. `enabled` gates everything; `allow` merges the config list + env
+ * (`parseList` handles a `string[]` or a delimited string). Empty `allow` is
+ * allowed here (the gate then denies everyone - a deliberate fail-closed state).
+ */
+export declare function resolveAuthConfig(auth: AuthConfig | undefined): ResolvedAuthConfig | undefined;
 /**
  * Resolve plugin config over environment defaults.
  *

package/lib/src/config.js

@@ -25,7 +25,7 @@
  */
 import { resolve } from "node:path";
 import { ConfigurationError, ValidationError } from "@databricks/appkit";
-import { object } from "@dbx-tools/shared-core";
+import { object, string } from "@dbx-tools/shared-core";
 import { parseAllowedSenders } from "./sender.js";
 /** SMTP submission port used when none is configured. */
 export const DEFAULT_SMTP_PORT = 587;
@@ -104,8 +104,60 @@ export const EMAIL_CONFIG_SCHEMA = {
             },
             required: ["accent", "fontFamily"],
         },
+        auth: {
+            type: "object",
+            description: "Email-OTP access gate. When enabled, mounts a login flow at /api/email/auth/* and gates every other route behind a session cookie.",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    description: "Turn the gate on (env EMAIL_AUTH_ENABLED). Default off.",
+                },
+                allow: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: 'Allow-list of who may request a code: domain shortcut ("databricks.com"), glob ("*.databricks.com"), or "/regex/". Empty = nobody. Also accepts a comma/space-separated string. Env EMAIL_AUTH_ALLOW.',
+                },
+                sessionTtlSeconds: {
+                    type: "number",
+                    description: "Session lifetime in seconds (env EMAIL_AUTH_SESSION_TTL). Default 43200.",
+                },
+                codeTtlSeconds: {
+                    type: "number",
+                    description: "One-time-code lifetime in seconds (env EMAIL_AUTH_CODE_TTL). Default 600.",
+                },
+                maxAttempts: {
+                    type: "number",
+                    description: "Max verify attempts per issued code. Default 5.",
+                },
+            },
+        },
     },
 };
+/**
+ * Resolve {@link AuthConfig} against env, returning `undefined` when the gate is
+ * off. `enabled` gates everything; `allow` merges the config list + env
+ * (`parseList` handles a `string[]` or a delimited string). Empty `allow` is
+ * allowed here (the gate then denies everyone - a deliberate fail-closed state).
+ */
+export function resolveAuthConfig(auth) {
+    const enabled = auth?.enabled ?? object.toBoolean(process.env.EMAIL_AUTH_ENABLED) ?? false;
+    if (!enabled)
+        return undefined;
+    const allow = [
+        ...string.parseList(auth?.allow),
+        ...string.parseList(process.env.EMAIL_AUTH_ALLOW),
+    ];
+    const num = (value, env, fallback) => {
+        const raw = value ?? (env ? Number(env) : undefined);
+        return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : fallback;
+    };
+    return {
+        allow,
+        sessionTtlSeconds: num(auth?.sessionTtlSeconds, process.env.EMAIL_AUTH_SESSION_TTL, 43200),
+        codeTtlSeconds: num(auth?.codeTtlSeconds, process.env.EMAIL_AUTH_CODE_TTL, 600),
+        maxAttempts: auth?.maxAttempts ?? 5,
+    };
+}
 /** Parse the `SMTP_SECURE` env / config flag, defaulting by port. */
 function resolveSecure(flag, port) {
     if (typeof flag === "boolean")
@@ -209,4 +261,4 @@ export function resolveEmailConfig(config = {}) {
     const outDir = resolve(config.outDir ?? process.env.EMAIL_OUTBOX_DIR ?? resolve(process.cwd(), "tmp"));
     return { mode: "file", outDir, ...sender };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SMTP configuration for the email plugin: the typed\n * {@link EmailPluginConfig} (the plugin's slice of AppKit config), the\n * JSON Schema the manifest publishes for it, and {@link resolveEmailConfig}\n * which layers that config over environment defaults into the concrete\n * {@link ResolvedEmailConfig} the runtime needs.\n *\n * Two modes fall out of the resolution. When SMTP credentials (host +\n * user + password) are all present it resolves to `mode: \"smtp\"` and\n * mail is sent for real. When they are absent and `EMAIL_OUTBOX_MODE`\n * is explicitly enabled it resolves to `mode: \"file\"` (an \"outbox\")\n * and each message is written to disk as HTML instead of sent. Any\n * partial SMTP configuration or a send attempt with no credentials and\n * no outbox opt-in throws.\n *\n * Precedence per field: explicit plugin config wins, then the matching\n * environment variable. Env names are unprefixed because the app talks\n * to a single SMTP server (e.g. SMTP2GO): `SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, plus `EMAIL_DOMAIN` for\n * the derived sender's domain, `EMAIL_FROM` for an explicit override,\n * `EMAIL_SENDER_POLICY` for the sender restriction mode, and\n * `EMAIL_OUTBOX_DIR` for the outbox directory.\n *\n * @module\n */\nimport { resolve } from \"node:path\";\nimport { ConfigurationError, ValidationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { object } from \"@dbx-tools/shared-core\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport type { EmailBrand } from \"./brand.ts\";\nimport { parseAllowedSenders } from \"./sender.ts\";\n\n/** SMTP submission port used when none is configured. */\nexport const DEFAULT_SMTP_PORT = 587;\n\n/** SMTP port that implies a TLS-on-connect socket rather than STARTTLS. */\nexport const IMPLICIT_TLS_SMTP_PORT = 465;\n\n/**\n * How the sender (`From`) address is restricted.\n *\n * `\"allowlist\"` is the default and the deny-by-default posture: a send is\n * permitted only from an address the configuration names, either through\n * {@link EmailPluginConfig.allowedSenders} or, when that is empty, through\n * the configured sender source ({@link EmailPluginConfig.from} as an exact\n * address, {@link EmailPluginConfig.domain} as a `*@domain` wildcard).\n *\n * `\"unrestricted\"` is the explicit opt-out: any `From` a caller supplies is\n * accepted. Only reach for it when an upstream system already vets the\n * sender.\n */\nexport type SenderPolicy = \"allowlist\" | \"unrestricted\";\n\n/** SMTP connection + credentials. All fields fall back to env when unset. */\nexport interface SmtpConfig {\n  /** SMTP server hostname (`SMTP_HOST`). */\n  host?: string;\n  /** SMTP server port (`SMTP_PORT`). Defaults to {@link DEFAULT_SMTP_PORT}. */\n  port?: number;\n  /**\n   * Use a TLS-on-connect socket (`SMTP_SECURE`). Defaults to\n   * `port === ` {@link IMPLICIT_TLS_SMTP_PORT}.\n   */\n  secure?: boolean;\n  /** SMTP auth username (`SMTP_USER`). */\n  user?: string;\n  /** SMTP auth password / API key (`SMTP_PASSWORD`). */\n  password?: string;\n}\n\n/** AppKit config accepted by the email plugin. */\nexport interface EmailPluginConfig extends BasePluginConfig {\n  /** SMTP connection + credentials. Omit to run in file/outbox mode. */\n  smtp?: SmtpConfig;\n  /**\n   * Domain used to build the sender address from the on-behalf-of user\n   * (`<local-part>@<domain>`). Falls back to `EMAIL_DOMAIN`. Required in\n   * SMTP mode unless {@link from} is set; optional in file mode (the\n   * outbox falls back to the user's own email address).\n   */\n  domain?: string;\n  /**\n   * Explicit `From` address. When set, the sender is used verbatim and\n   * the per-user derivation is skipped. Falls back to `EMAIL_FROM`.\n   */\n  from?: string;\n  /**\n   * Directory for the file/outbox fallback. Falls back to\n   * `EMAIL_OUTBOX_DIR`, then `<cwd>/tmp`. Only used when SMTP\n   * credentials are absent.\n   */\n  outDir?: string;\n  /**\n   * Allow-list restricting the sender (`From`) address. Each entry is an\n   * exact address (`user@domain.com`), a domain wildcard (`*@domain.com`\n   * or the bare `domain.com`, matching any local part on that domain), or\n   * `*` (any). A resolved / chosen sender that matches no entry is\n   * rejected at send time. Accepts a `string[]` or a single comma- /\n   * whitespace-separated string; falls back to `EMAIL_ALLOWED_SENDERS`.\n   * When empty, the {@link senderPolicy} decides what is permitted.\n   */\n  allowedSenders?: string | string[];\n  /**\n   * How the sender address is restricted when {@link allowedSenders} is\n   * empty (`EMAIL_SENDER_POLICY`). Defaults to `\"allowlist\"`, which\n   * narrows sends to the configured sender source. See\n   * {@link SenderPolicy}.\n   */\n  senderPolicy?: SenderPolicy;\n  /**\n   * Optional brand styling (accent, font, header logo) applied to the\n   * rendered HTML of every message. Omit for the neutral default layout.\n   * Pass {@link emailBrandFromContext} to derive it from a shared\n   * `BrandContext`.\n   */\n  brand?: EmailBrand;\n}\n\n/** Config shared by both resolved modes. */\ninterface ResolvedSender {\n  /** Sender domain; present whenever {@link from} is absent. */\n  domain?: string;\n  /** Explicit sender override; present skips per-user derivation. */\n  from?: string;\n  /**\n   * Effective sender allow-list: the configured patterns when any were\n   * given, else the patterns implied by the sender source under an\n   * `\"allowlist\"` policy. Empty means unenforceable (an `\"unrestricted\"`\n   * policy, or an outbox with no sender source to narrow to).\n   */\n  allowedSenders: string[];\n  /** The restriction mode the allow-list was resolved under. */\n  senderPolicy: SenderPolicy;\n  /** Brand styling applied to rendered HTML; absent for the default layout. */\n  brand?: EmailBrand;\n}\n\n/** Resolved config for real SMTP delivery. */\nexport interface ResolvedSmtpConfig extends ResolvedSender {\n  mode: \"smtp\";\n  host: string;\n  port: number;\n  secure: boolean;\n  auth: { user: string; pass: string };\n}\n\n/** Resolved config for the file/outbox fallback (no SMTP credentials). */\nexport interface ResolvedFileConfig extends ResolvedSender {\n  mode: \"file\";\n  /** Absolute directory messages are written under. */\n  outDir: string;\n}\n\n/** Concrete, validated config the runtime dispatches through. */\nexport type ResolvedEmailConfig = ResolvedSmtpConfig | ResolvedFileConfig;\n\n/** JSON Schema published on the manifest's `config.schema`. */\nexport const EMAIL_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  properties: {\n    smtp: {\n      type: \"object\",\n      description: \"SMTP connection and credentials (env fallbacks: SMTP_*).\",\n      properties: {\n        host: { type: \"string\", description: \"SMTP server hostname (SMTP_HOST).\" },\n        port: {\n          type: \"number\",\n          description: `SMTP server port (SMTP_PORT). Defaults to ${DEFAULT_SMTP_PORT}.`,\n        },\n        secure: {\n          type: \"boolean\",\n          description: `TLS-on-connect socket (SMTP_SECURE). Defaults to port === ${IMPLICIT_TLS_SMTP_PORT}.`,\n        },\n        user: { type: \"string\", description: \"SMTP auth username (SMTP_USER).\" },\n        password: {\n          type: \"string\",\n          description: \"SMTP auth password / API key (SMTP_PASSWORD).\",\n        },\n      },\n    },\n    domain: {\n      type: \"string\",\n      description:\n        \"Domain for the derived sender address (<user-local-part>@<domain>). Falls back to EMAIL_DOMAIN.\",\n    },\n    from: {\n      type: \"string\",\n      description: \"Explicit From address; skips per-user derivation. Falls back to EMAIL_FROM.\",\n    },\n    outDir: {\n      type: \"string\",\n      description:\n        \"Directory for the file/outbox fallback when SMTP is unconfigured. Falls back to EMAIL_OUTBOX_DIR, then <cwd>/tmp.\",\n    },\n    allowedSenders: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description:\n        'Allow-list of permitted sender (From) patterns: exact addresses (\"user@domain.com\"), domain wildcards (\"*@domain.com\"), or \"*\". Also accepts a comma/space-separated string. Falls back to EMAIL_ALLOWED_SENDERS. When empty, senderPolicy decides.',\n    },\n    senderPolicy: {\n      type: \"string\",\n      enum: [\"allowlist\", \"unrestricted\"],\n      description:\n        'How the sender is restricted when allowedSenders is empty (EMAIL_SENDER_POLICY). \"allowlist\" (default) narrows sends to the configured sender source; \"unrestricted\" accepts any From.',\n    },\n    brand: {\n      type: \"object\",\n      description:\n        \"Brand styling inlined into every rendered message. Omit for the neutral default layout.\",\n      properties: {\n        accent: {\n          type: \"string\",\n          description: 'Header-band background and body link color (e.g. \"#FF3621\").',\n        },\n        onAccent: {\n          type: \"string\",\n          description: \"Text and logo color rendered on the accent band. Defaults to white.\",\n        },\n        fontFamily: {\n          type: \"string\",\n          description: 'Body font stack (e.g. \"Inter, ui-sans-serif, system-ui, sans-serif\").',\n        },\n        name: {\n          type: \"string\",\n          description: \"Product / display name used as the header text and the logo alt text.\",\n        },\n        logoUrl: {\n          type: \"string\",\n          description:\n            \"Logo image for the header band. Only an http(s): or data: URL renders; other values are dropped because a mail client cannot load them.\",\n        },\n      },\n      required: [\"accent\", \"fontFamily\"],\n    },\n  },\n};\n\n/** Parse the `SMTP_SECURE` env / config flag, defaulting by port. */\nfunction resolveSecure(flag: boolean | undefined, port: number): boolean {\n  if (typeof flag === \"boolean\") return flag;\n  return object.toBoolean(process.env.SMTP_SECURE) ?? port === IMPLICIT_TLS_SMTP_PORT;\n}\n\n/** Parse the `EMAIL_SENDER_POLICY` env / config value, defaulting to deny-by-default. */\nfunction resolveSenderPolicy(policy: SenderPolicy | undefined): SenderPolicy {\n  const raw = policy ?? process.env.EMAIL_SENDER_POLICY?.trim().toLowerCase();\n  if (raw === \"unrestricted\") return \"unrestricted\";\n  if (raw === undefined || raw === \"\" || raw === \"allowlist\") return \"allowlist\";\n  throw ValidationError.invalidValue(\"senderPolicy\", raw, '\"allowlist\" or \"unrestricted\"');\n}\n\n/**\n * Effective allow-list for an `\"allowlist\"` policy with no explicit patterns:\n * the sender source itself, so a configured domain or fixed address is the\n * boundary rather than \"anything goes\". Yields nothing when neither is set,\n * which only happens in outbox mode (where the sender falls back to the\n * on-behalf-of user's own address and cannot be enumerated up front).\n */\nfunction impliedSenderPatterns(domain: string | undefined, from: string | undefined): string[] {\n  const patterns: string[] = [];\n  if (from) patterns.push(from.trim().toLowerCase());\n  if (domain) patterns.push(`*@${domain.trim().toLowerCase()}`);\n  return patterns;\n}\n\n/** Whether `EMAIL_OUTBOX_MODE` explicitly opts into the file/outbox fallback. */\nfunction isOutboxModeEnabled(): boolean {\n  return object.toBoolean(process.env.EMAIL_OUTBOX_MODE) ?? false;\n}\n\nconst SMTP_REQUIRED_FIELDS = [\"SMTP_HOST\", \"SMTP_USER\", \"SMTP_PASSWORD\"] as const;\n\n/** List env keys for SMTP fields that are unset in the resolved credential set. */\nfunction missingSmtpFields(\n  host: string | undefined,\n  user: string | undefined,\n  pass: string | undefined,\n): string[] {\n  const values = [host, user, pass] as const;\n  return SMTP_REQUIRED_FIELDS.filter((_, index) => !values[index]);\n}\n\n/**\n * Resolve plugin config over environment defaults.\n *\n * When SMTP host + user + password are all present, returns `mode:\n * \"smtp\"` for real delivery (and throws if no sender source - domain or\n * from - is configured, since SMTP can't derive one from nothing).\n * When all three are absent and `EMAIL_OUTBOX_MODE` is enabled, returns\n * `mode: \"file\"` so the runtime writes messages to the outbox directory\n * for local testing; in that mode a sender source is optional (the\n * outbox falls back to the OBO user's own address). Partial SMTP\n * configuration or a send with no credentials and no outbox opt-in\n * throws.\n *\n * The sender allow-list is resolved here too: under the default\n * `\"allowlist\"` policy an empty list is filled in from the sender source,\n * so a deployment that only sets `EMAIL_DOMAIN` still rejects a `From` on\n * any other domain. See {@link SenderPolicy}.\n */\nexport function resolveEmailConfig(config: EmailPluginConfig = {}): ResolvedEmailConfig {\n  const smtp = config.smtp ?? {};\n  const host = smtp.host ?? process.env.SMTP_HOST;\n  const user = smtp.user ?? process.env.SMTP_USER;\n  const pass = smtp.password ?? process.env.SMTP_PASSWORD;\n  const domain = config.domain ?? process.env.EMAIL_DOMAIN;\n  const from = config.from ?? process.env.EMAIL_FROM;\n  const senderPolicy = resolveSenderPolicy(config.senderPolicy);\n  const configuredSenders = parseAllowedSenders(\n    config.allowedSenders ?? process.env.EMAIL_ALLOWED_SENDERS,\n  );\n  const allowedSenders =\n    configuredSenders.length > 0 || senderPolicy === \"unrestricted\"\n      ? configuredSenders\n      : impliedSenderPatterns(domain, from);\n  const sender: ResolvedSender = {\n    ...(domain ? { domain } : {}),\n    ...(from ? { from } : {}),\n    allowedSenders,\n    senderPolicy,\n    ...(config.brand ? { brand: config.brand } : {}),\n  };\n\n  const hasAllSmtp = Boolean(host && user && pass);\n  const hasAnySmtp = Boolean(host || user || pass);\n\n  if (hasAnySmtp && !hasAllSmtp) {\n    throw ValidationError.missingEnvVars(missingSmtpFields(host, user, pass));\n  }\n\n  if (hasAllSmtp) {\n    if (!domain && !from) {\n      throw ConfigurationError.resourceNotFound(\n        \"Email sender source\",\n        \"Set EMAIL_DOMAIN to derive <user-local-part>@<domain>, or EMAIL_FROM for a fixed address.\",\n      );\n    }\n    const portRaw = smtp.port ?? Number(process.env.SMTP_PORT);\n    const port = Number.isFinite(portRaw) && portRaw ? Number(portRaw) : DEFAULT_SMTP_PORT;\n    return {\n      mode: \"smtp\",\n      host: host!,\n      port,\n      secure: resolveSecure(smtp.secure, port),\n      auth: { user: user!, pass: pass! },\n      ...sender,\n    };\n  }\n\n  if (!isOutboxModeEnabled()) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      `Set ${SMTP_REQUIRED_FIELDS.join(\", \")}, or EMAIL_OUTBOX_MODE=1 to write messages to a local outbox instead.`,\n    );\n  }\n\n  const outDir = resolve(\n    config.outDir ?? process.env.EMAIL_OUTBOX_DIR ?? resolve(process.cwd(), \"tmp\"),\n  );\n  return { mode: \"file\", outDir, ...sender };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SMTP configuration for the email plugin: the typed\n * {@link EmailPluginConfig} (the plugin's slice of AppKit config), the\n * JSON Schema the manifest publishes for it, and {@link resolveEmailConfig}\n * which layers that config over environment defaults into the concrete\n * {@link ResolvedEmailConfig} the runtime needs.\n *\n * Two modes fall out of the resolution. When SMTP credentials (host +\n * user + password) are all present it resolves to `mode: \"smtp\"` and\n * mail is sent for real. When they are absent and `EMAIL_OUTBOX_MODE`\n * is explicitly enabled it resolves to `mode: \"file\"` (an \"outbox\")\n * and each message is written to disk as HTML instead of sent. Any\n * partial SMTP configuration or a send attempt with no credentials and\n * no outbox opt-in throws.\n *\n * Precedence per field: explicit plugin config wins, then the matching\n * environment variable. Env names are unprefixed because the app talks\n * to a single SMTP server (e.g. SMTP2GO): `SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, plus `EMAIL_DOMAIN` for\n * the derived sender's domain, `EMAIL_FROM` for an explicit override,\n * `EMAIL_SENDER_POLICY` for the sender restriction mode, and\n * `EMAIL_OUTBOX_DIR` for the outbox directory.\n *\n * @module\n */\nimport { resolve } from \"node:path\";\nimport { ConfigurationError, ValidationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { object, string } from \"@dbx-tools/shared-core\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport type { EmailBrand } from \"./brand.ts\";\nimport { parseAllowedSenders } from \"./sender.ts\";\n\n/** SMTP submission port used when none is configured. */\nexport const DEFAULT_SMTP_PORT = 587;\n\n/** SMTP port that implies a TLS-on-connect socket rather than STARTTLS. */\nexport const IMPLICIT_TLS_SMTP_PORT = 465;\n\n/**\n * How the sender (`From`) address is restricted.\n *\n * `\"allowlist\"` is the default and the deny-by-default posture: a send is\n * permitted only from an address the configuration names, either through\n * {@link EmailPluginConfig.allowedSenders} or, when that is empty, through\n * the configured sender source ({@link EmailPluginConfig.from} as an exact\n * address, {@link EmailPluginConfig.domain} as a `*@domain` wildcard).\n *\n * `\"unrestricted\"` is the explicit opt-out: any `From` a caller supplies is\n * accepted. Only reach for it when an upstream system already vets the\n * sender.\n */\nexport type SenderPolicy = \"allowlist\" | \"unrestricted\";\n\n/** SMTP connection + credentials. All fields fall back to env when unset. */\nexport interface SmtpConfig {\n  /** SMTP server hostname (`SMTP_HOST`). */\n  host?: string;\n  /** SMTP server port (`SMTP_PORT`). Defaults to {@link DEFAULT_SMTP_PORT}. */\n  port?: number;\n  /**\n   * Use a TLS-on-connect socket (`SMTP_SECURE`). Defaults to\n   * `port === ` {@link IMPLICIT_TLS_SMTP_PORT}.\n   */\n  secure?: boolean;\n  /** SMTP auth username (`SMTP_USER`). */\n  user?: string;\n  /** SMTP auth password / API key (`SMTP_PASSWORD`). */\n  password?: string;\n}\n\n/** AppKit config accepted by the email plugin. */\nexport interface EmailPluginConfig extends BasePluginConfig {\n  /** SMTP connection + credentials. Omit to run in file/outbox mode. */\n  smtp?: SmtpConfig;\n  /**\n   * Domain used to build the sender address from the on-behalf-of user\n   * (`<local-part>@<domain>`). Falls back to `EMAIL_DOMAIN`. Required in\n   * SMTP mode unless {@link from} is set; optional in file mode (the\n   * outbox falls back to the user's own email address).\n   */\n  domain?: string;\n  /**\n   * Explicit `From` address. When set, the sender is used verbatim and\n   * the per-user derivation is skipped. Falls back to `EMAIL_FROM`.\n   */\n  from?: string;\n  /**\n   * Directory for the file/outbox fallback. Falls back to\n   * `EMAIL_OUTBOX_DIR`, then `<cwd>/tmp`. Only used when SMTP\n   * credentials are absent.\n   */\n  outDir?: string;\n  /**\n   * Allow-list restricting the sender (`From`) address. Each entry is an\n   * exact address (`user@domain.com`), a domain wildcard (`*@domain.com`\n   * or the bare `domain.com`, matching any local part on that domain), or\n   * `*` (any). A resolved / chosen sender that matches no entry is\n   * rejected at send time. Accepts a `string[]` or a single comma- /\n   * whitespace-separated string; falls back to `EMAIL_ALLOWED_SENDERS`.\n   * When empty, the {@link senderPolicy} decides what is permitted.\n   */\n  allowedSenders?: string | string[];\n  /**\n   * How the sender address is restricted when {@link allowedSenders} is\n   * empty (`EMAIL_SENDER_POLICY`). Defaults to `\"allowlist\"`, which\n   * narrows sends to the configured sender source. See\n   * {@link SenderPolicy}.\n   */\n  senderPolicy?: SenderPolicy;\n  /**\n   * Optional brand styling (accent, font, header logo) applied to the\n   * rendered HTML of every message. Omit for the neutral default layout.\n   * Pass {@link emailBrandFromContext} to derive it from a shared\n   * `BrandContext`.\n   */\n  brand?: EmailBrand;\n  /**\n   * Optional email-OTP ACCESS GATE. When `enabled`, the plugin mounts a login\n   * flow (`/api/email/auth/*`) and gates every other route behind a session\n   * cookie - the front door for an app exposed publicly (e.g. through a portr\n   * tunnel that bypasses the Databricks OAuth proxy). Reuses this plugin's\n   * transport to email the code. Omit or `enabled: false` to leave the app open.\n   */\n  auth?: AuthConfig;\n}\n\n/** Email-OTP access-gate configuration (see {@link EmailPluginConfig.auth}). */\nexport interface AuthConfig {\n  /** Turn the gate on. Falls back to `EMAIL_AUTH_ENABLED`. Default off. */\n  enabled?: boolean;\n  /**\n   * Who may request a code. Each entry is a domain shortcut (`databricks.com`\n   * or `@databricks.com`), a glob (`*.databricks.com`), or a `/regex/`. An\n   * EMPTY list allows nobody (fail closed). Falls back to `EMAIL_AUTH_ALLOW`\n   * (comma/space-separated).\n   */\n  allow?: string | string[];\n  /** Session lifetime (seconds). Falls back to `EMAIL_AUTH_SESSION_TTL`. Default 43200 (12h). */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Falls back to `EMAIL_AUTH_CODE_TTL`. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n}\n\n/** Config shared by both resolved modes. */\ninterface ResolvedSender {\n  /** Sender domain; present whenever {@link from} is absent. */\n  domain?: string;\n  /** Explicit sender override; present skips per-user derivation. */\n  from?: string;\n  /**\n   * Effective sender allow-list: the configured patterns when any were\n   * given, else the patterns implied by the sender source under an\n   * `\"allowlist\"` policy. Empty means unenforceable (an `\"unrestricted\"`\n   * policy, or an outbox with no sender source to narrow to).\n   */\n  allowedSenders: string[];\n  /** The restriction mode the allow-list was resolved under. */\n  senderPolicy: SenderPolicy;\n  /** Brand styling applied to rendered HTML; absent for the default layout. */\n  brand?: EmailBrand;\n}\n\n/** Resolved config for real SMTP delivery. */\nexport interface ResolvedSmtpConfig extends ResolvedSender {\n  mode: \"smtp\";\n  host: string;\n  port: number;\n  secure: boolean;\n  auth: { user: string; pass: string };\n}\n\n/** Resolved config for the file/outbox fallback (no SMTP credentials). */\nexport interface ResolvedFileConfig extends ResolvedSender {\n  mode: \"file\";\n  /** Absolute directory messages are written under. */\n  outDir: string;\n}\n\n/** Concrete, validated config the runtime dispatches through. */\nexport type ResolvedEmailConfig = ResolvedSmtpConfig | ResolvedFileConfig;\n\n/** JSON Schema published on the manifest's `config.schema`. */\nexport const EMAIL_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  properties: {\n    smtp: {\n      type: \"object\",\n      description: \"SMTP connection and credentials (env fallbacks: SMTP_*).\",\n      properties: {\n        host: { type: \"string\", description: \"SMTP server hostname (SMTP_HOST).\" },\n        port: {\n          type: \"number\",\n          description: `SMTP server port (SMTP_PORT). Defaults to ${DEFAULT_SMTP_PORT}.`,\n        },\n        secure: {\n          type: \"boolean\",\n          description: `TLS-on-connect socket (SMTP_SECURE). Defaults to port === ${IMPLICIT_TLS_SMTP_PORT}.`,\n        },\n        user: { type: \"string\", description: \"SMTP auth username (SMTP_USER).\" },\n        password: {\n          type: \"string\",\n          description: \"SMTP auth password / API key (SMTP_PASSWORD).\",\n        },\n      },\n    },\n    domain: {\n      type: \"string\",\n      description:\n        \"Domain for the derived sender address (<user-local-part>@<domain>). Falls back to EMAIL_DOMAIN.\",\n    },\n    from: {\n      type: \"string\",\n      description: \"Explicit From address; skips per-user derivation. Falls back to EMAIL_FROM.\",\n    },\n    outDir: {\n      type: \"string\",\n      description:\n        \"Directory for the file/outbox fallback when SMTP is unconfigured. Falls back to EMAIL_OUTBOX_DIR, then <cwd>/tmp.\",\n    },\n    allowedSenders: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description:\n        'Allow-list of permitted sender (From) patterns: exact addresses (\"user@domain.com\"), domain wildcards (\"*@domain.com\"), or \"*\". Also accepts a comma/space-separated string. Falls back to EMAIL_ALLOWED_SENDERS. When empty, senderPolicy decides.',\n    },\n    senderPolicy: {\n      type: \"string\",\n      enum: [\"allowlist\", \"unrestricted\"],\n      description:\n        'How the sender is restricted when allowedSenders is empty (EMAIL_SENDER_POLICY). \"allowlist\" (default) narrows sends to the configured sender source; \"unrestricted\" accepts any From.',\n    },\n    brand: {\n      type: \"object\",\n      description:\n        \"Brand styling inlined into every rendered message. Omit for the neutral default layout.\",\n      properties: {\n        accent: {\n          type: \"string\",\n          description: 'Header-band background and body link color (e.g. \"#FF3621\").',\n        },\n        onAccent: {\n          type: \"string\",\n          description: \"Text and logo color rendered on the accent band. Defaults to white.\",\n        },\n        fontFamily: {\n          type: \"string\",\n          description: 'Body font stack (e.g. \"Inter, ui-sans-serif, system-ui, sans-serif\").',\n        },\n        name: {\n          type: \"string\",\n          description: \"Product / display name used as the header text and the logo alt text.\",\n        },\n        logoUrl: {\n          type: \"string\",\n          description:\n            \"Logo image for the header band. Only an http(s): or data: URL renders; other values are dropped because a mail client cannot load them.\",\n        },\n      },\n      required: [\"accent\", \"fontFamily\"],\n    },\n    auth: {\n      type: \"object\",\n      description:\n        \"Email-OTP access gate. When enabled, mounts a login flow at /api/email/auth/* and gates every other route behind a session cookie.\",\n      properties: {\n        enabled: {\n          type: \"boolean\",\n          description: \"Turn the gate on (env EMAIL_AUTH_ENABLED). Default off.\",\n        },\n        allow: {\n          type: \"array\",\n          items: { type: \"string\" },\n          description:\n            'Allow-list of who may request a code: domain shortcut (\"databricks.com\"), glob (\"*.databricks.com\"), or \"/regex/\". Empty = nobody. Also accepts a comma/space-separated string. Env EMAIL_AUTH_ALLOW.',\n        },\n        sessionTtlSeconds: {\n          type: \"number\",\n          description: \"Session lifetime in seconds (env EMAIL_AUTH_SESSION_TTL). Default 43200.\",\n        },\n        codeTtlSeconds: {\n          type: \"number\",\n          description: \"One-time-code lifetime in seconds (env EMAIL_AUTH_CODE_TTL). Default 600.\",\n        },\n        maxAttempts: {\n          type: \"number\",\n          description: \"Max verify attempts per issued code. Default 5.\",\n        },\n      },\n    },\n  },\n};\n\n/** Resolved email-OTP gate config, with env fallbacks applied (or `undefined` when off). */\nexport interface ResolvedAuthConfig {\n  readonly allow: string[];\n  readonly sessionTtlSeconds: number;\n  readonly codeTtlSeconds: number;\n  readonly maxAttempts: number;\n}\n\n/**\n * Resolve {@link AuthConfig} against env, returning `undefined` when the gate is\n * off. `enabled` gates everything; `allow` merges the config list + env\n * (`parseList` handles a `string[]` or a delimited string). Empty `allow` is\n * allowed here (the gate then denies everyone - a deliberate fail-closed state).\n */\nexport function resolveAuthConfig(auth: AuthConfig | undefined): ResolvedAuthConfig | undefined {\n  const enabled = auth?.enabled ?? object.toBoolean(process.env.EMAIL_AUTH_ENABLED) ?? false;\n  if (!enabled) return undefined;\n  const allow = [\n    ...string.parseList(auth?.allow),\n    ...string.parseList(process.env.EMAIL_AUTH_ALLOW),\n  ];\n  const num = (value: number | undefined, env: string | undefined, fallback: number): number => {\n    const raw = value ?? (env ? Number(env) : undefined);\n    return typeof raw === \"number\" && Number.isFinite(raw) && raw > 0 ? raw : fallback;\n  };\n  return {\n    allow,\n    sessionTtlSeconds: num(auth?.sessionTtlSeconds, process.env.EMAIL_AUTH_SESSION_TTL, 43200),\n    codeTtlSeconds: num(auth?.codeTtlSeconds, process.env.EMAIL_AUTH_CODE_TTL, 600),\n    maxAttempts: auth?.maxAttempts ?? 5,\n  };\n}\n\n/** Parse the `SMTP_SECURE` env / config flag, defaulting by port. */\nfunction resolveSecure(flag: boolean | undefined, port: number): boolean {\n  if (typeof flag === \"boolean\") return flag;\n  return object.toBoolean(process.env.SMTP_SECURE) ?? port === IMPLICIT_TLS_SMTP_PORT;\n}\n\n/** Parse the `EMAIL_SENDER_POLICY` env / config value, defaulting to deny-by-default. */\nfunction resolveSenderPolicy(policy: SenderPolicy | undefined): SenderPolicy {\n  const raw = policy ?? process.env.EMAIL_SENDER_POLICY?.trim().toLowerCase();\n  if (raw === \"unrestricted\") return \"unrestricted\";\n  if (raw === undefined || raw === \"\" || raw === \"allowlist\") return \"allowlist\";\n  throw ValidationError.invalidValue(\"senderPolicy\", raw, '\"allowlist\" or \"unrestricted\"');\n}\n\n/**\n * Effective allow-list for an `\"allowlist\"` policy with no explicit patterns:\n * the sender source itself, so a configured domain or fixed address is the\n * boundary rather than \"anything goes\". Yields nothing when neither is set,\n * which only happens in outbox mode (where the sender falls back to the\n * on-behalf-of user's own address and cannot be enumerated up front).\n */\nfunction impliedSenderPatterns(domain: string | undefined, from: string | undefined): string[] {\n  const patterns: string[] = [];\n  if (from) patterns.push(from.trim().toLowerCase());\n  if (domain) patterns.push(`*@${domain.trim().toLowerCase()}`);\n  return patterns;\n}\n\n/** Whether `EMAIL_OUTBOX_MODE` explicitly opts into the file/outbox fallback. */\nfunction isOutboxModeEnabled(): boolean {\n  return object.toBoolean(process.env.EMAIL_OUTBOX_MODE) ?? false;\n}\n\nconst SMTP_REQUIRED_FIELDS = [\"SMTP_HOST\", \"SMTP_USER\", \"SMTP_PASSWORD\"] as const;\n\n/** List env keys for SMTP fields that are unset in the resolved credential set. */\nfunction missingSmtpFields(\n  host: string | undefined,\n  user: string | undefined,\n  pass: string | undefined,\n): string[] {\n  const values = [host, user, pass] as const;\n  return SMTP_REQUIRED_FIELDS.filter((_, index) => !values[index]);\n}\n\n/**\n * Resolve plugin config over environment defaults.\n *\n * When SMTP host + user + password are all present, returns `mode:\n * \"smtp\"` for real delivery (and throws if no sender source - domain or\n * from - is configured, since SMTP can't derive one from nothing).\n * When all three are absent and `EMAIL_OUTBOX_MODE` is enabled, returns\n * `mode: \"file\"` so the runtime writes messages to the outbox directory\n * for local testing; in that mode a sender source is optional (the\n * outbox falls back to the OBO user's own address). Partial SMTP\n * configuration or a send with no credentials and no outbox opt-in\n * throws.\n *\n * The sender allow-list is resolved here too: under the default\n * `\"allowlist\"` policy an empty list is filled in from the sender source,\n * so a deployment that only sets `EMAIL_DOMAIN` still rejects a `From` on\n * any other domain. See {@link SenderPolicy}.\n */\nexport function resolveEmailConfig(config: EmailPluginConfig = {}): ResolvedEmailConfig {\n  const smtp = config.smtp ?? {};\n  const host = smtp.host ?? process.env.SMTP_HOST;\n  const user = smtp.user ?? process.env.SMTP_USER;\n  const pass = smtp.password ?? process.env.SMTP_PASSWORD;\n  const domain = config.domain ?? process.env.EMAIL_DOMAIN;\n  const from = config.from ?? process.env.EMAIL_FROM;\n  const senderPolicy = resolveSenderPolicy(config.senderPolicy);\n  const configuredSenders = parseAllowedSenders(\n    config.allowedSenders ?? process.env.EMAIL_ALLOWED_SENDERS,\n  );\n  const allowedSenders =\n    configuredSenders.length > 0 || senderPolicy === \"unrestricted\"\n      ? configuredSenders\n      : impliedSenderPatterns(domain, from);\n  const sender: ResolvedSender = {\n    ...(domain ? { domain } : {}),\n    ...(from ? { from } : {}),\n    allowedSenders,\n    senderPolicy,\n    ...(config.brand ? { brand: config.brand } : {}),\n  };\n\n  const hasAllSmtp = Boolean(host && user && pass);\n  const hasAnySmtp = Boolean(host || user || pass);\n\n  if (hasAnySmtp && !hasAllSmtp) {\n    throw ValidationError.missingEnvVars(missingSmtpFields(host, user, pass));\n  }\n\n  if (hasAllSmtp) {\n    if (!domain && !from) {\n      throw ConfigurationError.resourceNotFound(\n        \"Email sender source\",\n        \"Set EMAIL_DOMAIN to derive <user-local-part>@<domain>, or EMAIL_FROM for a fixed address.\",\n      );\n    }\n    const portRaw = smtp.port ?? Number(process.env.SMTP_PORT);\n    const port = Number.isFinite(portRaw) && portRaw ? Number(portRaw) : DEFAULT_SMTP_PORT;\n    return {\n      mode: \"smtp\",\n      host: host!,\n      port,\n      secure: resolveSecure(smtp.secure, port),\n      auth: { user: user!, pass: pass! },\n      ...sender,\n    };\n  }\n\n  if (!isOutboxModeEnabled()) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      `Set ${SMTP_REQUIRED_FIELDS.join(\", \")}, or EMAIL_OUTBOX_MODE=1 to write messages to a local outbox instead.`,\n    );\n  }\n\n  const outDir = resolve(\n    config.outDir ?? process.env.EMAIL_OUTBOX_DIR ?? resolve(process.cwd(), \"tmp\"),\n  );\n  return { mode: \"file\", outDir, ...sender };\n}\n"]}

package/lib/src/plugin.d.ts

@@ -47,6 +47,8 @@ import { type EmailPluginConfig } from "./config.ts";
  * ```
  */
 export declare class EmailPlugin extends Plugin<EmailPluginConfig> implements ToolProvider {
+    /** The email-OTP access gate, constructed in {@link setup} when `auth.enabled`. */
+    private authGate?;
     static manifest: {
         name: "email";
         displayName: string;
@@ -101,6 +103,15 @@ export declare class EmailPlugin extends Plugin<EmailPluginConfig> implements To
      * local part.
      */
     injectRoutes(router: IAppRouter): void;
+    /**
+     * Mount the email-OTP login flow under `/api/email/auth/*` when the gate is
+     * enabled. These routes are the ONLY ones the gate middleware leaves open (see
+     * {@link AuthGate.middleware}); everything else requires the session cookie
+     * they establish. No-op when auth is off.
+     */
+    private injectAuthRoutes;
+    /** Client IP for rate-limiting, honoring the Apps ingress `x-forwarded-for`. */
+    private clientIp;
     exports(): {
         /**
          * Send a message immediately from `from` through the shared
@@ -129,6 +140,18 @@ export declare class EmailPlugin extends Plugin<EmailPluginConfig> implements To
      * not wrap it again.
      */
     private send;
+    /**
+     * Build the email-OTP access gate when `auth.enabled`, wiring its code
+     * delivery through this plugin's own transport. Called from {@link setup}; a
+     * no-op (leaves {@link authGate} undefined) when the gate is off.
+     */
+    private setupAuthGate;
+    /**
+     * Deliver a one-time code to `email` through this plugin's transport. Throws
+     * on failure (the gate swallows it, so a delivery error never leaks whether
+     * the address was allow-listed).
+     */
+    private sendOtpEmail;
     /** Run the sender-options lookup through the plugin's interceptor chain. */
     private executeListSenders;
     /**