@dbx-tools/email 0.6.41 → 0.6.42

package/lib/src/plugin.js

@@ -26,7 +26,9 @@ import { AuthenticationError, ConfigurationError, ConnectionError, ExecutionErro
 import { defineTool, executeFromRegistry, toolsFromRegistry, } from "@databricks/appkit/beta";
 import { log } from "@dbx-tools/shared-core";
 import { email as emailWire, } from "@dbx-tools/shared-email";
-import { EMAIL_CONFIG_SCHEMA } from "./config.js";
+import { authRequestSchema, authVerifySchema } from "@dbx-tools/shared-email";
+import { EMAIL_CONFIG_SCHEMA, resolveAuthConfig } from "./config.js";
+import { AuthGate, SESSION_COOKIE } from "./auth/gate.js";
 import { EMAIL_SENDERS_SETTINGS, EMAIL_VERIFY_SETTINGS } from "./defaults.js";
 import { isSenderAllowed, listSenderOptions, resolveSenderAddress } from "./sender.js";
 import { SEND_EMAIL_DESCRIPTION } from "./tool.js";
@@ -57,6 +59,8 @@ const logger = log.logger("email");
  * ```
  */
 export class EmailPlugin extends Plugin {
+    /** The email-OTP access gate, constructed in {@link setup} when `auth.enabled`. */
+    authGate;
     static manifest = {
         name: "email",
         displayName: "Email",
@@ -103,6 +107,7 @@ export class EmailPlugin extends Plugin {
     async setup() {
         const { transporter, config } = getEmailRuntime(this.config);
         setEmailExecutor((fn, settings) => this.execute(fn, settings));
+        this.setupAuthGate();
         const policy = {
             mode: config.mode,
             senderPolicy: config.senderPolicy,
@@ -169,6 +174,75 @@ export class EmailPlugin extends Plugin {
                 res.json(result.data);
             },
         });
+        this.injectAuthRoutes(router);
+    }
+    /**
+     * 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.
+     */
+    injectAuthRoutes(router) {
+        const gate = this.authGate;
+        if (!gate)
+            return;
+        // `request` and `verify` take a raw email/code, not an OBO user, so they are
+        // NOT wrapped in `asUser` - the caller is anonymous until verified.
+        this.route(router, {
+            name: "authRequest",
+            method: "post",
+            path: "/auth/request",
+            handler: async (req, res) => {
+                const parsed = authRequestSchema.safeParse(req.body);
+                if (!parsed.success) {
+                    // Even a malformed body reports success (anti-enumeration).
+                    res.json({ ok: true });
+                    return;
+                }
+                const result = await gate.handleRequest(parsed.data.email, this.clientIp(req));
+                res.json(result);
+            },
+        });
+        this.route(router, {
+            name: "authVerify",
+            method: "post",
+            path: "/auth/verify",
+            handler: async (req, res) => {
+                const parsed = authVerifySchema.safeParse(req.body);
+                if (!parsed.success) {
+                    res.json({ ok: false });
+                    return;
+                }
+                const result = await gate.handleVerify(parsed.data.email, parsed.data.code, this.clientIp(req), req.secure);
+                if (result.ok && result.token && result.cookieOptions) {
+                    res.cookie(SESSION_COOKIE, result.token, result.cookieOptions);
+                }
+                res.json({ ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) });
+            },
+        });
+        this.route(router, {
+            name: "authLogout",
+            method: "post",
+            path: "/auth/logout",
+            handler: async (_req, res) => {
+                res.clearCookie(SESSION_COOKIE, { path: "/" });
+                res.json({ ok: true });
+            },
+        });
+        this.route(router, {
+            name: "authStatus",
+            method: "get",
+            path: "/auth/status",
+            handler: async (req, res) => {
+                res.json(await gate.status(req));
+            },
+        });
+    }
+    /** Client IP for rate-limiting, honoring the Apps ingress `x-forwarded-for`. */
+    clientIp(req) {
+        const fwd = req.headers["x-forwarded-for"];
+        const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(",")[0];
+        return (first ?? req.ip ?? "unknown").trim();
     }
     exports() {
         return {
@@ -206,6 +280,64 @@ export class EmailPlugin extends Plugin {
     async send(message, from, signal) {
         return sendEmail(message, from ?? this.resolveSender(), signal);
     }
+    /**
+     * 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.
+     */
+    setupAuthGate() {
+        const auth = resolveAuthConfig(this.config.auth);
+        if (!auth)
+            return;
+        const gate = new AuthGate({
+            allow: auth.allow,
+            sessionTtlSeconds: auth.sessionTtlSeconds,
+            codeTtlSeconds: auth.codeTtlSeconds,
+            maxAttempts: auth.maxAttempts,
+            secureCookies: process.env.NODE_ENV === "production",
+            sendCode: (email, code) => this.sendOtpEmail(email, code),
+        });
+        this.authGate = gate;
+        // The gate must protect the WHOLE app, but a plugin's own `injectRoutes`
+        // router only covers `/api/email/*`. AppKit's `server` plugin exposes
+        // `addExtension(fn)` for exactly this: an app-level middleware registered
+        // before the server listens. Look it up by its registered name (no
+        // dependency on a specific server-plugin package) and mount the gate there.
+        // The login routes themselves are exempted by the middleware's `emailBase`
+        // open-prefix (`/api/email/auth`).
+        const server = this.context?.getPlugins().get("server");
+        if (server?.addExtension) {
+            server.addExtension((app) => app.use(gate.middleware(`/api/${EmailPlugin.manifest.name}`)));
+            logger.info("auth:enabled", {
+                patterns: auth.allow.length,
+                sessionTtlSeconds: auth.sessionTtlSeconds,
+            });
+        }
+        else {
+            // No server plugin to gate through - the login routes still work, but the
+            // rest of the app would be ungated, so refuse to half-enable silently.
+            this.authGate = undefined;
+            logger.warn("auth:disabled - the `server` plugin is required to gate the app; add server() to your plugins");
+        }
+    }
+    /**
+     * 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).
+     */
+    async sendOtpEmail(email, code) {
+        await this.send({
+            to: [email],
+            subject: `Your sign-in code: ${code}`,
+            body: [
+                `Your one-time sign-in code is:`,
+                ``,
+                `## ${code}`,
+                ``,
+                `It expires shortly. If you didn't request this, you can ignore this email.`,
+            ].join("\n"),
+        }, undefined);
+    }
     /** Run the sender-options lookup through the plugin's interceptor chain. */
     async executeListSenders() {
         return this.execute(async () => this.listSenders(), EMAIL_SENDERS_SETTINGS);
@@ -291,4 +423,4 @@ function unwrap(result) {
  * ```
  */
 export const email = toPlugin(EmailPlugin);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin (registered name: `email`) that owns the SMTP runtime\n * for outbound mail. Registering it validates the SMTP configuration\n * and verifies connectivity at startup, so a bad host / credential\n * surfaces in the boot logs instead of on the first approved send, and\n * installs this plugin's `execute()` as the runtime's executor so every\n * send picks up AppKit's retry / timeout / telemetry chain.\n *\n * The plugin is also a `ToolProvider`, so an AppKit agent can reach an\n * `email.send` tool directly; the {@link emailTool} export is the same\n * capability for a Mastra agent. Both share the transport primed here,\n * and {@link sendEmail} is available to non-agent callers.\n *\n * Configuration is the manifest-published {@link EmailPluginConfig}\n * (SMTP host/port/credentials, sender domain or explicit `from`, the\n * sender policy, and an optional `allowedSenders` restriction), with\n * unprefixed `SMTP_*` / `EMAIL_*` environment fallbacks.\n *\n * The plugin mounts one route under its base path (`/api/email`):\n * `GET /senders` returns the permitted `From` options for the calling\n * user, so a compose UI can offer them in a dropdown.\n *\n * @module\n */\n\nimport {\n  AuthenticationError,\n  ConfigurationError,\n  ConnectionError,\n  ExecutionError,\n  getExecutionContext,\n  Plugin,\n  toPlugin,\n  ValidationError,\n  type AppKitError,\n  type ExecutionResult,\n  type IAppRouter,\n  type PluginManifest,\n} from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  toolsFromRegistry,\n  type AgentToolDefinition,\n  type ToolProvider,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  email as emailWire,\n  type EmailMessage,\n  type EmailResult,\n  type EmailSenders,\n} from \"@dbx-tools/shared-email\";\nimport { EMAIL_CONFIG_SCHEMA, type EmailPluginConfig } from \"./config.ts\";\nimport { EMAIL_SENDERS_SETTINGS, EMAIL_VERIFY_SETTINGS } from \"./defaults.ts\";\nimport { isSenderAllowed, listSenderOptions, resolveSenderAddress } from \"./sender.ts\";\nimport { SEND_EMAIL_DESCRIPTION } from \"./tool.ts\";\nimport {\n  getEmailRuntime,\n  resetEmailRuntime,\n  sendEmail,\n  setEmailExecutor,\n  verifyEmailTransport,\n} from \"./transport.ts\";\n\n/** Mount-relative route (under `/api/email`) for the sender-options lookup. */\nconst SENDERS_ROUTE = \"/senders\";\n\n/** Registry key of the agent tool, which agents address as `email.send`. */\nconst SEND_TOOL = \"send\";\n\nconst logger = log.logger(\"email\");\n\n/**\n * AppKit plugin that configures and verifies the SMTP transport used by\n * the `send_email` tool, and exposes sending as an AppKit agent tool.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as emailPlugin } from \"@dbx-tools/email\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     emailPlugin.email({\n *       smtp: { host: \"smtp.example.com\", user: \"apikey\", password: process.env.SMTP_KEY },\n *       domain: \"mail.example.com\",\n *     }),\n *   ],\n * });\n * ```\n */\nexport class EmailPlugin extends Plugin<EmailPluginConfig> implements ToolProvider {\n  static manifest = {\n    name: \"email\",\n    displayName: \"Email\",\n    description:\n      \"Sends approval-gated email over SMTP, with the sender derived from \" +\n      \"the on-behalf-of user's address on a configured domain.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [],\n    },\n    config: { schema: EMAIL_CONFIG_SCHEMA },\n  } satisfies PluginManifest<\"email\">;\n\n  /**\n   * The tool this plugin offers to an AppKit agent.\n   *\n   * Not `autoInheritable`: a send is irreversible and leaves the workspace,\n   * so it must only appear in an agent that asked for it and accepted the\n   * sender policy that comes with it.\n   *\n   * `execute` re-parses its arguments with the local schema: AppKit validates\n   * against the same schema first, but re-parsing is what gives the body typed\n   * arguments instead of `unknown`.\n   */\n  private readonly tools: ToolRegistry = {\n    [SEND_TOOL]: defineTool({\n      description: SEND_EMAIL_DESCRIPTION,\n      schema: emailWire.emailMessageSchema,\n      annotations: { effect: \"write\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) =>\n        this.send(emailWire.emailMessageSchema.parse(args), undefined, signal),\n    }),\n  };\n\n  /**\n   * Prime the shared runtime from this plugin's config (over env), route the\n   * tools' sends through this plugin's interceptor chain, and log the\n   * effective sender policy so an active restriction is obvious at boot. In\n   * SMTP mode, fail setup when the transport cannot be verified: a bad host\n   * or credential is a deploy-time mistake and should stop the app rather\n   * than wait for a user to approve a send that cannot work. With no SMTP\n   * credentials the runtime is in file/outbox mode (only when\n   * `EMAIL_OUTBOX_MODE` is set), logged loudly here so it is obvious mail\n   * is being written to disk rather than sent.\n   */\n  override async setup(): Promise<void> {\n    const { transporter, config } = getEmailRuntime(this.config);\n    setEmailExecutor((fn, settings) => this.execute(fn, settings));\n    const policy = {\n      mode: config.mode,\n      senderPolicy: config.senderPolicy,\n      restricted: config.allowedSenders.length > 0,\n      ...(config.allowedSenders.length > 0 ? { allowedSenders: config.allowedSenders } : {}),\n    };\n    if (config.mode === \"file\") {\n      logger.warn(\"outbox:enabled\", {\n        dir: config.outDir,\n        reason: \"no SMTP credentials configured; emails are written to disk instead of sent\",\n      });\n      logger.info(\"ready\", policy);\n      return;\n    }\n    const verified = await this.execute(\n      async (signal) => verifyEmailTransport(transporter, signal),\n      EMAIL_VERIFY_SETTINGS,\n    );\n    if (!verified.ok) {\n      logger.error(\"smtp:unverified\", {\n        host: config.host,\n        port: config.port,\n        status: verified.status,\n        error: verified.message,\n      });\n      throw ConfigurationError.invalidConnection(\n        \"SMTP\",\n        `Could not verify ${config.host}:${config.port}. Check SMTP_HOST, SMTP_PORT, SMTP_SECURE, and the credentials, or set EMAIL_OUTBOX_MODE=1 for local outbox testing.`,\n      );\n    }\n    logger.info(\"ready\", {\n      ...policy,\n      host: config.host,\n      port: config.port,\n      secure: config.secure,\n    });\n  }\n\n  /** Close the SMTP connection pool. Idempotent. */\n  async shutdown(): Promise<void> {\n    resetEmailRuntime();\n  }\n\n  /**\n   * Abort in-flight work. AppKit's graceful shutdown only invokes this hook -\n   * it never calls {@link shutdown} - so the SMTP pool is closed from here or\n   * it leaks at SIGTERM. The teardown is synchronous and idempotent, so the\n   * un-awaited call costs nothing.\n   */\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    void this.shutdown();\n  }\n\n  /**\n   * Expose the sender-options lookup so UI compose views can populate a\n   * `From` dropdown from the configured allow-list. Mounted under the\n   * plugin base path, i.e. `GET /api/email/senders`. Runs in the OBO\n   * user scope so domain wildcards resolve against the caller's own\n   * local part.\n   */\n  override injectRoutes(router: IAppRouter): void {\n    this.route(router, {\n      name: \"listSenders\",\n      method: \"get\",\n      path: SENDERS_ROUTE,\n      handler: async (req, res) => {\n        const result = await this.asUser(req).executeListSenders();\n        if (!result.ok) {\n          res.status(result.status).json({ error: result.message });\n          return;\n        }\n        res.json(result.data);\n      },\n    });\n  }\n\n  override exports() {\n    return {\n      /**\n       * Send a message immediately from `from` through the shared\n       * transport, bypassing the approval flow. For agent-driven sends\n       * use {@link emailTool} instead.\n       */\n      sendEmail: (\n        message: EmailMessage,\n        from: string,\n        signal?: AbortSignal,\n      ): Promise<EmailResult> => this.send(message, from, signal),\n      /**\n       * Sender options for the current user (the `GET /senders` payload).\n       * AppKit wraps this with `asUser(req)` for OBO scoping.\n       */\n      listSenders: async (): Promise<EmailSenders> => unwrap(await this.executeListSenders()),\n    };\n  }\n\n  /** AppKit `ToolProvider`: the tool definitions offered to an agent. */\n  getAgentTools(): AgentToolDefinition[] {\n    return toolsFromRegistry(this.tools);\n  }\n\n  /**\n   * AppKit `ToolProvider`: run one tool call. Arguments are validated against\n   * the tool's schema first, and a validation failure comes back as an\n   * LLM-friendly string so the model can correct itself on the next turn.\n   */\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    return executeFromRegistry(this.tools, name, args, signal);\n  }\n\n  /**\n   * Send one message, resolving the sender for the caller in scope when\n   * `from` is not pinned. The interceptor chain is applied inside\n   * {@link sendEmail} through the executor installed at setup, so this must\n   * not wrap it again.\n   */\n  private async send(\n    message: EmailMessage,\n    from: string | undefined,\n    signal?: AbortSignal,\n  ): Promise<EmailResult> {\n    return sendEmail(message, from ?? this.resolveSender(), signal);\n  }\n\n  /** Run the sender-options lookup through the plugin's interceptor chain. */\n  private async executeListSenders(): Promise<ExecutionResult<EmailSenders>> {\n    return this.execute(async () => this.listSenders(), EMAIL_SENDERS_SETTINGS);\n  }\n\n  /**\n   * Compute the `From` options offered to the current user: the concrete\n   * addresses the effective allow-list permits (domain wildcards expanded\n   * against the OBO user's local part), the default among them, and\n   * whether the list is an enforced restriction. See\n   * {@link listSenderOptions}.\n   */\n  private async listSenders(): Promise<EmailSenders> {\n    const { config } = getEmailRuntime();\n    const senders = listSenderOptions(config, currentUserEmail());\n    // Prefer the address a send would actually default to; fall back to\n    // the first offered option when that can't be resolved / permitted.\n    let defaultSender = senders[0];\n    try {\n      const resolved = this.resolveSender().toLowerCase();\n      if (isSenderAllowed(resolved, config.allowedSenders)) defaultSender = resolved;\n    } catch {\n      // Keep the first offered option (or none) as the default.\n    }\n    return {\n      senders,\n      ...(defaultSender ? { defaultSender } : {}),\n      restricted: config.allowedSenders.length > 0,\n    };\n  }\n\n  /** The `From` a send defaults to for the caller in scope. */\n  private resolveSender(): string {\n    return resolveSenderAddress(getEmailRuntime().config, currentUserEmail());\n  }\n}\n\n/** The OBO user's address, or undefined outside a user context. */\nfunction currentUserEmail(): string | undefined {\n  const ctx = getExecutionContext();\n  return \"isUserContext\" in ctx ? ctx.userEmail : undefined;\n}\n\n/**\n * Re-raise a failed execution as the AppKit error class that already carries\n * the status AppKit resolved, so a programmatic caller sees the same 400 /\n * 401 / 503 an HTTP caller would.\n */\nfunction toAppKitError(status: number, message: string): AppKitError {\n  if (status === 400) return new ValidationError(message);\n  if (status === 401) return new AuthenticationError(message);\n  if (status === 503) return new ConnectionError(message);\n  return new ExecutionError(message);\n}\n\n/**\n * Surface a failed {@link ExecutionResult} to a programmatic caller as a\n * throw. HTTP handlers map `status` onto the response instead.\n */\nfunction unwrap<T>(result: ExecutionResult<T>): T {\n  if (result.ok) return result.data;\n  throw toAppKitError(result.status, result.message);\n}\n\n/**\n * Register the email plugin.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { brand, plugin as emailPlugin } from \"@dbx-tools/email\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     emailPlugin.email({\n *       domain: \"mail.example.com\",\n *       allowedSenders: [\"*@mail.example.com\"],\n *       brand: brand.defaultEmailBrand,\n *     }),\n *   ],\n * });\n * ```\n */\nexport const email = toPlugin(EmailPlugin);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,MAAM,EACN,QAAQ,EACR,eAAe,GAKhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,iBAAiB,GAIlB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EACL,KAAK,IAAI,SAAS,GAInB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAA0B,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,+EAA+E;AAC/E,MAAM,aAAa,GAAG,UAAU,CAAC;AAEjC,4EAA4E;AAC5E,MAAM,SAAS,GAAG,MAAM,CAAC;AAEzB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,WAAY,SAAQ,MAAyB;IACxD,mFAAmF;IAC3E,QAAQ,CAAY;IAE5B,MAAM,CAAC,QAAQ,GAAG;QAChB,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,OAAO;QACpB,WAAW,EACT,qEAAqE;YACrE,yDAAyD;QAC3D,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE;YACT,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,EAAE;SACb;QACD,MAAM,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE;KACN,CAAC;IAEpC;;;;;;;;;;OAUG;IACc,KAAK,GAAiB;QACrC,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;YACtB,WAAW,EAAE,sBAAsB;YACnC,MAAM,EAAE,SAAS,CAAC,kBAAkB;YACpC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE;YAC3D,eAAe,EAAE,KAAK;YACtB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAC9B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC;SACzE,CAAC;KACH,CAAC;IAEF;;;;;;;;;;OAUG;IACM,KAAK,CAAC,KAAK;QAClB,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC7D,gBAAgB,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC/D,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,MAAM,MAAM,GAAG;YACb,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,UAAU,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC;YAC5C,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACvF,CAAC;QACF,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE;gBAC5B,GAAG,EAAE,MAAM,CAAC,MAAM;gBAClB,MAAM,EAAE,4EAA4E;aACrF,CAAC,CAAC;YACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CACjC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,oBAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,EAC3D,qBAAqB,CACtB,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,MAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE;gBAC9B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,KAAK,EAAE,QAAQ,CAAC,OAAO;aACxB,CAAC,CAAC;YACH,MAAM,kBAAkB,CAAC,iBAAiB,CACxC,MAAM,EACN,oBAAoB,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,sHAAsH,CACrK,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;YACnB,GAAG,MAAM;YACT,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;IACL,CAAC;IAED,kDAAkD;IAClD,KAAK,CAAC,QAAQ;QACZ,iBAAiB,EAAE,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACM,qBAAqB;QAC5B,KAAK,CAAC,qBAAqB,EAAE,CAAC;QAC9B,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACM,YAAY,CAAC,MAAkB;QACtC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,aAAa;YACnB,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;gBAC1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,kBAAkB,EAAE,CAAC;gBAC3D,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;oBACf,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC1D,OAAO;gBACT,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;SACF,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACK,gBAAgB,CAAC,MAAkB;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC3B,IAAI,CAAC,IAAI;YAAE,OAAO;QAElB,6EAA6E;QAC7E,oEAAoE;QACpE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;gBAC1B,MAAM,MAAM,GAAG,iBAAiB,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACrD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBACpB,4DAA4D;oBAC5D,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;oBACvB,OAAO;gBACT,CAAC;gBACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC/E,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACnB,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,cAAc;YACpB,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;gBAC1B,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBACpB,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;oBACxB,OAAO;gBACT,CAAC;gBACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CACpC,MAAM,CAAC,IAAI,CAAC,KAAK,EACjB,MAAM,CAAC,IAAI,CAAC,IAAI,EAChB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAClB,GAAG,CAAC,MAAM,CACX,CAAC;gBACF,IAAI,MAAM,CAAC,EAAE,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;oBACtD,GAAG,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC;gBACjE,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC/F,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,cAAc;YACpB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;gBAC3B,GAAG,CAAC,WAAW,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;gBAC/C,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;YACzB,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,cAAc;YACpB,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;gBAC1B,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACnC,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,gFAAgF;IACxE,QAAQ,CAAC,GAAoB;QACnC,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/D,OAAO,CAAC,KAAK,IAAI,GAAG,CAAC,EAAE,IAAI,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,CAAC;IAEQ,OAAO;QACd,OAAO;YACL;;;;eAIG;YACH,SAAS,EAAE,CACT,OAAqB,EACrB,IAAY,EACZ,MAAoB,EACE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC;YAC3D;;;eAGG;YACH,WAAW,EAAE,KAAK,IAA2B,EAAE,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,kBAAkB,EAAE,CAAC;SACxF,CAAC;IACJ,CAAC;IAED,uEAAuE;IACvE,aAAa;QACX,OAAO,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,gBAAgB,CAAC,IAAY,EAAE,IAAa,EAAE,MAAoB;QACtE,OAAO,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,IAAI,CAChB,OAAqB,EACrB,IAAwB,EACxB,MAAoB;QAEpB,OAAO,SAAS,CAAC,OAAO,EAAE,IAAI,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,MAAM,CAAC,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACK,aAAa;QACnB,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC;YACxB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;YACpD,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC;SAC1D,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,yEAAyE;QACzE,sEAAsE;QACtE,0EAA0E;QAC1E,mEAAmE;QACnE,4EAA4E;QAC5E,2EAA2E;QAC3E,mCAAmC;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,CAEzC,CAAC;QACd,IAAI,MAAM,EAAE,YAAY,EAAE,CAAC;YACzB,MAAM,CAAC,YAAY,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;YAC5F,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE;gBAC1B,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC3B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;aAC1C,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,0EAA0E;YAC1E,uEAAuE;YACvE,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;YAC1B,MAAM,CAAC,IAAI,CACT,+FAA+F,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,YAAY,CAAC,KAAa,EAAE,IAAY;QACpD,MAAM,IAAI,CAAC,IAAI,CACb;YACE,EAAE,EAAE,CAAC,KAAK,CAAC;YACX,OAAO,EAAE,sBAAsB,IAAI,EAAE;YACrC,IAAI,EAAE;gBACJ,gCAAgC;gBAChC,EAAE;gBACF,MAAM,IAAI,EAAE;gBACZ,EAAE;gBACF,4EAA4E;aAC7E,CAAC,IAAI,CAAC,IAAI,CAAC;SACb,EACD,SAAS,CACV,CAAC;IACJ,CAAC;IAED,4EAA4E;IACpE,KAAK,CAAC,kBAAkB;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,sBAAsB,CAAC,CAAC;IAC9E,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,WAAW;QACvB,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE,CAAC;QACrC,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9D,oEAAoE;QACpE,oEAAoE;QACpE,IAAI,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,WAAW,EAAE,CAAC;YACpD,IAAI,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,cAAc,CAAC;gBAAE,aAAa,GAAG,QAAQ,CAAC;QACjF,CAAC;QAAC,MAAM,CAAC;YACP,0DAA0D;QAC5D,CAAC;QACD,OAAO;YACL,OAAO;YACP,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3C,UAAU,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED,6DAA6D;IACrD,aAAa;QACnB,OAAO,oBAAoB,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC5E,CAAC;;AAGH,mEAAmE;AACnE,SAAS,gBAAgB;IACvB,MAAM,GAAG,GAAG,mBAAmB,EAAE,CAAC;IAClC,OAAO,eAAe,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5D,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,MAAc,EAAE,OAAe;IACpD,IAAI,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;IACxD,IAAI,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAC5D,IAAI,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;IACxD,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,SAAS,MAAM,CAAI,MAA0B;IAC3C,IAAI,MAAM,CAAC,EAAE;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IAClC,MAAM,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC","sourcesContent":["/**\n * AppKit plugin (registered name: `email`) that owns the SMTP runtime\n * for outbound mail. Registering it validates the SMTP configuration\n * and verifies connectivity at startup, so a bad host / credential\n * surfaces in the boot logs instead of on the first approved send, and\n * installs this plugin's `execute()` as the runtime's executor so every\n * send picks up AppKit's retry / timeout / telemetry chain.\n *\n * The plugin is also a `ToolProvider`, so an AppKit agent can reach an\n * `email.send` tool directly; the {@link emailTool} export is the same\n * capability for a Mastra agent. Both share the transport primed here,\n * and {@link sendEmail} is available to non-agent callers.\n *\n * Configuration is the manifest-published {@link EmailPluginConfig}\n * (SMTP host/port/credentials, sender domain or explicit `from`, the\n * sender policy, and an optional `allowedSenders` restriction), with\n * unprefixed `SMTP_*` / `EMAIL_*` environment fallbacks.\n *\n * The plugin mounts one route under its base path (`/api/email`):\n * `GET /senders` returns the permitted `From` options for the calling\n * user, so a compose UI can offer them in a dropdown.\n *\n * @module\n */\n\nimport {\n  AuthenticationError,\n  ConfigurationError,\n  ConnectionError,\n  ExecutionError,\n  getExecutionContext,\n  Plugin,\n  toPlugin,\n  ValidationError,\n  type AppKitError,\n  type ExecutionResult,\n  type IAppRouter,\n  type PluginManifest,\n} from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  toolsFromRegistry,\n  type AgentToolDefinition,\n  type ToolProvider,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  email as emailWire,\n  type EmailMessage,\n  type EmailResult,\n  type EmailSenders,\n} from \"@dbx-tools/shared-email\";\nimport type express from \"express\";\nimport { authRequestSchema, authVerifySchema } from \"@dbx-tools/shared-email\";\nimport { EMAIL_CONFIG_SCHEMA, resolveAuthConfig, type EmailPluginConfig } from \"./config.ts\";\nimport { AuthGate, SESSION_COOKIE } from \"./auth/gate.ts\";\nimport { EMAIL_SENDERS_SETTINGS, EMAIL_VERIFY_SETTINGS } from \"./defaults.ts\";\nimport { isSenderAllowed, listSenderOptions, resolveSenderAddress } from \"./sender.ts\";\nimport { SEND_EMAIL_DESCRIPTION } from \"./tool.ts\";\nimport {\n  getEmailRuntime,\n  resetEmailRuntime,\n  sendEmail,\n  setEmailExecutor,\n  verifyEmailTransport,\n} from \"./transport.ts\";\n\n/** Mount-relative route (under `/api/email`) for the sender-options lookup. */\nconst SENDERS_ROUTE = \"/senders\";\n\n/** Registry key of the agent tool, which agents address as `email.send`. */\nconst SEND_TOOL = \"send\";\n\nconst logger = log.logger(\"email\");\n\n/**\n * AppKit plugin that configures and verifies the SMTP transport used by\n * the `send_email` tool, and exposes sending as an AppKit agent tool.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as emailPlugin } from \"@dbx-tools/email\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     emailPlugin.email({\n *       smtp: { host: \"smtp.example.com\", user: \"apikey\", password: process.env.SMTP_KEY },\n *       domain: \"mail.example.com\",\n *     }),\n *   ],\n * });\n * ```\n */\nexport class EmailPlugin extends Plugin<EmailPluginConfig> implements ToolProvider {\n  /** The email-OTP access gate, constructed in {@link setup} when `auth.enabled`. */\n  private authGate?: AuthGate;\n\n  static manifest = {\n    name: \"email\",\n    displayName: \"Email\",\n    description:\n      \"Sends approval-gated email over SMTP, with the sender derived from \" +\n      \"the on-behalf-of user's address on a configured domain.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [],\n    },\n    config: { schema: EMAIL_CONFIG_SCHEMA },\n  } satisfies PluginManifest<\"email\">;\n\n  /**\n   * The tool this plugin offers to an AppKit agent.\n   *\n   * Not `autoInheritable`: a send is irreversible and leaves the workspace,\n   * so it must only appear in an agent that asked for it and accepted the\n   * sender policy that comes with it.\n   *\n   * `execute` re-parses its arguments with the local schema: AppKit validates\n   * against the same schema first, but re-parsing is what gives the body typed\n   * arguments instead of `unknown`.\n   */\n  private readonly tools: ToolRegistry = {\n    [SEND_TOOL]: defineTool({\n      description: SEND_EMAIL_DESCRIPTION,\n      schema: emailWire.emailMessageSchema,\n      annotations: { effect: \"write\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) =>\n        this.send(emailWire.emailMessageSchema.parse(args), undefined, signal),\n    }),\n  };\n\n  /**\n   * Prime the shared runtime from this plugin's config (over env), route the\n   * tools' sends through this plugin's interceptor chain, and log the\n   * effective sender policy so an active restriction is obvious at boot. In\n   * SMTP mode, fail setup when the transport cannot be verified: a bad host\n   * or credential is a deploy-time mistake and should stop the app rather\n   * than wait for a user to approve a send that cannot work. With no SMTP\n   * credentials the runtime is in file/outbox mode (only when\n   * `EMAIL_OUTBOX_MODE` is set), logged loudly here so it is obvious mail\n   * is being written to disk rather than sent.\n   */\n  override async setup(): Promise<void> {\n    const { transporter, config } = getEmailRuntime(this.config);\n    setEmailExecutor((fn, settings) => this.execute(fn, settings));\n    this.setupAuthGate();\n    const policy = {\n      mode: config.mode,\n      senderPolicy: config.senderPolicy,\n      restricted: config.allowedSenders.length > 0,\n      ...(config.allowedSenders.length > 0 ? { allowedSenders: config.allowedSenders } : {}),\n    };\n    if (config.mode === \"file\") {\n      logger.warn(\"outbox:enabled\", {\n        dir: config.outDir,\n        reason: \"no SMTP credentials configured; emails are written to disk instead of sent\",\n      });\n      logger.info(\"ready\", policy);\n      return;\n    }\n    const verified = await this.execute(\n      async (signal) => verifyEmailTransport(transporter, signal),\n      EMAIL_VERIFY_SETTINGS,\n    );\n    if (!verified.ok) {\n      logger.error(\"smtp:unverified\", {\n        host: config.host,\n        port: config.port,\n        status: verified.status,\n        error: verified.message,\n      });\n      throw ConfigurationError.invalidConnection(\n        \"SMTP\",\n        `Could not verify ${config.host}:${config.port}. Check SMTP_HOST, SMTP_PORT, SMTP_SECURE, and the credentials, or set EMAIL_OUTBOX_MODE=1 for local outbox testing.`,\n      );\n    }\n    logger.info(\"ready\", {\n      ...policy,\n      host: config.host,\n      port: config.port,\n      secure: config.secure,\n    });\n  }\n\n  /** Close the SMTP connection pool. Idempotent. */\n  async shutdown(): Promise<void> {\n    resetEmailRuntime();\n  }\n\n  /**\n   * Abort in-flight work. AppKit's graceful shutdown only invokes this hook -\n   * it never calls {@link shutdown} - so the SMTP pool is closed from here or\n   * it leaks at SIGTERM. The teardown is synchronous and idempotent, so the\n   * un-awaited call costs nothing.\n   */\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    void this.shutdown();\n  }\n\n  /**\n   * Expose the sender-options lookup so UI compose views can populate a\n   * `From` dropdown from the configured allow-list. Mounted under the\n   * plugin base path, i.e. `GET /api/email/senders`. Runs in the OBO\n   * user scope so domain wildcards resolve against the caller's own\n   * local part.\n   */\n  override injectRoutes(router: IAppRouter): void {\n    this.route(router, {\n      name: \"listSenders\",\n      method: \"get\",\n      path: SENDERS_ROUTE,\n      handler: async (req, res) => {\n        const result = await this.asUser(req).executeListSenders();\n        if (!result.ok) {\n          res.status(result.status).json({ error: result.message });\n          return;\n        }\n        res.json(result.data);\n      },\n    });\n    this.injectAuthRoutes(router);\n  }\n\n  /**\n   * Mount the email-OTP login flow under `/api/email/auth/*` when the gate is\n   * enabled. These routes are the ONLY ones the gate middleware leaves open (see\n   * {@link AuthGate.middleware}); everything else requires the session cookie\n   * they establish. No-op when auth is off.\n   */\n  private injectAuthRoutes(router: IAppRouter): void {\n    const gate = this.authGate;\n    if (!gate) return;\n\n    // `request` and `verify` take a raw email/code, not an OBO user, so they are\n    // NOT wrapped in `asUser` - the caller is anonymous until verified.\n    this.route(router, {\n      name: \"authRequest\",\n      method: \"post\",\n      path: \"/auth/request\",\n      handler: async (req, res) => {\n        const parsed = authRequestSchema.safeParse(req.body);\n        if (!parsed.success) {\n          // Even a malformed body reports success (anti-enumeration).\n          res.json({ ok: true });\n          return;\n        }\n        const result = await gate.handleRequest(parsed.data.email, this.clientIp(req));\n        res.json(result);\n      },\n    });\n\n    this.route(router, {\n      name: \"authVerify\",\n      method: \"post\",\n      path: \"/auth/verify\",\n      handler: async (req, res) => {\n        const parsed = authVerifySchema.safeParse(req.body);\n        if (!parsed.success) {\n          res.json({ ok: false });\n          return;\n        }\n        const result = await gate.handleVerify(\n          parsed.data.email,\n          parsed.data.code,\n          this.clientIp(req),\n          req.secure,\n        );\n        if (result.ok && result.token && result.cookieOptions) {\n          res.cookie(SESSION_COOKIE, result.token, result.cookieOptions);\n        }\n        res.json({ ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) });\n      },\n    });\n\n    this.route(router, {\n      name: \"authLogout\",\n      method: \"post\",\n      path: \"/auth/logout\",\n      handler: async (_req, res) => {\n        res.clearCookie(SESSION_COOKIE, { path: \"/\" });\n        res.json({ ok: true });\n      },\n    });\n\n    this.route(router, {\n      name: \"authStatus\",\n      method: \"get\",\n      path: \"/auth/status\",\n      handler: async (req, res) => {\n        res.json(await gate.status(req));\n      },\n    });\n  }\n\n  /** Client IP for rate-limiting, honoring the Apps ingress `x-forwarded-for`. */\n  private clientIp(req: express.Request): string {\n    const fwd = req.headers[\"x-forwarded-for\"];\n    const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(\",\")[0];\n    return (first ?? req.ip ?? \"unknown\").trim();\n  }\n\n  override exports() {\n    return {\n      /**\n       * Send a message immediately from `from` through the shared\n       * transport, bypassing the approval flow. For agent-driven sends\n       * use {@link emailTool} instead.\n       */\n      sendEmail: (\n        message: EmailMessage,\n        from: string,\n        signal?: AbortSignal,\n      ): Promise<EmailResult> => this.send(message, from, signal),\n      /**\n       * Sender options for the current user (the `GET /senders` payload).\n       * AppKit wraps this with `asUser(req)` for OBO scoping.\n       */\n      listSenders: async (): Promise<EmailSenders> => unwrap(await this.executeListSenders()),\n    };\n  }\n\n  /** AppKit `ToolProvider`: the tool definitions offered to an agent. */\n  getAgentTools(): AgentToolDefinition[] {\n    return toolsFromRegistry(this.tools);\n  }\n\n  /**\n   * AppKit `ToolProvider`: run one tool call. Arguments are validated against\n   * the tool's schema first, and a validation failure comes back as an\n   * LLM-friendly string so the model can correct itself on the next turn.\n   */\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    return executeFromRegistry(this.tools, name, args, signal);\n  }\n\n  /**\n   * Send one message, resolving the sender for the caller in scope when\n   * `from` is not pinned. The interceptor chain is applied inside\n   * {@link sendEmail} through the executor installed at setup, so this must\n   * not wrap it again.\n   */\n  private async send(\n    message: EmailMessage,\n    from: string | undefined,\n    signal?: AbortSignal,\n  ): Promise<EmailResult> {\n    return sendEmail(message, from ?? this.resolveSender(), signal);\n  }\n\n  /**\n   * Build the email-OTP access gate when `auth.enabled`, wiring its code\n   * delivery through this plugin's own transport. Called from {@link setup}; a\n   * no-op (leaves {@link authGate} undefined) when the gate is off.\n   */\n  private setupAuthGate(): void {\n    const auth = resolveAuthConfig(this.config.auth);\n    if (!auth) return;\n    const gate = new AuthGate({\n      allow: auth.allow,\n      sessionTtlSeconds: auth.sessionTtlSeconds,\n      codeTtlSeconds: auth.codeTtlSeconds,\n      maxAttempts: auth.maxAttempts,\n      secureCookies: process.env.NODE_ENV === \"production\",\n      sendCode: (email, code) => this.sendOtpEmail(email, code),\n    });\n    this.authGate = gate;\n\n    // The gate must protect the WHOLE app, but a plugin's own `injectRoutes`\n    // router only covers `/api/email/*`. AppKit's `server` plugin exposes\n    // `addExtension(fn)` for exactly this: an app-level middleware registered\n    // before the server listens. Look it up by its registered name (no\n    // dependency on a specific server-plugin package) and mount the gate there.\n    // The login routes themselves are exempted by the middleware's `emailBase`\n    // open-prefix (`/api/email/auth`).\n    const server = this.context?.getPlugins().get(\"server\") as\n      | { addExtension?: (fn: (app: express.Application) => void) => void }\n      | undefined;\n    if (server?.addExtension) {\n      server.addExtension((app) => app.use(gate.middleware(`/api/${EmailPlugin.manifest.name}`)));\n      logger.info(\"auth:enabled\", {\n        patterns: auth.allow.length,\n        sessionTtlSeconds: auth.sessionTtlSeconds,\n      });\n    } else {\n      // No server plugin to gate through - the login routes still work, but the\n      // rest of the app would be ungated, so refuse to half-enable silently.\n      this.authGate = undefined;\n      logger.warn(\n        \"auth:disabled - the `server` plugin is required to gate the app; add server() to your plugins\",\n      );\n    }\n  }\n\n  /**\n   * Deliver a one-time code to `email` through this plugin's transport. Throws\n   * on failure (the gate swallows it, so a delivery error never leaks whether\n   * the address was allow-listed).\n   */\n  private async sendOtpEmail(email: string, code: string): Promise<void> {\n    await this.send(\n      {\n        to: [email],\n        subject: `Your sign-in code: ${code}`,\n        body: [\n          `Your one-time sign-in code is:`,\n          ``,\n          `## ${code}`,\n          ``,\n          `It expires shortly. If you didn't request this, you can ignore this email.`,\n        ].join(\"\\n\"),\n      },\n      undefined,\n    );\n  }\n\n  /** Run the sender-options lookup through the plugin's interceptor chain. */\n  private async executeListSenders(): Promise<ExecutionResult<EmailSenders>> {\n    return this.execute(async () => this.listSenders(), EMAIL_SENDERS_SETTINGS);\n  }\n\n  /**\n   * Compute the `From` options offered to the current user: the concrete\n   * addresses the effective allow-list permits (domain wildcards expanded\n   * against the OBO user's local part), the default among them, and\n   * whether the list is an enforced restriction. See\n   * {@link listSenderOptions}.\n   */\n  private async listSenders(): Promise<EmailSenders> {\n    const { config } = getEmailRuntime();\n    const senders = listSenderOptions(config, currentUserEmail());\n    // Prefer the address a send would actually default to; fall back to\n    // the first offered option when that can't be resolved / permitted.\n    let defaultSender = senders[0];\n    try {\n      const resolved = this.resolveSender().toLowerCase();\n      if (isSenderAllowed(resolved, config.allowedSenders)) defaultSender = resolved;\n    } catch {\n      // Keep the first offered option (or none) as the default.\n    }\n    return {\n      senders,\n      ...(defaultSender ? { defaultSender } : {}),\n      restricted: config.allowedSenders.length > 0,\n    };\n  }\n\n  /** The `From` a send defaults to for the caller in scope. */\n  private resolveSender(): string {\n    return resolveSenderAddress(getEmailRuntime().config, currentUserEmail());\n  }\n}\n\n/** The OBO user's address, or undefined outside a user context. */\nfunction currentUserEmail(): string | undefined {\n  const ctx = getExecutionContext();\n  return \"isUserContext\" in ctx ? ctx.userEmail : undefined;\n}\n\n/**\n * Re-raise a failed execution as the AppKit error class that already carries\n * the status AppKit resolved, so a programmatic caller sees the same 400 /\n * 401 / 503 an HTTP caller would.\n */\nfunction toAppKitError(status: number, message: string): AppKitError {\n  if (status === 400) return new ValidationError(message);\n  if (status === 401) return new AuthenticationError(message);\n  if (status === 503) return new ConnectionError(message);\n  return new ExecutionError(message);\n}\n\n/**\n * Surface a failed {@link ExecutionResult} to a programmatic caller as a\n * throw. HTTP handlers map `status` onto the response instead.\n */\nfunction unwrap<T>(result: ExecutionResult<T>): T {\n  if (result.ok) return result.data;\n  throw toAppKitError(result.status, result.message);\n}\n\n/**\n * Register the email plugin.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { brand, plugin as emailPlugin } from \"@dbx-tools/email\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     emailPlugin.email({\n *       domain: \"mail.example.com\",\n *       allowedSenders: [\"*@mail.example.com\"],\n *       brand: brand.defaultEmailBrand,\n *     }),\n *   ],\n * });\n * ```\n */\nexport const email = toPlugin(EmailPlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/brand.ts","../src/config.ts","../src/defaults.ts","../src/email-html.ts","../src/juice.d.ts","../src/markdown.ts","../src/outbox.ts","../src/plugin.ts","../src/sender.ts","../src/tool.ts","../src/transport.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/brand.ts","../src/config.ts","../src/defaults.ts","../src/email-html.ts","../src/juice.d.ts","../src/markdown.ts","../src/outbox.ts","../src/plugin.ts","../src/sender.ts","../src/tool.ts","../src/transport.ts","../src/auth/allowlist.ts","../src/auth/gate.ts","../src/auth/otp.ts","../src/auth/rate-limit.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -27,9 +27,10 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/shared-core": "0.6.41",
-    "@dbx-tools/shared-email": "0.6.41",
+    "@dbx-tools/shared-core": "0.6.42",
+    "@dbx-tools/shared-email": "0.6.42",
     "@mastra/core": "^1.47.0",
+    "jose": "^6.2.3",
     "juice": "^12.1.1",
     "marked": "^18.0.5",
     "nodemailer": "^7.0.13"
@@ -48,7 +49,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.41",
+  "version": "0.6.42",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/auth/allowlist.ts

@@ -0,0 +1,88 @@
+/**
+ * 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: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** Compile a shell-style glob (`*`, `?`) into an anchored, case-insensitive RegExp. */
+function globToRegExp(glob: string): RegExp {
+  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: string): RegExp | undefined {
+  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: string, pattern: string): boolean {
+  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: string, patterns: readonly string[] | undefined): boolean {
+  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: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+}

package/src/auth/gate.ts

@@ -0,0 +1,163 @@
+/**
+ * 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 { http, log } from "@dbx-tools/shared-core";
+import type { AuthStatus } from "@dbx-tools/shared-email";
+import { looksLikeEmail, matchesAllowlist } from "./allowlist.ts";
+import { CodeStore, signSession, verifySession } from "./otp.ts";
+import { RateLimiter } from "./rate-limit.ts";
+
+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";
+
+/** 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 class AuthGate {
+  private readonly codes: CodeStore;
+  // 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.
+  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);
+  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);
+
+  constructor(private readonly options: AuthGateOptions) {
+    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: string, ip: string): Promise<{ ok: true; retryAfter?: number }> {
+    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: string,
+    code: string,
+    ip: string,
+    secure: boolean,
+  ): Promise<{ ok: boolean; token?: string; cookieOptions?: CookieOptions; retryAfter?: number }> {
+    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: boolean): CookieOptions {
+    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: Request): Promise<string | undefined> {
+    // 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: Request): Promise<AuthStatus> {
+    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: string): (req: Request, res: Response, next: NextFunction) => void {
+    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 });
+        }
+      });
+    };
+  }
+}