@dbx-tools/tunnel 0.6.60

package/lib/src/signing-key.js

@@ -0,0 +1,170 @@
+/**
+ * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ *
+ * The key decides whether a session COOKIE still verifies. Before this module the
+ * fallback was `randomBytes(32)` per process, so every restart invalidated every
+ * outstanding cookie and each signed-in user had to request a new code - painful
+ * for a tunnel, which restarts whenever the app it wraps does. Now the key is
+ * stored in the cache AppKit already configured (memory, or Lakebase when the
+ * host wires a persistent `CacheStorage`), so with persistent storage a restart
+ * keeps sessions alive for {@link KEY_TTL_SECONDS}.
+ *
+ * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is
+ * the right answer for a fleet: an operator-held secret needs no shared cache and
+ * no convergence, and it survives a cache flush.
+ *
+ * ## get / generate / get
+ *
+ * Two instances booting at once both miss, so both would generate - and the loser
+ * would sign cookies with a key the winner rejects. Resolution is a re-READ after
+ * the write: whatever the cache holds afterwards is the key everyone adopts, so
+ * the instances converge on ONE value instead of trusting the one they minted.
+ * (`set` is not conditional in the cache API - there is no `setnx` to lean on -
+ * and this runs once per process, so the extra round-trip is free.)
+ *
+ * A pathological interleave can still cost a key: if A writes between B's write
+ * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -
+ * a cookie minted in that window fails to verify and the holder signs in again -
+ * and it cannot produce a key one instance TRUSTS but another rejects for longer
+ * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race
+ * entirely.
+ *
+ * ## Forcing every session to end
+ *
+ * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or
+ * `--session-cutoff`), and that date is part of the cache KEY. Moving it forward
+ * makes every prior key unreachable, so every cookie signed against it stops
+ * verifying - the log-everyone-out switch, without having to find and flush a
+ * cache entry. The cutoff is also asserted against each token's `iat`, so a
+ * cookie that predates it is refused even if it was signed with the key that is
+ * somehow still current.
+ *
+ * @module
+ */
+import { randomBytes } from "node:crypto";
+import { CacheManager } from "@databricks/appkit";
+import { env, log, object } from "@dbx-tools/shared-core";
+import { JWT_SECRET_ENV, SESSION_CUTOFF_ENV } from "./env.js";
+const logger = log.logger("tunnel:signing-key");
+/**
+ * How long a cached signing key lives: 30 days.
+ *
+ * This is the ceiling on how long a session cookie can stay valid across
+ * restarts, so it is deliberately >= the default session TTL - a key that expired
+ * before the cookies it signed would log everyone out for no reason.
+ */
+export const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;
+/** Cache-key prefix for the signing key, namespaced away from other cache use. */
+const KEY_PREFIX = "tunnel:auth:signing-key:";
+/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */
+const KEY_BYTES = 32;
+/**
+ * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO
+ * instant, epoch seconds or millis from `date +%s`, or a relative duration
+ * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this
+ * usually wants: sign out everyone who signed in more than a month ago.
+ *
+ * An UNPARSEABLE value is ignored with a warning rather than throwing: this is
+ * the switch that logs a fleet back in, and failing to boot over a typo is worse
+ * than not rotating.
+ */
+export function resolveSessionCutoff(configured) {
+    const raw = configured ?? env.text(SESSION_CUTOFF_ENV) ?? undefined;
+    if (raw === undefined || raw === null || raw === "")
+        return 0;
+    const date = object.toDate(raw);
+    if (!date) {
+        logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });
+        return 0;
+    }
+    return clampToPast(date.getTime());
+}
+/**
+ * Hold the cutoff at "now", because a FUTURE cutoff would refuse the sessions it
+ * is about to mint as well as the old ones - an app nobody can sign in to, from a
+ * mistyped year, with the fix hidden behind understanding this flag. Clamped, a
+ * future date means what an operator setting it always meant: clear everything
+ * outstanding, then carry on.
+ */
+function clampToPast(cutoffMs) {
+    const now = Date.now();
+    if (cutoffMs <= now)
+        return cutoffMs;
+    logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {
+        configured: new Date(cutoffMs).toISOString(),
+    });
+    return now;
+}
+/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */
+function cacheKey(cutoffMs) {
+    return `${KEY_PREFIX}${cutoffMs}`;
+}
+function decode(stored) {
+    return new Uint8Array(Buffer.from(stored.secret, "base64url"));
+}
+/**
+ * Load the signing key for `cutoffMs` from the cache, minting and storing one
+ * when absent. See the module docs for why the write is followed by a re-read.
+ */
+async function loadFromCache(cutoffMs) {
+    const cache = CacheManager.getInstanceSync();
+    const key = cacheKey(cutoffMs);
+    const existing = await cache.get(key);
+    if (existing?.secret) {
+        logger.info("reusing cached signing key", { createdAt: existing.createdAt });
+        return decode(existing);
+    }
+    const minted = {
+        secret: Buffer.from(randomBytes(KEY_BYTES)).toString("base64url"),
+        createdAt: new Date().toISOString(),
+    };
+    await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });
+    // Re-read rather than trusting `minted`: another instance that raced this boot
+    // may have written first, and adopting whatever is stored is what makes the two
+    // converge on one key.
+    const settled = (await cache.get(key)) ?? minted;
+    logger.info("stored a new signing key", {
+        createdAt: settled.createdAt,
+        ttlSeconds: KEY_TTL_SECONDS,
+        adopted: settled.createdAt === minted.createdAt ? "own" : "concurrent-instance",
+    });
+    return decode(settled);
+}
+let pending;
+/**
+ * The signing key for this gate, resolved once per process.
+ *
+ * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the
+ * plugin's `setup()` passes its resolved value there, before any request can
+ * reach the lazy path.
+ *
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * unavailable degrades to an ephemeral per-process key (the previous behaviour)
+ * rather than refusing to sign: the key only validates an ALREADY-issued session,
+ * so losing it costs sessions, never admission - a caller still needs a code
+ * delivered to an allow-listed address.
+ */
+export function signingKey(configuredCutoff) {
+    pending ??= (async () => {
+        const cutoffMs = resolveSessionCutoff(configuredCutoff);
+        const configured = env.text(JWT_SECRET_ENV);
+        if (configured) {
+            return { key: new TextEncoder().encode(configured), cutoffMs };
+        }
+        try {
+            return { key: await loadFromCache(cutoffMs), cutoffMs };
+        }
+        catch (error) {
+            logger.warn(`no ${env.name(JWT_SECRET_ENV)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`, { error });
+            return { key: new Uint8Array(randomBytes(KEY_BYTES)), cutoffMs };
+        }
+    })();
+    return pending;
+}
+/** Reset the per-process key (tests, or after changing the env in-process). */
+export function resetSigningKey() {
+    pending = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signing-key.js","sourceRoot":"","sources":["../../src/signing-key.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The gate's HS256 session-signing key, persisted in AppKit's cache.\n *\n * The key decides whether a session COOKIE still verifies. Before this module the\n * fallback was `randomBytes(32)` per process, so every restart invalidated every\n * outstanding cookie and each signed-in user had to request a new code - painful\n * for a tunnel, which restarts whenever the app it wraps does. Now the key is\n * stored in the cache AppKit already configured (memory, or Lakebase when the\n * host wires a persistent `CacheStorage`), so with persistent storage a restart\n * keeps sessions alive for {@link KEY_TTL_SECONDS}.\n *\n * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is\n * the right answer for a fleet: an operator-held secret needs no shared cache and\n * no convergence, and it survives a cache flush.\n *\n * ## get / generate / get\n *\n * Two instances booting at once both miss, so both would generate - and the loser\n * would sign cookies with a key the winner rejects. Resolution is a re-READ after\n * the write: whatever the cache holds afterwards is the key everyone adopts, so\n * the instances converge on ONE value instead of trusting the one they minted.\n * (`set` is not conditional in the cache API - there is no `setnx` to lean on -\n * and this runs once per process, so the extra round-trip is free.)\n *\n * A pathological interleave can still cost a key: if A writes between B's write\n * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -\n * a cookie minted in that window fails to verify and the holder signs in again -\n * and it cannot produce a key one instance TRUSTS but another rejects for longer\n * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race\n * entirely.\n *\n * ## Forcing every session to end\n *\n * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or\n * `--session-cutoff`), and that date is part of the cache KEY. Moving it forward\n * makes every prior key unreachable, so every cookie signed against it stops\n * verifying - the log-everyone-out switch, without having to find and flush a\n * cache entry. The cutoff is also asserted against each token's `iat`, so a\n * cookie that predates it is refused even if it was signed with the key that is\n * somehow still current.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { env, log, object } from \"@dbx-tools/shared-core\";\nimport { JWT_SECRET_ENV, SESSION_CUTOFF_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:signing-key\");\n\n/**\n * How long a cached signing key lives: 30 days.\n *\n * This is the ceiling on how long a session cookie can stay valid across\n * restarts, so it is deliberately >= the default session TTL - a key that expired\n * before the cookies it signed would log everyone out for no reason.\n */\nexport const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;\n\n/** Cache-key prefix for the signing key, namespaced away from other cache use. */\nconst KEY_PREFIX = \"tunnel:auth:signing-key:\";\n\n/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */\nconst KEY_BYTES = 32;\n\n/** What the cache stores: the key plus when it was minted, for observability. */\ninterface StoredKey {\n  /** Base64url of the raw key bytes. */\n  secret: string;\n  /** When this key was generated, ISO-8601. */\n  createdAt: string;\n}\n\n/**\n * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.\n *\n * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO\n * instant, epoch seconds or millis from `date +%s`, or a relative duration\n * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this\n * usually wants: sign out everyone who signed in more than a month ago.\n *\n * An UNPARSEABLE value is ignored with a warning rather than throwing: this is\n * the switch that logs a fleet back in, and failing to boot over a typo is worse\n * than not rotating.\n */\nexport function resolveSessionCutoff(configured?: string | number | Date): number {\n  const raw = configured ?? env.text(SESSION_CUTOFF_ENV) ?? undefined;\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n\n  const date = object.toDate(raw);\n  if (!date) {\n    logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });\n    return 0;\n  }\n  return clampToPast(date.getTime());\n}\n\n/**\n * Hold the cutoff at \"now\", because a FUTURE cutoff would refuse the sessions it\n * is about to mint as well as the old ones - an app nobody can sign in to, from a\n * mistyped year, with the fix hidden behind understanding this flag. Clamped, a\n * future date means what an operator setting it always meant: clear everything\n * outstanding, then carry on.\n */\nfunction clampToPast(cutoffMs: number): number {\n  const now = Date.now();\n  if (cutoffMs <= now) return cutoffMs;\n  logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {\n    configured: new Date(cutoffMs).toISOString(),\n  });\n  return now;\n}\n\n/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */\nfunction cacheKey(cutoffMs: number): string {\n  return `${KEY_PREFIX}${cutoffMs}`;\n}\n\nfunction decode(stored: StoredKey): Uint8Array {\n  return new Uint8Array(Buffer.from(stored.secret, \"base64url\"));\n}\n\n/**\n * Load the signing key for `cutoffMs` from the cache, minting and storing one\n * when absent. See the module docs for why the write is followed by a re-read.\n */\nasync function loadFromCache(cutoffMs: number): Promise<Uint8Array> {\n  const cache = CacheManager.getInstanceSync();\n  const key = cacheKey(cutoffMs);\n\n  const existing = await cache.get<StoredKey>(key);\n  if (existing?.secret) {\n    logger.info(\"reusing cached signing key\", { createdAt: existing.createdAt });\n    return decode(existing);\n  }\n\n  const minted: StoredKey = {\n    secret: Buffer.from(randomBytes(KEY_BYTES)).toString(\"base64url\"),\n    createdAt: new Date().toISOString(),\n  };\n  await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });\n\n  // Re-read rather than trusting `minted`: another instance that raced this boot\n  // may have written first, and adopting whatever is stored is what makes the two\n  // converge on one key.\n  const settled = (await cache.get<StoredKey>(key)) ?? minted;\n  logger.info(\"stored a new signing key\", {\n    createdAt: settled.createdAt,\n    ttlSeconds: KEY_TTL_SECONDS,\n    adopted: settled.createdAt === minted.createdAt ? \"own\" : \"concurrent-instance\",\n  });\n  return decode(settled);\n}\n\n/** A resolved key plus the cutoff it is scoped to. */\nexport interface SigningKey {\n  key: Uint8Array;\n  /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */\n  cutoffMs: number;\n}\n\nlet pending: Promise<SigningKey> | undefined;\n\n/**\n * The signing key for this gate, resolved once per process.\n *\n * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the\n * plugin's `setup()` passes its resolved value there, before any request can\n * reach the lazy path.\n *\n * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is\n * unavailable degrades to an ephemeral per-process key (the previous behaviour)\n * rather than refusing to sign: the key only validates an ALREADY-issued session,\n * so losing it costs sessions, never admission - a caller still needs a code\n * delivered to an allow-listed address.\n */\nexport function signingKey(configuredCutoff?: string | number | Date): Promise<SigningKey> {\n  pending ??= (async () => {\n    const cutoffMs = resolveSessionCutoff(configuredCutoff);\n    const configured = env.text(JWT_SECRET_ENV);\n    if (configured) {\n      return { key: new TextEncoder().encode(configured), cutoffMs };\n    }\n    try {\n      return { key: await loadFromCache(cutoffMs), cutoffMs };\n    } catch (error) {\n      logger.warn(\n        `no ${env.name(JWT_SECRET_ENV)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`,\n        { error },\n      );\n      return { key: new Uint8Array(randomBytes(KEY_BYTES)), cutoffMs };\n    }\n  })();\n  return pending;\n}\n\n/** Reset the per-process key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  pending = undefined;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@dbx-tools/tunnel",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/node/tunnel"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "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",
+    "jose": "^6.2.3"
+  },
+  "main": "./lib/index.js",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.6.60",
+  "types": "./lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/allowlist.ts

@@ -0,0 +1,60 @@
+/**
+ * Unified access allow-list matching for the email-OTP gate.
+ *
+ * Each pattern in the configured list is one of three shapes:
+ *
+ *   - **domain shortcut** - `example.com` or `@example.com`: matches any
+ *     address whose domain equals it. This is the gate's OWN semantic (a bare
+ *     value means "the domain", not "the whole address"), so it is handled here.
+ *   - **glob** - contains `*` or `?`, e.g. `*@example.com`: matched against the
+ *     WHOLE address with shell-style wildcards.
+ *   - **regex** - wrapped in slashes, `/.../ [flags]`: tested against the whole
+ *     address. An invalid regex never matches (it is skipped with a warning
+ *     rather than throwing).
+ *
+ * Only the first shape is this module's business: the glob and regex shapes are
+ * delegated to `@dbx-tools/shared-core`'s {@link pattern.toPattern}, which is
+ * where that compilation lives for every allow-list in the repo (the tunnel's
+ * inbound-header policy uses the same one). Matching is case-insensitive
+ * throughout.
+ *
+ * An EMPTY list matches nobody (fail closed): an app that enables the gate but
+ * configures no patterns lets no one in, which is the safe default.
+ *
+ * @module
+ */
+
+import { pattern } from "@dbx-tools/shared-core";
+
+/** True when `email` matches a single allow-list `pattern`. */
+function matchesPattern(email: string, entry: string): boolean {
+  const trimmed = entry.trim();
+  if (!trimmed) return false;
+  const address = email.trim().toLowerCase();
+
+  // A bare value with no wildcard and no regex delimiters is a DOMAIN shortcut,
+  // the one shape shared-core cannot infer: there it would mean whole-string
+  // equality against the address, which is never what an operator writing
+  // `example.com` in an access list intends.
+  if (!trimmed.startsWith("/") && !trimmed.includes("*") && !trimmed.includes("?")) {
+    const domain = trimmed.replace(/^@/, "").toLowerCase();
+    const at = address.lastIndexOf("@");
+    return at >= 0 && address.slice(at + 1) === domain;
+  }
+
+  return pattern.toPattern(trimmed)?.(address) ?? false;
+}
+
+/**
+ * True when `email` is allowed by ANY pattern in `patterns`. An empty (or
+ * missing) list allows nobody - the gate fails closed.
+ */
+export function matchesAllowlist(email: string, patterns: readonly string[] | undefined): boolean {
+  if (!email || !patterns || patterns.length === 0) return false;
+  return patterns.some((entry) => matchesPattern(email, entry));
+}
+
+/** Rough shape check so a clearly-invalid address is rejected before any work. */
+export function looksLikeEmail(value: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+}

package/src/app.ts

@@ -0,0 +1,292 @@
+/**
+ * The tunnel gate's tiny AppKit "app" - `createApp` WITHOUT a `server()` plugin.
+ *
+ * There is no HTTP server here: the tunnel proxy is the server, and it calls the
+ * gate handlers in-process. `createApp` is used only for what it auto-wires:
+ *   - `CacheManager` (Lakebase when this process can reach it, else memory) -
+ *     which the OTP `CodeStore` and the session signing key use for storage + TTL
+ *     eviction;
+ *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can
+ *     deliver the one-time code;
+ *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.
+ *
+ * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here
+ * (the plugin can't resolve HOW to send on its own) to the email plugin's
+ * transport. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it
+ * and no reply to it reaches anyone - so it sends from the email config's
+ * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names
+ * another).
+ *
+ * FAIL FAST: a gate that can't email a code is useless, so if email does not
+ * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set
+ * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the
+ * tunnel OPEN with no gate.
+ *
+ * @module
+ */
+
+import { createApp as createAppNs, lakebaseResolver } from "@dbx-tools/appkit";
+import { brand as nodeBrand } from "@dbx-tools/core";
+import { brand as emailBrand, email, sender, transport } from "@dbx-tools/email";
+import { env, log, string } from "@dbx-tools/shared-core";
+import { authGate, type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from "./plugin.ts";
+
+const logger = log.logger("tunnel:app");
+
+/**
+ * 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 parts of {@link SendCodeOptions} the code email's copy is built from. */
+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.";
+
+/**
+ * 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}`;
+}
+
+const { createApp } = createAppNs;
+const { applyLakebaseEnv } = lakebaseResolver;
+const { resolveSystemSenderAddress } = sender;
+const { getEmailRuntime, sendEmail } = transport;
+const { emailBrandFromContext } = emailBrand;
+const { loadBrandContext } = nodeBrand;
+
+/**
+ * Env vars whose presence means a Lakebase database was bound to this deployment.
+ * `LAKEBASE_ENDPOINT` is what a Databricks App `postgres` resource binding sets;
+ * `PGHOST` is the local/manual spelling.
+ */
+const LAKEBASE_ENV = ["LAKEBASE_ENDPOINT", "PGHOST"] as const;
+
+/**
+ * Upper bound on resolving the Lakebase connection. The gate is in the request
+ * path for every visitor, so a slow workspace API must not hold up boot
+ * indefinitely; a memory cache is a degraded gate, an unbooted one is no gate.
+ */
+const LAKEBASE_RESOLVE_TIMEOUT_MS = 60_000;
+
+/**
+ * Fill in the Lakebase connection env AppKit's cache needs, so `CacheManager`
+ * chooses PERSISTENT storage instead of memory.
+ *
+ * This is what makes the gate's session signing key and outstanding one-time
+ * codes survive a restart. `applyLakebaseEnv` is the SHARED helper AppKit
+ * auto-configuration uses, so the gate gets exactly the env a pool needs -
+ * `LAKEBASE_ENDPOINT`, `PGHOST`, `PGDATABASE`, and `PGUSER` - rather than a
+ * hand-rolled subset. All four matter: `createLakebasePool()` throws without any
+ * one of them, and a Databricks App `postgres` resource binding supplies only the
+ * first. Without them the pool cannot be built, the cache silently degrades to
+ * in-memory, and every redeploy signs out every user (the exact symptom this
+ * exists to prevent).
+ *
+ * It is called here rather than left to `createApp`'s `autoConfigure` because that
+ * gates on a `lakebase()` plugin being registered - and this app registers none,
+ * having no server to mount Lakebase routes on. Calling the helper directly also
+ * lets the gate be stricter than `autoConfigure` is:
+ *
+ *   - It runs ONLY when a Lakebase env var is present. A tunnel is a wrapper
+ *     around someone else's app and must not invent infrastructure, so with
+ *     nothing bound it skips rather than falling through the resolver's
+ *     list-or-CREATE-a-project path.
+ *   - `autoCreate: false` for the same reason, in case a project happens to exist.
+ *   - Every failure is a WARNING, never a throw. The cache is an optimization for
+ *     session durability; admission still requires a code delivered to an
+ *     allow-listed address, so a gate with a memory cache is safe, just forgetful.
+ */
+export async function resolveCacheStorageEnv(): Promise<boolean> {
+  if (!env.text(LAKEBASE_ENV)) {
+    logger.info(
+      `no ${env.name(LAKEBASE_ENV)} - the gate cache stays in memory; sessions and codes will not survive a restart`,
+    );
+    return false;
+  }
+  try {
+    const { resolved, user } = await applyLakebaseEnv(
+      { autoCreate: false },
+      AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS),
+    );
+    logger.info("lakebase resolved for the gate cache", {
+      host: resolved.host,
+      database: resolved.database,
+      endpoint: resolved.endpoint,
+      user,
+    });
+    return true;
+  } catch (error) {
+    logger.warn(
+      "could not resolve lakebase - the gate cache stays in memory; sessions and codes will not survive a restart",
+      { error },
+    );
+    return false;
+  }
+}
+
+/**
+ * Boot the gate app and return the API the proxy calls. Throws when email is not
+ * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at
+ * startup rather than silently accepting nobody; the caller may catch this and
+ * fall back to insecure/open mode when the operator opted in.
+ */
+export async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi> {
+  // The host app's own brand (`branding/brand.yaml` discovered from cwd) or the
+  // dbx-tools default. This is the ONE brand source for the gate: it styles the
+  // code email (accent band, font, logo) via the email plugin AND supplies the
+  // display name the copy uses, so a deployment that themes its app themes its
+  // sign-in email with it. An explicit `brandName` still wins (see below).
+  const context = await loadBrandContext();
+
+  // Before `createApp`, because AppKit resolves the cache's storage during it and
+  // reads the connection out of `process.env` when it does. See the function's
+  // docs for why the gate resolves this itself.
+  await resolveCacheStorageEnv();
+
+  // `sendCode` delivers the OTP through the email plugin's SHARED transport, which
+  // the `email()` plugin primes during its `setup()` (awaited by `createApp`
+  // below). Using the module-level `sendEmail` avoids a circular dependency on the
+  // app handle's inferred type. The `From` is the SYSTEM sender: a verification
+  // code is machine-generated and unanswerable, so it must not arrive from a
+  // person's address inviting a reply.
+  const sendCode: NonNullable<AuthGateConfig["sendCode"]> = async (to, code, opts) => {
+    const from = resolveSystemSenderAddress(getEmailRuntime().config);
+    await sendEmail(
+      {
+        to: [to],
+        // The code rides in the SUBJECT and the preheader, not just the body:
+        // those two strings are the whole of a push notification, and a
+        // notification is what mobile autofill reads. See `codeEmailSubject`.
+        subject: codeEmailSubject(code, opts.subject),
+        body: codeEmailHtmlBody(code, opts),
+      },
+      from,
+      undefined,
+      { text: codeEmailTextBody(code, opts), preview: codeEmailPreview(code, opts) },
+    );
+  };
+
+  // `createApp` namespaces each plugin's exports on the handle by manifest name;
+  // `handle.authGate` is the in-process gate API the proxy drives.
+  //
+  // `autoConfigure: false` because {@link resolveCacheStorageEnv} above already
+  // ran the one piece of it this app wants (`applyLakebaseEnv`), on this app's
+  // terms - no auto-create, and a warning instead of a throw.
+  const handle = await createApp({
+    autoConfigure: false,
+    plugins: [
+      // Brand the code email from the resolved context, the same bridge every
+      // other dbx-tools email surface uses (accent + font inlined, logo only when
+      // it is a fetchable URL - a package-export path cannot load in an inbox).
+      email({ brand: emailBrandFromContext(context) }),
+      // `brandName` falls back to the resolved context's display name, so the
+      // email copy names the app rather than a generic placeholder. Spelled as an
+      // explicit `??` rather than a key before `...config`: commander sets
+      // `brandName` on the options object whether or not the flag was passed, so
+      // spreading it would clobber the context name with `undefined`.
+      authGate({ ...config, brandName: config.brandName ?? context.name, sendCode }),
+    ],
+  });
+
+  // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to
+  // `mode: "file"` (outbox) or throws when no SMTP creds are configured - neither
+  // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.
+  if (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 to run the tunnel open.",
+    );
+  }
+
+  logger.info("gate app ready (no server; proxy-driven)");
+  return handle.authGate as AuthGateApi;
+}