@dbx-tools/cli-tunnel 0.6.57 → 0.6.58

package/README.md

@@ -30,6 +30,12 @@ address against an allow-list, verified by a code sent over
   Android detect a code from that shape and offer it directly from the
   notification; novel phrasing is what breaks the detection. Both MIME parts carry
   the code as visible text, never an image, and no trailer follows the copy.
+- The code rides in the SUBJECT and the preheader, not only the body:
+  `123456 is your verification code`. Mobile autofill reads an incoming
+  NOTIFICATION, and a notification contains the sender, the subject, and a short
+  snippet - nothing else - so a code that lives only in the body is unreachable
+  however cleanly the body is shaped. See
+  [Why the code is in the subject](#why-the-code-is-in-the-subject).
 - The two MIME parts are built separately, on purpose. The HTML part is the full
   branded template with the code as a large styled heading; the `text/plain` part
   is authored directly, keeping the prompt and the code on ONE line
@@ -43,9 +49,16 @@ address against an allow-list, verified by a code sent over
   machine-generated code reaches nobody. `EMAIL_FROM` is not required - see
   [`@dbx-tools/email`](../../node/email#sender-addresses).
 - Email one-time-code gate: a 6-digit code stored as a SHA-256 hash with an
-  attempt counter, verified in constant time, in AppKit's `CacheManager` (memory
-  by default, Lakebase when the app configures persistent `CacheStorage`) so TTL
-  expiry and eviction are the cache's job.
+  attempt counter, verified in constant time, in AppKit's `CacheManager` (Lakebase
+  when a database is bound to the deployment, else memory) so TTL expiry and
+  eviction are the cache's job.
+- The gate resolves Lakebase for itself, so its cache is actually persistent. The
+  gate is its own tiny AppKit app with no `lakebase()` plugin (it has no server to
+  mount routes on), and AppKit only chooses Lakebase for the cache when a pool can
+  be built from `LAKEBASE_ENDPOINT` **and** `PGHOST` **and** `PGDATABASE` - while a
+  Databricks App `postgres` binding supplies only the first. The gate fills in the
+  rest at boot, and skips entirely when nothing is bound rather than creating
+  infrastructure on someone else's behalf.
 - HS256 session JWT (via `jose`) carrying only the email, signed with a key that
   is PERSISTED in AppKit's cache for 30 days - so a signed-in browser stays signed
   in across the restarts a tunnel sees whenever the app it wraps reloads. An
@@ -151,6 +164,15 @@ Resolution order:
    across restarts - which a tunnel does often, since it restarts whenever the app
    it wraps reloads. On the default in-memory cache the key is per-process, the
    same as having no secret at all.
+
+   Getting that persistence is not automatic, and the gate does the work at boot:
+   it resolves `LAKEBASE_ENDPOINT` into the `PGHOST` / `PGDATABASE` the cache's
+   pool also needs. Without it AppKit cannot build the pool, silently uses an
+   in-memory cache, and every redeploy signs everyone out - so the startup log
+   says which one you got (`lakebase resolved for the gate cache`, or
+   `the gate cache stays in memory`). Bind a `postgres` resource to the app to
+   get the persistent path.
+
 3. **An ephemeral per-process key**, when there is no secret and no reachable
    cache. Sessions do not survive a restart, but the gate still serves: the key
    only validates an ALREADY-issued session, so losing it costs sessions, never
@@ -165,6 +187,35 @@ the one it minted. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race entirely.
 purpose - a key that expired before the cookies it signed would sign everyone out
 for no reason.
 
+## Why The Code Is In The Subject
+
+The subject line the gate SENDS is `123456 is your verification code` -
+`--subject` is the template the code is spliced into, not the literal line.
+
+Mobile autofill does not read the email; it reads the NOTIFICATION. iOS scans
+incoming notification text for a code and offers to fill it - natively for
+Messages and Mail, and since iOS 26 for any app's notification, which is what
+finally made Gmail work. A notification carries the sender, the subject, and a
+short snippet. That is all. A code sitting in the body is invisible to it no
+matter how carefully the body is formatted, which is why a perfectly shaped
+`text/plain` part alone produced no prompt in Gmail.
+
+So the code goes in both strings a notification actually shows:
+
+- **The subject**, code FIRST, because a notification and an inbox row both
+  truncate: `123456 is your verification code` survives the cut wherever it lands,
+  and keeps the code in the same sentence as the words the heuristics look for.
+  A subject that does not use the conventional `Your ...` phrasing is treated as
+  deliberate and only prefixed (`123456 - Acme Ops access`).
+- **The preheader**, the hidden snippet a client shows beside the subject and puts
+  in the notification body, repeating the prompt with the code
+  (`Your verification code is: 123456`).
+
+The body keeps the code as a large styled heading regardless, for a recipient
+reading the mail rather than a notification. This is deliberately NOT Apple's
+domain-bound `@domain #code` trailer, which binds a code to a single origin;
+subject + preheader works across clients and needs no origin.
+
 ### Signing everyone out
 
 `--session-cutoff` / `TUNNEL_AUTH_SESSION_CUTOFF` invalidates every session issued

package/lib/src/app.d.ts

@@ -3,8 +3,9 @@
  *
  * 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` (memory, or Lakebase when the deploy configures persistent
- *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;
+ *   - `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`.
@@ -59,6 +60,69 @@ export declare function codeEmailHtmlBody(code: string, opts: CodeCopy): string;
  * code to one origin and is not what the broadly-compatible shape needs.
  */
 export declare function codeEmailTextBody(code: string, opts: CodeCopy): string;
+/**
+ * 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 declare function codeEmailSubject(code: string, subject: string): string;
+/**
+ * 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 declare function codeEmailPreview(code: string, opts: CodeCopy): string;
+/**
+ * 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, and it has to be done explicitly here. AppKit picks
+ * Lakebase for the cache only when `createLakebasePool()` succeeds, and that pool
+ * reads FOUR things off `process.env`: `LAKEBASE_ENDPOINT`, `PGHOST`,
+ * `PGDATABASE`, and a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a service
+ * principal). A Databricks App `postgres` resource binding supplies only
+ * `LAKEBASE_ENDPOINT`. The resolver turns that one value into the host and
+ * database; the username is looked up separately, because missing it fails pool
+ * construction just as hard as a missing host - and it is what a LOCAL run (a
+ * developer on a PAT, with no `DATABRICKS_CLIENT_ID`) is always missing. Without
+ * all four 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).
+ *
+ * `@dbx-tools/appkit`'s `createApp` would normally do this via `autoConfigure`,
+ * but it gates that on a `lakebase()` plugin being registered - and this app
+ * registers none, because it has no server to mount Lakebase routes on. Calling
+ * the resolver 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 declare function resolveCacheStorageEnv(): Promise<boolean>;
 /**
  * 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

package/lib/src/app.js

@@ -3,8 +3,9 @@
  *
  * 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` (memory, or Lakebase when the deploy configures persistent
- *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;
+ *   - `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`.
@@ -23,10 +24,11 @@
  *
  * @module
  */
-import { createApp as createAppNs } from "@dbx-tools/appkit";
+import { getUsernameWithApiLookup } from "@databricks/appkit";
+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 { log, string } from "@dbx-tools/shared-core";
+import { env, log, string } from "@dbx-tools/shared-core";
 import { authGate } from "./plugin.js";
 const logger = log.logger("tunnel:app");
 /**
@@ -85,11 +87,120 @@ export function codeEmailTextBody(code, opts) {
         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, subject) {
+    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, opts) {
+    return `${opts.message} ${code}`;
+}
 const { createApp } = createAppNs;
+const { applyLakebaseToEnv, resolveLakebaseConnection } = 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"];
+/**
+ * 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, and it has to be done explicitly here. AppKit picks
+ * Lakebase for the cache only when `createLakebasePool()` succeeds, and that pool
+ * reads FOUR things off `process.env`: `LAKEBASE_ENDPOINT`, `PGHOST`,
+ * `PGDATABASE`, and a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a service
+ * principal). A Databricks App `postgres` resource binding supplies only
+ * `LAKEBASE_ENDPOINT`. The resolver turns that one value into the host and
+ * database; the username is looked up separately, because missing it fails pool
+ * construction just as hard as a missing host - and it is what a LOCAL run (a
+ * developer on a PAT, with no `DATABRICKS_CLIENT_ID`) is always missing. Without
+ * all four 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).
+ *
+ * `@dbx-tools/appkit`'s `createApp` would normally do this via `autoConfigure`,
+ * but it gates that on a `lakebase()` plugin being registered - and this app
+ * registers none, because it has no server to mount Lakebase routes on. Calling
+ * the resolver 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() {
+    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 = await resolveLakebaseConnection({ autoCreate: false }, AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS));
+        applyLakebaseToEnv(resolved);
+        // `??=` so an explicitly configured PGUSER stays authoritative. The lookup
+        // falls back to the workspace API and returns undefined rather than throwing,
+        // so a failure here just leaves the pool to find its own username.
+        const user = await getUsernameWithApiLookup({});
+        if (user)
+            process.env.PGUSER ??= user;
+        logger.info("lakebase resolved for the gate cache", {
+            host: resolved.host,
+            database: resolved.database,
+            endpoint: resolved.endpoint,
+            user: process.env.PGUSER,
+        });
+        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
@@ -103,6 +214,10 @@ export async function startGateApp(config) {
     // 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
@@ -113,13 +228,20 @@ export async function startGateApp(config) {
         const from = resolveSystemSenderAddress(getEmailRuntime().config);
         await sendEmail({
             to: [to],
-            subject: opts.subject,
+            // 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) });
+        }, 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
+    // did the one piece of it this app wants, on this app's terms.
     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
@@ -143,4 +265,4 @@ export async function startGateApp(config) {
     logger.info("gate app ready (no server; proxy-driven)");
     return handle.authGate;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../src/app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate's tiny AppKit \"app\" - `createApp` WITHOUT a `server()` plugin.\n *\n * There is no HTTP server here: the tunnel proxy is the server, and it calls the\n * gate handlers in-process. `createApp` is used only for what it auto-wires:\n *   - `CacheManager` (memory, or Lakebase when the deploy configures persistent\n *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;\n *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can\n *     deliver the one-time code;\n *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.\n *\n * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here\n * (the plugin can't resolve HOW to send on its own) to the email plugin's\n * transport. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it\n * and no reply to it reaches anyone - so it sends from the email config's\n * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names\n * another).\n *\n * FAIL FAST: a gate that can't email a code is useless, so if email does not\n * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set\n * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the\n * tunnel OPEN with no gate.\n *\n * @module\n */\n\nimport { createApp as createAppNs } from \"@dbx-tools/appkit\";\nimport { brand as nodeBrand } from \"@dbx-tools/core\";\nimport { brand as emailBrand, email, sender, transport } from \"@dbx-tools/email\";\nimport { log, string } from \"@dbx-tools/shared-core\";\nimport { authGate, type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:app\");\n\n/**\n * A code TTL as the plain phrase the email states (\"10 minutes\", \"45 seconds\").\n *\n * Whole minutes read as minutes; anything else stays in seconds rather than\n * rounding, so a 90-second TTL is not advertised as \"1 minute\" and a recipient is\n * never told the code lives longer than it does.\n */\nexport function expiresIn(seconds: number): string {\n  return seconds >= 60 && seconds % 60 === 0\n    ? string.pluralize(seconds / 60, \"minute\")\n    : string.pluralize(seconds, \"second\");\n}\n\n/** The parts of {@link SendCodeOptions} the code email's copy is built from. */\ntype CodeCopy = Pick<SendCodeOptions, \"message\" | \"codeTtlSeconds\">;\n\n/** The reassurance line closing both parts. */\nconst IGNORE_LINE = \"If you did not request this code, you can ignore this email.\";\n\n/**\n * The HTML part's source: the full branded template, with the code as a large\n * styled heading (`## ` is what makes it prominent in an inbox).\n */\nexport function codeEmailHtmlBody(code: string, opts: CodeCopy): string {\n  return [\n    opts.message,\n    \"\",\n    `## ${code}`,\n    \"\",\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\n/**\n * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree\n * above. Both parts say the same thing; only the line layout differs.\n *\n * The prompt and the code share ONE line (\"Your verification code is: 123456\").\n * That single-line shape is what iOS, Gmail, Outlook, and Android code detection\n * keys on most reliably - the heuristics look for a code in the same sentence as\n * a recognized prompt, so splitting them across lines makes detection dependent\n * on the client, and any blank line between them defeats it outright.\n *\n * The GENERATED text part cannot hold that shape at all: it is a rendering of the\n * HTML, so it carries the brand header/footer and turns the code heading's CSS\n * margin into blank lines, arriving as `prompt\\n\\n\\ncode`.\n *\n * The code is visible text in BOTH parts, never an image, so a client scraping\n * either one finds it. No trailer line follows the copy - Apple's domain-bound\n * `@domain #code` footer is deliberately NOT emitted, since it constrains the\n * code to one origin and is not what the broadly-compatible shape needs.\n */\nexport function codeEmailTextBody(code: string, opts: CodeCopy): string {\n  return [\n    `${opts.message} ${code}`,\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\nconst { createApp } = createAppNs;\nconst { resolveSystemSenderAddress } = sender;\nconst { getEmailRuntime, sendEmail } = transport;\nconst { emailBrandFromContext } = emailBrand;\nconst { loadBrandContext } = nodeBrand;\n\n/**\n * Boot the gate app and return the API the proxy calls. Throws when email is not\n * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at\n * startup rather than silently accepting nobody; the caller may catch this and\n * fall back to insecure/open mode when the operator opted in.\n */\nexport async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi> {\n  // The host app's own brand (`branding/brand.yaml` discovered from cwd) or the\n  // dbx-tools default. This is the ONE brand source for the gate: it styles the\n  // code email (accent band, font, logo) via the email plugin AND supplies the\n  // display name the copy uses, so a deployment that themes its app themes its\n  // sign-in email with it. An explicit `brandName` still wins (see below).\n  const context = await loadBrandContext();\n\n  // `sendCode` delivers the OTP through the email plugin's SHARED transport, which\n  // the `email()` plugin primes during its `setup()` (awaited by `createApp`\n  // below). Using the module-level `sendEmail` avoids a circular dependency on the\n  // app handle's inferred type. The `From` is the SYSTEM sender: a verification\n  // code is machine-generated and unanswerable, so it must not arrive from a\n  // person's address inviting a reply.\n  const sendCode: NonNullable<AuthGateConfig[\"sendCode\"]> = async (to, code, opts) => {\n    const from = resolveSystemSenderAddress(getEmailRuntime().config);\n    await sendEmail(\n      {\n        to: [to],\n        subject: opts.subject,\n        body: codeEmailHtmlBody(code, opts),\n      },\n      from,\n      undefined,\n      { text: codeEmailTextBody(code, opts) },\n    );\n  };\n\n  // `createApp` namespaces each plugin's exports on the handle by manifest name;\n  // `handle.authGate` is the in-process gate API the proxy drives.\n  const handle = await createApp({\n    plugins: [\n      // Brand the code email from the resolved context, the same bridge every\n      // other dbx-tools email surface uses (accent + font inlined, logo only when\n      // it is a fetchable URL - a package-export path cannot load in an inbox).\n      email({ brand: emailBrandFromContext(context) }),\n      // `brandName` falls back to the resolved context's display name, so the\n      // email copy names the app rather than a generic placeholder. Spelled as an\n      // explicit `??` rather than a key before `...config`: commander sets\n      // `brandName` on the options object whether or not the flag was passed, so\n      // spreading it would clobber the context name with `undefined`.\n      authGate({ ...config, brandName: config.brandName ?? context.name, sendCode }),\n    ],\n  });\n\n  // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to\n  // `mode: \"file\"` (outbox) or throws when no SMTP creds are configured - neither\n  // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.\n  if (getEmailRuntime().config.mode !== \"smtp\") {\n    throw new Error(\n      \"email is not configured for SMTP delivery - the OTP gate cannot send codes. \" +\n        \"Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true to run the tunnel open.\",\n    );\n  }\n\n  logger.info(\"gate app ready (no server; proxy-driven)\");\n  return handle.authGate as AuthGateApi;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../src/app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate's tiny AppKit \"app\" - `createApp` WITHOUT a `server()` plugin.\n *\n * There is no HTTP server here: the tunnel proxy is the server, and it calls the\n * gate handlers in-process. `createApp` is used only for what it auto-wires:\n *   - `CacheManager` (Lakebase when this process can reach it, else memory) -\n *     which the OTP `CodeStore` and the session signing key use for storage + TTL\n *     eviction;\n *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can\n *     deliver the one-time code;\n *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.\n *\n * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here\n * (the plugin can't resolve HOW to send on its own) to the email plugin's\n * transport. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it\n * and no reply to it reaches anyone - so it sends from the email config's\n * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names\n * another).\n *\n * FAIL FAST: a gate that can't email a code is useless, so if email does not\n * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set\n * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the\n * tunnel OPEN with no gate.\n *\n * @module\n */\n\nimport { getUsernameWithApiLookup } from \"@databricks/appkit\";\nimport { createApp as createAppNs, lakebaseResolver } from \"@dbx-tools/appkit\";\nimport { brand as nodeBrand } from \"@dbx-tools/core\";\nimport { brand as emailBrand, email, sender, transport } from \"@dbx-tools/email\";\nimport { env, log, string } from \"@dbx-tools/shared-core\";\nimport { authGate, type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:app\");\n\n/**\n * A code TTL as the plain phrase the email states (\"10 minutes\", \"45 seconds\").\n *\n * Whole minutes read as minutes; anything else stays in seconds rather than\n * rounding, so a 90-second TTL is not advertised as \"1 minute\" and a recipient is\n * never told the code lives longer than it does.\n */\nexport function expiresIn(seconds: number): string {\n  return seconds >= 60 && seconds % 60 === 0\n    ? string.pluralize(seconds / 60, \"minute\")\n    : string.pluralize(seconds, \"second\");\n}\n\n/** The parts of {@link SendCodeOptions} the code email's copy is built from. */\ntype CodeCopy = Pick<SendCodeOptions, \"message\" | \"codeTtlSeconds\">;\n\n/** The reassurance line closing both parts. */\nconst IGNORE_LINE = \"If you did not request this code, you can ignore this email.\";\n\n/**\n * The HTML part's source: the full branded template, with the code as a large\n * styled heading (`## ` is what makes it prominent in an inbox).\n */\nexport function codeEmailHtmlBody(code: string, opts: CodeCopy): string {\n  return [\n    opts.message,\n    \"\",\n    `## ${code}`,\n    \"\",\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\n/**\n * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree\n * above. Both parts say the same thing; only the line layout differs.\n *\n * The prompt and the code share ONE line (\"Your verification code is: 123456\").\n * That single-line shape is what iOS, Gmail, Outlook, and Android code detection\n * keys on most reliably - the heuristics look for a code in the same sentence as\n * a recognized prompt, so splitting them across lines makes detection dependent\n * on the client, and any blank line between them defeats it outright.\n *\n * The GENERATED text part cannot hold that shape at all: it is a rendering of the\n * HTML, so it carries the brand header/footer and turns the code heading's CSS\n * margin into blank lines, arriving as `prompt\\n\\n\\ncode`.\n *\n * The code is visible text in BOTH parts, never an image, so a client scraping\n * either one finds it. No trailer line follows the copy - Apple's domain-bound\n * `@domain #code` footer is deliberately NOT emitted, since it constrains the\n * code to one origin and is not what the broadly-compatible shape needs.\n */\nexport function codeEmailTextBody(code: string, opts: CodeCopy): string {\n  return [\n    `${opts.message} ${code}`,\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\n/**\n * The SUBJECT line, with the code in it: `\"123456 is your verification code\"`.\n *\n * The code has to be here, not only in the body, because of what mobile autofill\n * actually reads. iOS offers a code from an incoming NOTIFICATION - natively for\n * Messages and Mail, and since iOS 26 for any app's notification text, which is\n * what finally made Gmail work - and a notification contains the sender, the\n * subject, and a short snippet. Nothing else. A code that lives in the body is\n * invisible to it, however cleanly the body is formatted, which is why a perfectly\n * shaped `text/plain` part still produced no autofill prompt in Gmail.\n *\n * `<code> is your <thing>` rather than `<thing>: <code>` because the leading code\n * survives TRUNCATION: a notification and an inbox list both cut the subject, and\n * the platform heuristics want the code in the same sentence as a recognized\n * prompt (\"code\", \"verification\"). Putting it first keeps both intact no matter\n * where the cut lands.\n *\n * `subject` is the configured line (\"Your verification code\"), lower-cased at its\n * first word so the sentence reads naturally, and left ALONE when it does not look\n * like the conventional phrasing - an operator who set a deliberate subject gets\n * theirs with the code prefixed, not a mangled hybrid.\n */\nexport function codeEmailSubject(code: string, subject: string): string {\n  const trimmed = subject.trim();\n  const conventional = /^your\\s+/i.exec(trimmed);\n  const rest = conventional ? trimmed.slice(conventional[0].length) : trimmed;\n  return conventional ? `${code} is your ${rest}` : `${code} - ${trimmed}`;\n}\n\n/**\n * The PREHEADER: the snippet beside the subject in an inbox list, and the body of\n * the push notification. Carries the code for the same reason the subject does -\n * it is the other half of what a notification shows - and repeats the prompt\n * wording so a heuristic scanning the snippet alone finds a code next to a phrase\n * it recognizes.\n */\nexport function codeEmailPreview(code: string, opts: CodeCopy): string {\n  return `${opts.message} ${code}`;\n}\n\nconst { createApp } = createAppNs;\nconst { applyLakebaseToEnv, resolveLakebaseConnection } = lakebaseResolver;\nconst { resolveSystemSenderAddress } = sender;\nconst { getEmailRuntime, sendEmail } = transport;\nconst { emailBrandFromContext } = emailBrand;\nconst { loadBrandContext } = nodeBrand;\n\n/**\n * Env vars whose presence means a Lakebase database was bound to this deployment.\n * `LAKEBASE_ENDPOINT` is what a Databricks App `postgres` resource binding sets;\n * `PGHOST` is the local/manual spelling.\n */\nconst LAKEBASE_ENV = [\"LAKEBASE_ENDPOINT\", \"PGHOST\"] as const;\n\n/**\n * Upper bound on resolving the Lakebase connection. The gate is in the request\n * path for every visitor, so a slow workspace API must not hold up boot\n * indefinitely; a memory cache is a degraded gate, an unbooted one is no gate.\n */\nconst LAKEBASE_RESOLVE_TIMEOUT_MS = 60_000;\n\n/**\n * Fill in the Lakebase connection env AppKit's cache needs, so `CacheManager`\n * chooses PERSISTENT storage instead of memory.\n *\n * This is what makes the gate's session signing key and outstanding one-time\n * codes survive a restart, and it has to be done explicitly here. AppKit picks\n * Lakebase for the cache only when `createLakebasePool()` succeeds, and that pool\n * reads FOUR things off `process.env`: `LAKEBASE_ENDPOINT`, `PGHOST`,\n * `PGDATABASE`, and a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a service\n * principal). A Databricks App `postgres` resource binding supplies only\n * `LAKEBASE_ENDPOINT`. The resolver turns that one value into the host and\n * database; the username is looked up separately, because missing it fails pool\n * construction just as hard as a missing host - and it is what a LOCAL run (a\n * developer on a PAT, with no `DATABRICKS_CLIENT_ID`) is always missing. Without\n * all four the pool cannot be built, the cache silently degrades to in-memory, and\n * every redeploy signs out every user (the exact symptom this exists to prevent).\n *\n * `@dbx-tools/appkit`'s `createApp` would normally do this via `autoConfigure`,\n * but it gates that on a `lakebase()` plugin being registered - and this app\n * registers none, because it has no server to mount Lakebase routes on. Calling\n * the resolver directly also lets the gate be stricter than `autoConfigure` is:\n *\n *   - It runs ONLY when a Lakebase env var is present. A tunnel is a wrapper\n *     around someone else's app and must not invent infrastructure, so with\n *     nothing bound it skips rather than falling through the resolver's\n *     list-or-CREATE-a-project path.\n *   - `autoCreate: false` for the same reason, in case a project happens to exist.\n *   - Every failure is a WARNING, never a throw. The cache is an optimization for\n *     session durability; admission still requires a code delivered to an\n *     allow-listed address, so a gate with a memory cache is safe, just forgetful.\n */\nexport async function resolveCacheStorageEnv(): Promise<boolean> {\n  if (!env.text(LAKEBASE_ENV)) {\n    logger.info(\n      `no ${env.name(LAKEBASE_ENV)} - the gate cache stays in memory; sessions and codes will not survive a restart`,\n    );\n    return false;\n  }\n  try {\n    const resolved = await resolveLakebaseConnection(\n      { autoCreate: false },\n      AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS),\n    );\n    applyLakebaseToEnv(resolved);\n    // `??=` so an explicitly configured PGUSER stays authoritative. The lookup\n    // falls back to the workspace API and returns undefined rather than throwing,\n    // so a failure here just leaves the pool to find its own username.\n    const user = await getUsernameWithApiLookup({});\n    if (user) process.env.PGUSER ??= user;\n    logger.info(\"lakebase resolved for the gate cache\", {\n      host: resolved.host,\n      database: resolved.database,\n      endpoint: resolved.endpoint,\n      user: process.env.PGUSER,\n    });\n    return true;\n  } catch (error) {\n    logger.warn(\n      \"could not resolve lakebase - the gate cache stays in memory; sessions and codes will not survive a restart\",\n      { error },\n    );\n    return false;\n  }\n}\n\n/**\n * Boot the gate app and return the API the proxy calls. Throws when email is not\n * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at\n * startup rather than silently accepting nobody; the caller may catch this and\n * fall back to insecure/open mode when the operator opted in.\n */\nexport async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi> {\n  // The host app's own brand (`branding/brand.yaml` discovered from cwd) or the\n  // dbx-tools default. This is the ONE brand source for the gate: it styles the\n  // code email (accent band, font, logo) via the email plugin AND supplies the\n  // display name the copy uses, so a deployment that themes its app themes its\n  // sign-in email with it. An explicit `brandName` still wins (see below).\n  const context = await loadBrandContext();\n\n  // Before `createApp`, because AppKit resolves the cache's storage during it and\n  // reads the connection out of `process.env` when it does. See the function's\n  // docs for why the gate resolves this itself.\n  await resolveCacheStorageEnv();\n\n  // `sendCode` delivers the OTP through the email plugin's SHARED transport, which\n  // the `email()` plugin primes during its `setup()` (awaited by `createApp`\n  // below). Using the module-level `sendEmail` avoids a circular dependency on the\n  // app handle's inferred type. The `From` is the SYSTEM sender: a verification\n  // code is machine-generated and unanswerable, so it must not arrive from a\n  // person's address inviting a reply.\n  const sendCode: NonNullable<AuthGateConfig[\"sendCode\"]> = async (to, code, opts) => {\n    const from = resolveSystemSenderAddress(getEmailRuntime().config);\n    await sendEmail(\n      {\n        to: [to],\n        // The code rides in the SUBJECT and the preheader, not just the body:\n        // those two strings are the whole of a push notification, and a\n        // notification is what mobile autofill reads. See `codeEmailSubject`.\n        subject: codeEmailSubject(code, opts.subject),\n        body: codeEmailHtmlBody(code, opts),\n      },\n      from,\n      undefined,\n      { text: codeEmailTextBody(code, opts), preview: codeEmailPreview(code, opts) },\n    );\n  };\n\n  // `createApp` namespaces each plugin's exports on the handle by manifest name;\n  // `handle.authGate` is the in-process gate API the proxy drives.\n  //\n  // `autoConfigure: false` because {@link resolveCacheStorageEnv} above already\n  // did the one piece of it this app wants, on this app's terms.\n  const handle = await createApp({\n    autoConfigure: false,\n    plugins: [\n      // Brand the code email from the resolved context, the same bridge every\n      // other dbx-tools email surface uses (accent + font inlined, logo only when\n      // it is a fetchable URL - a package-export path cannot load in an inbox).\n      email({ brand: emailBrandFromContext(context) }),\n      // `brandName` falls back to the resolved context's display name, so the\n      // email copy names the app rather than a generic placeholder. Spelled as an\n      // explicit `??` rather than a key before `...config`: commander sets\n      // `brandName` on the options object whether or not the flag was passed, so\n      // spreading it would clobber the context name with `undefined`.\n      authGate({ ...config, brandName: config.brandName ?? context.name, sendCode }),\n    ],\n  });\n\n  // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to\n  // `mode: \"file\"` (outbox) or throws when no SMTP creds are configured - neither\n  // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.\n  if (getEmailRuntime().config.mode !== \"smtp\") {\n    throw new Error(\n      \"email is not configured for SMTP delivery - the OTP gate cannot send codes. \" +\n        \"Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true to run the tunnel open.\",\n    );\n  }\n\n  logger.info(\"gate app ready (no server; proxy-driven)\");\n  return handle.authGate as AuthGateApi;\n}\n"]}

package/lib/src/plugin.d.ts

@@ -29,6 +29,11 @@ export interface AuthGateConfig extends BasePluginConfig {
      * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time
      * code from this shape and offer to autofill it, and a novel phrasing is what
      * breaks that detection.
+     *
+     * This is the subject TEMPLATE, not the literal line sent: the code is spliced
+     * into it (`"123456 is your verification code"`) because a push notification
+     * shows only the subject and preheader, and that notification is what mobile
+     * autofill reads. See `codeEmailSubject` in `./app.ts`.
      */
     subject?: string;
     /**

package/lib/src/plugin.js

@@ -135,4 +135,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  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 { 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"]}

package/package.json

@@ -29,11 +29,11 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.57",
-    "@dbx-tools/core": "0.6.57",
-    "@dbx-tools/email": "0.6.57",
-    "@dbx-tools/shared-core": "0.6.57",
-    "@dbx-tools/shared-email": "0.6.57",
+    "@dbx-tools/appkit": "0.6.58",
+    "@dbx-tools/core": "0.6.58",
+    "@dbx-tools/email": "0.6.58",
+    "@dbx-tools/shared-core": "0.6.58",
+    "@dbx-tools/shared-email": "0.6.58",
     "commander": "^15.0.0",
     "http-proxy-3": "^1.23.3",
     "jose": "^6.2.3"
@@ -100,7 +100,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.57",
+  "version": "0.6.58",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/app.ts

@@ -3,8 +3,9 @@
  *
  * 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` (memory, or Lakebase when the deploy configures persistent
- *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;
+ *   - `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`.
@@ -24,10 +25,11 @@
  * @module
  */
 
-import { createApp as createAppNs } from "@dbx-tools/appkit";
+import { getUsernameWithApiLookup } from "@databricks/appkit";
+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 { log, string } from "@dbx-tools/shared-core";
+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");
@@ -95,12 +97,132 @@ export function codeEmailTextBody(code: string, opts: CodeCopy): string {
   ].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 { applyLakebaseToEnv, resolveLakebaseConnection } = 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, and it has to be done explicitly here. AppKit picks
+ * Lakebase for the cache only when `createLakebasePool()` succeeds, and that pool
+ * reads FOUR things off `process.env`: `LAKEBASE_ENDPOINT`, `PGHOST`,
+ * `PGDATABASE`, and a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a service
+ * principal). A Databricks App `postgres` resource binding supplies only
+ * `LAKEBASE_ENDPOINT`. The resolver turns that one value into the host and
+ * database; the username is looked up separately, because missing it fails pool
+ * construction just as hard as a missing host - and it is what a LOCAL run (a
+ * developer on a PAT, with no `DATABRICKS_CLIENT_ID`) is always missing. Without
+ * all four 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).
+ *
+ * `@dbx-tools/appkit`'s `createApp` would normally do this via `autoConfigure`,
+ * but it gates that on a `lakebase()` plugin being registered - and this app
+ * registers none, because it has no server to mount Lakebase routes on. Calling
+ * the resolver 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 = await resolveLakebaseConnection(
+      { autoCreate: false },
+      AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS),
+    );
+    applyLakebaseToEnv(resolved);
+    // `??=` so an explicitly configured PGUSER stays authoritative. The lookup
+    // falls back to the workspace API and returns undefined rather than throwing,
+    // so a failure here just leaves the pool to find its own username.
+    const user = await getUsernameWithApiLookup({});
+    if (user) process.env.PGUSER ??= user;
+    logger.info("lakebase resolved for the gate cache", {
+      host: resolved.host,
+      database: resolved.database,
+      endpoint: resolved.endpoint,
+      user: process.env.PGUSER,
+    });
+    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
@@ -115,6 +237,11 @@ export async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi>
   // 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
@@ -126,18 +253,25 @@ export async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi>
     await sendEmail(
       {
         to: [to],
-        subject: opts.subject,
+        // 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) },
+      { 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
+  // did the one piece of it this app wants, on this app's terms.
   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

package/src/plugin.ts

@@ -46,6 +46,11 @@ export interface AuthGateConfig extends BasePluginConfig {
    * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time
    * code from this shape and offer to autofill it, and a novel phrasing is what
    * breaks that detection.
+   *
+   * This is the subject TEMPLATE, not the literal line sent: the code is spliced
+   * into it (`"123456 is your verification code"`) because a push notification
+   * shows only the subject and preheader, and that notification is what mobile
+   * autofill reads. See `codeEmailSubject` in `./app.ts`.
    */
   subject?: string;
   /**