@dbx-tools/email 0.6.46 → 0.6.49

package/lib/src/plugin.js

@@ -24,7 +24,7 @@
  */
 import { AuthenticationError, ConfigurationError, ConnectionError, ExecutionError, getExecutionContext, Plugin, toPlugin, ValidationError, } from "@databricks/appkit";
 import { defineTool, executeFromRegistry, toolsFromRegistry, } from "@databricks/appkit/beta";
-import { log } from "@dbx-tools/shared-core";
+import { log, string, token } from "@dbx-tools/shared-core";
 import { email as emailWire, } from "@dbx-tools/shared-email";
 import { EMAIL_CONFIG_SCHEMA } from "./config.js";
 import { EMAIL_SENDERS_SETTINGS, EMAIL_VERIFY_SETTINGS } from "./defaults.js";
@@ -154,6 +154,20 @@ export class EmailPlugin extends Plugin {
      * plugin base path, i.e. `GET /api/email/senders`. Runs in the OBO
      * user scope so domain wildcards resolve against the caller's own
      * local part.
+     *
+     * OBO is used only WHEN the request can support it. `asUser(req)` throws
+     * `AuthenticationError` outside `NODE_ENV=development` if the request carries
+     * no forwarded OBO token, and AppKit does not catch a rejection raised inside
+     * a handler - so unconditionally wrapping this route takes the process down
+     * for a caller that authenticated some other way (a `@dbx-tools/cli-tunnel`
+     * OTP session, a health probe, a local `curl`). The user context is only ever
+     * an ENRICHMENT here: without it, wildcard senders simply expand against no
+     * local part. Degrading to the service context therefore answers correctly
+     * instead of failing, and a front-door request is unchanged.
+     *
+     * This is the same rule `@dbx-tools/appkit`'s `identity` module applies in
+     * `"auto"` mode; the header check is inlined rather than taking a dependency
+     * on that package for one predicate.
      */
     injectRoutes(router) {
         this.route(router, {
@@ -161,7 +175,9 @@ export class EmailPlugin extends Plugin {
             method: "get",
             path: SENDERS_ROUTE,
             handler: async (req, res) => {
-                const result = await this.asUser(req).executeListSenders();
+                const oboToken = string.trimToNull(req.header(token.ACCESS_TOKEN_HEADER));
+                const scoped = oboToken === null ? this : this.asUser(req);
+                const result = await scoped.executeListSenders();
                 if (!result.ok) {
                     res.status(result.status).json({ error: result.message });
                     return;
@@ -291,4 +307,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":"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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, string, token } 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   * OBO is used only WHEN the request can support it. `asUser(req)` throws\n   * `AuthenticationError` outside `NODE_ENV=development` if the request carries\n   * no forwarded OBO token, and AppKit does not catch a rejection raised inside\n   * a handler - so unconditionally wrapping this route takes the process down\n   * for a caller that authenticated some other way (a `@dbx-tools/cli-tunnel`\n   * OTP session, a health probe, a local `curl`). The user context is only ever\n   * an ENRICHMENT here: without it, wildcard senders simply expand against no\n   * local part. Degrading to the service context therefore answers correctly\n   * instead of failing, and a front-door request is unchanged.\n   *\n   * This is the same rule `@dbx-tools/appkit`'s `identity` module applies in\n   * `\"auto\"` mode; the header check is inlined rather than taking a dependency\n   * on that package for one predicate.\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 oboToken = string.trimToNull(req.header(token.ACCESS_TOKEN_HEADER));\n        const scoped = oboToken === null ? this : this.asUser(req);\n        const result = await scoped.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"]}

package/lib/src/tool.d.ts

@@ -19,7 +19,7 @@
 /**
  * The model-facing description of the send capability, shared by the Mastra
  * {@link emailTool} and the AppKit `email.send` tool so both agents get the
- * same guidance about approval, scope, and body formatting.
+ * same guidance about approval and scope.
  */
 export declare const SEND_EMAIL_DESCRIPTION: string;
 /** Options accepted by {@link emailTool}. */

package/lib/src/tool.js

@@ -26,7 +26,7 @@ const logger = log.logger("email/tool/send-email");
 /**
  * The model-facing description of the send capability, shared by the Mastra
  * {@link emailTool} and the AppKit `email.send` tool so both agents get the
- * same guidance about approval, scope, and body formatting.
+ * same guidance about approval and scope.
  */
 export const SEND_EMAIL_DESCRIPTION = string.toDescription(`
   Send an email on the user's behalf. Pass one or more recipient
@@ -34,11 +34,9 @@ export const SEND_EMAIL_DESCRIPTION = string.toDescription(`
   and a body; the user is prompted to approve the send before it goes
   out (this tool is approval-gated). Use it only when the user
   explicitly asks to send / forward / share something via email -
-  never autonomously. Keep subjects short and bodies self-contained:
-  the recipient has none of the chat context. Write the body in
-  GitHub-Flavored Markdown - headings, lists, and real Markdown
-  tables - not ASCII art (no "=====" dividers or space/pipe-drawn
-  tables); it is rendered to HTML before sending.
+  never autonomously. Compose whatever subject and body best fulfill
+  the user's request; the configured React Email template handles the
+  responsive layout, rich presentation, and brand styling.
 `);
 /**
  * Build the approval-gated `send_email` tool. Spread it into the agents
@@ -79,4 +77,4 @@ export function emailTool(opts = {}) {
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/transport.d.ts

@@ -89,8 +89,8 @@ export declare function verifyEmailTransport(transporter: Transporter | undefine
  * Send (SMTP mode) or persist (file/outbox mode) one message from the
  * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept
  * one or more addresses, and `attachments` are forwarded as files. The
- * body is markdown: SMTP sends it as both a plain-text part (the raw
- * source) and an HTML part (rendered), and the outbox embeds the
+ * body is rendered by React Email into matching plain-text and HTML MIME
+ * alternatives, and the outbox embeds the
  * rendered HTML in a document. In file mode the returned `messageId` is
  * the path written. Throws when `to` carries no recipient, when the body
  * or attachments exceed the plugin's caps, or when `from` is not permitted

package/lib/src/transport.js

@@ -21,12 +21,12 @@
  *
  * @module
  */
-import { AppKitError, ConfigurationError, ExecutionError, ValidationError, } from "@databricks/appkit";
-import { async, error, log } from "@dbx-tools/shared-core";
+import { ConfigurationError, ExecutionError, ValidationError, } from "@databricks/appkit";
+import { execution, log } from "@dbx-tools/shared-core";
 import nodemailer from "nodemailer";
 import { resolveEmailConfig } from "./config.js";
 import { EMAIL_SEND_SETTINGS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_BODY_CHARS, } from "./defaults.js";
-import { renderEmailHtml } from "./email-html.js";
+import { renderEmail } from "./email-html.js";
 import { writeOutboxEmail } from "./outbox.js";
 import { assertSenderAllowed } from "./sender.js";
 const logger = log.logger("email/transport");
@@ -35,18 +35,7 @@ const logger = log.logger("email/transport");
  * directly, mapping a throw onto the same {@link ExecutionResult} shape so
  * call sites branch on `ok` either way.
  */
-const directExecute = async (fn) => {
-    try {
-        return { ok: true, data: await fn() };
-    }
-    catch (err) {
-        return {
-            ok: false,
-            status: err instanceof AppKitError ? err.statusCode : 500,
-            message: error.errorMessage(err),
-        };
-    }
-};
+const directExecute = execution.directExecutor();
 let runtime;
 /**
  * Return the shared runtime, building it on first use by resolving
@@ -113,19 +102,23 @@ export function resetEmailRuntime() {
  */
 export async function executeWrite(operation, settings, fn, signal) {
     const { execute } = getEmailRuntime();
-    const result = await execute((executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)), settings);
-    if (result.ok)
-        return result.data;
-    // A caller that cancelled is not a failure worth reporting as one.
-    if (signal?.aborted)
-        throw ExecutionError.canceled();
-    logger.warn("execution-failed", {
+    return execution.run({
         operation,
-        status: result.status,
-        error: result.message,
-    });
-    throw new ExecutionError(`email: ${operation} failed`, {
-        context: { operation, status: result.status },
+        settings,
+        execute,
+        fn,
+        signal,
+        canceled: ExecutionError.canceled,
+        failed: (failure) => {
+            logger.warn("execution-failed", {
+                operation: failure.operation,
+                status: failure.status,
+                error: failure.message,
+            });
+            return new ExecutionError(`email: ${failure.operation} failed`, {
+                context: { operation: failure.operation, status: failure.status },
+            });
+        },
     });
 }
 /**
@@ -256,16 +249,17 @@ async function dispatch(message, from, signal) {
         throw ConfigurationError.invalidConnection("SMTP", "No transport was built for the resolved configuration.");
     }
     const attachments = toMailAttachments(message.attachments);
+    const rendered = await renderEmail({
+        subject: message.subject,
+        body: message.body,
+        brand: config.brand,
+    });
     const info = await abortable(transporter.sendMail({
         from,
         to: message.to,
         subject: message.subject,
-        text: message.body,
-        html: renderEmailHtml({
-            subject: message.subject,
-            body: message.body,
-            ...(config.brand ? { brand: config.brand } : {}),
-        }),
+        text: rendered.text,
+        html: rendered.html,
         ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),
         ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),
         ...(attachments ? { attachments } : {}),
@@ -281,8 +275,8 @@ async function dispatch(message, from, signal) {
  * Send (SMTP mode) or persist (file/outbox mode) one message from the
  * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept
  * one or more addresses, and `attachments` are forwarded as files. The
- * body is markdown: SMTP sends it as both a plain-text part (the raw
- * source) and an HTML part (rendered), and the outbox embeds the
+ * body is rendered by React Email into matching plain-text and HTML MIME
+ * alternatives, and the outbox embeds the
  * rendered HTML in a document. In file mode the returned `messageId` is
  * the path written. Throws when `to` carries no recipient, when the body
  * or attachments exceed the plugin's caps, or when `from` is not permitted
@@ -300,4 +294,4 @@ export async function sendEmail(message, from, signal) {
     assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);
     return executeWrite("send", EMAIL_SEND_SETTINGS, (executeSignal) => dispatch(message, from, executeSignal), signal);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email runtime: a lazily-built, process-wide dispatcher plus its\n * resolved config, and {@link sendEmail} which sends one\n * {@link EmailMessage} through it. In SMTP mode the runtime holds a\n * memoized nodemailer transport (shared by the plugin's setup and the\n * agent tool, so they reuse one connection pool); in file/outbox mode it\n * holds no transport and {@link sendEmail} writes HTML to disk instead.\n * The first caller (normally the plugin at setup) primes it with the\n * plugin's config; later callers reuse it.\n *\n * The runtime also carries the {@link EmailExecutor} every outbound send runs\n * through. The plugin installs its own `execute()` there at setup, which is\n * how the Mastra tool - a plain function with no plugin instance in scope -\n * still gets AppKit's retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the send still runs, just\n * without interceptors.\n *\n * Every entry point takes an optional {@link AbortSignal} so the plugin's\n * `execute()` timeout and a client disconnect both stop the caller waiting\n * on SMTP.\n *\n * @module\n */\n\nimport {\n  AppKitError,\n  ConfigurationError,\n  ExecutionError,\n  ValidationError,\n  type ExecutionResult,\n} from \"@databricks/appkit\";\nimport { async, error, log } from \"@dbx-tools/shared-core\";\nimport type { EmailAttachment, EmailMessage, EmailResult } from \"@dbx-tools/shared-email\";\nimport nodemailer, { type SendMailOptions, type Transporter } from \"nodemailer\";\nimport { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from \"./config.ts\";\nimport {\n  EMAIL_SEND_SETTINGS,\n  MAX_ATTACHMENT_BYTES,\n  MAX_ATTACHMENT_COUNT,\n  MAX_ATTACHMENTS_TOTAL_BYTES,\n  MAX_BODY_CHARS,\n  type EmailExecutionSettings,\n} from \"./defaults.ts\";\nimport { renderEmailHtml } from \"./email-html.ts\";\nimport { writeOutboxEmail } from \"./outbox.ts\";\nimport { assertSenderAllowed } from \"./sender.ts\";\n\nconst logger = log.logger(\"email/transport\");\n\n/**\n * Runs one outbound send through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type EmailExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: EmailExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared dispatcher, its resolved config, and the send executor. */\nexport interface EmailRuntime {\n  /** Present only in SMTP mode. */\n  transporter?: Transporter;\n  config: ResolvedEmailConfig;\n  execute: EmailExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the send\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute: EmailExecutor = async (fn) => {\n  try {\n    return { ok: true, data: await fn() };\n  } catch (err) {\n    return {\n      ok: false,\n      status: err instanceof AppKitError ? err.statusCode : 500,\n      message: error.errorMessage(err),\n    };\n  }\n};\n\nlet runtime: EmailRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use by resolving\n * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,\n * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,\n * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through\n * {@link resolveEmailConfig}. With SMTP credentials present it holds a\n * nodemailer transport and its connection pool; otherwise it is in\n * file/outbox mode and holds none.\n *\n * `overrides` is read only on the call that builds the runtime, so prime it\n * from the plugin's config at setup; later callers (the tool's `execute`,\n * the sender-options route) pass nothing and get the same instance. Throws\n * whatever {@link resolveEmailConfig} throws for an unusable configuration.\n */\nexport function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime {\n  if (!runtime) {\n    const config = resolveEmailConfig(overrides);\n    runtime = {\n      config,\n      execute: directExecute,\n      ...(config.mode === \"smtp\"\n        ? {\n            transporter: nodemailer.createTransport({\n              host: config.host,\n              port: config.port,\n              secure: config.secure,\n              auth: config.auth,\n            }),\n          }\n        : {}),\n    };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound sends run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setEmailExecutor(execute: EmailExecutor): void {\n  getEmailRuntime().execute = execute;\n}\n\n/**\n * Drop the memoized runtime, closing the SMTP connection pool, so the next\n * {@link getEmailRuntime} rebuilds it from fresh config and stops calling\n * through a torn-down plugin's `execute()`. Idempotent, and the plugin's\n * `shutdown()` hook.\n */\nexport function resetEmailRuntime(): void {\n  runtime?.transporter?.close();\n  runtime = undefined;\n}\n\n/**\n * Run one non-idempotent write through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeWrite<T>(\n  operation: string,\n  settings: EmailExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getEmailRuntime();\n  const result = await execute(\n    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),\n    settings,\n  );\n  if (result.ok) return result.data;\n  // A caller that cancelled is not a failure worth reporting as one.\n  if (signal?.aborted) throw ExecutionError.canceled();\n  logger.warn(\"execution-failed\", {\n    operation,\n    status: result.status,\n    error: result.message,\n  });\n  throw new ExecutionError(`email: ${operation} failed`, {\n    context: { operation, status: result.status },\n  });\n}\n\n/**\n * Open and tear down one SMTP connection to prove the host, port, and\n * credentials work. Called at plugin setup so a bad relay shows up in the\n * boot logs rather than on the first approved send.\n */\nexport async function verifyEmailTransport(\n  transporter: Transporter | undefined,\n  signal?: AbortSignal,\n): Promise<void> {\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"The runtime resolved to outbox mode, so there is no transport to verify.\",\n    );\n  }\n  await abortable(transporter.verify(), signal);\n}\n\n/**\n * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no\n * cancellation hook, so the SMTP conversation itself finishes on its own\n * connection; what unwinds is the caller and everything downstream of it.\n */\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n  signal.throwIfAborted();\n  // The listener is detached once the race settles so a long-lived run signal\n  // does not accumulate one per send.\n  const listener = new AbortController();\n  const aborted = new Promise<never>((_, reject) => {\n    signal.addEventListener(\"abort\", () => reject(signal.reason), {\n      once: true,\n      signal: listener.signal,\n    });\n  });\n  return Promise.race([promise, aborted]).finally(() => listener.abort());\n}\n\n/** The comma-joined recipient string echoed back in {@link EmailResult}. */\nfunction recipientEcho(to: string[]): string {\n  return to.join(\", \");\n}\n\n/**\n * Node buffer encodings a wire attachment may name for its inline `content`.\n * Anything else is measured as UTF-8, which over-counts rather than letting\n * an unrecognized encoding slip past the size cap.\n */\nconst CONTENT_ENCODINGS: ReadonlySet<string> = new Set([\n  \"ascii\",\n  \"base64\",\n  \"base64url\",\n  \"binary\",\n  \"hex\",\n  \"latin1\",\n  \"ucs2\",\n  \"ucs-2\",\n  \"utf8\",\n  \"utf-8\",\n  \"utf16le\",\n  \"utf-16le\",\n]);\n\n/**\n * Decoded byte size of one attachment's inline content. A `path` attachment\n * contributes nothing: nodemailer streams it, so its bytes never sit in this\n * process and cannot be measured here.\n */\nfunction attachmentBytes(attachment: EmailAttachment): number {\n  const { content, encoding } = attachment;\n  if (content === undefined) return 0;\n  const declared = encoding?.toLowerCase();\n  const resolved =\n    declared && CONTENT_ENCODINGS.has(declared) ? (declared as BufferEncoding) : \"utf8\";\n  return Buffer.byteLength(content, resolved);\n}\n\n/**\n * Reject a message whose body or attachments exceed the plugin's caps. The\n * body and attachment list arrive from a model, so they are unbounded until\n * something bounds them; most SMTP relays also reject an oversized message\n * only after the whole payload has been uploaded.\n */\nfunction assertMessageWithinCaps(message: EmailMessage): void {\n  if (message.body.length > MAX_BODY_CHARS) {\n    throw ValidationError.invalidValue(\n      \"body\",\n      message.body.length,\n      `at most ${MAX_BODY_CHARS} characters`,\n    );\n  }\n  const attachments = message.attachments ?? [];\n  if (attachments.length > MAX_ATTACHMENT_COUNT) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      attachments.length,\n      `at most ${MAX_ATTACHMENT_COUNT} files`,\n    );\n  }\n  let total = 0;\n  for (const attachment of attachments) {\n    const bytes = attachmentBytes(attachment);\n    if (bytes > MAX_ATTACHMENT_BYTES) {\n      throw ValidationError.invalidValue(\n        \"attachments[].content\",\n        bytes,\n        `at most ${MAX_ATTACHMENT_BYTES} bytes per file`,\n      );\n    }\n    total += bytes;\n  }\n  if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      total,\n      `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`,\n    );\n  }\n}\n\n/**\n * Map the wire-format {@link EmailAttachment}s onto nodemailer's\n * attachment shape, dropping unset optional keys so nodemailer applies\n * its own defaults (utf-8 encoding, filename-inferred content type). The\n * wire fields are a deliberate subset of nodemailer's, so this is a\n * straight structural pass-through.\n */\nfunction toMailAttachments(\n  attachments: EmailAttachment[] | undefined,\n): SendMailOptions[\"attachments\"] {\n  if (!attachments || attachments.length === 0) return undefined;\n  return attachments.map((att) => ({\n    filename: att.filename,\n    ...(att.content !== undefined ? { content: att.content } : {}),\n    ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),\n    ...(att.path !== undefined ? { path: att.path } : {}),\n    ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),\n  }));\n}\n\n/**\n * Hand one already-validated message to SMTP, or write it to the outbox when\n * no credentials are configured. The half of a send that performs I/O, so it\n * is what runs inside the interceptor chain.\n */\nasync function dispatch(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  const { config, transporter } = getEmailRuntime();\n  const recipient = recipientEcho(message.to);\n  signal?.throwIfAborted();\n\n  if (config.mode === \"file\") {\n    const path = await writeOutboxEmail(message, from, config.outDir, config.brand);\n    return { sent: true, recipient, from, messageId: path };\n  }\n\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"No transport was built for the resolved configuration.\",\n    );\n  }\n  const attachments = toMailAttachments(message.attachments);\n  const info = await abortable(\n    transporter.sendMail({\n      from,\n      to: message.to,\n      subject: message.subject,\n      text: message.body,\n      html: renderEmailHtml({\n        subject: message.subject,\n        body: message.body,\n        ...(config.brand ? { brand: config.brand } : {}),\n      }),\n      ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),\n      ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),\n      ...(attachments ? { attachments } : {}),\n    }),\n    signal,\n  );\n  return {\n    sent: true,\n    recipient,\n    from,\n    ...(info.messageId ? { messageId: info.messageId } : {}),\n  };\n}\n\n/**\n * Send (SMTP mode) or persist (file/outbox mode) one message from the\n * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept\n * one or more addresses, and `attachments` are forwarded as files. The\n * body is markdown: SMTP sends it as both a plain-text part (the raw\n * source) and an HTML part (rendered), and the outbox embeds the\n * rendered HTML in a document. In file mode the returned `messageId` is\n * the path written. Throws when `to` carries no recipient, when the body\n * or attachments exceed the plugin's caps, or when `from` is not permitted\n * by the effective sender allow-list.\n *\n * The recipient, cap, and sender checks run before the interceptor chain so\n * their specific status and actionable message reach the caller instead of\n * the chain's stable failure text. `signal` cancels the send.\n */\nexport async function sendEmail(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  if (message.to.length === 0) {\n    throw ValidationError.missingField(\"to\");\n  }\n  assertMessageWithinCaps(message);\n  assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);\n  return executeWrite(\n    \"send\",\n    EMAIL_SEND_SETTINGS,\n    (executeSignal) => dispatch(message, from, executeSignal),\n    signal,\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email runtime: a lazily-built, process-wide dispatcher plus its\n * resolved config, and {@link sendEmail} which sends one\n * {@link EmailMessage} through it. In SMTP mode the runtime holds a\n * memoized nodemailer transport (shared by the plugin's setup and the\n * agent tool, so they reuse one connection pool); in file/outbox mode it\n * holds no transport and {@link sendEmail} writes HTML to disk instead.\n * The first caller (normally the plugin at setup) primes it with the\n * plugin's config; later callers reuse it.\n *\n * The runtime also carries the {@link EmailExecutor} every outbound send runs\n * through. The plugin installs its own `execute()` there at setup, which is\n * how the Mastra tool - a plain function with no plugin instance in scope -\n * still gets AppKit's retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the send still runs, just\n * without interceptors.\n *\n * Every entry point takes an optional {@link AbortSignal} so the plugin's\n * `execute()` timeout and a client disconnect both stop the caller waiting\n * on SMTP.\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ExecutionError,\n  ValidationError,\n  type ExecutionResult,\n} from \"@databricks/appkit\";\nimport { execution, log } from \"@dbx-tools/shared-core\";\nimport type { EmailAttachment, EmailMessage, EmailResult } from \"@dbx-tools/shared-email\";\nimport nodemailer, { type SendMailOptions, type Transporter } from \"nodemailer\";\nimport { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from \"./config.ts\";\nimport {\n  EMAIL_SEND_SETTINGS,\n  MAX_ATTACHMENT_BYTES,\n  MAX_ATTACHMENT_COUNT,\n  MAX_ATTACHMENTS_TOTAL_BYTES,\n  MAX_BODY_CHARS,\n  type EmailExecutionSettings,\n} from \"./defaults.ts\";\nimport { renderEmail } from \"./email-html.ts\";\nimport { writeOutboxEmail } from \"./outbox.ts\";\nimport { assertSenderAllowed } from \"./sender.ts\";\n\nconst logger = log.logger(\"email/transport\");\n\n/**\n * Runs one outbound send through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type EmailExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: EmailExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared dispatcher, its resolved config, and the send executor. */\nexport interface EmailRuntime {\n  /** Present only in SMTP mode. */\n  transporter?: Transporter;\n  config: ResolvedEmailConfig;\n  execute: EmailExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the send\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute = execution.directExecutor<EmailExecutionSettings>();\n\nlet runtime: EmailRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use by resolving\n * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,\n * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,\n * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through\n * {@link resolveEmailConfig}. With SMTP credentials present it holds a\n * nodemailer transport and its connection pool; otherwise it is in\n * file/outbox mode and holds none.\n *\n * `overrides` is read only on the call that builds the runtime, so prime it\n * from the plugin's config at setup; later callers (the tool's `execute`,\n * the sender-options route) pass nothing and get the same instance. Throws\n * whatever {@link resolveEmailConfig} throws for an unusable configuration.\n */\nexport function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime {\n  if (!runtime) {\n    const config = resolveEmailConfig(overrides);\n    runtime = {\n      config,\n      execute: directExecute,\n      ...(config.mode === \"smtp\"\n        ? {\n            transporter: nodemailer.createTransport({\n              host: config.host,\n              port: config.port,\n              secure: config.secure,\n              auth: config.auth,\n            }),\n          }\n        : {}),\n    };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound sends run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setEmailExecutor(execute: EmailExecutor): void {\n  getEmailRuntime().execute = execute;\n}\n\n/**\n * Drop the memoized runtime, closing the SMTP connection pool, so the next\n * {@link getEmailRuntime} rebuilds it from fresh config and stops calling\n * through a torn-down plugin's `execute()`. Idempotent, and the plugin's\n * `shutdown()` hook.\n */\nexport function resetEmailRuntime(): void {\n  runtime?.transporter?.close();\n  runtime = undefined;\n}\n\n/**\n * Run one non-idempotent write through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeWrite<T>(\n  operation: string,\n  settings: EmailExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getEmailRuntime();\n  return execution.run({\n    operation,\n    settings,\n    execute,\n    fn,\n    signal,\n    canceled: ExecutionError.canceled,\n    failed: (failure) => {\n      logger.warn(\"execution-failed\", {\n        operation: failure.operation,\n        status: failure.status,\n        error: failure.message,\n      });\n      return new ExecutionError(`email: ${failure.operation} failed`, {\n        context: { operation: failure.operation, status: failure.status },\n      });\n    },\n  });\n}\n\n/**\n * Open and tear down one SMTP connection to prove the host, port, and\n * credentials work. Called at plugin setup so a bad relay shows up in the\n * boot logs rather than on the first approved send.\n */\nexport async function verifyEmailTransport(\n  transporter: Transporter | undefined,\n  signal?: AbortSignal,\n): Promise<void> {\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"The runtime resolved to outbox mode, so there is no transport to verify.\",\n    );\n  }\n  await abortable(transporter.verify(), signal);\n}\n\n/**\n * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no\n * cancellation hook, so the SMTP conversation itself finishes on its own\n * connection; what unwinds is the caller and everything downstream of it.\n */\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n  signal.throwIfAborted();\n  // The listener is detached once the race settles so a long-lived run signal\n  // does not accumulate one per send.\n  const listener = new AbortController();\n  const aborted = new Promise<never>((_, reject) => {\n    signal.addEventListener(\"abort\", () => reject(signal.reason), {\n      once: true,\n      signal: listener.signal,\n    });\n  });\n  return Promise.race([promise, aborted]).finally(() => listener.abort());\n}\n\n/** The comma-joined recipient string echoed back in {@link EmailResult}. */\nfunction recipientEcho(to: string[]): string {\n  return to.join(\", \");\n}\n\n/**\n * Node buffer encodings a wire attachment may name for its inline `content`.\n * Anything else is measured as UTF-8, which over-counts rather than letting\n * an unrecognized encoding slip past the size cap.\n */\nconst CONTENT_ENCODINGS: ReadonlySet<string> = new Set([\n  \"ascii\",\n  \"base64\",\n  \"base64url\",\n  \"binary\",\n  \"hex\",\n  \"latin1\",\n  \"ucs2\",\n  \"ucs-2\",\n  \"utf8\",\n  \"utf-8\",\n  \"utf16le\",\n  \"utf-16le\",\n]);\n\n/**\n * Decoded byte size of one attachment's inline content. A `path` attachment\n * contributes nothing: nodemailer streams it, so its bytes never sit in this\n * process and cannot be measured here.\n */\nfunction attachmentBytes(attachment: EmailAttachment): number {\n  const { content, encoding } = attachment;\n  if (content === undefined) return 0;\n  const declared = encoding?.toLowerCase();\n  const resolved =\n    declared && CONTENT_ENCODINGS.has(declared) ? (declared as BufferEncoding) : \"utf8\";\n  return Buffer.byteLength(content, resolved);\n}\n\n/**\n * Reject a message whose body or attachments exceed the plugin's caps. The\n * body and attachment list arrive from a model, so they are unbounded until\n * something bounds them; most SMTP relays also reject an oversized message\n * only after the whole payload has been uploaded.\n */\nfunction assertMessageWithinCaps(message: EmailMessage): void {\n  if (message.body.length > MAX_BODY_CHARS) {\n    throw ValidationError.invalidValue(\n      \"body\",\n      message.body.length,\n      `at most ${MAX_BODY_CHARS} characters`,\n    );\n  }\n  const attachments = message.attachments ?? [];\n  if (attachments.length > MAX_ATTACHMENT_COUNT) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      attachments.length,\n      `at most ${MAX_ATTACHMENT_COUNT} files`,\n    );\n  }\n  let total = 0;\n  for (const attachment of attachments) {\n    const bytes = attachmentBytes(attachment);\n    if (bytes > MAX_ATTACHMENT_BYTES) {\n      throw ValidationError.invalidValue(\n        \"attachments[].content\",\n        bytes,\n        `at most ${MAX_ATTACHMENT_BYTES} bytes per file`,\n      );\n    }\n    total += bytes;\n  }\n  if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      total,\n      `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`,\n    );\n  }\n}\n\n/**\n * Map the wire-format {@link EmailAttachment}s onto nodemailer's\n * attachment shape, dropping unset optional keys so nodemailer applies\n * its own defaults (utf-8 encoding, filename-inferred content type). The\n * wire fields are a deliberate subset of nodemailer's, so this is a\n * straight structural pass-through.\n */\nfunction toMailAttachments(\n  attachments: EmailAttachment[] | undefined,\n): SendMailOptions[\"attachments\"] {\n  if (!attachments || attachments.length === 0) return undefined;\n  return attachments.map((att) => ({\n    filename: att.filename,\n    ...(att.content !== undefined ? { content: att.content } : {}),\n    ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),\n    ...(att.path !== undefined ? { path: att.path } : {}),\n    ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),\n  }));\n}\n\n/**\n * Hand one already-validated message to SMTP, or write it to the outbox when\n * no credentials are configured. The half of a send that performs I/O, so it\n * is what runs inside the interceptor chain.\n */\nasync function dispatch(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  const { config, transporter } = getEmailRuntime();\n  const recipient = recipientEcho(message.to);\n  signal?.throwIfAborted();\n\n  if (config.mode === \"file\") {\n    const path = await writeOutboxEmail(message, from, config.outDir, config.brand);\n    return { sent: true, recipient, from, messageId: path };\n  }\n\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"No transport was built for the resolved configuration.\",\n    );\n  }\n  const attachments = toMailAttachments(message.attachments);\n  const rendered = await renderEmail({\n    subject: message.subject,\n    body: message.body,\n    brand: config.brand,\n  });\n  const info = await abortable(\n    transporter.sendMail({\n      from,\n      to: message.to,\n      subject: message.subject,\n      text: rendered.text,\n      html: rendered.html,\n      ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),\n      ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),\n      ...(attachments ? { attachments } : {}),\n    }),\n    signal,\n  );\n  return {\n    sent: true,\n    recipient,\n    from,\n    ...(info.messageId ? { messageId: info.messageId } : {}),\n  };\n}\n\n/**\n * Send (SMTP mode) or persist (file/outbox mode) one message from the\n * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept\n * one or more addresses, and `attachments` are forwarded as files. The\n * body is rendered by React Email into matching plain-text and HTML MIME\n * alternatives, and the outbox embeds the\n * rendered HTML in a document. In file mode the returned `messageId` is\n * the path written. Throws when `to` carries no recipient, when the body\n * or attachments exceed the plugin's caps, or when `from` is not permitted\n * by the effective sender allow-list.\n *\n * The recipient, cap, and sender checks run before the interceptor chain so\n * their specific status and actionable message reach the caller instead of\n * the chain's stable failure text. `signal` cancels the send.\n */\nexport async function sendEmail(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  if (message.to.length === 0) {\n    throw ValidationError.missingField(\"to\");\n  }\n  assertMessageWithinCaps(message);\n  assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);\n  return executeWrite(\n    \"send\",\n    EMAIL_SEND_SETTINGS,\n    (executeSignal) => dispatch(message, from, executeSignal),\n    signal,\n  );\n}\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/markdown.ts","../src/outbox.ts","../src/plugin.ts","../src/sender.ts","../src/tool.ts","../src/transport.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -27,12 +27,14 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/shared-core": "0.6.46",
-    "@dbx-tools/shared-email": "0.6.46",
+    "@dbx-tools/shared-core": "0.6.49",
+    "@dbx-tools/shared-email": "0.6.49",
+    "@dbx-tools/shared-email-template": "0.6.49",
     "@mastra/core": "^1.47.0",
-    "juice": "^12.1.1",
-    "marked": "^18.0.5",
-    "nodemailer": "^7.0.13"
+    "@react-email/render": "^2.1.0",
+    "nodemailer": "^7.0.13",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -48,7 +50,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.46",
+  "version": "0.6.49",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/brand.ts

@@ -1,64 +1,14 @@
 /**
- * Optional brand styling for outbound email. {@link EmailBrand} is the
- * small, email-safe slice of a brand a message actually needs - an accent
- * color, a font stack, a display name, and an optional logo image - and
- * {@link emailBrandFromContext} derives it from the portable `BrandContext`
- * shared across the UI and libraries.
+ * Email brand compatibility exports.
  *
- * Email can't use the `[data-brand]` CSS bridge the browser UI uses (mail
- * clients strip `<style>` blocks and ignore `var()`), so branding is applied
- * by inlining these values at render time. A logo is only emitted when it's
- * a fetchable `http(s):` or `data:` URL - a package-export path (the default
- * asset form) can't resolve in an inbox, so it's dropped rather than shown
- * as a broken image.
+ * The universal brand contract and defaults live with the shared React Email
+ * template so Node delivery and browser previews cannot drift.
  *
  * @module
  */
-import { brand, type BrandContext } from "@dbx-tools/shared-core";
-
-/** Email-safe brand values inlined into the message layout at render time. */
-export interface EmailBrand {
-  /** Header-band background and link color. */
-  accent: string;
-  /** Text and logo color rendered on the accent band. Defaults to white. */
-  onAccent?: string;
-  /** Body font stack. */
-  fontFamily: string;
-  /** Product/display name, used as the header text and the logo `alt`. */
-  name?: string;
-  /**
-   * Logo image rendered in the header band. Only an `http(s):` or `data:`
-   * URL renders; other values (e.g. a package-export path) are ignored,
-   * since they can't load in a mail client.
-   */
-  logoUrl?: string;
-}
-
-/** Whether `value` is an image reference a mail client can actually load. */
-function isRenderableImageUrl(value: string | undefined): value is string {
-  return typeof value === "string" && /^(?:https?:|data:)/i.test(value);
-}
-
-/**
- * Derive the email-safe {@link EmailBrand} from a full brand context: the
- * primary color as the accent, the sans font stack, the display name, and
- * the dark-surface logo (the header band is dark) when it's a renderable URL.
- */
-export function emailBrandFromContext(context: BrandContext): EmailBrand {
-  const logo = context.assets.logo.dark ?? context.assets.logo.light;
-  return {
-    accent: context.colors.primary,
-    onAccent: "#ffffff",
-    fontFamily: context.typography.sans,
-    name: context.name,
-    ...(isRenderableImageUrl(logo) ? { logoUrl: logo } : {}),
-  };
-}
-
-/**
- * The dbx-tools brand as an {@link EmailBrand}, ready to pass to the email
- * plugin (`email({ brand: defaultEmailBrand })`). Convenience so a consumer
- * needs only `@dbx-tools/email`, not the shared brand context, for the
- * common case of the default brand.
- */
-export const defaultEmailBrand: EmailBrand = emailBrandFromContext(brand.defaultBrandContext);
+export {
+  defaultEmailBrand,
+  emailBrandFromContext,
+  resolveEmailBrand,
+} from "@dbx-tools/shared-email-template";
+export type { EmailBrand, ResolvedEmailBrand } from "@dbx-tools/shared-email-template";