@dbx-tools/tunnel 0.6.60 → 0.6.62

package/lib/src/plugin.js

@@ -18,18 +18,37 @@
 import { Plugin, toPlugin } from "@databricks/appkit";
 import { brand, env, log, object, string } from "@dbx-tools/shared-core";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
-import { ALLOW_ENV, BRAND_NAME_ENV, CODE_TTL_ENV, MESSAGE_ENV, SESSION_TTL_ENV, SUBJECT_ENV, } from "./env.js";
+import { ALLOW_ENV, BRAND_NAME_ENV, CODE_TTL_ENV, FORWARD_HEADERS_ENV, INSECURE_ENV, MESSAGE_ENV, PUBLIC_DOMAIN_ENV, SESSION_TTL_ENV, SUBJECT_ENV, } from "./env.js";
+import { mountGate } from "./gate.js";
 import { CodeStore, signSession, verifySession } from "./otp.js";
 import { RateLimiter } from "./rate-limit.js";
+import { ensureEmailAvailable, sendCode as defaultSendCode } from "./send-code.js";
 import { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from "./signing-key.js";
 const logger = log.logger("tunnel:auth");
+function serverApplication(context) {
+    const server = context.getPlugins().get("server");
+    const application = server?.serverApplication;
+    return application &&
+        typeof application.get === "function" &&
+        typeof application.post === "function" &&
+        typeof application.use === "function"
+        ? application
+        : undefined;
+}
+export function mountGateOnContext(context, options) {
+    const application = serverApplication(context);
+    if (application) {
+        mountGate(options, (method, path, handler) => application[method](path, handler), (path, handler) => application.use(path, handler));
+        return;
+    }
+    mountGate(options, (method, path, handler) => context.addRoute(method, path, handler), (path, handler) => context.addMiddleware(path, handler));
+}
 const DEFAULTS = {
     subject: "Your verification code",
     // The repo-wide brand context's display name, NOT a hardcoded product string:
     // this name is what the recipient reads in the code email, so it has to be the
     // same identity the rest of the app presents. A host with its own
-    // `branding/brand.yaml` overrides it by passing `brandName` (see
-    // {@link startGateApp}, which resolves the on-disk context); the shared default
+    // `branding/brand.yaml` overrides it by passing `brandName`; the shared default
     // is the fallback when nothing is configured.
     brandName: brand.defaultBrandContext.name,
     message: "Your verification code is:",
@@ -53,9 +72,21 @@ export function resolveAuthGateConfig(config) {
         codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),
         maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
         sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),
+        publicDomain: env.string(config.publicDomain, PUBLIC_DOMAIN_ENV) ?? undefined,
+        forwardHeaders: [
+            ...string.parseList(config.forwardHeaders),
+            ...string.parseList(env.text(FORWARD_HEADERS_ENV)),
+        ],
+        insecure: env.boolean(config.insecure, INSECURE_ENV) ?? false,
     };
 }
-/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */
+/**
+ * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login
+ * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express
+ * server via `this.context`, so a public portr caller must prove an email before
+ * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and
+ * other local callers pass through untouched (the gate keys on the `Host` header).
+ */
 export class AuthGatePlugin extends Plugin {
     static manifest = {
         name: "authGate",
@@ -77,12 +108,52 @@ export class AuthGatePlugin extends Plugin {
         // cache that cannot hold it (and the resulting "sessions won't survive a
         // restart" warning) shows up in the startup log, not hours later.
         const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);
+        if (this.resolved.insecure) {
+            logger.warn("insecure mode - the tunnel runs OPEN with no email-OTP gate");
+        }
+        else {
+            // `server()` is deferred, so it does not exist during this plugin's setup.
+            // At `setup:complete` the Express app exists but has not injected plugin
+            // routes or static handling yet, which is the one point the gate can mount
+            // ahead of every protected route.
+            this.context?.onLifecycle("setup:complete", async () => {
+                this.mountGateRoutes();
+                // Fail fast once the sibling email plugin has primed its transport: a
+                // gate that cannot email a code lets nobody in.
+                await ensureEmailAvailable();
+            });
+        }
         logger.info("ready", {
             patterns: this.resolved.allow.length,
             sessionTtlSeconds: this.resolved.sessionTtlSeconds,
+            publicDomain: this.resolved.publicDomain ?? null,
+            insecure: this.resolved.insecure,
             ...object.optional("sessionCutoff", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),
         });
     }
+    /**
+     * Register the login routes (`/api/email/auth/*`) and the gating middleware on
+     * the app's OWN Express server. At `setup:complete`, the deferred server plugin
+     * has constructed its Express app but has not injected plugin routes or static
+     * handling, so direct registration puts the gate first. The context's buffered
+     * route API remains a fallback for compatible non-standard server plugins.
+     */
+    mountGateRoutes() {
+        const context = this.context;
+        if (!context) {
+            logger.warn("no plugin context - the OTP gate cannot mount its routes");
+            return;
+        }
+        mountGateOnContext(context, {
+            gate: this.exports(),
+            publicDomain: this.resolved.publicDomain,
+            forwardHeaders: this.resolved.forwardHeaders,
+        });
+    }
+    /** The code sender: the configured `sendCode`, else the shared-transport default. */
+    get sendCode() {
+        return this.config.sendCode ?? defaultSendCode;
+    }
     exports() {
         return {
             sessionTtlSeconds: this.resolved.sessionTtlSeconds,
@@ -106,7 +177,7 @@ export class AuthGatePlugin extends Plugin {
         if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {
             const code = await this.codes.issue(address);
             try {
-                await this.config.sendCode?.(address, code, {
+                await this.sendCode(address, code, {
                     subject: this.resolved.subject,
                     brandName: this.resolved.brandName,
                     message: this.resolved.message,
@@ -135,4 +206,4 @@ export class AuthGatePlugin extends Plugin {
 }
 /** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
 export const authGate = toPlugin(AuthGatePlugin);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { brand, env, log, object, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport {\n  ALLOW_ENV,\n  BRAND_NAME_ENV,\n  CODE_TTL_ENV,\n  MESSAGE_ENV,\n  SESSION_TTL_ENV,\n  SUBJECT_ENV,\n} from \"./env.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./app.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /** Deliver a code to an address. Wired by the app to the email plugin. */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName` (see\n  // {@link startGateApp}, which resolves the on-disk context); the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `env.list`, which stops at the first\n    // source that yields anything.\n    allow: [...string.parseList(config.allow), ...string.parseList(env.text(ALLOW_ENV))],\n    subject: env.string(config.subject, SUBJECT_ENV) ?? DEFAULTS.subject,\n    brandName: env.string(config.brandName, BRAND_NAME_ENV) ?? DEFAULTS.brandName,\n    message: env.string(config.message, MESSAGE_ENV) ?? DEFAULTS.message,\n    sessionTtlSeconds: env.positiveInt(\n      config.sessionTtlSeconds,\n      SESSION_TTL_ENV,\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n  };\n}\n\n/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    // Resolve the signing key HERE rather than lazily on the first sign-in, so a\n    // cache that cannot hold it (and the resulting \"sessions won't survive a\n    // restart\" warning) shows up in the startup log, not hours later.\n    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      ...object.optional(\"sessionCutoff\", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),\n    });\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.config.sendCode?.(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n          codeTtlSeconds: this.resolved.codeTtlSeconds,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { brand, env, log, object, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport type { RequestHandler } from \"express\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport {\n  ALLOW_ENV,\n  BRAND_NAME_ENV,\n  CODE_TTL_ENV,\n  FORWARD_HEADERS_ENV,\n  INSECURE_ENV,\n  MESSAGE_ENV,\n  PUBLIC_DOMAIN_ENV,\n  SESSION_TTL_ENV,\n  SUBJECT_ENV,\n} from \"./env.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `env.list`, which stops at the first\n    // source that yields anything.\n    allow: [...string.parseList(config.allow), ...string.parseList(env.text(ALLOW_ENV))],\n    subject: env.string(config.subject, SUBJECT_ENV) ?? DEFAULTS.subject,\n    brandName: env.string(config.brandName, BRAND_NAME_ENV) ?? DEFAULTS.brandName,\n    message: env.string(config.message, MESSAGE_ENV) ?? DEFAULTS.message,\n    sessionTtlSeconds: env.positiveInt(\n      config.sessionTtlSeconds,\n      SESSION_TTL_ENV,\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    publicDomain: env.string(config.publicDomain, PUBLIC_DOMAIN_ENV) ?? undefined,\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(env.text(FORWARD_HEADERS_ENV)),\n    ],\n    insecure: env.boolean(config.insecure, INSECURE_ENV) ?? false,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/**\n * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    // Resolve the signing key HERE rather than lazily on the first sign-in, so a\n    // cache that cannot hold it (and the resulting \"sessions won't survive a\n    // restart\" warning) shows up in the startup log, not hours later.\n    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no email-OTP gate\");\n    } else {\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      ...object.optional(\"sessionCutoff\", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),\n    });\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the OTP gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.sendCode(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n          codeTtlSeconds: this.resolved.codeTtlSeconds,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}

package/lib/src/send-code.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The default `sendCode` for the {@link AuthGatePlugin}: deliver the OTP through
+ * the host app's ALREADY-PRIMED `@dbx-tools/email` transport, as the system
+ * sender (a verification code is machine-generated and unanswerable, so it must
+ * not arrive from a person's address inviting a reply).
+ *
+ * `@dbx-tools/email` is an OPTIONAL dependency of the tunnel - a tunnel used
+ * without the gate needs no mail. So it is imported LAZILY here; a missing module
+ * surfaces only when a gate actually tries to send a code, and
+ * {@link ensureEmailAvailable} turns that into a clear fail-fast at boot.
+ *
+ * @module
+ */
+import type { AuthGateConfig } from "./plugin.ts";
+/**
+ * Fail fast when the gate cannot deliver codes: the optional email module must be
+ * importable AND configured for SMTP (real delivery). `mode: "file"` (outbox) or a
+ * throwing runtime means no code reaches a real inbox, so a gate on that config
+ * would silently admit nobody. Called from the plugin's `setup:complete` unless
+ * insecure.
+ */
+export declare function ensureEmailAvailable(): Promise<void>;
+/**
+ * The default code sender: render the OTP email (code in the subject + preheader
+ * for mobile autofill; see `codeEmailSubject`) and send it through the shared
+ * transport as the system sender.
+ */
+export declare const sendCode: NonNullable<AuthGateConfig["sendCode"]>;

package/lib/src/send-code.js

@@ -0,0 +1,68 @@
+/**
+ * The default `sendCode` for the {@link AuthGatePlugin}: deliver the OTP through
+ * the host app's ALREADY-PRIMED `@dbx-tools/email` transport, as the system
+ * sender (a verification code is machine-generated and unanswerable, so it must
+ * not arrive from a person's address inviting a reply).
+ *
+ * `@dbx-tools/email` is an OPTIONAL dependency of the tunnel - a tunnel used
+ * without the gate needs no mail. So it is imported LAZILY here; a missing module
+ * surfaces only when a gate actually tries to send a code, and
+ * {@link ensureEmailAvailable} turns that into a clear fail-fast at boot.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+import { codeEmailHtmlBody, codeEmailPreview, codeEmailSubject, codeEmailTextBody, } from "./code-email.js";
+const logger = log.logger("tunnel:send-code");
+let cached;
+/**
+ * Import `@dbx-tools/email` lazily. Throws a clear, actionable error when the
+ * optional dependency is absent - the caller (a gate that is NOT insecure) treats
+ * that as fatal, since a gate that cannot email a code lets nobody in.
+ */
+async function loadEmail() {
+    if (cached)
+        return cached;
+    try {
+        const mod = (await import("@dbx-tools/email"));
+        cached = mod;
+        return mod;
+    }
+    catch (cause) {
+        throw new Error("the OTP gate needs @dbx-tools/email to send codes, but it is not installed. " +
+            "Add @dbx-tools/email to the app, or run the tunnel with --insecure / TUNNEL_INSECURE=true.", { cause });
+    }
+}
+/**
+ * Fail fast when the gate cannot deliver codes: the optional email module must be
+ * importable AND configured for SMTP (real delivery). `mode: "file"` (outbox) or a
+ * throwing runtime means no code reaches a real inbox, so a gate on that config
+ * would silently admit nobody. Called from the plugin's `setup:complete` unless
+ * insecure.
+ */
+export async function ensureEmailAvailable() {
+    const { transport } = await loadEmail();
+    if (transport.getEmailRuntime().config.mode !== "smtp") {
+        throw new Error("email is not configured for SMTP delivery - the OTP gate cannot send codes. " +
+            "Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true.");
+    }
+}
+/**
+ * The default code sender: render the OTP email (code in the subject + preheader
+ * for mobile autofill; see `codeEmailSubject`) and send it through the shared
+ * transport as the system sender.
+ */
+export const sendCode = async (to, code, opts) => {
+    const { sender, transport } = await loadEmail();
+    const from = sender.resolveSystemSenderAddress(transport.getEmailRuntime().config);
+    await sendEmailWith(transport, to, code, opts, from);
+};
+function sendEmailWith(transport, to, code, opts, from) {
+    logger.debug("sending code email", { to });
+    return transport.sendEmail({
+        to: [to],
+        subject: codeEmailSubject(code, opts.subject),
+        body: codeEmailHtmlBody(code, opts),
+    }, from, undefined, { text: codeEmailTextBody(code, opts), preview: codeEmailPreview(code, opts) });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/allowlist.ts","../src/app.ts","../src/env.ts","../src/headers.ts","../src/interceptor.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/proxy.ts","../src/rate-limit.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/allowlist.ts","../src/code-email.ts","../src/env.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/rate-limit.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -18,18 +18,19 @@
     "projen": "projen"
   },
   "devDependencies": {
+    "@dbx-tools/email": "0.6.62",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "@dbx-tools/email": "0.6.62"
+  },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.60",
-    "@dbx-tools/core": "0.6.60",
-    "@dbx-tools/email": "0.6.60",
-    "@dbx-tools/shared-core": "0.6.60",
-    "@dbx-tools/shared-email": "0.6.60",
-    "http-proxy-3": "^1.23.3",
+    "@dbx-tools/appkit": "0.6.62",
+    "@dbx-tools/shared-core": "0.6.62",
+    "@dbx-tools/shared-email": "0.6.62",
     "jose": "^6.2.3"
   },
   "main": "./lib/index.js",
@@ -46,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.60",
+  "version": "0.6.62",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -61,6 +62,11 @@
     "src",
     "lib"
   ],
+  "peerDependenciesMeta": {
+    "@dbx-tools/email": {
+      "optional": true
+    }
+  },
   "dbxToolsConfig": {
     "tags": [
       "node"

package/src/code-email.ts

@@ -0,0 +1,118 @@
+/**
+ * Pure builders for the OTP code email's copy - subject, preheader, and the HTML
+ * and text bodies. No transport, no `@dbx-tools/email` import, so this module is
+ * safe to load whether or not the optional email dependency is present; the actual
+ * send lives in `./send-code`.
+ *
+ * The shapes here are load-bearing for mobile autofill: the code rides in the
+ * SUBJECT and the PREHEADER (the whole of a push notification), and the text part
+ * keeps the prompt and code on ONE line. See each function for why.
+ *
+ * @module
+ */
+
+import { string } from "@dbx-tools/shared-core";
+import type { SendCodeOptions } from "./plugin.ts";
+
+/** The parts of {@link SendCodeOptions} the code email's copy is built from. */
+export type CodeCopy = Pick<SendCodeOptions, "message" | "codeTtlSeconds">;
+
+/** The reassurance line closing both parts. */
+const IGNORE_LINE = "If you did not request this code, you can ignore this email.";
+
+/**
+ * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
+ *
+ * Whole minutes read as minutes; anything else stays in seconds rather than
+ * rounding, so a 90-second TTL is not advertised as "1 minute" and a recipient is
+ * never told the code lives longer than it does.
+ */
+export function expiresIn(seconds: number): string {
+  return seconds >= 60 && seconds % 60 === 0
+    ? string.pluralize(seconds / 60, "minute")
+    : string.pluralize(seconds, "second");
+}
+
+/**
+ * The HTML part's source: the full branded template, with the code as a large
+ * styled heading (`## ` is what makes it prominent in an inbox).
+ */
+export function codeEmailHtmlBody(code: string, opts: CodeCopy): string {
+  return [
+    opts.message,
+    "",
+    `## ${code}`,
+    "",
+    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+    "",
+    IGNORE_LINE,
+  ].join("\n");
+}
+
+/**
+ * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree
+ * above. Both parts say the same thing; only the line layout differs.
+ *
+ * The prompt and the code share ONE line ("Your verification code is: 123456").
+ * That single-line shape is what iOS, Gmail, Outlook, and Android code detection
+ * keys on most reliably - the heuristics look for a code in the same sentence as
+ * a recognized prompt, so splitting them across lines makes detection dependent
+ * on the client, and any blank line between them defeats it outright.
+ *
+ * The GENERATED text part cannot hold that shape at all: it is a rendering of the
+ * HTML, so it carries the brand header/footer and turns the code heading's CSS
+ * margin into blank lines, arriving as `prompt\n\n\ncode`.
+ *
+ * The code is visible text in BOTH parts, never an image, so a client scraping
+ * either one finds it. No trailer line follows the copy - Apple's domain-bound
+ * `@domain #code` footer is deliberately NOT emitted, since it constrains the
+ * code to one origin and is not what the broadly-compatible shape needs.
+ */
+export function codeEmailTextBody(code: string, opts: CodeCopy): string {
+  return [
+    `${opts.message} ${code}`,
+    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+    "",
+    IGNORE_LINE,
+  ].join("\n");
+}
+
+/**
+ * The SUBJECT line, with the code in it: `"123456 is your verification code"`.
+ *
+ * The code has to be here, not only in the body, because of what mobile autofill
+ * actually reads. iOS offers a code from an incoming NOTIFICATION - natively for
+ * Messages and Mail, and since iOS 26 for any app's notification text, which is
+ * what finally made Gmail work - and a notification contains the sender, the
+ * subject, and a short snippet. Nothing else. A code that lives in the body is
+ * invisible to it, however cleanly the body is formatted, which is why a perfectly
+ * shaped `text/plain` part still produced no autofill prompt in Gmail.
+ *
+ * `<code> is your <thing>` rather than `<thing>: <code>` because the leading code
+ * survives TRUNCATION: a notification and an inbox list both cut the subject, and
+ * the platform heuristics want the code in the same sentence as a recognized
+ * prompt ("code", "verification"). Putting it first keeps both intact no matter
+ * where the cut lands.
+ *
+ * `subject` is the configured line ("Your verification code"), lower-cased at its
+ * first word so the sentence reads naturally, and left ALONE when it does not look
+ * like the conventional phrasing - an operator who set a deliberate subject gets
+ * theirs with the code prefixed, not a mangled hybrid.
+ */
+export function codeEmailSubject(code: string, subject: string): string {
+  const trimmed = subject.trim();
+  const conventional = /^your\s+/i.exec(trimmed);
+  const rest = conventional ? trimmed.slice(conventional[0].length) : trimmed;
+  return conventional ? `${code} is your ${rest}` : `${code} - ${trimmed}`;
+}
+
+/**
+ * The PREHEADER: the snippet beside the subject in an inbox list, and the body of
+ * the push notification. Carries the code for the same reason the subject does -
+ * it is the other half of what a notification shows - and repeats the prompt
+ * wording so a heuristic scanning the snippet alone finds a code next to a phrase
+ * it recognizes.
+ */
+export function codeEmailPreview(code: string, opts: CodeCopy): string {
+  return `${opts.message} ${code}`;
+}