@dbx-tools/email 0.3.43 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+export * as brand from "./src/brand.js";
+export * as config from "./src/config.js";
+export * as defaults from "./src/defaults.js";
+export * as emailHtml from "./src/email-html.js";
+export * as markdown from "./src/markdown.js";
+export * as outbox from "./src/outbox.js";
+export * as plugin from "./src/plugin.js";
+export * as sender from "./src/sender.js";
+export * as tool from "./src/tool.js";
+export * as transport from "./src/transport.js";
+export { emailBrandFromContext, defaultEmailBrand } from "./src/brand.js";
+export type { EmailBrand } from "./src/brand.js";
+export { DEFAULT_SMTP_PORT, IMPLICIT_TLS_SMTP_PORT, EMAIL_CONFIG_SCHEMA, resolveEmailConfig } from "./src/config.js";
+export type { SenderPolicy, SmtpConfig, EmailPluginConfig, ResolvedSmtpConfig, ResolvedFileConfig, ResolvedEmailConfig } from "./src/config.js";
+export { SEND_TIMEOUT_MS, VERIFY_TIMEOUT_MS, VERIFY_ATTEMPTS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_COUNT, MAX_BODY_CHARS, EMAIL_SEND_SETTINGS, EMAIL_VERIFY_SETTINGS, EMAIL_SENDERS_SETTINGS } from "./src/defaults.js";
+export type { EmailExecuteConfig, EmailExecutionSettings } from "./src/defaults.js";
+export { escapeHtml, renderEmailHtml } from "./src/email-html.js";
+export type { EmailHtmlOptions } from "./src/email-html.js";
+export { normalizeMarkdown, markdownToHtml } from "./src/markdown.js";
+export { writeOutboxEmail } from "./src/outbox.js";
+export { EmailPlugin, email } from "./src/plugin.js";
+export { deriveSenderAddress, parseAllowedSenders, isSenderAllowed, assertSenderAllowed, resolveSenderAddress, listSenderOptions } from "./src/sender.js";
+export { SEND_EMAIL_DESCRIPTION, emailTool } from "./src/tool.js";
+export type { EmailToolOptions } from "./src/tool.js";
+export { getEmailRuntime, setEmailExecutor, resetEmailRuntime, executeWrite, verifyEmailTransport, sendEmail } from "./src/transport.js";
+export type { EmailExecutor, EmailRuntime } from "./src/transport.js";

package/lib/index.js

@@ -0,0 +1,24 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as brand from "./src/brand.js";
+export * as config from "./src/config.js";
+export * as defaults from "./src/defaults.js";
+export * as emailHtml from "./src/email-html.js";
+export * as markdown from "./src/markdown.js";
+export * as outbox from "./src/outbox.js";
+export * as plugin from "./src/plugin.js";
+export * as sender from "./src/sender.js";
+export * as tool from "./src/tool.js";
+export * as transport from "./src/transport.js";
+export { emailBrandFromContext, defaultEmailBrand } from "./src/brand.js";
+export { DEFAULT_SMTP_PORT, IMPLICIT_TLS_SMTP_PORT, EMAIL_CONFIG_SCHEMA, resolveEmailConfig } from "./src/config.js";
+export { SEND_TIMEOUT_MS, VERIFY_TIMEOUT_MS, VERIFY_ATTEMPTS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_COUNT, MAX_BODY_CHARS, EMAIL_SEND_SETTINGS, EMAIL_VERIFY_SETTINGS, EMAIL_SENDERS_SETTINGS } from "./src/defaults.js";
+export { escapeHtml, renderEmailHtml } from "./src/email-html.js";
+export { normalizeMarkdown, markdownToHtml } from "./src/markdown.js";
+export { writeOutboxEmail } from "./src/outbox.js";
+export { EmailPlugin, email } from "./src/plugin.js";
+export { deriveSenderAddress, parseAllowedSenders, isSenderAllowed, assertSenderAllowed, resolveSenderAddress, listSenderOptions } from "./src/sender.js";
+export { SEND_EMAIL_DESCRIPTION, emailTool } from "./src/tool.js";
+export { getEmailRuntime, setEmailExecutor, resetEmailRuntime, executeWrite, verifyEmailTransport, sendEmail } from "./src/transport.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssS0FBSyxNQUFNLGFBQWEsQ0FBQztBQUNyQyxPQUFPLEtBQUssTUFBTSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEtBQUssUUFBUSxNQUFNLGdCQUFnQixDQUFDO0FBQzNDLE9BQU8sS0FBSyxTQUFTLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxLQUFLLFFBQVEsTUFBTSxnQkFBZ0IsQ0FBQztBQUMzQyxPQUFPLEtBQUssTUFBTSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEtBQUssTUFBTSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEtBQUssTUFBTSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEtBQUssSUFBSSxNQUFNLFlBQVksQ0FBQztBQUNuQyxPQUFPLEtBQUssU0FBUyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUV2RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsc0JBQXNCLEVBQUUsbUJBQW1CLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFbEgsT0FBTyxFQUFFLGVBQWUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsb0JBQW9CLEVBQUUsMkJBQTJCLEVBQUUsb0JBQW9CLEVBQUUsY0FBYyxFQUFFLG1CQUFtQixFQUFFLHFCQUFxQixFQUFFLHNCQUFzQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFbFAsT0FBTyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDbkUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2hELE9BQU8sRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2xELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxtQkFBbUIsRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsb0JBQW9CLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDdkosT0FBTyxFQUFFLHNCQUFzQixFQUFFLFNBQVMsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUvRCxPQUFPLEVBQUUsZUFBZSxFQUFFLGdCQUFnQixFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxvQkFBb0IsRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIGJyYW5kIGZyb20gXCIuL3NyYy9icmFuZFwiO1xuZXhwb3J0ICogYXMgY29uZmlnIGZyb20gXCIuL3NyYy9jb25maWdcIjtcbmV4cG9ydCAqIGFzIGRlZmF1bHRzIGZyb20gXCIuL3NyYy9kZWZhdWx0c1wiO1xuZXhwb3J0ICogYXMgZW1haWxIdG1sIGZyb20gXCIuL3NyYy9lbWFpbC1odG1sXCI7XG5leHBvcnQgKiBhcyBtYXJrZG93biBmcm9tIFwiLi9zcmMvbWFya2Rvd25cIjtcbmV4cG9ydCAqIGFzIG91dGJveCBmcm9tIFwiLi9zcmMvb3V0Ym94XCI7XG5leHBvcnQgKiBhcyBwbHVnaW4gZnJvbSBcIi4vc3JjL3BsdWdpblwiO1xuZXhwb3J0ICogYXMgc2VuZGVyIGZyb20gXCIuL3NyYy9zZW5kZXJcIjtcbmV4cG9ydCAqIGFzIHRvb2wgZnJvbSBcIi4vc3JjL3Rvb2xcIjtcbmV4cG9ydCAqIGFzIHRyYW5zcG9ydCBmcm9tIFwiLi9zcmMvdHJhbnNwb3J0XCI7XG5leHBvcnQgeyBlbWFpbEJyYW5kRnJvbUNvbnRleHQsIGRlZmF1bHRFbWFpbEJyYW5kIH0gZnJvbSBcIi4vc3JjL2JyYW5kXCI7XG5leHBvcnQgdHlwZSB7IEVtYWlsQnJhbmQgfSBmcm9tIFwiLi9zcmMvYnJhbmRcIjtcbmV4cG9ydCB7IERFRkFVTFRfU01UUF9QT1JULCBJTVBMSUNJVF9UTFNfU01UUF9QT1JULCBFTUFJTF9DT05GSUdfU0NIRU1BLCByZXNvbHZlRW1haWxDb25maWcgfSBmcm9tIFwiLi9zcmMvY29uZmlnXCI7XG5leHBvcnQgdHlwZSB7IFNlbmRlclBvbGljeSwgU210cENvbmZpZywgRW1haWxQbHVnaW5Db25maWcsIFJlc29sdmVkU210cENvbmZpZywgUmVzb2x2ZWRGaWxlQ29uZmlnLCBSZXNvbHZlZEVtYWlsQ29uZmlnIH0gZnJvbSBcIi4vc3JjL2NvbmZpZ1wiO1xuZXhwb3J0IHsgU0VORF9USU1FT1VUX01TLCBWRVJJRllfVElNRU9VVF9NUywgVkVSSUZZX0FUVEVNUFRTLCBNQVhfQVRUQUNITUVOVF9CWVRFUywgTUFYX0FUVEFDSE1FTlRTX1RPVEFMX0JZVEVTLCBNQVhfQVRUQUNITUVOVF9DT1VOVCwgTUFYX0JPRFlfQ0hBUlMsIEVNQUlMX1NFTkRfU0VUVElOR1MsIEVNQUlMX1ZFUklGWV9TRVRUSU5HUywgRU1BSUxfU0VOREVSU19TRVRUSU5HUyB9IGZyb20gXCIuL3NyYy9kZWZhdWx0c1wiO1xuZXhwb3J0IHR5cGUgeyBFbWFpbEV4ZWN1dGVDb25maWcsIEVtYWlsRXhlY3V0aW9uU2V0dGluZ3MgfSBmcm9tIFwiLi9zcmMvZGVmYXVsdHNcIjtcbmV4cG9ydCB7IGVzY2FwZUh0bWwsIHJlbmRlckVtYWlsSHRtbCB9IGZyb20gXCIuL3NyYy9lbWFpbC1odG1sXCI7XG5leHBvcnQgdHlwZSB7IEVtYWlsSHRtbE9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvZW1haWwtaHRtbFwiO1xuZXhwb3J0IHsgbm9ybWFsaXplTWFya2Rvd24sIG1hcmtkb3duVG9IdG1sIH0gZnJvbSBcIi4vc3JjL21hcmtkb3duXCI7XG5leHBvcnQgeyB3cml0ZU91dGJveEVtYWlsIH0gZnJvbSBcIi4vc3JjL291dGJveFwiO1xuZXhwb3J0IHsgRW1haWxQbHVnaW4sIGVtYWlsIH0gZnJvbSBcIi4vc3JjL3BsdWdpblwiO1xuZXhwb3J0IHsgZGVyaXZlU2VuZGVyQWRkcmVzcywgcGFyc2VBbGxvd2VkU2VuZGVycywgaXNTZW5kZXJBbGxvd2VkLCBhc3NlcnRTZW5kZXJBbGxvd2VkLCByZXNvbHZlU2VuZGVyQWRkcmVzcywgbGlzdFNlbmRlck9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvc2VuZGVyXCI7XG5leHBvcnQgeyBTRU5EX0VNQUlMX0RFU0NSSVBUSU9OLCBlbWFpbFRvb2wgfSBmcm9tIFwiLi9zcmMvdG9vbFwiO1xuZXhwb3J0IHR5cGUgeyBFbWFpbFRvb2xPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3Rvb2xcIjtcbmV4cG9ydCB7IGdldEVtYWlsUnVudGltZSwgc2V0RW1haWxFeGVjdXRvciwgcmVzZXRFbWFpbFJ1bnRpbWUsIGV4ZWN1dGVXcml0ZSwgdmVyaWZ5RW1haWxUcmFuc3BvcnQsIHNlbmRFbWFpbCB9IGZyb20gXCIuL3NyYy90cmFuc3BvcnRcIjtcbmV4cG9ydCB0eXBlIHsgRW1haWxFeGVjdXRvciwgRW1haWxSdW50aW1lIH0gZnJvbSBcIi4vc3JjL3RyYW5zcG9ydFwiO1xuIl19

package/lib/src/brand.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 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.
+ *
+ * @module
+ */
+import { 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;
+}
+/**
+ * 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 declare function emailBrandFromContext(context: BrandContext): EmailBrand;
+/**
+ * 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 declare const defaultEmailBrand: EmailBrand;

package/lib/src/brand.js

@@ -0,0 +1,44 @@
+/**
+ * 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 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.
+ *
+ * @module
+ */
+import { brand } from "@dbx-tools/shared-core";
+/** Whether `value` is an image reference a mail client can actually load. */
+function isRenderableImageUrl(value) {
+    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) {
+    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 = emailBrandFromContext(brand.defaultBrandContext);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/config.d.ts

@@ -0,0 +1,143 @@
+import { type BasePluginConfig } from "@databricks/appkit";
+import type { JSONSchema7 } from "json-schema";
+import type { EmailBrand } from "./brand.js";
+/** SMTP submission port used when none is configured. */
+export declare const DEFAULT_SMTP_PORT = 587;
+/** SMTP port that implies a TLS-on-connect socket rather than STARTTLS. */
+export declare const IMPLICIT_TLS_SMTP_PORT = 465;
+/**
+ * How the sender (`From`) address is restricted.
+ *
+ * `"allowlist"` is the default and the deny-by-default posture: a send is
+ * permitted only from an address the configuration names, either through
+ * {@link EmailPluginConfig.allowedSenders} or, when that is empty, through
+ * the configured sender source ({@link EmailPluginConfig.from} as an exact
+ * address, {@link EmailPluginConfig.domain} as a `*@domain` wildcard).
+ *
+ * `"unrestricted"` is the explicit opt-out: any `From` a caller supplies is
+ * accepted. Only reach for it when an upstream system already vets the
+ * sender.
+ */
+export type SenderPolicy = "allowlist" | "unrestricted";
+/** SMTP connection + credentials. All fields fall back to env when unset. */
+export interface SmtpConfig {
+    /** SMTP server hostname (`SMTP_HOST`). */
+    host?: string;
+    /** SMTP server port (`SMTP_PORT`). Defaults to {@link DEFAULT_SMTP_PORT}. */
+    port?: number;
+    /**
+     * Use a TLS-on-connect socket (`SMTP_SECURE`). Defaults to
+     * `port === ` {@link IMPLICIT_TLS_SMTP_PORT}.
+     */
+    secure?: boolean;
+    /** SMTP auth username (`SMTP_USER`). */
+    user?: string;
+    /** SMTP auth password / API key (`SMTP_PASSWORD`). */
+    password?: string;
+}
+/** AppKit config accepted by the email plugin. */
+export interface EmailPluginConfig extends BasePluginConfig {
+    /** SMTP connection + credentials. Omit to run in file/outbox mode. */
+    smtp?: SmtpConfig;
+    /**
+     * Domain used to build the sender address from the on-behalf-of user
+     * (`<local-part>@<domain>`). Falls back to `EMAIL_DOMAIN`. Required in
+     * SMTP mode unless {@link from} is set; optional in file mode (the
+     * outbox falls back to the user's own email address).
+     */
+    domain?: string;
+    /**
+     * Explicit `From` address. When set, the sender is used verbatim and
+     * the per-user derivation is skipped. Falls back to `EMAIL_FROM`.
+     */
+    from?: string;
+    /**
+     * Directory for the file/outbox fallback. Falls back to
+     * `EMAIL_OUTBOX_DIR`, then `<cwd>/tmp`. Only used when SMTP
+     * credentials are absent.
+     */
+    outDir?: string;
+    /**
+     * Allow-list restricting the sender (`From`) address. Each entry is an
+     * exact address (`user@domain.com`), a domain wildcard (`*@domain.com`
+     * or the bare `domain.com`, matching any local part on that domain), or
+     * `*` (any). A resolved / chosen sender that matches no entry is
+     * rejected at send time. Accepts a `string[]` or a single comma- /
+     * whitespace-separated string; falls back to `EMAIL_ALLOWED_SENDERS`.
+     * When empty, the {@link senderPolicy} decides what is permitted.
+     */
+    allowedSenders?: string | string[];
+    /**
+     * How the sender address is restricted when {@link allowedSenders} is
+     * empty (`EMAIL_SENDER_POLICY`). Defaults to `"allowlist"`, which
+     * narrows sends to the configured sender source. See
+     * {@link SenderPolicy}.
+     */
+    senderPolicy?: SenderPolicy;
+    /**
+     * Optional brand styling (accent, font, header logo) applied to the
+     * rendered HTML of every message. Omit for the neutral default layout.
+     * Pass {@link emailBrandFromContext} to derive it from a shared
+     * `BrandContext`.
+     */
+    brand?: EmailBrand;
+}
+/** Config shared by both resolved modes. */
+interface ResolvedSender {
+    /** Sender domain; present whenever {@link from} is absent. */
+    domain?: string;
+    /** Explicit sender override; present skips per-user derivation. */
+    from?: string;
+    /**
+     * Effective sender allow-list: the configured patterns when any were
+     * given, else the patterns implied by the sender source under an
+     * `"allowlist"` policy. Empty means unenforceable (an `"unrestricted"`
+     * policy, or an outbox with no sender source to narrow to).
+     */
+    allowedSenders: string[];
+    /** The restriction mode the allow-list was resolved under. */
+    senderPolicy: SenderPolicy;
+    /** Brand styling applied to rendered HTML; absent for the default layout. */
+    brand?: EmailBrand;
+}
+/** Resolved config for real SMTP delivery. */
+export interface ResolvedSmtpConfig extends ResolvedSender {
+    mode: "smtp";
+    host: string;
+    port: number;
+    secure: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+}
+/** Resolved config for the file/outbox fallback (no SMTP credentials). */
+export interface ResolvedFileConfig extends ResolvedSender {
+    mode: "file";
+    /** Absolute directory messages are written under. */
+    outDir: string;
+}
+/** Concrete, validated config the runtime dispatches through. */
+export type ResolvedEmailConfig = ResolvedSmtpConfig | ResolvedFileConfig;
+/** JSON Schema published on the manifest's `config.schema`. */
+export declare const EMAIL_CONFIG_SCHEMA: JSONSchema7;
+/**
+ * Resolve plugin config over environment defaults.
+ *
+ * When SMTP host + user + password are all present, returns `mode:
+ * "smtp"` for real delivery (and throws if no sender source - domain or
+ * from - is configured, since SMTP can't derive one from nothing).
+ * When all three are absent and `EMAIL_OUTBOX_MODE` is enabled, returns
+ * `mode: "file"` so the runtime writes messages to the outbox directory
+ * for local testing; in that mode a sender source is optional (the
+ * outbox falls back to the OBO user's own address). Partial SMTP
+ * configuration or a send with no credentials and no outbox opt-in
+ * throws.
+ *
+ * The sender allow-list is resolved here too: under the default
+ * `"allowlist"` policy an empty list is filled in from the sender source,
+ * so a deployment that only sets `EMAIL_DOMAIN` still rejects a `From` on
+ * any other domain. See {@link SenderPolicy}.
+ */
+export declare function resolveEmailConfig(config?: EmailPluginConfig): ResolvedEmailConfig;
+export {};

package/lib/src/config.js

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

package/lib/src/defaults.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Interceptor defaults and hard payload caps for the email plugin.
+ *
+ * The execution settings are what the runtime's executor hands
+ * `Plugin.execute()`, kept here rather than at the call sites so the
+ * caching / retry / timeout posture of every outbound operation is
+ * reviewable in one place. The caps bound the one unbounded input the
+ * plugin accepts: a model-drafted message with attachments.
+ *
+ * @module
+ */
+/**
+ * The `PluginExecuteConfig` slice this package sets. Mirrored structurally
+ * because AppKit's `PluginExecuteConfig` lives behind a subpath its `exports`
+ * map does not publish, so the nominal type cannot be imported. Written as a
+ * type alias rather than an interface so it stays assignable to the nominal
+ * type's index signature.
+ */
+export type EmailExecuteConfig = {
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+        cacheKey?: (string | number | object)[];
+    };
+    retry?: {
+        enabled?: boolean;
+        attempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+    timeout?: number;
+};
+/**
+ * The `PluginExecutionSettings` shape accepted by AppKit's `Plugin.execute()`.
+ * Mirrored structurally for the same reason as {@link EmailExecuteConfig}.
+ */
+export type EmailExecutionSettings = {
+    default: EmailExecuteConfig;
+    user?: EmailExecuteConfig;
+};
+/** Ceiling on how long a single SMTP conversation may take. */
+export declare const SEND_TIMEOUT_MS = 30000;
+/** Ceiling on the SMTP handshake performed at plugin setup. */
+export declare const VERIFY_TIMEOUT_MS = 15000;
+/** Attempts allowed for the setup-time SMTP handshake, including the first. */
+export declare const VERIFY_ATTEMPTS = 3;
+/** Largest single attachment accepted, in decoded bytes (10 MiB). */
+export declare const MAX_ATTACHMENT_BYTES = 10485760;
+/** Largest combined attachment payload accepted, in decoded bytes (20 MiB). */
+export declare const MAX_ATTACHMENTS_TOTAL_BYTES = 20971520;
+/** Largest number of attachments accepted on one message. */
+export declare const MAX_ATTACHMENT_COUNT = 20;
+/** Largest markdown body accepted, in characters. */
+export declare const MAX_BODY_CHARS = 200000;
+/** Execution settings for a send (SMTP dispatch or an outbox write). */
+export declare const EMAIL_SEND_SETTINGS: EmailExecutionSettings;
+/** Execution settings for the setup-time SMTP connectivity check. */
+export declare const EMAIL_VERIFY_SETTINGS: EmailExecutionSettings;
+/** Execution settings for the sender-options lookup. */
+export declare const EMAIL_SENDERS_SETTINGS: EmailExecutionSettings;