@dbx-tools/email 0.6.41 → 0.6.42

package/index.ts

@@ -2,6 +2,10 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 
+export * as authAllowlist from "./src/auth/allowlist.ts";
+export * as authGate from "./src/auth/gate.ts";
+export * as authOtp from "./src/auth/otp.ts";
+export * as authRateLimit from "./src/auth/rate-limit.ts";
 export * as brand from "./src/brand.ts";
 export * as config from "./src/config.ts";
 export * as defaults from "./src/defaults.ts";
@@ -12,10 +16,15 @@ export * as plugin from "./src/plugin.ts";
 export * as sender from "./src/sender.ts";
 export * as tool from "./src/tool.ts";
 export * as transport from "./src/transport.ts";
+export { SESSION_COOKIE, AuthGate } from "./src/auth/gate.ts";
+export type { AuthGateOptions } from "./src/auth/gate.ts";
+export { CodeStore } from "./src/auth/otp.ts";
+export type { VerifyOutcome } from "./src/auth/otp.ts";
+export { RateLimiter } from "./src/auth/rate-limit.ts";
 export { defaultEmailBrand } from "./src/brand.ts";
 export type { EmailBrand } from "./src/brand.ts";
 export { DEFAULT_SMTP_PORT, IMPLICIT_TLS_SMTP_PORT, EMAIL_CONFIG_SCHEMA } from "./src/config.ts";
-export type { SenderPolicy, SmtpConfig, EmailPluginConfig, ResolvedSmtpConfig, ResolvedFileConfig, ResolvedEmailConfig } from "./src/config.ts";
+export type { SenderPolicy, SmtpConfig, EmailPluginConfig, AuthConfig, ResolvedSmtpConfig, ResolvedFileConfig, ResolvedEmailConfig, ResolvedAuthConfig } from "./src/config.ts";
 export { SEND_TIMEOUT_MS, VERIFY_TIMEOUT_MS, VERIFY_ATTEMPTS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_COUNT, MAX_BODY_CHARS, EMAIL_SEND_SETTINGS, EMAIL_VERIFY_SETTINGS, EMAIL_SENDERS_SETTINGS } from "./src/defaults.ts";
 export type { EmailExecuteConfig, EmailExecutionSettings } from "./src/defaults.ts";
 export { escapeHtml } from "./src/email-html.ts";

package/lib/index.d.ts

@@ -1,3 +1,7 @@
+export * as authAllowlist from "./src/auth/allowlist.ts";
+export * as authGate from "./src/auth/gate.ts";
+export * as authOtp from "./src/auth/otp.ts";
+export * as authRateLimit from "./src/auth/rate-limit.ts";
 export * as brand from "./src/brand.ts";
 export * as config from "./src/config.ts";
 export * as defaults from "./src/defaults.ts";
@@ -8,10 +12,15 @@ export * as plugin from "./src/plugin.ts";
 export * as sender from "./src/sender.ts";
 export * as tool from "./src/tool.ts";
 export * as transport from "./src/transport.ts";
+export { SESSION_COOKIE, AuthGate } from "./src/auth/gate.ts";
+export type { AuthGateOptions } from "./src/auth/gate.ts";
+export { CodeStore } from "./src/auth/otp.ts";
+export type { VerifyOutcome } from "./src/auth/otp.ts";
+export { RateLimiter } from "./src/auth/rate-limit.ts";
 export { defaultEmailBrand } from "./src/brand.ts";
 export type { EmailBrand } from "./src/brand.ts";
 export { DEFAULT_SMTP_PORT, IMPLICIT_TLS_SMTP_PORT, EMAIL_CONFIG_SCHEMA } from "./src/config.ts";
-export type { SenderPolicy, SmtpConfig, EmailPluginConfig, ResolvedSmtpConfig, ResolvedFileConfig, ResolvedEmailConfig } from "./src/config.ts";
+export type { SenderPolicy, SmtpConfig, EmailPluginConfig, AuthConfig, ResolvedSmtpConfig, ResolvedFileConfig, ResolvedEmailConfig, ResolvedAuthConfig } from "./src/config.ts";
 export { SEND_TIMEOUT_MS, VERIFY_TIMEOUT_MS, VERIFY_ATTEMPTS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_COUNT, MAX_BODY_CHARS, EMAIL_SEND_SETTINGS, EMAIL_VERIFY_SETTINGS, EMAIL_SENDERS_SETTINGS } from "./src/defaults.ts";
 export type { EmailExecuteConfig, EmailExecutionSettings } from "./src/defaults.ts";
 export { escapeHtml } from "./src/email-html.ts";

package/lib/index.js

@@ -1,6 +1,10 @@
 // GENERATED by projen watch - DO NOT EDIT.
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
+export * as authAllowlist from "./src/auth/allowlist.js";
+export * as authGate from "./src/auth/gate.js";
+export * as authOtp from "./src/auth/otp.js";
+export * as authRateLimit from "./src/auth/rate-limit.js";
 export * as brand from "./src/brand.js";
 export * as config from "./src/config.js";
 export * as defaults from "./src/defaults.js";
@@ -11,10 +15,13 @@ export * as plugin from "./src/plugin.js";
 export * as sender from "./src/sender.js";
 export * as tool from "./src/tool.js";
 export * as transport from "./src/transport.js";
+export { SESSION_COOKIE, AuthGate } from "./src/auth/gate.js";
+export { CodeStore } from "./src/auth/otp.js";
+export { RateLimiter } from "./src/auth/rate-limit.js";
 export { defaultEmailBrand } from "./src/brand.js";
 export { DEFAULT_SMTP_PORT, IMPLICIT_TLS_SMTP_PORT, EMAIL_CONFIG_SCHEMA } from "./src/config.js";
 export { SEND_TIMEOUT_MS, VERIFY_TIMEOUT_MS, VERIFY_ATTEMPTS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_COUNT, MAX_BODY_CHARS, EMAIL_SEND_SETTINGS, EMAIL_VERIFY_SETTINGS, EMAIL_SENDERS_SETTINGS } from "./src/defaults.js";
 export { escapeHtml } from "./src/email-html.js";
 export { EmailPlugin, email } from "./src/plugin.js";
 export { SEND_EMAIL_DESCRIPTION } from "./src/tool.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/auth/allowlist.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Unified access allow-list matching for the email-OTP gate.
+ *
+ * Each pattern in the configured list is one of three shapes, tried in order:
+ *
+ *   - **domain shortcut** - `databricks.com` or `@databricks.com`: matches any
+ *     address whose domain equals it (case-insensitive). The leading `@` is
+ *     optional and stripped.
+ *   - **glob** - contains `*` or `?`, e.g. `*.databricks.com` or
+ *     `*@databricks.com`: matched against the WHOLE address with shell-style
+ *     wildcards (`*` = any run, `?` = one char).
+ *   - **regex** - wrapped in slashes, `/.../ [flags]`: compiled and tested
+ *     against the whole address. An invalid regex never matches (it is skipped
+ *     with a warning rather than throwing).
+ *
+ * An EMPTY list matches nobody (fail closed): an app that enables the gate but
+ * configures no patterns lets no one in, which is the safe default.
+ *
+ * @module
+ */
+/**
+ * True when `email` is allowed by ANY pattern in `patterns`. An empty (or
+ * missing) list allows nobody - the gate fails closed.
+ */
+export declare function matchesAllowlist(email: string, patterns: readonly string[] | undefined): boolean;
+/** Rough shape check so a clearly-invalid address is rejected before any work. */
+export declare function looksLikeEmail(value: string): boolean;

package/lib/src/auth/allowlist.js

@@ -0,0 +1,82 @@
+/**
+ * Unified access allow-list matching for the email-OTP gate.
+ *
+ * Each pattern in the configured list is one of three shapes, tried in order:
+ *
+ *   - **domain shortcut** - `databricks.com` or `@databricks.com`: matches any
+ *     address whose domain equals it (case-insensitive). The leading `@` is
+ *     optional and stripped.
+ *   - **glob** - contains `*` or `?`, e.g. `*.databricks.com` or
+ *     `*@databricks.com`: matched against the WHOLE address with shell-style
+ *     wildcards (`*` = any run, `?` = one char).
+ *   - **regex** - wrapped in slashes, `/.../ [flags]`: compiled and tested
+ *     against the whole address. An invalid regex never matches (it is skipped
+ *     with a warning rather than throwing).
+ *
+ * An EMPTY list matches nobody (fail closed): an app that enables the gate but
+ * configures no patterns lets no one in, which is the safe default.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("email:auth:allowlist");
+/** Escape a string for literal use inside a `RegExp`. */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Compile a shell-style glob (`*`, `?`) into an anchored, case-insensitive RegExp. */
+function globToRegExp(glob) {
+    const body = glob
+        .split(/([*?])/)
+        .map((part) => (part === "*" ? ".*" : part === "?" ? "." : escapeRegExp(part)))
+        .join("");
+    return new RegExp(`^${body}$`, "i");
+}
+/** Parse a `/pattern/flags` string into a RegExp, or `undefined` if malformed. */
+function parseRegexLiteral(pattern) {
+    const match = /^\/(.+)\/([a-z]*)$/is.exec(pattern);
+    if (!match)
+        return undefined;
+    try {
+        const flags = match[2].includes("i") ? match[2] : `${match[2]}i`;
+        return new RegExp(match[1], flags);
+    }
+    catch (error) {
+        logger.warn("ignoring invalid regex allow-list pattern", { pattern, error });
+        return undefined;
+    }
+}
+/** True when `email` matches a single allow-list `pattern`. */
+function matchesPattern(email, pattern) {
+    const trimmed = pattern.trim();
+    if (!trimmed)
+        return false;
+    const address = email.trim().toLowerCase();
+    // Regex literal: /.../
+    if (trimmed.startsWith("/")) {
+        const re = parseRegexLiteral(trimmed);
+        return re ? re.test(address) : false;
+    }
+    // Glob: contains a wildcard.
+    if (trimmed.includes("*") || trimmed.includes("?")) {
+        return globToRegExp(trimmed).test(address);
+    }
+    // Domain shortcut: `@d.com` or `d.com` -> match the address's domain.
+    const domain = trimmed.replace(/^@/, "").toLowerCase();
+    const at = address.lastIndexOf("@");
+    return at >= 0 && address.slice(at + 1) === domain;
+}
+/**
+ * True when `email` is allowed by ANY pattern in `patterns`. An empty (or
+ * missing) list allows nobody - the gate fails closed.
+ */
+export function matchesAllowlist(email, patterns) {
+    if (!email || !patterns || patterns.length === 0)
+        return false;
+    return patterns.some((pattern) => matchesPattern(email, pattern));
+}
+/** Rough shape check so a clearly-invalid address is rejected before any work. */
+export function looksLikeEmail(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/auth/gate.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The email-OTP access gate: runtime + Express middleware + request handlers.
+ *
+ * {@link AuthGate} owns the allow-list, rate limiters, code store, and session
+ * signing. The plugin wires four routes to it (`request`/`verify`/`logout`/
+ * `status`) and mounts {@link AuthGate.middleware} so every OTHER request needs a
+ * valid session cookie.
+ *
+ * Design points:
+ *   - `request` ALWAYS resolves `{ ok: true }` (anti-enumeration): a code is only
+ *     generated + emailed when the address is allow-listed AND under the rate
+ *     limit, but the caller can't tell the difference.
+ *   - the session lives in an HttpOnly + SameSite=Lax cookie (Secure in prod), so
+ *     it survives reloads and is not readable by page scripts.
+ *   - fail-open on a missing signing secret (see `otp.ts`): a Databricks App is
+ *     already access-limited; an unset `AUTH_JWT_SECRET` degrades to
+ *     non-durable sessions, not a lockout.
+ *
+ * @module
+ */
+import type { CookieOptions, NextFunction, Request, Response } from "express";
+import type { AuthStatus } from "@dbx-tools/shared-email";
+/** Cookie the session JWT rides in. */
+export declare const SESSION_COOKIE = "dbx_auth";
+/** Resolved gate configuration. */
+export interface AuthGateOptions {
+    /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. */
+    readonly allow: readonly string[];
+    /** Session lifetime in seconds. */
+    readonly sessionTtlSeconds: number;
+    /** One-time code lifetime in seconds. */
+    readonly codeTtlSeconds: number;
+    /** Max verify attempts per issued code. */
+    readonly maxAttempts: number;
+    /** Send the code email. Returns nothing; failures are logged, not surfaced. */
+    readonly sendCode: (email: string, code: string) => Promise<void>;
+    /** True in production (sets the `Secure` cookie flag). */
+    readonly secureCookies: boolean;
+}
+/** The email-OTP gate for one app. */
+export declare class AuthGate {
+    private readonly options;
+    private readonly codes;
+    private readonly requestLimiter;
+    private readonly verifyLimiter;
+    constructor(options: AuthGateOptions);
+    /**
+     * Handle `POST /auth/request`. Always resolves `{ ok: true }` (plus a
+     * `retryAfter` when rate-limited); a code is issued + emailed only for an
+     * allow-listed address under the limit. Errors in sending are swallowed so the
+     * response never reveals whether an address exists / is allowed.
+     */
+    handleRequest(email: string, ip: string): Promise<{
+        ok: true;
+        retryAfter?: number;
+    }>;
+    /**
+     * Handle `POST /auth/verify`. On a correct code, returns the session `token`
+     * plus the `cookieOptions` for it so the route sets it with Express's own
+     * `res.cookie(SESSION_COOKIE, token, options)` (no hand-rolled Set-Cookie).
+     * Failures return `{ ok: false }` with a generic reason.
+     */
+    handleVerify(email: string, code: string, ip: string, secure: boolean): Promise<{
+        ok: boolean;
+        token?: string;
+        cookieOptions?: CookieOptions;
+        retryAfter?: number;
+    }>;
+    /** Express cookie options for the session (used with `res.cookie`/`res.clearCookie`). */
+    cookieOptions(secure: boolean): CookieOptions;
+    /** Resolve the authenticated email for a request, or `undefined`. */
+    authenticate(req: Request): Promise<string | undefined>;
+    /** The `GET /auth/status` payload for a request. */
+    status(req: Request): Promise<AuthStatus>;
+    /**
+     * Express middleware gating requests on the APP router (mounted at the app
+     * root). Requests to the login flow (`<emailBase>/auth/*`) pass through so a
+     * caller can authenticate; the app's own API/asset requests need a valid
+     * session or get a 401. `emailBase` is the plugin's mount path (e.g.
+     * `/api/email`) so the open prefix is matched against the full request path.
+     */
+    middleware(emailBase: string): (req: Request, res: Response, next: NextFunction) => void;
+}

package/lib/src/auth/gate.js

@@ -0,0 +1,134 @@
+/**
+ * The email-OTP access gate: runtime + Express middleware + request handlers.
+ *
+ * {@link AuthGate} owns the allow-list, rate limiters, code store, and session
+ * signing. The plugin wires four routes to it (`request`/`verify`/`logout`/
+ * `status`) and mounts {@link AuthGate.middleware} so every OTHER request needs a
+ * valid session cookie.
+ *
+ * Design points:
+ *   - `request` ALWAYS resolves `{ ok: true }` (anti-enumeration): a code is only
+ *     generated + emailed when the address is allow-listed AND under the rate
+ *     limit, but the caller can't tell the difference.
+ *   - the session lives in an HttpOnly + SameSite=Lax cookie (Secure in prod), so
+ *     it survives reloads and is not readable by page scripts.
+ *   - fail-open on a missing signing secret (see `otp.ts`): a Databricks App is
+ *     already access-limited; an unset `AUTH_JWT_SECRET` degrades to
+ *     non-durable sessions, not a lockout.
+ *
+ * @module
+ */
+import { http, log } from "@dbx-tools/shared-core";
+import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
+import { CodeStore, signSession, verifySession } from "./otp.js";
+import { RateLimiter } from "./rate-limit.js";
+const logger = log.logger("email:auth");
+/** Cookie the session JWT rides in. */
+export const SESSION_COOKIE = "dbx_auth";
+/** Route prefix (under the plugin base `/api/email`) the gate leaves open. */
+const AUTH_PATH_PREFIX = "/auth";
+/** The email-OTP gate for one app. */
+export class AuthGate {
+    options;
+    codes;
+    // Separate limiters: requesting a code is cheap-to-abuse (email spam), verifying
+    // is a brute-force surface. Per-email AND per-IP so neither axis alone is a bypass.
+    requestLimiter = new RateLimiter(5, 15 * 60 * 1000);
+    verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);
+    constructor(options) {
+        this.options = options;
+        this.codes = new CodeStore(options.codeTtlSeconds * 1000, options.maxAttempts);
+    }
+    /**
+     * Handle `POST /auth/request`. Always resolves `{ ok: true }` (plus a
+     * `retryAfter` when rate-limited); a code is issued + emailed only for an
+     * allow-listed address under the limit. Errors in sending are swallowed so the
+     * response never reveals whether an address exists / is allowed.
+     */
+    async handleRequest(email, ip) {
+        const address = email.trim().toLowerCase();
+        const byIp = this.requestLimiter.hit(`ip:${ip}`);
+        const byEmail = this.requestLimiter.hit(`email:${address}`);
+        if (!byIp.allowed || !byEmail.allowed) {
+            return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
+        }
+        if (looksLikeEmail(address) && matchesAllowlist(address, this.options.allow)) {
+            const code = this.codes.issue(address);
+            try {
+                await this.options.sendCode(address, code);
+            }
+            catch (error) {
+                logger.warn("failed to send OTP email", { error });
+            }
+        }
+        return { ok: true };
+    }
+    /**
+     * Handle `POST /auth/verify`. On a correct code, returns the session `token`
+     * plus the `cookieOptions` for it so the route sets it with Express's own
+     * `res.cookie(SESSION_COOKIE, token, options)` (no hand-rolled Set-Cookie).
+     * Failures return `{ ok: false }` with a generic reason.
+     */
+    async handleVerify(email, code, ip, secure) {
+        const address = email.trim().toLowerCase();
+        const byIp = this.verifyLimiter.hit(`ip:${ip}`);
+        const byEmail = this.verifyLimiter.hit(`email:${address}`);
+        if (!byIp.allowed || !byEmail.allowed) {
+            return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
+        }
+        if (this.codes.verify(address, code.trim()) !== "ok")
+            return { ok: false };
+        // Correct code: clear the caller's request/verify budget and mint a session.
+        this.requestLimiter.reset(`email:${address}`);
+        this.verifyLimiter.reset(`email:${address}`);
+        const token = await signSession(address, this.options.sessionTtlSeconds);
+        return { ok: true, token, cookieOptions: this.cookieOptions(secure) };
+    }
+    /** Express cookie options for the session (used with `res.cookie`/`res.clearCookie`). */
+    cookieOptions(secure) {
+        return {
+            httpOnly: true,
+            sameSite: "lax",
+            secure: secure || this.options.secureCookies,
+            path: "/",
+            maxAge: this.options.sessionTtlSeconds * 1000,
+        };
+    }
+    /** Resolve the authenticated email for a request, or `undefined`. */
+    async authenticate(req) {
+        // Reuse shared-core's cookie parser (accepts an Express req directly) rather
+        // than re-implementing header splitting here.
+        const token = http.parseCookies(req)[SESSION_COOKIE];
+        return verifySession(token);
+    }
+    /** The `GET /auth/status` payload for a request. */
+    async status(req) {
+        const email = await this.authenticate(req);
+        return { authenticated: Boolean(email), email, enabled: true };
+    }
+    /**
+     * Express middleware gating requests on the APP router (mounted at the app
+     * root). Requests to the login flow (`<emailBase>/auth/*`) pass through so a
+     * caller can authenticate; the app's own API/asset requests need a valid
+     * session or get a 401. `emailBase` is the plugin's mount path (e.g.
+     * `/api/email`) so the open prefix is matched against the full request path.
+     */
+    middleware(emailBase) {
+        const openPrefix = `${emailBase}${AUTH_PATH_PREFIX}`;
+        return (req, res, next) => {
+            if (req.path.startsWith(openPrefix)) {
+                next();
+                return;
+            }
+            void this.authenticate(req).then((email) => {
+                if (email) {
+                    next();
+                }
+                else {
+                    res.status(401).json({ error: "authentication required", loginPath: openPrefix });
+                }
+            });
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../../src/auth/gate.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email-OTP access gate: runtime + Express middleware + request handlers.\n *\n * {@link AuthGate} owns the allow-list, rate limiters, code store, and session\n * signing. The plugin wires four routes to it (`request`/`verify`/`logout`/\n * `status`) and mounts {@link AuthGate.middleware} so every OTHER request needs a\n * valid session cookie.\n *\n * Design points:\n *   - `request` ALWAYS resolves `{ ok: true }` (anti-enumeration): a code is only\n *     generated + emailed when the address is allow-listed AND under the rate\n *     limit, but the caller can't tell the difference.\n *   - the session lives in an HttpOnly + SameSite=Lax cookie (Secure in prod), so\n *     it survives reloads and is not readable by page scripts.\n *   - fail-open on a missing signing secret (see `otp.ts`): a Databricks App is\n *     already access-limited; an unset `AUTH_JWT_SECRET` degrades to\n *     non-durable sessions, not a lockout.\n *\n * @module\n */\n\nimport type { CookieOptions, NextFunction, Request, Response } from \"express\";\nimport { http, log } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\n\nconst logger = log.logger(\"email:auth\");\n\n/** Cookie the session JWT rides in. */\nexport const SESSION_COOKIE = \"dbx_auth\";\n\n/** Route prefix (under the plugin base `/api/email`) the gate leaves open. */\nconst AUTH_PATH_PREFIX = \"/auth\";\n\n/** Resolved gate configuration. */\nexport interface AuthGateOptions {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. */\n  readonly allow: readonly string[];\n  /** Session lifetime in seconds. */\n  readonly sessionTtlSeconds: number;\n  /** One-time code lifetime in seconds. */\n  readonly codeTtlSeconds: number;\n  /** Max verify attempts per issued code. */\n  readonly maxAttempts: number;\n  /** Send the code email. Returns nothing; failures are logged, not surfaced. */\n  readonly sendCode: (email: string, code: string) => Promise<void>;\n  /** True in production (sets the `Secure` cookie flag). */\n  readonly secureCookies: boolean;\n}\n\n/** The email-OTP gate for one app. */\nexport class AuthGate {\n  private readonly codes: CodeStore;\n  // Separate limiters: requesting a code is cheap-to-abuse (email spam), verifying\n  // is a brute-force surface. Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  constructor(private readonly options: AuthGateOptions) {\n    this.codes = new CodeStore(options.codeTtlSeconds * 1000, options.maxAttempts);\n  }\n\n  /**\n   * Handle `POST /auth/request`. Always resolves `{ ok: true }` (plus a\n   * `retryAfter` when rate-limited); a code is issued + emailed only for an\n   * allow-listed address under the limit. Errors in sending are swallowed so the\n   * response never reveals whether an address exists / is allowed.\n   */\n  async handleRequest(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.options.allow)) {\n      const code = this.codes.issue(address);\n      try {\n        await this.options.sendCode(address, code);\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  /**\n   * Handle `POST /auth/verify`. On a correct code, returns the session `token`\n   * plus the `cookieOptions` for it so the route sets it with Express's own\n   * `res.cookie(SESSION_COOKIE, token, options)` (no hand-rolled Set-Cookie).\n   * Failures return `{ ok: false }` with a generic reason.\n   */\n  async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n    secure: boolean,\n  ): Promise<{ ok: boolean; token?: string; cookieOptions?: CookieOptions; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (this.codes.verify(address, code.trim()) !== \"ok\") return { ok: false };\n    // Correct code: clear the caller's request/verify budget and mint a session.\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    const token = await signSession(address, this.options.sessionTtlSeconds);\n    return { ok: true, token, cookieOptions: this.cookieOptions(secure) };\n  }\n\n  /** Express cookie options for the session (used with `res.cookie`/`res.clearCookie`). */\n  cookieOptions(secure: boolean): CookieOptions {\n    return {\n      httpOnly: true,\n      sameSite: \"lax\",\n      secure: secure || this.options.secureCookies,\n      path: \"/\",\n      maxAge: this.options.sessionTtlSeconds * 1000,\n    };\n  }\n\n  /** Resolve the authenticated email for a request, or `undefined`. */\n  async authenticate(req: Request): Promise<string | undefined> {\n    // Reuse shared-core's cookie parser (accepts an Express req directly) rather\n    // than re-implementing header splitting here.\n    const token = http.parseCookies(req)[SESSION_COOKIE];\n    return verifySession(token);\n  }\n\n  /** The `GET /auth/status` payload for a request. */\n  async status(req: Request): Promise<AuthStatus> {\n    const email = await this.authenticate(req);\n    return { authenticated: Boolean(email), email, enabled: true };\n  }\n\n  /**\n   * Express middleware gating requests on the APP router (mounted at the app\n   * root). Requests to the login flow (`<emailBase>/auth/*`) pass through so a\n   * caller can authenticate; the app's own API/asset requests need a valid\n   * session or get a 401. `emailBase` is the plugin's mount path (e.g.\n   * `/api/email`) so the open prefix is matched against the full request path.\n   */\n  middleware(emailBase: string): (req: Request, res: Response, next: NextFunction) => void {\n    const openPrefix = `${emailBase}${AUTH_PATH_PREFIX}`;\n    return (req, res, next) => {\n      if (req.path.startsWith(openPrefix)) {\n        next();\n        return;\n      }\n      void this.authenticate(req).then((email) => {\n        if (email) {\n          next();\n        } else {\n          res.status(401).json({ error: \"authentication required\", loginPath: openPrefix });\n        }\n      });\n    };\n  }\n}\n"]}

package/lib/src/auth/otp.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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
+ */
+/** Result of {@link CodeStore.verify}. */
+export type VerifyOutcome = "ok" | "invalid" | "expired" | "too-many-attempts";
+/** In-memory store of pending one-time codes, keyed by lowercased email. */
+export declare class CodeStore {
+    private readonly ttlMs;
+    private readonly maxAttempts;
+    private readonly codes;
+    constructor(ttlMs: number, maxAttempts: number);
+    /**
+     * 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: string, now?: number): string;
+    /**
+     * 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: string, code: string, now?: number): VerifyOutcome;
+    /** Drop every pending code (tests). */
+    clear(): void;
+}
+/** Reset the memoized key (tests, or after changing the env in-process). */
+export declare function resetSigningKey(): void;
+/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */
+export declare function signSession(email: string, ttlSeconds: number): Promise<string>;
+/** Validate a session JWT, returning the email it was minted for, or `undefined`. */
+export declare function verifySession(token: string | undefined): Promise<string | undefined>;