@dbx-tools/tunnel 0.6.60 → 0.6.62

package/README.md

@@ -18,8 +18,8 @@ so the app and portr live and die as one (concurrently-style - signals pass
 through, either death tears the pair down). The app is the process; the tunnel
 rides along inside it. Access is granted per email address against an allow-list,
 verified by a code sent over [`@dbx-tools/email`](../../node/email); the gate
-itself is the `authGate` AppKit plugin plus the `startProxy` reverse-proxy, both
-exported here for an app that wants to gate the tunnelled traffic.
+itself is the `authGate` AppKit plugin, which registers the login routes and a
+gating middleware on the app's OWN Express server (no separate proxy process).
 
 **Key features:**
 
@@ -27,11 +27,9 @@ exported here for an app that wants to gate the tunnelled traffic.
   no separate process: `createApp({ interceptor: tunnelInterceptor() })`. A no-op
   when no `PORTR_TOKEN` / `TUNNEL_PUBLIC_DOMAIN` is set, so it is safe to register
   unconditionally.
-- Branded from the repo-wide brand context: the code email's accent colour, font,
-  logo, and display name come from the app's own `branding/brand.yaml` (via
-  `@dbx-tools/core`'s `loadBrandContext()`), falling back to the dbx-tools
-  default - so the sign-in email looks like the app it fronts with nothing to
-  configure. `TUNNEL_AUTH_BRAND_NAME` overrides just the name.
+- Uses the shared email-template brand for the code email's color, font, and
+  logo. The displayed app name defaults to the dbx-tools brand and can be set
+  with `brandName` or `TUNNEL_AUTH_BRAND_NAME`.
 - Conventional one-time-code copy, so platform autofill works: the email is
   `Your verification code is: / <code> / This code expires in N minutes`, and the
   code input carries `autocomplete="one-time-code"`. iOS, Gmail, Outlook, and
@@ -83,18 +81,22 @@ exported here for an app that wants to gate the tunnelled traffic.
   `x-forwarded-access-token`, which would otherwise let anyone drive the app's
   workspace calls with a pasted token. Add an app's own headers with
   `TUNNEL_FORWARD_HEADERS`.
-- Platform traffic passes through UNGATED. The gate distinguishes the portr
-  client (a loopback source address, same container) from the hosting platform's
-  front door (a non-loopback container-network address), so health checks and the
-  workspace UI keep working while public tunnel traffic is gated.
+- Only PORTR traffic is gated. The gate identifies tunnel requests by their
+  `Host` header (`TUNNEL_PUBLIC_DOMAIN`), which portr's client preserves from the
+  public visitor. Platform front-door traffic and any other local caller carry a
+  different `Host` and pass through UNGATED, so health checks and the workspace UI
+  keep working. (There is no portr-injected identifying header and no source-IP
+  signal - the client dials the app over plain loopback - so `Host` is the signal.)
 - SPA-aware gating: static assets and the login routes stay open so the browser
   can load the client and render the login form; every other `/api/*` needs a
-  valid session cookie or gets `401`. WebSocket upgrades are gated the same way.
+  valid session cookie or gets `401`. A WebSocket handshake is an ordinary `GET`
+  and runs through the same gate.
 - Supervised teardown - `tunnelInterceptor` binds portr through the `createApp`
   interceptor context, so the app and the tunnel are tied together: if either
   exits, `bindProcess` brings the whole set down and passes signals through.
 - The gate fails fast when email is not configured for SMTP, because a gate that
-  cannot send codes locks everyone out (see `startGateApp` in the `app` module).
+  cannot send codes locks everyone out. `@dbx-tools/email` is an OPTIONAL peer
+  dependency, imported lazily; the app that mounts the gate provides it.
 
 ## Why This Over An Ad-Hoc Tunnel
 
@@ -109,24 +111,35 @@ supervise and no wrapper command to thread flags through.
 
 ```ts
 import { createApp } from "@dbx-tools/appkit";
+import { email } from "@dbx-tools/email";
 import { server } from "@databricks/appkit";
-import { interceptor } from "@dbx-tools/tunnel";
+import { interceptor, plugin } from "@dbx-tools/tunnel";
 
 const { tunnelInterceptor } = interceptor;
+const { authGate } = plugin;
 
 await createApp.createApp({
-  plugins: [server({ host, staticPath })],
+  plugins: [
+    server({ host, staticPath }),
+    // Delivers the OTP codes; the gate reuses this shared transport.
+    email(),
+    // The OTP gate: login routes + a gating middleware on THIS server. Gates only
+    // portr traffic (Host === TUNNEL_PUBLIC_DOMAIN); the platform front door passes
+    // through. Inert when no tunnel domain is configured.
+    authGate({}),
+  ],
   // Applies DATABRICKS_HOST, launches portr at the app's public port, and binds
   // it to the app. No-op when no PORTR_TOKEN / TUNNEL_PUBLIC_DOMAIN is set.
   interceptor: tunnelInterceptor(),
 });
 ```
 
-`tunnelInterceptor(opts)` takes optional `publicDomain` / `subdomain` / `port`;
-each falls back to env (and `port` to the `DATABRICKS_APP_PORT` contract), so a
-deployment usually passes nothing and configures through the environment. The
-OTP gate is a separate concern - see [Use The Gate](#use-the-gate) to mount
-`authGate` + `startProxy` for gated traffic.
+Two pieces, one process: `tunnelInterceptor()` runs portr (a child, bound to the
+app), and `authGate()` is the in-app gate. `tunnelInterceptor(opts)` takes optional
+`publicDomain` / `subdomain` / `port`, each falling back to env (and `port` to the
+`DATABRICKS_APP_PORT` contract); `authGate` reads `TUNNEL_AUTH_ALLOW` /
+`TUNNEL_PUBLIC_DOMAIN` from the environment, so a deployment usually passes nothing.
+See [Use The Gate](#use-the-gate) for the gate on its own.
 
 ## Options
 
@@ -274,7 +287,7 @@ configuration:
 | `x-requested-with` | the conventional AJAX marker                        |
 
 Add an app's own headers with `TUNNEL_FORWARD_HEADERS` (or `forwardHeaders` on
-`startProxy`). Each entry is a literal name, a shell-style glob, or a `/regex/` -
+`authGate`). Each entry is a literal name, a shell-style glob, or a `/regex/` -
 the same three shapes the email allow-list takes - and the configured list is
 UNIONED with the defaults, so extending it never silently breaks the built-in
 surfaces:
@@ -299,63 +312,59 @@ The identity headers are AppKit's OBO contract; the rest are the
 [`X-Forwarded-*` set Databricks Apps documents passing to an
 app](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers),
 plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` a library may read
-anyway. Dropping the transport headers costs nothing: the proxy re-adds them from
-the real socket after the policy runs, so the app sees the honest values instead
-of the caller's claim. Rate limiting reads the client IP before stripping, and
-takes the **rightmost** `x-forwarded-for` entry - the only one a proxy appended
-rather than a client supplied.
+anyway. Dropping the transport headers costs nothing: `xfwd` re-adds them from the
+real socket after the policy runs, so the app sees the honest values instead of the
+caller's claim. Rate limiting reads the client IP before stripping, and takes the
+**rightmost** `x-forwarded-for` entry - the only one portr appended rather than a
+client supplied.
 
 ## Use The Gate
 
-The gate is an AppKit plugin, so an app that wants the OTP flow can mount it
-directly - with or without the portr tunnel. It registers no routes - it exposes
-handlers the caller invokes (drive them from the `startProxy` reverse-proxy, or
-your own server) - and it takes a `sendCode` callback because delivering mail is
-the one thing it cannot resolve on its own:
+`authGate()` is the gate. Register it in your app's `createApp` plugins and it
+mounts the `/api/email/auth/*` login routes plus a gating middleware on your app's
+own server (via AppKit's `this.context`). By default it delivers codes through the
+app's shared `@dbx-tools/email` transport - so the minimal wiring is just an
+`allow` list (or `TUNNEL_AUTH_ALLOW`):
 
 ```ts
 import { createApp } from "@dbx-tools/appkit";
+import { email } from "@dbx-tools/email";
 import { authGate } from "@dbx-tools/tunnel";
-import { brand, email, sender, transport } from "@dbx-tools/email";
 
-const handle = await createApp({
+await createApp.createApp({
   plugins: [
-    email({ brand: brand.defaultEmailBrand }),
-    authGate({
-      allow: ["example.com"],
-      sendCode: async (to, code, opts) => {
-        const runtime = transport.getEmailRuntime();
-        await transport.sendEmail(
-          {
-            to: [to],
-            subject: opts.subject,
-            body: `${opts.message}\n\n## ${code}`,
-          },
-          // The app's configured sender; a code email has no on-behalf-of user.
-          sender.resolveSenderAddress(runtime.config, undefined),
-        );
-      },
-    }),
+    server({ host, staticPath }),
+    email(), // the gate reuses this transport to send codes
+    authGate({ allow: ["example.com"] }),
   ],
 });
-
-// The gate exposes handlers rather than routes - call them from your own server.
-const status = await handle.authGate.status(sessionCookieValue);
 ```
 
-`sendCode` is the one thing the plugin cannot resolve on its own. The `app`
-module's `startGateApp()` wires this same callback and derives the email styling
-from the brand context, so mounting the plugin directly is the only case that
-needs it by hand.
+Override `sendCode` only to deliver through something other than the shared
+transport; the default builds the OTP email (code in the subject + preheader for
+mobile autofill) and sends it as the system sender. `@dbx-tools/email` is an
+OPTIONAL peer dependency - a tunnel without the gate needs no mail - so the app
+that mounts `authGate` must include it (or run `TUNNEL_INSECURE=true` to skip the
+gate); a missing transport fails fast at boot.
+
+`GET /api/email/auth/status` is what a client asks before deciding to render a
+login screen, and it answers per REQUEST, not per deployment: on a non-tunnel
+`Host` it returns `{ authenticated: false, enabled: false }` without looking at
+the cookie, because that request was never going to be gated. So the same running
+app shows the OTP screen to a portr visitor and no login at all to a browser on
+`localhost` or the platform front door.
 
 ## Modules
 
 - `interceptor` - `tunnelInterceptor()`, the `createApp` interceptor that applies
   `DATABRICKS_HOST`, launches portr, and binds it to the app.
-- `plugin` - `authGate()`, its config/env resolution, and the `AuthGateApi`
-  handlers the proxy calls in-process.
-- `proxy` - the public-port reverse proxy: loopback-vs-platform classification,
-  open login routes, session enforcement, and WebSocket forwarding.
+- `plugin` - `authGate()`, its config/env resolution, the `AuthGateApi` handlers,
+  and the `setup()` that mounts the gate on the app's server.
+- `gate` - the login routes + gating middleware (`mountGate`, `isTunnelHost`):
+  `Host`-based tunnel classification, session enforcement, and identity injection.
+- `send-code` - the default OTP delivery through the shared email transport
+  (lazily imported) and the SMTP fail-fast.
+- `code-email` - pure builders for the code email's subject/preheader/bodies.
 - `otp` - the `CacheManager`-backed code store and the session JWT.
 - `signingKey` - the cache-persisted HS256 session key (30-day TTL, get/generate/
   re-read convergence) and the `TUNNEL_AUTH_SESSION_CUTOFF` force-clear cutoff.
@@ -366,7 +375,6 @@ needs it by hand.
   distributed).
 - `portr` - portr install, config rendering, and child launch.
 - `env` - the environment-variable names, each with its deprecated aliases.
-- `app` - boots the minimal gate AppKit app and returns the `AuthGateApi`.
 
 Browser-safe login wire schemas (the request/verify payloads and the session
 cookie name) live in [`@dbx-tools/shared-email`](../../shared/email); the React

package/index.ts

@@ -3,17 +3,21 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export * as allowlist from "./src/allowlist.ts";
-export * as app from "./src/app.ts";
+export * as codeEmail from "./src/code-email.ts";
 export * as env from "./src/env.ts";
+export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
 export * as otp from "./src/otp.ts";
 export * as plugin from "./src/plugin.ts";
 export * as portr from "./src/portr.ts";
-export * as proxy from "./src/proxy.ts";
 export * as rateLimit from "./src/rate-limit.ts";
+export * as sendCode from "./src/send-code.ts";
 export * as signingKey from "./src/signing-key.ts";
+export type { CodeCopy } from "./src/code-email.ts";
 export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.ts";
+export { AUTH_PREFIX } from "./src/gate.ts";
+export type { GateOptions } from "./src/gate.ts";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.ts";
 export type { HeaderPolicy } from "./src/headers.ts";
 export type { TunnelInterceptorOptions } from "./src/interceptor.ts";
@@ -22,7 +26,6 @@ export type { VerifyOutcome } from "./src/otp.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
 export type { PortrConfig } from "./src/portr.ts";
-export type { ProxyOptions } from "./src/proxy.ts";
 export { RateLimiter } from "./src/rate-limit.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";

package/lib/index.d.ts

@@ -1,15 +1,19 @@
 export * as allowlist from "./src/allowlist.ts";
-export * as app from "./src/app.ts";
+export * as codeEmail from "./src/code-email.ts";
 export * as env from "./src/env.ts";
+export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
 export * as otp from "./src/otp.ts";
 export * as plugin from "./src/plugin.ts";
 export * as portr from "./src/portr.ts";
-export * as proxy from "./src/proxy.ts";
 export * as rateLimit from "./src/rate-limit.ts";
+export * as sendCode from "./src/send-code.ts";
 export * as signingKey from "./src/signing-key.ts";
+export type { CodeCopy } from "./src/code-email.ts";
 export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.ts";
+export { AUTH_PREFIX } from "./src/gate.ts";
+export type { GateOptions } from "./src/gate.ts";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.ts";
 export type { HeaderPolicy } from "./src/headers.ts";
 export type { TunnelInterceptorOptions } from "./src/interceptor.ts";
@@ -18,7 +22,6 @@ export type { VerifyOutcome } from "./src/otp.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
 export type { PortrConfig } from "./src/portr.ts";
-export type { ProxyOptions } from "./src/proxy.ts";
 export { RateLimiter } from "./src/rate-limit.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";

package/lib/index.js

@@ -2,20 +2,22 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as allowlist from "./src/allowlist.js";
-export * as app from "./src/app.js";
+export * as codeEmail from "./src/code-email.js";
 export * as env from "./src/env.js";
+export * as gate from "./src/gate.js";
 export * as headers from "./src/headers.js";
 export * as interceptor from "./src/interceptor.js";
 export * as otp from "./src/otp.js";
 export * as plugin from "./src/plugin.js";
 export * as portr from "./src/portr.js";
-export * as proxy from "./src/proxy.js";
 export * as rateLimit from "./src/rate-limit.js";
+export * as sendCode from "./src/send-code.js";
 export * as signingKey from "./src/signing-key.js";
 export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.js";
+export { AUTH_PREFIX } from "./src/gate.js";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.js";
 export { CodeStore } from "./src/otp.js";
 export { AuthGatePlugin, authGate } from "./src/plugin.js";
 export { RateLimiter } from "./src/rate-limit.js";
 export { KEY_TTL_SECONDS } from "./src/signing-key.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/{app.d.ts → code-email.d.ts}

@@ -1,30 +1,18 @@
 /**
- * The tunnel gate's tiny AppKit "app" - `createApp` WITHOUT a `server()` plugin.
+ * Pure builders for the OTP code email's copy - subject, preheader, and the HTML
+ * and text bodies. No transport, no `@dbx-tools/email` import, so this module is
+ * safe to load whether or not the optional email dependency is present; the actual
+ * send lives in `./send-code`.
  *
- * 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.
+ * The shapes here are load-bearing for mobile autofill: the code rides in the
+ * SUBJECT and the PREHEADER (the whole of a push notification), and the text part
+ * keeps the prompt and code on ONE line. See each function for why.
  *
  * @module
  */
-import { type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from "./plugin.ts";
+import type { SendCodeOptions } from "./plugin.ts";
+/** The parts of {@link SendCodeOptions} the code email's copy is built from. */
+export type CodeCopy = Pick<SendCodeOptions, "message" | "codeTtlSeconds">;
 /**
  * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
  *
@@ -33,8 +21,6 @@ import { type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from "./p
  * never told the code lives longer than it does.
  */
 export declare function expiresIn(seconds: number): string;
-/** The parts of {@link SendCodeOptions} the code email's copy is built from. */
-type CodeCopy = Pick<SendCodeOptions, "message" | "codeTtlSeconds">;
 /**
  * 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).
@@ -91,40 +77,3 @@ export declare function codeEmailSubject(code: string, subject: string): string;
  * 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. `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 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
- * startup rather than silently accepting nobody; the caller may catch this and
- * fall back to insecure/open mode when the operator opted in.
- */
-export declare function startGateApp(config: AuthGateConfig): Promise<AuthGateApi>;
-export {};

package/lib/src/code-email.js

@@ -0,0 +1,108 @@
+/**
+ * Pure builders for the OTP code email's copy - subject, preheader, and the HTML
+ * and text bodies. No transport, no `@dbx-tools/email` import, so this module is
+ * safe to load whether or not the optional email dependency is present; the actual
+ * send lives in `./send-code`.
+ *
+ * The shapes here are load-bearing for mobile autofill: the code rides in the
+ * SUBJECT and the PREHEADER (the whole of a push notification), and the text part
+ * keeps the prompt and code on ONE line. See each function for why.
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+/** The reassurance line closing both parts. */
+const IGNORE_LINE = "If you did not request this code, you can ignore this email.";
+/**
+ * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
+ *
+ * Whole minutes read as minutes; anything else stays in seconds rather than
+ * rounding, so a 90-second TTL is not advertised as "1 minute" and a recipient is
+ * never told the code lives longer than it does.
+ */
+export function expiresIn(seconds) {
+    return seconds >= 60 && seconds % 60 === 0
+        ? string.pluralize(seconds / 60, "minute")
+        : string.pluralize(seconds, "second");
+}
+/**
+ * The HTML part's source: the full branded template, with the code as a large
+ * styled heading (`## ` is what makes it prominent in an inbox).
+ */
+export function codeEmailHtmlBody(code, opts) {
+    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, opts) {
+    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, 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}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-email.js","sourceRoot":"","sources":["../../src/code-email.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMhD,+CAA+C;AAC/C,MAAM,WAAW,GAAG,8DAA8D,CAAC;AAEnF;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,OAAe;IACvC,OAAO,OAAO,IAAI,EAAE,IAAI,OAAO,GAAG,EAAE,KAAK,CAAC;QACxC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,GAAG,EAAE,EAAE,QAAQ,CAAC;QAC1C,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,IAAc;IAC5D,OAAO;QACL,IAAI,CAAC,OAAO;QACZ,EAAE;QACF,MAAM,IAAI,EAAE;QACZ,EAAE;QACF,wBAAwB,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG;QACzD,EAAE;QACF,WAAW;KACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,IAAc;IAC5D,OAAO;QACL,GAAG,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE;QACzB,wBAAwB,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG;QACzD,EAAE;QACF,WAAW;KACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,OAAe;IAC5D,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,MAAM,YAAY,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAC5E,OAAO,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,YAAY,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,MAAM,OAAO,EAAE,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,IAAc;IAC3D,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;AACnC,CAAC","sourcesContent":["/**\n * Pure builders for the OTP code email's copy - subject, preheader, and the HTML\n * and text bodies. No transport, no `@dbx-tools/email` import, so this module is\n * safe to load whether or not the optional email dependency is present; the actual\n * send lives in `./send-code`.\n *\n * The shapes here are load-bearing for mobile autofill: the code rides in the\n * SUBJECT and the PREHEADER (the whole of a push notification), and the text part\n * keeps the prompt and code on ONE line. See each function for why.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\nimport type { SendCodeOptions } from \"./plugin.ts\";\n\n/** The parts of {@link SendCodeOptions} the code email's copy is built from. */\nexport type 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 * 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/**\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"]}

package/lib/src/gate.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The tunnel's in-app AUTH GATE - Express middleware + login routes the
+ * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.
+ *
+ * This replaces the old standalone reverse-proxy (`proxy.ts`): the app is now the
+ * process, so there is nothing to forward to. Instead the gate is middleware that
+ * either short-circuits (401, or answers the open login routes) or calls `next()`
+ * to let the app's real handlers run. It is the "stands in for AppKit auth" path:
+ * a portr caller proves an email via OTP, and on success the gate injects the
+ * identity headers AppKit reads, so a gated request runs like a front-door one.
+ *
+ * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client
+ * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that
+ * PRESERVES the original `Host`, so tunnel requests arrive with
+ * `Host: <subdomain>.<server>` (the public domain). A local process hitting the
+ * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose
+ * `Host` matches the configured public domain are gated; the platform front door
+ * and any other local client pass through untouched. There is no portr-injected
+ * identifying header and no TCP/source-IP signal to use instead (the client dials
+ * the target over plain loopback).
+ *
+ * @module
+ */
+import type { Request, RequestHandler } from "express";
+import type { AuthGateApi } from "./plugin.ts";
+/** Route prefix the login flow lives under (open, answered in-process). */
+export declare const AUTH_PREFIX = "/api/email/auth";
+/** Options for {@link mountGate}. */
+export interface GateOptions {
+    /** The in-process gate API (session/request/verify/status). */
+    gate: AuthGateApi;
+    /**
+     * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.
+     * When absent, no request is ever classified as tunnel traffic and the gate is
+     * inert (everything passes through) - a tunnel with no public domain gates
+     * nothing.
+     */
+    publicDomain?: string;
+    /**
+     * Extra `x-` request headers tunnel traffic may forward (unioned with the
+     * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.
+     */
+    forwardHeaders?: readonly string[];
+}
+/**
+ * True when the request's `Host` is the tunnel's public domain - i.e. it came in
+ * over portr. Case-insensitive; the optional `:port` is ignored. When no public
+ * domain is configured, nothing is tunnel traffic.
+ */
+export declare function isTunnelHost(req: Request, publicDomain: string | undefined): boolean;
+/**
+ * Register the login routes and the gating middleware on the app's Express
+ * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
+ * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.
+ *
+ * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login
+ * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),
+ * not under the plugin's `/api/authGate` base.
+ */
+export declare function mountGate(opts: GateOptions, addRoute: (method: "get" | "post", path: string, handler: RequestHandler) => void, addMiddleware: (path: string, handler: RequestHandler) => void): void;