@dbx-tools/tunnel 0.6.96 → 0.6.97

package/index.ts

@@ -8,6 +8,7 @@ export * as codeEmail from "./src/code-email.ts";
 export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
+export * as loginPage from "./src/login-page.ts";
 export * as plugin from "./src/plugin.ts";
 export * as portr from "./src/portr.ts";
 export * as sendCode from "./src/send-code.ts";
@@ -18,6 +19,7 @@ export type { GateOptions, GateAction } 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";
+export type { LoginPageOptions } from "./src/login-page.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
 export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";

package/lib/index.d.ts

@@ -4,6 +4,7 @@ export * as codeEmail from "./src/code-email.ts";
 export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
+export * as loginPage from "./src/login-page.ts";
 export * as plugin from "./src/plugin.ts";
 export * as portr from "./src/portr.ts";
 export * as sendCode from "./src/send-code.ts";
@@ -14,6 +15,7 @@ export type { GateOptions, GateAction } 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";
+export type { LoginPageOptions } from "./src/login-page.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
 export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";

package/lib/index.js

@@ -7,6 +7,7 @@ export * as codeEmail from "./src/code-email.js";
 export * as gate from "./src/gate.js";
 export * as headers from "./src/headers.js";
 export * as interceptor from "./src/interceptor.js";
+export * as loginPage from "./src/login-page.js";
 export * as plugin from "./src/plugin.js";
 export * as portr from "./src/portr.js";
 export * as sendCode from "./src/send-code.js";
@@ -15,4 +16,4 @@ export { AUTH_PREFIX, UNAUTHORIZED_BODY } from "./src/gate.js";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.js";
 export { AuthGatePlugin, authGate } from "./src/plugin.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/gate.d.ts

@@ -46,6 +46,14 @@ export interface GateOptions {
      * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.
      */
     forwardHeaders?: readonly string[];
+    /**
+     * Path prefixes that require a valid session, beyond the built-in `/api/`.
+     * The default gating model assumes a self-protecting SPA: static loads freely
+     * so the app can render, and only `/api/*` is gated. An app whose privileged
+     * surface is NOT under `/api/` (e.g. a WebSocket at `/ws`) lists those prefixes
+     * here so they are gated too. Login routes (`AUTH_PREFIX`) are always open.
+     */
+    gatePaths?: readonly string[];
 }
 /**
  * True when the request's `Host` is the tunnel's public domain - i.e. it came in
@@ -97,6 +105,18 @@ export declare const UNAUTHORIZED_BODY: {
     readonly error: "authentication required";
     readonly loginPath: "/api/email/auth";
 };
+/**
+ * Whether a denied request is a top-level BROWSER NAVIGATION that should be
+ * answered with the hosted login page rather than a 401.
+ *
+ * An app fronted by the gate (via `gatePaths`) may serve its own HTML from an
+ * ungated path while its privileged surface (`/ws`, `/api`) is gated. A browser
+ * navigating to it would otherwise load the app shell and only see the gated
+ * request fail, with no way to sign in. Serving the login page on the navigation
+ * itself puts sign-in in front of the app. Applies only to GET requests that
+ * accept HTML and are not asking for the login API or an asset.
+ */
+export declare function wantsLoginPage(req: IncomingMessage): boolean;
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands

package/lib/src/gate.js

@@ -164,12 +164,24 @@ export async function gateRequest(req, options) {
     const removed = policy.apply(req.headers);
     if (removed.length)
         logger.debug("stripped inbound headers", { removed });
-    // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
-    if (!path.startsWith("/api/")) {
+    const gatePaths = options.gatePaths ?? [];
+    // A path is gated if it is under `/api/` or any caller-supplied prefix (e.g.
+    // `/ws` for a WebSocket app).
+    const gated = path.startsWith("/api/") ||
+        gatePaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+    // App-gating mode: when `gatePaths` is set the caller is fronting a whole app
+    // (not a self-protecting SPA), so an unauthenticated top-level browser
+    // navigation is denied too — the transport answers it with the hosted login
+    // page, putting sign-in in front of the app instead of loading its shell with
+    // a dead gated request. Non-navigation static (assets) still loads freely so
+    // the login page and app can render.
+    const appGating = gatePaths.length > 0;
+    const mustAuth = gated || (appGating && wantsLoginPage(req));
+    if (!mustAuth) {
         stripSessionCookie(req);
         return "pass";
     }
-    // Every other /api/* needs a valid Better Auth session.
+    // A gated request needs a valid Better Auth session.
     const email = await gate.session(webHeaders(req));
     if (!email)
         return "deny";
@@ -182,6 +194,27 @@ export const UNAUTHORIZED_BODY = {
     error: "authentication required",
     loginPath: AUTH_PREFIX,
 };
+/**
+ * Whether a denied request is a top-level BROWSER NAVIGATION that should be
+ * answered with the hosted login page rather than a 401.
+ *
+ * An app fronted by the gate (via `gatePaths`) may serve its own HTML from an
+ * ungated path while its privileged surface (`/ws`, `/api`) is gated. A browser
+ * navigating to it would otherwise load the app shell and only see the gated
+ * request fail, with no way to sign in. Serving the login page on the navigation
+ * itself puts sign-in in front of the app. Applies only to GET requests that
+ * accept HTML and are not asking for the login API or an asset.
+ */
+export function wantsLoginPage(req) {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD")
+        return false;
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    if (path.startsWith(AUTH_PREFIX))
+        return false;
+    const accept = String(req.headers.accept ?? "");
+    return accept.includes("text/html");
+}
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
@@ -192,9 +225,9 @@ export const UNAUTHORIZED_BODY = {
  * not under the plugin's `/api/authGate` base.
  */
 export function mountGate(opts, _addRoute, addMiddleware) {
-    const { gate, publicDomain, forwardHeaders } = opts;
+    const { gate, publicDomain, forwardHeaders, gatePaths } = opts;
     const headerPolicy = toHeaderPolicy(forwardHeaders);
-    logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
+    logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns, gatePaths });
     // Better Auth and the compatibility routes share one fetch-compatible
     // handler in both hosting modes.
     const authHandler = (async (req, res) => {
@@ -213,7 +246,7 @@ export function mountGate(opts, _addRoute, addMiddleware) {
     addMiddleware(AUTH_PREFIX, authHandler);
     // --- The gate middleware (runs before static + the app's /api handlers) ---
     const gateMiddleware = (async (req, res, next) => {
-        const action = await gateRequest(req, { gate, publicDomain, headerPolicy });
+        const action = await gateRequest(req, { gate, publicDomain, headerPolicy, gatePaths });
         if (action === "deny")
             res.status(401).json(UNAUTHORIZED_BODY);
         else
@@ -221,4 +254,4 @@ export function mountGate(opts, _addRoute, addMiddleware) {
     });
     addMiddleware("/", gateMiddleware);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../src/gate.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel's in-app AUTH GATE - Express middleware + login routes the\n * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.\n *\n * The gate is MIDDLEWARE, not a reverse proxy - the app is the process, so there is\n * nothing to forward to. It either short-circuits (401, or answers the open login\n * routes) or calls `next()` to let the app's real handlers run. It is the\n * \"stands in for AppKit auth\" path:\n * a portr caller authenticates with Better Auth OTP or a passkey, and on\n * success the gate injects the identity headers AppKit reads.\n *\n * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client\n * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that\n * PRESERVES the original `Host`, so tunnel requests arrive with\n * `Host: <subdomain>.<server>` (the public domain). A local process hitting the\n * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose\n * `Host` matches the configured public domain are gated; the platform front door\n * and any other local client pass through untouched. There is no portr-injected\n * identifying header and no TCP/source-IP signal to use instead (the client dials\n * the target over plain loopback).\n *\n * @module\n */\n\nimport type { IncomingMessage } from \"node:http\";\nimport { log, token } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler, Response } from \"express\";\nimport { toHeaderPolicy, type HeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:gate\");\n\ntype WebRequestInput = IncomingMessage & {\n  body?: unknown;\n  originalUrl?: string;\n};\n\nexport const AUTH_PREFIX = \"/api/email/auth\";\n\n/** Options for {@link mountGate}. */\nexport interface GateOptions {\n  /** The in-process gate API (session/request/verify/status). */\n  gate: AuthGateApi;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.\n   * When absent, no request is ever classified as tunnel traffic and the gate is\n   * inert (everything passes through) - a tunnel with no public domain gates\n   * nothing.\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (unioned with the\n   * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.\n   */\n  forwardHeaders?: readonly string[];\n}\n\n/**\n * True when the request's `Host` is the tunnel's public domain - i.e. it came in\n * over portr. Case-insensitive; the optional `:port` is ignored. When no public\n * domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(req: IncomingMessage, publicDomain: string | undefined): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  return host === publicDomain.toLowerCase().split(\":\")[0];\n}\n\n/**\n * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value\n * the nearest trusted hop - portr - wrote), else the socket address. Reading the\n * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by\n * varying the header. Called before {@link stripHeaders}.\n */\nexport function clientIp(req: IncomingMessage): string {\n  const forwarded = req.headers[\"x-forwarded-for\"];\n  const chain = (Array.isArray(forwarded) ? forwarded.join(\",\") : (forwarded ?? \"\"))\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  return chain.at(-1) ?? req.socket.remoteAddress ?? \"unknown\";\n}\n\n/**\n * Remove the gate's session cookie from the `Cookie` header before the app's\n * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).\n * Preserves other cookies; deletes the header when it becomes empty.\n */\nfunction stripSessionCookie(req: IncomingMessage): void {\n  const raw = req.headers.cookie;\n  if (!raw) return;\n  const kept = raw\n    .split(\";\")\n    .map((c) => c.trim())\n    .filter((c) => c && !c.startsWith(\"dbx-tools-auth=\") && !c.startsWith(\"dbx-tools-passkey=\"));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present a passwordless-authenticated caller to the app the SAME way a platform front\n * door does: set the front-door identity headers to the verified address (AppKit\n * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no\n * gate-specific code path.\n *\n * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an auth session\n * proves an email, not possession of a Databricks credential. Its absence is what\n * `@dbx-tools/appkit`'s `identity: \"auto\"` detects, so a gated request runs as the\n * app service principal instead of throwing.\n */\nfunction injectIdentity(req: IncomingMessage, email: string): void {\n  req.headers[token.USER_ID_HEADER] = email;\n  req.headers[token.USER_EMAIL_HEADER] = email;\n}\n\n/** Read the raw request body as text (AppKit parses JSON, but the gate routes\n * are mounted before that runs for tunnel traffic, so read defensively). */\nfunction readBody(req: WebRequestInput): Promise<string> {\n  // AppKit's json body-parser may have already populated req.body; prefer it.\n  if (req.body !== undefined && req.body !== null) {\n    return Promise.resolve(typeof req.body === \"string\" ? req.body : JSON.stringify(req.body));\n  }\n  return new Promise((resolve) => {\n    let data = \"\";\n    req.on(\"data\", (chunk) => (data += chunk));\n    req.on(\"end\", () => resolve(data));\n    req.on(\"error\", () => resolve(data));\n  });\n}\n\nexport function webHeaders(req: IncomingMessage): Headers {\n  const headers = new Headers();\n  for (const [name, value] of Object.entries(req.headers)) {\n    if (Array.isArray(value)) {\n      for (const item of value) headers.append(name, item);\n    } else if (value !== undefined) {\n      headers.set(name, value);\n    }\n  }\n  headers.set(\"x-real-ip\", clientIp(req));\n  return headers;\n}\n\nexport async function webRequest(req: WebRequestInput): Promise<globalThis.Request> {\n  const host = req.headers.host ?? \"localhost\";\n  const hostname = host.split(\":\")[0]?.toLowerCase();\n  const protocol = hostname === \"localhost\" || hostname === \"127.0.0.1\" ? \"http\" : \"https\";\n  const method = (req.method ?? \"GET\").toUpperCase();\n  const body = method === \"GET\" || method === \"HEAD\" ? undefined : await readBody(req);\n  return new globalThis.Request(`${protocol}://${host}${req.originalUrl || req.url}`, {\n    method,\n    headers: webHeaders(req),\n    ...(body ? { body } : {}),\n  });\n}\n\nexport async function sendWebResponse(res: Response, response: globalThis.Response): Promise<void> {\n  for (const [name, value] of response.headers.entries()) {\n    if (name.toLowerCase() !== \"set-cookie\") res.setHeader(name, value);\n  }\n  const cookies = response.headers.getSetCookie();\n  if (cookies.length) res.setHeader(\"set-cookie\", cookies);\n  const body = Buffer.from(await response.arrayBuffer());\n  res.status(response.status).send(body);\n}\n\n/**\n * What the caller should do with a request, from {@link gateRequest}.\n *\n *   - `pass` - not tunnel traffic, or an open login route. Forward untouched.\n *   - `allow` - tunnel traffic that is authorized. The request's headers have\n *     ALREADY been rewritten (policy applied, identity injected, session cookie\n *     stripped), so forward it as it now stands.\n *   - `deny` - tunnel traffic with no valid session. Answer `401` with\n *     {@link AUTH_PREFIX} as the login path.\n */\nexport type GateAction = \"pass\" | \"allow\" | \"deny\";\n\n/**\n * THE gating decision, for one request, independent of how it will be answered.\n *\n * Both paths call this: the Express middleware below (where the app is the\n * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child\n * process on a private port). A divergence between them would be a security bug\n * the second path could not be tested into agreement - one path forgetting to\n * strip `x-forwarded-access-token` is enough - so the decision, the header\n * rewriting, and the identity injection live here once and the transports only\n * differ in how they WRITE the outcome.\n *\n * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly\n * what both callers want: Express hands the same object to the app's handlers, and\n * the proxy forwards it upstream.\n */\nexport async function gateRequest(\n  req: IncomingMessage,\n  options: GateOptions & { headerPolicy?: HeaderPolicy },\n): Promise<GateAction> {\n  const { gate, publicDomain } = options;\n  // Not tunnel traffic (platform front door, or any other local caller): the\n  // request is already authenticated, or is not ours to gate.\n  if (!isTunnelHost(req, publicDomain)) return \"pass\";\n\n  const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n  // The login flow is open so the browser can render <AuthGate> and sign in.\n  if (path.startsWith(AUTH_PREFIX)) return \"pass\";\n\n  // Anti-spoof: only the gate may assert identity on tunnel traffic.\n  const policy = options.headerPolicy ?? toHeaderPolicy(options.forwardHeaders);\n  const removed = policy.apply(req.headers as Record<string, unknown>);\n  if (removed.length) logger.debug(\"stripped inbound headers\", { removed });\n\n  // Static (non-API) loads freely so the SPA can render; drop the gate cookie.\n  if (!path.startsWith(\"/api/\")) {\n    stripSessionCookie(req);\n    return \"pass\";\n  }\n\n  // Every other /api/* needs a valid Better Auth session.\n  const email = await gate.session(webHeaders(req));\n  if (!email) return \"deny\";\n  injectIdentity(req, email);\n  stripSessionCookie(req);\n  return \"allow\";\n}\n\n/** The body of a `deny`, shared so both paths answer a 401 identically. */\nexport const UNAUTHORIZED_BODY = {\n  error: \"authentication required\",\n  loginPath: AUTH_PREFIX,\n} as const;\n\n/**\n * Register the login routes and the gating middleware on the app's Express\n * instance. Called from {@link AuthGatePlugin} with the router AppKit hands\n * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.\n *\n * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login\n * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),\n * not under the plugin's `/api/authGate` base.\n */\nexport function mountGate(\n  opts: GateOptions,\n  _addRoute: (method: \"get\" | \"post\", path: string, handler: RequestHandler) => void,\n  addMiddleware: (path: string, handler: RequestHandler) => void,\n): void {\n  const { gate, publicDomain, forwardHeaders } = opts;\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"gate mounted\", { publicDomain, forward: headerPolicy.patterns });\n\n  // Better Auth and the compatibility routes share one fetch-compatible\n  // handler in both hosting modes.\n  const authHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n      if (path.endsWith(\"/status\")) {\n        res.status(200).json({ authenticated: false, enabled: false, passkeysEnabled: false });\n      } else {\n        res.status(404).json({ error: \"not found\" });\n      }\n      return;\n    }\n    await sendWebResponse(res, await gate.handler(await webRequest(req)));\n  }) as RequestHandler;\n  addMiddleware(AUTH_PREFIX, authHandler);\n\n  // --- The gate middleware (runs before static + the app's /api handlers) ---\n\n  const gateMiddleware = (async (req, res, next) => {\n    const action = await gateRequest(req, { gate, publicDomain, headerPolicy });\n    if (action === \"deny\") res.status(401).json(UNAUTHORIZED_BODY);\n    else next();\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../src/gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAqB,MAAM,cAAc,CAAC;AAGjE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAOzC,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC;AA4B7C;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,GAAoB,EAAE,YAAgC;IACjF,IAAI,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IAChC,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,OAAO,IAAI,KAAK,YAAY,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAoB;IAC3C,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjD,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;SAC/E,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;SAC5B,MAAM,CAAC,OAAO,CAAC,CAAC;IACnB,OAAO,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,SAAS,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,GAAoB;IAC9C,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;IAC/B,IAAI,CAAC,GAAG;QAAE,OAAO;IACjB,MAAM,IAAI,GAAG,GAAG;SACb,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAC/F,IAAI,IAAI,CAAC,MAAM;QAAE,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;QACjD,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;AACjC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,cAAc,CAAC,GAAoB,EAAE,KAAa;IACzD,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC;IAC1C,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,KAAK,CAAC;AAC/C,CAAC;AAED;4EAC4E;AAC5E,SAAS,QAAQ,CAAC,GAAoB;IACpC,4EAA4E;IAC5E,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7F,CAAC;IACD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC;QAC3C,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACnC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,GAAoB;IAC7C,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACxD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,KAAK,MAAM,IAAI,IAAI,KAAK;gBAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACvD,CAAC;aAAM,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACxC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,GAAoB;IACnD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,WAAW,CAAC;IAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;IACnD,MAAM,QAAQ,GAAG,QAAQ,KAAK,WAAW,IAAI,QAAQ,KAAK,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IACzF,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IACnD,MAAM,IAAI,GAAG,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,GAAG,CAAC,CAAC;IACrF,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,MAAM,IAAI,GAAG,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,EAAE,EAAE;QAClF,MAAM;QACN,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC;QACxB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1B,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,GAAa,EAAE,QAA6B;IAChF,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;QACvD,IAAI,IAAI,CAAC,WAAW,EAAE,KAAK,YAAY;YAAE,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;IAChD,IAAI,OAAO,CAAC,MAAM;QAAE,GAAG,CAAC,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IACzD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;IACvD,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAcD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,GAAoB,EACpB,OAAsD;IAEtD,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;IACvC,2EAA2E;IAC3E,4DAA4D;IAC5D,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,YAAY,CAAC;QAAE,OAAO,MAAM,CAAC;IAEpD,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;IACnD,2EAA2E;IAC3E,IAAI,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QAAE,OAAO,MAAM,CAAC;IAEhD,mEAAmE;IACnE,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,IAAI,cAAc,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC9E,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,OAAkC,CAAC,CAAC;IACrE,IAAI,OAAO,CAAC,MAAM;QAAE,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAE1E,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;IAC1C,6EAA6E;IAC7E,8BAA8B;IAC9B,MAAM,KAAK,GACT,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;QACxB,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;IAE/E,8EAA8E;IAC9E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,6EAA6E;IAC7E,qCAAqC;IACrC,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,KAAK,IAAI,CAAC,SAAS,IAAI,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,CAAC,CAAC;QACxB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,qDAAqD;IACrD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAClD,IAAI,CAAC,KAAK;QAAE,OAAO,MAAM,CAAC;IAC1B,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC3B,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACxB,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,2EAA2E;AAC3E,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,KAAK,EAAE,yBAAyB;IAChC,SAAS,EAAE,WAAW;CACd,CAAC;AAEX;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,GAAoB;IACjD,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IACnD,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IACxD,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;IACnD,IAAI,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;IAChD,OAAO,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CACvB,IAAiB,EACjB,SAAkF,EAClF,aAA8D;IAE9D,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAC/D,MAAM,YAAY,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;IACpD,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;IAE1F,sEAAsE;IACtE,iCAAiC;IACjC,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;QACtC,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,YAAY,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;YACnD,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC7B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,CAAC;YACzF,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;YAC/C,CAAC;YACD,OAAO;QACT,CAAC;QACD,MAAM,eAAe,CAAC,GAAG,EAAE,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC,CAAmB,CAAC;IACrB,aAAa,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAExC,6EAA6E;IAE7E,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QAC/C,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,CAAC;QACvF,IAAI,MAAM,KAAK,MAAM;YAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;;YAC1D,IAAI,EAAE,CAAC;IACd,CAAC,CAAmB,CAAC;IAErB,aAAa,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;AACrC,CAAC","sourcesContent":["/**\n * The tunnel's in-app AUTH GATE - Express middleware + login routes the\n * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.\n *\n * The gate is MIDDLEWARE, not a reverse proxy - the app is the process, so there is\n * nothing to forward to. It either short-circuits (401, or answers the open login\n * routes) or calls `next()` to let the app's real handlers run. It is the\n * \"stands in for AppKit auth\" path:\n * a portr caller authenticates with Better Auth OTP or a passkey, and on\n * success the gate injects the identity headers AppKit reads.\n *\n * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client\n * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that\n * PRESERVES the original `Host`, so tunnel requests arrive with\n * `Host: <subdomain>.<server>` (the public domain). A local process hitting the\n * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose\n * `Host` matches the configured public domain are gated; the platform front door\n * and any other local client pass through untouched. There is no portr-injected\n * identifying header and no TCP/source-IP signal to use instead (the client dials\n * the target over plain loopback).\n *\n * @module\n */\n\nimport type { IncomingMessage } from \"node:http\";\nimport { log, token } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler, Response } from \"express\";\nimport { toHeaderPolicy, type HeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:gate\");\n\ntype WebRequestInput = IncomingMessage & {\n  body?: unknown;\n  originalUrl?: string;\n};\n\nexport const AUTH_PREFIX = \"/api/email/auth\";\n\n/** Options for {@link mountGate}. */\nexport interface GateOptions {\n  /** The in-process gate API (session/request/verify/status). */\n  gate: AuthGateApi;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.\n   * When absent, no request is ever classified as tunnel traffic and the gate is\n   * inert (everything passes through) - a tunnel with no public domain gates\n   * nothing.\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (unioned with the\n   * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.\n   */\n  forwardHeaders?: readonly string[];\n  /**\n   * Path prefixes that require a valid session, beyond the built-in `/api/`.\n   * The default gating model assumes a self-protecting SPA: static loads freely\n   * so the app can render, and only `/api/*` is gated. An app whose privileged\n   * surface is NOT under `/api/` (e.g. a WebSocket at `/ws`) lists those prefixes\n   * here so they are gated too. Login routes (`AUTH_PREFIX`) are always open.\n   */\n  gatePaths?: readonly string[];\n}\n\n/**\n * True when the request's `Host` is the tunnel's public domain - i.e. it came in\n * over portr. Case-insensitive; the optional `:port` is ignored. When no public\n * domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(req: IncomingMessage, publicDomain: string | undefined): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  return host === publicDomain.toLowerCase().split(\":\")[0];\n}\n\n/**\n * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value\n * the nearest trusted hop - portr - wrote), else the socket address. Reading the\n * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by\n * varying the header. Called before {@link stripHeaders}.\n */\nexport function clientIp(req: IncomingMessage): string {\n  const forwarded = req.headers[\"x-forwarded-for\"];\n  const chain = (Array.isArray(forwarded) ? forwarded.join(\",\") : (forwarded ?? \"\"))\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  return chain.at(-1) ?? req.socket.remoteAddress ?? \"unknown\";\n}\n\n/**\n * Remove the gate's session cookie from the `Cookie` header before the app's\n * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).\n * Preserves other cookies; deletes the header when it becomes empty.\n */\nfunction stripSessionCookie(req: IncomingMessage): void {\n  const raw = req.headers.cookie;\n  if (!raw) return;\n  const kept = raw\n    .split(\";\")\n    .map((c) => c.trim())\n    .filter((c) => c && !c.startsWith(\"dbx-tools-auth=\") && !c.startsWith(\"dbx-tools-passkey=\"));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present a passwordless-authenticated caller to the app the SAME way a platform front\n * door does: set the front-door identity headers to the verified address (AppKit\n * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no\n * gate-specific code path.\n *\n * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an auth session\n * proves an email, not possession of a Databricks credential. Its absence is what\n * `@dbx-tools/appkit`'s `identity: \"auto\"` detects, so a gated request runs as the\n * app service principal instead of throwing.\n */\nfunction injectIdentity(req: IncomingMessage, email: string): void {\n  req.headers[token.USER_ID_HEADER] = email;\n  req.headers[token.USER_EMAIL_HEADER] = email;\n}\n\n/** Read the raw request body as text (AppKit parses JSON, but the gate routes\n * are mounted before that runs for tunnel traffic, so read defensively). */\nfunction readBody(req: WebRequestInput): Promise<string> {\n  // AppKit's json body-parser may have already populated req.body; prefer it.\n  if (req.body !== undefined && req.body !== null) {\n    return Promise.resolve(typeof req.body === \"string\" ? req.body : JSON.stringify(req.body));\n  }\n  return new Promise((resolve) => {\n    let data = \"\";\n    req.on(\"data\", (chunk) => (data += chunk));\n    req.on(\"end\", () => resolve(data));\n    req.on(\"error\", () => resolve(data));\n  });\n}\n\nexport function webHeaders(req: IncomingMessage): Headers {\n  const headers = new Headers();\n  for (const [name, value] of Object.entries(req.headers)) {\n    if (Array.isArray(value)) {\n      for (const item of value) headers.append(name, item);\n    } else if (value !== undefined) {\n      headers.set(name, value);\n    }\n  }\n  headers.set(\"x-real-ip\", clientIp(req));\n  return headers;\n}\n\nexport async function webRequest(req: WebRequestInput): Promise<globalThis.Request> {\n  const host = req.headers.host ?? \"localhost\";\n  const hostname = host.split(\":\")[0]?.toLowerCase();\n  const protocol = hostname === \"localhost\" || hostname === \"127.0.0.1\" ? \"http\" : \"https\";\n  const method = (req.method ?? \"GET\").toUpperCase();\n  const body = method === \"GET\" || method === \"HEAD\" ? undefined : await readBody(req);\n  return new globalThis.Request(`${protocol}://${host}${req.originalUrl || req.url}`, {\n    method,\n    headers: webHeaders(req),\n    ...(body ? { body } : {}),\n  });\n}\n\nexport async function sendWebResponse(res: Response, response: globalThis.Response): Promise<void> {\n  for (const [name, value] of response.headers.entries()) {\n    if (name.toLowerCase() !== \"set-cookie\") res.setHeader(name, value);\n  }\n  const cookies = response.headers.getSetCookie();\n  if (cookies.length) res.setHeader(\"set-cookie\", cookies);\n  const body = Buffer.from(await response.arrayBuffer());\n  res.status(response.status).send(body);\n}\n\n/**\n * What the caller should do with a request, from {@link gateRequest}.\n *\n *   - `pass` - not tunnel traffic, or an open login route. Forward untouched.\n *   - `allow` - tunnel traffic that is authorized. The request's headers have\n *     ALREADY been rewritten (policy applied, identity injected, session cookie\n *     stripped), so forward it as it now stands.\n *   - `deny` - tunnel traffic with no valid session. Answer `401` with\n *     {@link AUTH_PREFIX} as the login path.\n */\nexport type GateAction = \"pass\" | \"allow\" | \"deny\";\n\n/**\n * THE gating decision, for one request, independent of how it will be answered.\n *\n * Both paths call this: the Express middleware below (where the app is the\n * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child\n * process on a private port). A divergence between them would be a security bug\n * the second path could not be tested into agreement - one path forgetting to\n * strip `x-forwarded-access-token` is enough - so the decision, the header\n * rewriting, and the identity injection live here once and the transports only\n * differ in how they WRITE the outcome.\n *\n * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly\n * what both callers want: Express hands the same object to the app's handlers, and\n * the proxy forwards it upstream.\n */\nexport async function gateRequest(\n  req: IncomingMessage,\n  options: GateOptions & { headerPolicy?: HeaderPolicy },\n): Promise<GateAction> {\n  const { gate, publicDomain } = options;\n  // Not tunnel traffic (platform front door, or any other local caller): the\n  // request is already authenticated, or is not ours to gate.\n  if (!isTunnelHost(req, publicDomain)) return \"pass\";\n\n  const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n  // The login flow is open so the browser can render <AuthGate> and sign in.\n  if (path.startsWith(AUTH_PREFIX)) return \"pass\";\n\n  // Anti-spoof: only the gate may assert identity on tunnel traffic.\n  const policy = options.headerPolicy ?? toHeaderPolicy(options.forwardHeaders);\n  const removed = policy.apply(req.headers as Record<string, unknown>);\n  if (removed.length) logger.debug(\"stripped inbound headers\", { removed });\n\n  const gatePaths = options.gatePaths ?? [];\n  // A path is gated if it is under `/api/` or any caller-supplied prefix (e.g.\n  // `/ws` for a WebSocket app).\n  const gated =\n    path.startsWith(\"/api/\") ||\n    gatePaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));\n\n  // App-gating mode: when `gatePaths` is set the caller is fronting a whole app\n  // (not a self-protecting SPA), so an unauthenticated top-level browser\n  // navigation is denied too — the transport answers it with the hosted login\n  // page, putting sign-in in front of the app instead of loading its shell with\n  // a dead gated request. Non-navigation static (assets) still loads freely so\n  // the login page and app can render.\n  const appGating = gatePaths.length > 0;\n  const mustAuth = gated || (appGating && wantsLoginPage(req));\n  if (!mustAuth) {\n    stripSessionCookie(req);\n    return \"pass\";\n  }\n\n  // A gated request needs a valid Better Auth session.\n  const email = await gate.session(webHeaders(req));\n  if (!email) return \"deny\";\n  injectIdentity(req, email);\n  stripSessionCookie(req);\n  return \"allow\";\n}\n\n/** The body of a `deny`, shared so both paths answer a 401 identically. */\nexport const UNAUTHORIZED_BODY = {\n  error: \"authentication required\",\n  loginPath: AUTH_PREFIX,\n} as const;\n\n/**\n * Whether a denied request is a top-level BROWSER NAVIGATION that should be\n * answered with the hosted login page rather than a 401.\n *\n * An app fronted by the gate (via `gatePaths`) may serve its own HTML from an\n * ungated path while its privileged surface (`/ws`, `/api`) is gated. A browser\n * navigating to it would otherwise load the app shell and only see the gated\n * request fail, with no way to sign in. Serving the login page on the navigation\n * itself puts sign-in in front of the app. Applies only to GET requests that\n * accept HTML and are not asking for the login API or an asset.\n */\nexport function wantsLoginPage(req: IncomingMessage): boolean {\n  const method = (req.method ?? \"GET\").toUpperCase();\n  if (method !== \"GET\" && method !== \"HEAD\") return false;\n  const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n  if (path.startsWith(AUTH_PREFIX)) return false;\n  const accept = String(req.headers.accept ?? \"\");\n  return accept.includes(\"text/html\");\n}\n\n/**\n * Register the login routes and the gating middleware on the app's Express\n * instance. Called from {@link AuthGatePlugin} with the router AppKit hands\n * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.\n *\n * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login\n * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),\n * not under the plugin's `/api/authGate` base.\n */\nexport function mountGate(\n  opts: GateOptions,\n  _addRoute: (method: \"get\" | \"post\", path: string, handler: RequestHandler) => void,\n  addMiddleware: (path: string, handler: RequestHandler) => void,\n): void {\n  const { gate, publicDomain, forwardHeaders, gatePaths } = opts;\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"gate mounted\", { publicDomain, forward: headerPolicy.patterns, gatePaths });\n\n  // Better Auth and the compatibility routes share one fetch-compatible\n  // handler in both hosting modes.\n  const authHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n      if (path.endsWith(\"/status\")) {\n        res.status(200).json({ authenticated: false, enabled: false, passkeysEnabled: false });\n      } else {\n        res.status(404).json({ error: \"not found\" });\n      }\n      return;\n    }\n    await sendWebResponse(res, await gate.handler(await webRequest(req)));\n  }) as RequestHandler;\n  addMiddleware(AUTH_PREFIX, authHandler);\n\n  // --- The gate middleware (runs before static + the app's /api handlers) ---\n\n  const gateMiddleware = (async (req, res, next) => {\n    const action = await gateRequest(req, { gate, publicDomain, headerPolicy, gatePaths });\n    if (action === \"deny\") res.status(401).json(UNAUTHORIZED_BODY);\n    else next();\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}

package/lib/src/login-page.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A self-contained HTML login page the tunnel serves in front of an app that
+ * does not embed the `<AuthGate>` React component (e.g. a WebSocket app fronted
+ * by the CLI proxy).
+ *
+ * It speaks the same compatibility endpoints under {@link AUTH_PREFIX} that the
+ * React client uses — `POST /request` to email a code, `POST /verify` to
+ * exchange it for the `dbx-tools-auth` session cookie — with plain `fetch`, no
+ * build step and no dependency. Passkeys are intentionally omitted: the WebAuthn
+ * ceremony needs the better-auth client library, so passkey enrollment happens
+ * inside the app after this email-OTP sign-in. On success the page reloads, and
+ * the now-authenticated request reaches the app.
+ *
+ * @module
+ */
+export interface LoginPageOptions {
+    /** Product/brand name shown in the heading. */
+    brandName: string;
+}
+/** The login page HTML for a `text/html` request to a gated path with no session. */
+export declare function loginPageHtml(options: LoginPageOptions): string;

package/lib/src/login-page.js

@@ -0,0 +1,190 @@
+/**
+ * A self-contained HTML login page the tunnel serves in front of an app that
+ * does not embed the `<AuthGate>` React component (e.g. a WebSocket app fronted
+ * by the CLI proxy).
+ *
+ * It speaks the same compatibility endpoints under {@link AUTH_PREFIX} that the
+ * React client uses — `POST /request` to email a code, `POST /verify` to
+ * exchange it for the `dbx-tools-auth` session cookie — with plain `fetch`, no
+ * build step and no dependency. Passkeys are intentionally omitted: the WebAuthn
+ * ceremony needs the better-auth client library, so passkey enrollment happens
+ * inside the app after this email-OTP sign-in. On success the page reloads, and
+ * the now-authenticated request reaches the app.
+ *
+ * @module
+ */
+import { AUTH_PREFIX } from "./gate.js";
+/** The login page HTML for a `text/html` request to a gated path with no session. */
+export function loginPageHtml(options) {
+    const brand = escapeHtml(options.brandName);
+    // AUTH_PREFIX is a fixed constant, not user input, but JSON-encode it so the
+    // inlined script is always valid regardless of its value.
+    const prefix = JSON.stringify(AUTH_PREFIX);
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Sign in — ${brand}</title>
+<style>
+  :root {
+    color-scheme: light dark;
+    --bg: #ffffff; --fg: #1b1b1f; --muted: #6b7280; --border: #d9dce1;
+    --accent: #1a73e8; --accent-fg: #ffffff; --error: #c5221f; --field: #ffffff;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #16181d; --fg: #e8e6df; --muted: #9aa0aa; --border: #2c2f36;
+      --accent: #4c8dff; --accent-fg: #0b0f19; --error: #ff6b60; --field: #1e2128;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; min-height: 100vh; display: flex; align-items: center;
+    justify-content: center; background: var(--bg); color: var(--fg);
+    font-family: system-ui, -apple-system, "Segoe UI", sans-serif; padding: 24px;
+  }
+  .card {
+    width: 100%; max-width: 360px; border: 1px solid var(--border);
+    border-radius: 14px; padding: 28px; background: var(--bg);
+  }
+  h1 { font-size: 18px; margin: 0 0 4px; }
+  p.sub { margin: 0 0 20px; color: var(--muted); font-size: 13px; }
+  label { display: block; font-size: 12px; color: var(--muted); margin: 0 0 6px; }
+  input {
+    width: 100%; padding: 10px 12px; font-size: 15px; border-radius: 9px;
+    border: 1px solid var(--border); background: var(--field); color: var(--fg);
+  }
+  input:focus { outline: 2px solid var(--accent); outline-offset: -1px; }
+  button {
+    width: 100%; margin-top: 16px; padding: 10px 12px; font-size: 15px;
+    font-weight: 600; border: 0; border-radius: 9px; background: var(--accent);
+    color: var(--accent-fg); cursor: pointer;
+  }
+  button:disabled { opacity: 0.6; cursor: default; }
+  .msg { margin-top: 14px; font-size: 13px; min-height: 18px; }
+  .msg.error { color: var(--error); }
+  .hidden { display: none; }
+  .back { background: none; color: var(--muted); font-weight: 400; margin-top: 8px; }
+</style>
+</head>
+<body>
+  <main class="card">
+    <h1>Sign in to ${brand}</h1>
+    <p class="sub">Enter your email to receive a one-time code.</p>
+
+    <form id="email-form">
+      <label for="email">Email</label>
+      <input id="email" name="email" type="email" autocomplete="email" required autofocus>
+      <button id="email-submit" type="submit">Send code</button>
+    </form>
+
+    <form id="code-form" class="hidden">
+      <label for="code">Verification code</label>
+      <input id="code" name="code" inputmode="numeric" autocomplete="one-time-code" required>
+      <button id="code-submit" type="submit">Verify</button>
+      <button id="back" type="button" class="back">Use a different email</button>
+    </form>
+
+    <div id="msg" class="msg" role="status" aria-live="polite"></div>
+  </main>
+
+<script>
+(function () {
+  var PREFIX = ${prefix};
+  var emailForm = document.getElementById("email-form");
+  var codeForm = document.getElementById("code-form");
+  var emailInput = document.getElementById("email");
+  var codeInput = document.getElementById("code");
+  var back = document.getElementById("back");
+  var msg = document.getElementById("msg");
+  var email = "";
+
+  function say(text, isError) {
+    msg.textContent = text || "";
+    msg.className = "msg" + (isError ? " error" : "");
+  }
+
+  async function post(path, body) {
+    var res = await fetch(PREFIX + path, {
+      method: "POST",
+      credentials: "include",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    var data = {};
+    try { data = await res.json(); } catch (_e) { /* non-JSON */ }
+    return { ok: res.ok, status: res.status, data: data };
+  }
+
+  emailForm.addEventListener("submit", async function (e) {
+    e.preventDefault();
+    email = emailInput.value.trim();
+    if (!email) return;
+    var submit = document.getElementById("email-submit");
+    submit.disabled = true;
+    say("Sending…");
+    try {
+      var r = await post("/request", { email: email });
+      if (r.ok && r.data.ok) {
+        emailForm.classList.add("hidden");
+        codeForm.classList.remove("hidden");
+        codeInput.focus();
+        say("We emailed a code to " + email + ".");
+      } else {
+        say(r.data.error || "Could not send a code. Check the address and try again.", true);
+      }
+    } catch (_e) {
+      say("Network error. Try again.", true);
+    } finally {
+      submit.disabled = false;
+    }
+  });
+
+  codeForm.addEventListener("submit", async function (e) {
+    e.preventDefault();
+    var code = codeInput.value.trim();
+    if (!code) return;
+    var submit = document.getElementById("code-submit");
+    submit.disabled = true;
+    say("Verifying…");
+    try {
+      var r = await post("/verify", { email: email, code: code });
+      if (r.ok && r.data.ok) {
+        say("Signed in. Loading…");
+        // The session cookie is set; reload so the now-authenticated request
+        // reaches the app.
+        window.location.reload();
+      } else {
+        say(r.data.error || "That code was not accepted. Try again.", true);
+        submit.disabled = false;
+      }
+    } catch (_e) {
+      say("Network error. Try again.", true);
+      submit.disabled = false;
+    }
+  });
+
+  back.addEventListener("click", function () {
+    codeForm.classList.add("hidden");
+    emailForm.classList.remove("hidden");
+    codeInput.value = "";
+    say("");
+    emailInput.focus();
+  });
+})();
+</script>
+</body>
+</html>`;
+}
+const HTML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login-page.js","sourceRoot":"","sources":["../../src/login-page.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAOxC,qFAAqF;AACrF,MAAM,UAAU,aAAa,CAAC,OAAyB;IACrD,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5C,6EAA6E;IAC7E,0DAA0D;IAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,OAAO;;;;;mBAKU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6CH,KAAK;;;;;;;;;;;;;;;;;;;;;iBAqBT,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoFf,CAAC;AACT,CAAC;AAED,MAAM,YAAY,GAA2B;IAC3C,GAAG,EAAE,OAAO;IACZ,GAAG,EAAE,MAAM;IACX,GAAG,EAAE,MAAM;IACX,GAAG,EAAE,QAAQ;IACb,GAAG,EAAE,OAAO;CACb,CAAC;AAEF,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;AACnE,CAAC","sourcesContent":["/**\n * A self-contained HTML login page the tunnel serves in front of an app that\n * does not embed the `<AuthGate>` React component (e.g. a WebSocket app fronted\n * by the CLI proxy).\n *\n * It speaks the same compatibility endpoints under {@link AUTH_PREFIX} that the\n * React client uses — `POST /request` to email a code, `POST /verify` to\n * exchange it for the `dbx-tools-auth` session cookie — with plain `fetch`, no\n * build step and no dependency. Passkeys are intentionally omitted: the WebAuthn\n * ceremony needs the better-auth client library, so passkey enrollment happens\n * inside the app after this email-OTP sign-in. On success the page reloads, and\n * the now-authenticated request reaches the app.\n *\n * @module\n */\n\nimport { AUTH_PREFIX } from \"./gate.ts\";\n\nexport interface LoginPageOptions {\n  /** Product/brand name shown in the heading. */\n  brandName: string;\n}\n\n/** The login page HTML for a `text/html` request to a gated path with no session. */\nexport function loginPageHtml(options: LoginPageOptions): string {\n  const brand = escapeHtml(options.brandName);\n  // AUTH_PREFIX is a fixed constant, not user input, but JSON-encode it so the\n  // inlined script is always valid regardless of its value.\n  const prefix = JSON.stringify(AUTH_PREFIX);\n  return `<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<title>Sign in — ${brand}</title>\n<style>\n  :root {\n    color-scheme: light dark;\n    --bg: #ffffff; --fg: #1b1b1f; --muted: #6b7280; --border: #d9dce1;\n    --accent: #1a73e8; --accent-fg: #ffffff; --error: #c5221f; --field: #ffffff;\n  }\n  @media (prefers-color-scheme: dark) {\n    :root {\n      --bg: #16181d; --fg: #e8e6df; --muted: #9aa0aa; --border: #2c2f36;\n      --accent: #4c8dff; --accent-fg: #0b0f19; --error: #ff6b60; --field: #1e2128;\n    }\n  }\n  * { box-sizing: border-box; }\n  body {\n    margin: 0; min-height: 100vh; display: flex; align-items: center;\n    justify-content: center; background: var(--bg); color: var(--fg);\n    font-family: system-ui, -apple-system, \"Segoe UI\", sans-serif; padding: 24px;\n  }\n  .card {\n    width: 100%; max-width: 360px; border: 1px solid var(--border);\n    border-radius: 14px; padding: 28px; background: var(--bg);\n  }\n  h1 { font-size: 18px; margin: 0 0 4px; }\n  p.sub { margin: 0 0 20px; color: var(--muted); font-size: 13px; }\n  label { display: block; font-size: 12px; color: var(--muted); margin: 0 0 6px; }\n  input {\n    width: 100%; padding: 10px 12px; font-size: 15px; border-radius: 9px;\n    border: 1px solid var(--border); background: var(--field); color: var(--fg);\n  }\n  input:focus { outline: 2px solid var(--accent); outline-offset: -1px; }\n  button {\n    width: 100%; margin-top: 16px; padding: 10px 12px; font-size: 15px;\n    font-weight: 600; border: 0; border-radius: 9px; background: var(--accent);\n    color: var(--accent-fg); cursor: pointer;\n  }\n  button:disabled { opacity: 0.6; cursor: default; }\n  .msg { margin-top: 14px; font-size: 13px; min-height: 18px; }\n  .msg.error { color: var(--error); }\n  .hidden { display: none; }\n  .back { background: none; color: var(--muted); font-weight: 400; margin-top: 8px; }\n</style>\n</head>\n<body>\n  <main class=\"card\">\n    <h1>Sign in to ${brand}</h1>\n    <p class=\"sub\">Enter your email to receive a one-time code.</p>\n\n    <form id=\"email-form\">\n      <label for=\"email\">Email</label>\n      <input id=\"email\" name=\"email\" type=\"email\" autocomplete=\"email\" required autofocus>\n      <button id=\"email-submit\" type=\"submit\">Send code</button>\n    </form>\n\n    <form id=\"code-form\" class=\"hidden\">\n      <label for=\"code\">Verification code</label>\n      <input id=\"code\" name=\"code\" inputmode=\"numeric\" autocomplete=\"one-time-code\" required>\n      <button id=\"code-submit\" type=\"submit\">Verify</button>\n      <button id=\"back\" type=\"button\" class=\"back\">Use a different email</button>\n    </form>\n\n    <div id=\"msg\" class=\"msg\" role=\"status\" aria-live=\"polite\"></div>\n  </main>\n\n<script>\n(function () {\n  var PREFIX = ${prefix};\n  var emailForm = document.getElementById(\"email-form\");\n  var codeForm = document.getElementById(\"code-form\");\n  var emailInput = document.getElementById(\"email\");\n  var codeInput = document.getElementById(\"code\");\n  var back = document.getElementById(\"back\");\n  var msg = document.getElementById(\"msg\");\n  var email = \"\";\n\n  function say(text, isError) {\n    msg.textContent = text || \"\";\n    msg.className = \"msg\" + (isError ? \" error\" : \"\");\n  }\n\n  async function post(path, body) {\n    var res = await fetch(PREFIX + path, {\n      method: \"POST\",\n      credentials: \"include\",\n      headers: { \"content-type\": \"application/json\" },\n      body: JSON.stringify(body),\n    });\n    var data = {};\n    try { data = await res.json(); } catch (_e) { /* non-JSON */ }\n    return { ok: res.ok, status: res.status, data: data };\n  }\n\n  emailForm.addEventListener(\"submit\", async function (e) {\n    e.preventDefault();\n    email = emailInput.value.trim();\n    if (!email) return;\n    var submit = document.getElementById(\"email-submit\");\n    submit.disabled = true;\n    say(\"Sending…\");\n    try {\n      var r = await post(\"/request\", { email: email });\n      if (r.ok && r.data.ok) {\n        emailForm.classList.add(\"hidden\");\n        codeForm.classList.remove(\"hidden\");\n        codeInput.focus();\n        say(\"We emailed a code to \" + email + \".\");\n      } else {\n        say(r.data.error || \"Could not send a code. Check the address and try again.\", true);\n      }\n    } catch (_e) {\n      say(\"Network error. Try again.\", true);\n    } finally {\n      submit.disabled = false;\n    }\n  });\n\n  codeForm.addEventListener(\"submit\", async function (e) {\n    e.preventDefault();\n    var code = codeInput.value.trim();\n    if (!code) return;\n    var submit = document.getElementById(\"code-submit\");\n    submit.disabled = true;\n    say(\"Verifying…\");\n    try {\n      var r = await post(\"/verify\", { email: email, code: code });\n      if (r.ok && r.data.ok) {\n        say(\"Signed in. Loading…\");\n        // The session cookie is set; reload so the now-authenticated request\n        // reaches the app.\n        window.location.reload();\n      } else {\n        say(r.data.error || \"That code was not accepted. Try again.\", true);\n        submit.disabled = false;\n      }\n    } catch (_e) {\n      say(\"Network error. Try again.\", true);\n      submit.disabled = false;\n    }\n  });\n\n  back.addEventListener(\"click\", function () {\n    codeForm.classList.add(\"hidden\");\n    emailForm.classList.remove(\"hidden\");\n    codeInput.value = \"\";\n    say(\"\");\n    emailInput.focus();\n  });\n})();\n</script>\n</body>\n</html>`;\n}\n\nconst HTML_ESCAPES: Record<string, string> = {\n  \"&\": \"&amp;\",\n  \"<\": \"&lt;\",\n  \">\": \"&gt;\",\n  '\"': \"&quot;\",\n  \"'\": \"&#39;\",\n};\n\nfunction escapeHtml(value: string): string {\n  return value.replace(/[&<>\"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);\n}\n"]}

package/lib/src/plugin.d.ts

@@ -110,6 +110,13 @@ export interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {
      * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.
      */
     forwardHeaders?: string | string[];
+    /**
+     * Path prefixes to gate beyond the built-in `/api/` (literal prefixes, comma-
+     * or space-separated as a string). For an app whose privileged surface is not
+     * under `/api/` — e.g. a WebSocket at `/ws` — list those prefixes so they
+     * require a session too. Env `TUNNEL_GATE_PATHS`.
+     */
+    gatePaths?: string | string[];
     /**
      * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate
      * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when
@@ -147,6 +154,8 @@ export interface ResolvedAuthGateConfig {
     publicDomain?: string;
     /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */
     forwardHeaders: string[];
+    /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */
+    gatePaths: string[];
     /** Run OPEN with no gate. */
     insecure: boolean;
     storage: AuthStorageMode;

package/lib/src/plugin.js

@@ -88,6 +88,10 @@ export function resolveAuthGateConfig(config) {
             ...string.parseList(config.forwardHeaders),
             ...string.parseList(coreConfig.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
         ],
+        gatePaths: [
+            ...string.parseList(config.gatePaths),
+            ...string.parseList(coreConfig.text("GATE_PATHS", TUNNEL_CONFIG)),
+        ],
         insecure: coreConfig.boolean(config.insecure, "INSECURE", TUNNEL_CONFIG) ?? false,
         storage: storage.mode,
         sqlitePath: storage.sqlitePath,
@@ -212,6 +216,7 @@ export class AuthGatePlugin extends Plugin {
             gate: this.exports(),
             publicDomain: this.resolved.publicDomain,
             forwardHeaders: this.resolved.forwardHeaders,
+            gatePaths: this.resolved.gatePaths,
         });
     }
     /** The code sender: the configured `sendCode`, else the shared-transport default. */
@@ -247,4 +252,4 @@ function authOrigin(publicDomain) {
 }
 /** 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 adapter around `@dbx-tools/auth`.\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 tunnel authorization, AppKit Lakebase discovery, email delivery, and\n * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and\n * passkeys. `createApp` can run this plugin with or without `server()`.\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 {\n  lakebase,\n  Plugin,\n  toPlugin,\n  type BasePluginConfig,\n  type PluginManifest,\n  type ResourceRequirement,\n  ResourceType,\n} from \"@databricks/appkit\";\nimport { plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport {\n  auth as passwordlessAuth,\n  storage as authStorage,\n  type AuthorizeIdentity,\n  type AuthStorageConfig,\n  type AuthStorageMode,\n  type PasswordlessAuthRuntime,\n} from \"@dbx-tools/auth\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-auth\";\nimport { brand, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Same-origin path returned after a successful logout. Env\n   * `TUNNEL_AUTH_LOGOUT_REDIRECT`. Defaults to `/`, where the AuthGate presents\n   * login again.\n   */\n  logoutRedirectPath?: string;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * Identity authorization independent of authentication. Defaults to the\n   * configured allow-list and is re-evaluated for every accepted session.\n   */\n  authorizeIdentity?: AuthorizeIdentity;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Same-origin path returned after logout. */\n  logoutRedirectPath: string;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n  storage: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n  logoutRedirectPath: \"/\",\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  const storage = authStorage.resolveAuthStorageConfig({\n    storage:\n      config.storage ??\n      (coreConfig.text(\"AUTH_STORAGE\", TUNNEL_CONFIG) as AuthStorageMode | undefined),\n    sqlitePath: config.sqlitePath ?? coreConfig.text(\"AUTH_SQLITE_PATH\", TUNNEL_CONFIG),\n  });\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 `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    logoutRedirectPath: passwordlessAuth.normalizeLogoutRedirectPath(\n      coreConfig.string(config.logoutRedirectPath, \"AUTH_LOGOUT_REDIRECT\", TUNNEL_CONFIG) ??\n        DEFAULTS.logoutRedirectPath,\n    ),\n    publicDomain: coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n    storage: storage.mode,\n    sqlitePath: storage.sqlitePath,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Better Auth and compatibility routes under `/api/email/auth/*`. */\n  handler(request: Request): Promise<Response>;\n  /** Resolve the authorized email for request headers, or undefined. */\n  session(headers: Headers): Promise<string | undefined>;\n  /** The gate status payload. */\n  status(headers: Headers): Promise<AuthStatus>;\n  /** Whether the runtime exposes passkey enrollment and authentication. */\n  readonly passkeysEnabled: boolean;\n  /** Close auth storage owned by this runtime. */\n  close(): Promise<void>;\n}\n\n/**\n * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Better Auth email OTP and passkey access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [\n        {\n          type: ResourceType.POSTGRES,\n          alias: \"auth\",\n          resourceKey: \"auth-database\",\n          description: \"Durable users, sessions, OTP records, and passkeys.\",\n          permission: \"CAN_CONNECT_AND_CREATE\",\n          fields: {\n            instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n            database_name: { env: \"PGDATABASE\" },\n          },\n        },\n      ],\n    },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private runtime?: PasswordlessAuthRuntime;\n\n  static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[] {\n    if (authStorage.resolveAuthStorageConfig(config).mode !== \"lakebase\") return [];\n    return [\n      {\n        type: ResourceType.POSTGRES,\n        alias: \"auth\",\n        resourceKey: \"auth-database\",\n        description: \"Durable users, sessions, OTP records, and passkeys.\",\n        permission: \"CAN_CONNECT_AND_CREATE\",\n        fields: {\n          instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n          database_name: { env: \"PGDATABASE\" },\n        },\n        required: true,\n      },\n    ];\n  }\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no auth gate\");\n    } else {\n      const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);\n      const storage = await authStorage.createAuthStorage(\n        this.resolved,\n        lakebasePlugin?.exports().pool,\n      );\n      const { key } = await signingKey(this.resolved.sessionCutoffMs);\n      this.runtime = await passwordlessAuth.createPasswordlessAuth({\n        storage,\n        baseURL: authOrigin(this.resolved.publicDomain),\n        basePath: \"/api/email/auth\",\n        appName: this.resolved.brandName,\n        secret: Buffer.from(key).toString(\"base64url\"),\n        sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n        sessionCutoffMs: this.resolved.sessionCutoffMs,\n        logoutRedirectPath: this.resolved.logoutRedirectPath,\n        codeTtlSeconds: this.resolved.codeTtlSeconds,\n        maxAttempts: this.resolved.maxAttempts,\n        authorizeIdentity: (email) => this.authorizeIdentity(email),\n        sendCode: (email, code, options) => this.sendCode(email, code, options),\n        subject: this.resolved.subject,\n        message: this.resolved.message,\n      });\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        if (!this.config.sendCode) await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      storage: this.resolved.storage,\n      logoutRedirectPath: this.resolved.logoutRedirectPath,\n      sessionCutoff:\n        this.resolved.sessionCutoffMs > 0\n          ? new Date(this.resolved.sessionCutoffMs).toISOString()\n          : null,\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    await this.runtime?.close();\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the auth gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  private authorizeIdentity(email: string): boolean | Promise<boolean> {\n    if (this.config.authorizeIdentity) return this.config.authorizeIdentity(email);\n    return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);\n  }\n\n  override exports(): AuthGateApi {\n    const runtime = this.runtime;\n    return {\n      passkeysEnabled: runtime?.passkeysEnabled ?? false,\n      handler: (request) =>\n        runtime?.handler(request) ?? Promise.resolve(new Response(\"Not Found\", { status: 404 })),\n      session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),\n      status: (headers) =>\n        runtime?.status(headers) ??\n        Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),\n      close: () => runtime?.close() ?? Promise.resolve(),\n    };\n  }\n}\n\nfunction authOrigin(publicDomain?: string): string {\n  const value = string.trimToNull(publicDomain);\n  if (!value) return \"http://localhost\";\n  if (/^https?:\\/\\//i.test(value)) return new URL(value).origin;\n  const host = value.split(\"/\")[0]!;\n  const local = host === \"localhost\" || host.startsWith(\"localhost:\");\n  return `${local ? \"http\" : \"https\"}://${host}`;\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":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EAIR,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EACL,IAAI,IAAI,gBAAgB,EACxB,OAAO,IAAI,WAAW,GAKvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAoB,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAErF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAczC,SAAS,iBAAiB,CAAC,OAAyB;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,CACoB,CAAC;IACrE,MAAM,WAAW,GAAG,MAAM,EAAE,iBAAiB,CAAC;IAC9C,OAAO,WAAW;QAChB,OAAO,WAAW,CAAC,GAAG,KAAK,UAAU;QACrC,OAAO,WAAW,CAAC,IAAI,KAAK,UAAU;QACtC,OAAO,WAAW,CAAC,GAAG,KAAK,UAAU;QACrC,CAAC,CAAE,WAAqC;QACxC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAyB,EAAE,OAAoB;IAChF,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,WAAW,EAAE,CAAC;QAChB,SAAS,CACP,OAAO,EACP,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,EAC7D,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAClD,CAAC;QACF,OAAO;IACT,CAAC;IACD,SAAS,CACP,OAAO,EACP,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,EAClE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CACxD,CAAC;AACJ,CAAC;AA6ID,MAAM,QAAQ,GAAG;IACf,OAAO,EAAE,wBAAwB;IACjC,8EAA8E;IAC9E,+EAA+E;IAC/E,kEAAkE;IAClE,gFAAgF;IAChF,8CAA8C;IAC9C,SAAS,EAAE,KAAK,CAAC,mBAAmB,CAAC,IAAI;IACzC,OAAO,EAAE,4BAA4B;IACrC,uEAAuE;IACvE,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,GAAG;IACnB,WAAW,EAAE,CAAC;IACd,kBAAkB,EAAE,GAAG;CACxB,CAAC;AAEF,kFAAkF;AAClF,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IAC1D,MAAM,OAAO,GAAG,WAAW,CAAC,wBAAwB,CAAC;QACnD,OAAO,EACL,MAAM,CAAC,OAAO;YACb,UAAU,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,CAAiC;QACjF,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC;KACpF,CAAC,CAAC;IACH,OAAO;QACL,yEAAyE;QACzE,6EAA6E;QAC7E,0EAA0E;QAC1E,qCAAqC;QACrC,KAAK,EAAE;YACL,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC;YACjC,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,kBAAkB,CAAC,EAAE,aAAa,CAAC,CAAC;SACxF;QACD,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,OAAO;QAC7F,SAAS,EACP,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,SAAS;QAC7F,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,OAAO;QAC7F,iBAAiB,EAAE,UAAU,CAAC,WAAW,CACvC,MAAM,CAAC,iBAAiB,EACxB,kBAAkB,EAClB,QAAQ,CAAC,iBAAiB,EAC1B,aAAa,CACd;QACD,cAAc,EAAE,UAAU,CAAC,WAAW,CACpC,MAAM,CAAC,cAAc,EACrB,eAAe,EACf,QAAQ,CAAC,cAAc,EACvB,aAAa,CACd;QACD,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW;QACvD,eAAe,EAAE,oBAAoB,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3D,kBAAkB,EAAE,gBAAgB,CAAC,2BAA2B,CAC9D,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,CAAC;YACjF,QAAQ,CAAC,kBAAkB,CAC9B;QACD,YAAY,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,eAAe,EAAE,aAAa,CAAC;QACpF,cAAc,EAAE;YACd,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC;YAC1C,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC;SACvE;QACD,SAAS,EAAE;YACT,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;YACrC,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;SAClE;QACD,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,aAAa,CAAC,IAAI,KAAK;QACjF,OAAO,EAAE,OAAO,CAAC,IAAI;QACrB,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;AACJ,CAAC;AAgBD;;;;;;GAMG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAsB;IACxD,MAAM,CAAC,QAAQ,GAAG;QAChB,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,oEAAoE;QACjF,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE;YACT,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,YAAY,CAAC,QAAQ;oBAC3B,KAAK,EAAE,MAAM;oBACb,WAAW,EAAE,eAAe;oBAC5B,WAAW,EAAE,qDAAqD;oBAClE,UAAU,EAAE,wBAAwB;oBACpC,MAAM,EAAE;wBACN,aAAa,EAAE,EAAE,GAAG,EAAE,wBAAwB,EAAE;wBAChD,aAAa,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE;qBACrC;iBACF;aACF;SACF;KACmC,CAAC;IAE/B,QAAQ,CAA0B;IAClC,OAAO,CAA2B;IAE1C,MAAM,CAAC,uBAAuB,CAAC,MAAsB;QACnD,IAAI,WAAW,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,UAAU;YAAE,OAAO,EAAE,CAAC;QAChF,OAAO;YACL;gBACE,IAAI,EAAE,YAAY,CAAC,QAAQ;gBAC3B,KAAK,EAAE,MAAM;gBACb,WAAW,EAAE,eAAe;gBAC5B,WAAW,EAAE,qDAAqD;gBAClE,UAAU,EAAE,wBAAwB;gBACpC,MAAM,EAAE;oBACN,aAAa,EAAE,EAAE,GAAG,EAAE,wBAAwB,EAAE;oBAChD,aAAa,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE;iBACrC;gBACD,QAAQ,EAAE,IAAI;aACf;SACF,CAAC;IACJ,CAAC;IAEQ,KAAK,CAAC,KAAK;QAClB,IAAI,CAAC,QAAQ,GAAG,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEnD,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,MAAM,cAAc,GAAG,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,iBAAiB,CACjD,IAAI,CAAC,QAAQ,EACb,cAAc,EAAE,OAAO,EAAE,CAAC,IAAI,CAC/B,CAAC;YACF,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAChE,IAAI,CAAC,OAAO,GAAG,MAAM,gBAAgB,CAAC,sBAAsB,CAAC;gBAC3D,OAAO;gBACP,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAC/C,QAAQ,EAAE,iBAAiB;gBAC3B,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;gBAChC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;gBAC9C,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;gBAClD,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe;gBAC9C,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB;gBACpD,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc;gBAC5C,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW;gBACtC,iBAAiB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;gBAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC;gBACvE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;gBAC9B,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;aAC/B,CAAC,CAAC;YACH,2EAA2E;YAC3E,yEAAyE;YACzE,2EAA2E;YAC3E,kCAAkC;YAClC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE;gBACrD,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,sEAAsE;gBACtE,gDAAgD;gBAChD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ;oBAAE,MAAM,oBAAoB,EAAE,CAAC;YAC1D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM;YACpC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;YAClD,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI;YAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ;YAChC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;YAC9B,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB;YACpD,aAAa,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,GAAG,CAAC;gBAC/B,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,WAAW,EAAE;gBACvD,CAAC,CAAC,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACK,eAAe;QACrB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,2DAA2D,CAAC,CAAC;YACzE,OAAO;QACT,CAAC;QACD,kBAAkB,CAAC,OAAO,EAAE;YAC1B,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY;YACxC,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc;YAC5C,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC,CAAC;IACL,CAAC;IAED,qFAAqF;IACrF,IAAY,QAAQ;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,eAAe,CAAC;IACjD,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACrC,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC/E,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/E,CAAC;IAEQ,OAAO;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,OAAO;YACL,eAAe,EAAE,OAAO,EAAE,eAAe,IAAI,KAAK;YAClD,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CACnB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YAC1F,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;YAC7E,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAClB,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC;gBACxB,OAAO,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;YACnF,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,OAAO,CAAC,OAAO,EAAE;SACnD,CAAC;IACJ,CAAC;;AAGH,SAAS,UAAU,CAAC,YAAqB;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC9C,IAAI,CAAC,KAAK;QAAE,OAAO,kBAAkB,CAAC;IACtC,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;IAClC,MAAM,KAAK,GAAG,IAAI,KAAK,WAAW,IAAI,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACpE,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,MAAM,IAAI,EAAE,CAAC;AACjD,CAAC;AAED,kFAAkF;AAClF,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC","sourcesContent":["/**\n * `authGate()` - the AppKit adapter around `@dbx-tools/auth`.\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 tunnel authorization, AppKit Lakebase discovery, email delivery, and\n * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and\n * passkeys. `createApp` can run this plugin with or without `server()`.\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 {\n  lakebase,\n  Plugin,\n  toPlugin,\n  type BasePluginConfig,\n  type PluginManifest,\n  type ResourceRequirement,\n  ResourceType,\n} from \"@databricks/appkit\";\nimport { plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport {\n  auth as passwordlessAuth,\n  storage as authStorage,\n  type AuthorizeIdentity,\n  type AuthStorageConfig,\n  type AuthStorageMode,\n  type PasswordlessAuthRuntime,\n} from \"@dbx-tools/auth\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-auth\";\nimport { brand, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Same-origin path returned after a successful logout. Env\n   * `TUNNEL_AUTH_LOGOUT_REDIRECT`. Defaults to `/`, where the AuthGate presents\n   * login again.\n   */\n  logoutRedirectPath?: string;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * Identity authorization independent of authentication. Defaults to the\n   * configured allow-list and is re-evaluated for every accepted session.\n   */\n  authorizeIdentity?: AuthorizeIdentity;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Path prefixes to gate beyond the built-in `/api/` (literal prefixes, comma-\n   * or space-separated as a string). For an app whose privileged surface is not\n   * under `/api/` — e.g. a WebSocket at `/ws` — list those prefixes so they\n   * require a session too. Env `TUNNEL_GATE_PATHS`.\n   */\n  gatePaths?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Same-origin path returned after logout. */\n  logoutRedirectPath: string;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */\n  gatePaths: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n  storage: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n  logoutRedirectPath: \"/\",\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  const storage = authStorage.resolveAuthStorageConfig({\n    storage:\n      config.storage ??\n      (coreConfig.text(\"AUTH_STORAGE\", TUNNEL_CONFIG) as AuthStorageMode | undefined),\n    sqlitePath: config.sqlitePath ?? coreConfig.text(\"AUTH_SQLITE_PATH\", TUNNEL_CONFIG),\n  });\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 `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    logoutRedirectPath: passwordlessAuth.normalizeLogoutRedirectPath(\n      coreConfig.string(config.logoutRedirectPath, \"AUTH_LOGOUT_REDIRECT\", TUNNEL_CONFIG) ??\n        DEFAULTS.logoutRedirectPath,\n    ),\n    publicDomain: coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    gatePaths: [\n      ...string.parseList(config.gatePaths),\n      ...string.parseList(coreConfig.text(\"GATE_PATHS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n    storage: storage.mode,\n    sqlitePath: storage.sqlitePath,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Better Auth and compatibility routes under `/api/email/auth/*`. */\n  handler(request: Request): Promise<Response>;\n  /** Resolve the authorized email for request headers, or undefined. */\n  session(headers: Headers): Promise<string | undefined>;\n  /** The gate status payload. */\n  status(headers: Headers): Promise<AuthStatus>;\n  /** Whether the runtime exposes passkey enrollment and authentication. */\n  readonly passkeysEnabled: boolean;\n  /** Close auth storage owned by this runtime. */\n  close(): Promise<void>;\n}\n\n/**\n * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Better Auth email OTP and passkey access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [\n        {\n          type: ResourceType.POSTGRES,\n          alias: \"auth\",\n          resourceKey: \"auth-database\",\n          description: \"Durable users, sessions, OTP records, and passkeys.\",\n          permission: \"CAN_CONNECT_AND_CREATE\",\n          fields: {\n            instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n            database_name: { env: \"PGDATABASE\" },\n          },\n        },\n      ],\n    },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private runtime?: PasswordlessAuthRuntime;\n\n  static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[] {\n    if (authStorage.resolveAuthStorageConfig(config).mode !== \"lakebase\") return [];\n    return [\n      {\n        type: ResourceType.POSTGRES,\n        alias: \"auth\",\n        resourceKey: \"auth-database\",\n        description: \"Durable users, sessions, OTP records, and passkeys.\",\n        permission: \"CAN_CONNECT_AND_CREATE\",\n        fields: {\n          instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n          database_name: { env: \"PGDATABASE\" },\n        },\n        required: true,\n      },\n    ];\n  }\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no auth gate\");\n    } else {\n      const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);\n      const storage = await authStorage.createAuthStorage(\n        this.resolved,\n        lakebasePlugin?.exports().pool,\n      );\n      const { key } = await signingKey(this.resolved.sessionCutoffMs);\n      this.runtime = await passwordlessAuth.createPasswordlessAuth({\n        storage,\n        baseURL: authOrigin(this.resolved.publicDomain),\n        basePath: \"/api/email/auth\",\n        appName: this.resolved.brandName,\n        secret: Buffer.from(key).toString(\"base64url\"),\n        sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n        sessionCutoffMs: this.resolved.sessionCutoffMs,\n        logoutRedirectPath: this.resolved.logoutRedirectPath,\n        codeTtlSeconds: this.resolved.codeTtlSeconds,\n        maxAttempts: this.resolved.maxAttempts,\n        authorizeIdentity: (email) => this.authorizeIdentity(email),\n        sendCode: (email, code, options) => this.sendCode(email, code, options),\n        subject: this.resolved.subject,\n        message: this.resolved.message,\n      });\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        if (!this.config.sendCode) await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      storage: this.resolved.storage,\n      logoutRedirectPath: this.resolved.logoutRedirectPath,\n      sessionCutoff:\n        this.resolved.sessionCutoffMs > 0\n          ? new Date(this.resolved.sessionCutoffMs).toISOString()\n          : null,\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    await this.runtime?.close();\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the auth gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n      gatePaths: this.resolved.gatePaths,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  private authorizeIdentity(email: string): boolean | Promise<boolean> {\n    if (this.config.authorizeIdentity) return this.config.authorizeIdentity(email);\n    return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);\n  }\n\n  override exports(): AuthGateApi {\n    const runtime = this.runtime;\n    return {\n      passkeysEnabled: runtime?.passkeysEnabled ?? false,\n      handler: (request) =>\n        runtime?.handler(request) ?? Promise.resolve(new Response(\"Not Found\", { status: 404 })),\n      session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),\n      status: (headers) =>\n        runtime?.status(headers) ??\n        Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),\n      close: () => runtime?.close() ?? Promise.resolve(),\n    };\n  }\n}\n\nfunction authOrigin(publicDomain?: string): string {\n  const value = string.trimToNull(publicDomain);\n  if (!value) return \"http://localhost\";\n  if (/^https?:\\/\\//i.test(value)) return new URL(value).origin;\n  const host = value.split(\"/\")[0]!;\n  const local = host === \"localhost\" || host.startsWith(\"localhost:\");\n  return `${local ? \"http\" : \"https\"}://${host}`;\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/plugin.ts","../src/portr.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/login-page.ts","../src/plugin.ts","../src/portr.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -18,21 +18,21 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.96",
+    "@dbx-tools/email": "0.6.97",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.96"
+    "@dbx-tools/email": "0.6.97"
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.96",
-    "@dbx-tools/auth": "0.6.96",
-    "@dbx-tools/core": "0.6.96",
-    "@dbx-tools/shared-auth": "0.6.96",
-    "@dbx-tools/shared-core": "0.6.96"
+    "@dbx-tools/appkit": "0.6.97",
+    "@dbx-tools/auth": "0.6.97",
+    "@dbx-tools/core": "0.6.97",
+    "@dbx-tools/shared-auth": "0.6.97",
+    "@dbx-tools/shared-core": "0.6.97"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -48,7 +48,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.96",
+  "version": "0.6.97",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/gate.ts

@@ -53,6 +53,14 @@ export interface GateOptions {
    * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.
    */
   forwardHeaders?: readonly string[];
+  /**
+   * Path prefixes that require a valid session, beyond the built-in `/api/`.
+   * The default gating model assumes a self-protecting SPA: static loads freely
+   * so the app can render, and only `/api/*` is gated. An app whose privileged
+   * surface is NOT under `/api/` (e.g. a WebSocket at `/ws`) lists those prefixes
+   * here so they are gated too. Login routes (`AUTH_PREFIX`) are always open.
+   */
+  gatePaths?: readonly string[];
 }
 
 /**
@@ -209,13 +217,27 @@ export async function gateRequest(
   const removed = policy.apply(req.headers as Record<string, unknown>);
   if (removed.length) logger.debug("stripped inbound headers", { removed });
 
-  // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
-  if (!path.startsWith("/api/")) {
+  const gatePaths = options.gatePaths ?? [];
+  // A path is gated if it is under `/api/` or any caller-supplied prefix (e.g.
+  // `/ws` for a WebSocket app).
+  const gated =
+    path.startsWith("/api/") ||
+    gatePaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+
+  // App-gating mode: when `gatePaths` is set the caller is fronting a whole app
+  // (not a self-protecting SPA), so an unauthenticated top-level browser
+  // navigation is denied too — the transport answers it with the hosted login
+  // page, putting sign-in in front of the app instead of loading its shell with
+  // a dead gated request. Non-navigation static (assets) still loads freely so
+  // the login page and app can render.
+  const appGating = gatePaths.length > 0;
+  const mustAuth = gated || (appGating && wantsLoginPage(req));
+  if (!mustAuth) {
     stripSessionCookie(req);
     return "pass";
   }
 
-  // Every other /api/* needs a valid Better Auth session.
+  // A gated request needs a valid Better Auth session.
   const email = await gate.session(webHeaders(req));
   if (!email) return "deny";
   injectIdentity(req, email);
@@ -229,6 +251,26 @@ export const UNAUTHORIZED_BODY = {
   loginPath: AUTH_PREFIX,
 } as const;
 
+/**
+ * Whether a denied request is a top-level BROWSER NAVIGATION that should be
+ * answered with the hosted login page rather than a 401.
+ *
+ * An app fronted by the gate (via `gatePaths`) may serve its own HTML from an
+ * ungated path while its privileged surface (`/ws`, `/api`) is gated. A browser
+ * navigating to it would otherwise load the app shell and only see the gated
+ * request fail, with no way to sign in. Serving the login page on the navigation
+ * itself puts sign-in in front of the app. Applies only to GET requests that
+ * accept HTML and are not asking for the login API or an asset.
+ */
+export function wantsLoginPage(req: IncomingMessage): boolean {
+  const method = (req.method ?? "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") return false;
+  const path = (req.url ?? "/").split("?")[0] ?? "/";
+  if (path.startsWith(AUTH_PREFIX)) return false;
+  const accept = String(req.headers.accept ?? "");
+  return accept.includes("text/html");
+}
+
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
@@ -243,9 +285,9 @@ export function mountGate(
   _addRoute: (method: "get" | "post", path: string, handler: RequestHandler) => void,
   addMiddleware: (path: string, handler: RequestHandler) => void,
 ): void {
-  const { gate, publicDomain, forwardHeaders } = opts;
+  const { gate, publicDomain, forwardHeaders, gatePaths } = opts;
   const headerPolicy = toHeaderPolicy(forwardHeaders);
-  logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
+  logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns, gatePaths });
 
   // Better Auth and the compatibility routes share one fetch-compatible
   // handler in both hosting modes.
@@ -266,7 +308,7 @@ export function mountGate(
   // --- The gate middleware (runs before static + the app's /api handlers) ---
 
   const gateMiddleware = (async (req, res, next) => {
-    const action = await gateRequest(req, { gate, publicDomain, headerPolicy });
+    const action = await gateRequest(req, { gate, publicDomain, headerPolicy, gatePaths });
     if (action === "deny") res.status(401).json(UNAUTHORIZED_BODY);
     else next();
   }) as RequestHandler;

package/src/login-page.ts

@@ -0,0 +1,198 @@
+/**
+ * A self-contained HTML login page the tunnel serves in front of an app that
+ * does not embed the `<AuthGate>` React component (e.g. a WebSocket app fronted
+ * by the CLI proxy).
+ *
+ * It speaks the same compatibility endpoints under {@link AUTH_PREFIX} that the
+ * React client uses — `POST /request` to email a code, `POST /verify` to
+ * exchange it for the `dbx-tools-auth` session cookie — with plain `fetch`, no
+ * build step and no dependency. Passkeys are intentionally omitted: the WebAuthn
+ * ceremony needs the better-auth client library, so passkey enrollment happens
+ * inside the app after this email-OTP sign-in. On success the page reloads, and
+ * the now-authenticated request reaches the app.
+ *
+ * @module
+ */
+
+import { AUTH_PREFIX } from "./gate.ts";
+
+export interface LoginPageOptions {
+  /** Product/brand name shown in the heading. */
+  brandName: string;
+}
+
+/** The login page HTML for a `text/html` request to a gated path with no session. */
+export function loginPageHtml(options: LoginPageOptions): string {
+  const brand = escapeHtml(options.brandName);
+  // AUTH_PREFIX is a fixed constant, not user input, but JSON-encode it so the
+  // inlined script is always valid regardless of its value.
+  const prefix = JSON.stringify(AUTH_PREFIX);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Sign in — ${brand}</title>
+<style>
+  :root {
+    color-scheme: light dark;
+    --bg: #ffffff; --fg: #1b1b1f; --muted: #6b7280; --border: #d9dce1;
+    --accent: #1a73e8; --accent-fg: #ffffff; --error: #c5221f; --field: #ffffff;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #16181d; --fg: #e8e6df; --muted: #9aa0aa; --border: #2c2f36;
+      --accent: #4c8dff; --accent-fg: #0b0f19; --error: #ff6b60; --field: #1e2128;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; min-height: 100vh; display: flex; align-items: center;
+    justify-content: center; background: var(--bg); color: var(--fg);
+    font-family: system-ui, -apple-system, "Segoe UI", sans-serif; padding: 24px;
+  }
+  .card {
+    width: 100%; max-width: 360px; border: 1px solid var(--border);
+    border-radius: 14px; padding: 28px; background: var(--bg);
+  }
+  h1 { font-size: 18px; margin: 0 0 4px; }
+  p.sub { margin: 0 0 20px; color: var(--muted); font-size: 13px; }
+  label { display: block; font-size: 12px; color: var(--muted); margin: 0 0 6px; }
+  input {
+    width: 100%; padding: 10px 12px; font-size: 15px; border-radius: 9px;
+    border: 1px solid var(--border); background: var(--field); color: var(--fg);
+  }
+  input:focus { outline: 2px solid var(--accent); outline-offset: -1px; }
+  button {
+    width: 100%; margin-top: 16px; padding: 10px 12px; font-size: 15px;
+    font-weight: 600; border: 0; border-radius: 9px; background: var(--accent);
+    color: var(--accent-fg); cursor: pointer;
+  }
+  button:disabled { opacity: 0.6; cursor: default; }
+  .msg { margin-top: 14px; font-size: 13px; min-height: 18px; }
+  .msg.error { color: var(--error); }
+  .hidden { display: none; }
+  .back { background: none; color: var(--muted); font-weight: 400; margin-top: 8px; }
+</style>
+</head>
+<body>
+  <main class="card">
+    <h1>Sign in to ${brand}</h1>
+    <p class="sub">Enter your email to receive a one-time code.</p>
+
+    <form id="email-form">
+      <label for="email">Email</label>
+      <input id="email" name="email" type="email" autocomplete="email" required autofocus>
+      <button id="email-submit" type="submit">Send code</button>
+    </form>
+
+    <form id="code-form" class="hidden">
+      <label for="code">Verification code</label>
+      <input id="code" name="code" inputmode="numeric" autocomplete="one-time-code" required>
+      <button id="code-submit" type="submit">Verify</button>
+      <button id="back" type="button" class="back">Use a different email</button>
+    </form>
+
+    <div id="msg" class="msg" role="status" aria-live="polite"></div>
+  </main>
+
+<script>
+(function () {
+  var PREFIX = ${prefix};
+  var emailForm = document.getElementById("email-form");
+  var codeForm = document.getElementById("code-form");
+  var emailInput = document.getElementById("email");
+  var codeInput = document.getElementById("code");
+  var back = document.getElementById("back");
+  var msg = document.getElementById("msg");
+  var email = "";
+
+  function say(text, isError) {
+    msg.textContent = text || "";
+    msg.className = "msg" + (isError ? " error" : "");
+  }
+
+  async function post(path, body) {
+    var res = await fetch(PREFIX + path, {
+      method: "POST",
+      credentials: "include",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    var data = {};
+    try { data = await res.json(); } catch (_e) { /* non-JSON */ }
+    return { ok: res.ok, status: res.status, data: data };
+  }
+
+  emailForm.addEventListener("submit", async function (e) {
+    e.preventDefault();
+    email = emailInput.value.trim();
+    if (!email) return;
+    var submit = document.getElementById("email-submit");
+    submit.disabled = true;
+    say("Sending…");
+    try {
+      var r = await post("/request", { email: email });
+      if (r.ok && r.data.ok) {
+        emailForm.classList.add("hidden");
+        codeForm.classList.remove("hidden");
+        codeInput.focus();
+        say("We emailed a code to " + email + ".");
+      } else {
+        say(r.data.error || "Could not send a code. Check the address and try again.", true);
+      }
+    } catch (_e) {
+      say("Network error. Try again.", true);
+    } finally {
+      submit.disabled = false;
+    }
+  });
+
+  codeForm.addEventListener("submit", async function (e) {
+    e.preventDefault();
+    var code = codeInput.value.trim();
+    if (!code) return;
+    var submit = document.getElementById("code-submit");
+    submit.disabled = true;
+    say("Verifying…");
+    try {
+      var r = await post("/verify", { email: email, code: code });
+      if (r.ok && r.data.ok) {
+        say("Signed in. Loading…");
+        // The session cookie is set; reload so the now-authenticated request
+        // reaches the app.
+        window.location.reload();
+      } else {
+        say(r.data.error || "That code was not accepted. Try again.", true);
+        submit.disabled = false;
+      }
+    } catch (_e) {
+      say("Network error. Try again.", true);
+      submit.disabled = false;
+    }
+  });
+
+  back.addEventListener("click", function () {
+    codeForm.classList.add("hidden");
+    emailForm.classList.remove("hidden");
+    codeInput.value = "";
+    say("");
+    emailInput.focus();
+  });
+})();
+</script>
+</body>
+</html>`;
+}
+
+const HTML_ESCAPES: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+}

package/src/plugin.ts

@@ -171,6 +171,13 @@ export interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {
    * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.
    */
   forwardHeaders?: string | string[];
+  /**
+   * Path prefixes to gate beyond the built-in `/api/` (literal prefixes, comma-
+   * or space-separated as a string). For an app whose privileged surface is not
+   * under `/api/` — e.g. a WebSocket at `/ws` — list those prefixes so they
+   * require a session too. Env `TUNNEL_GATE_PATHS`.
+   */
+  gatePaths?: string | string[];
   /**
    * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate
    * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when
@@ -210,6 +217,8 @@ export interface ResolvedAuthGateConfig {
   publicDomain?: string;
   /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */
   forwardHeaders: string[];
+  /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */
+  gatePaths: string[];
   /** Run OPEN with no gate. */
   insecure: boolean;
   storage: AuthStorageMode;
@@ -276,6 +285,10 @@ export function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateC
       ...string.parseList(config.forwardHeaders),
       ...string.parseList(coreConfig.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
     ],
+    gatePaths: [
+      ...string.parseList(config.gatePaths),
+      ...string.parseList(coreConfig.text("GATE_PATHS", TUNNEL_CONFIG)),
+    ],
     insecure: coreConfig.boolean(config.insecure, "INSECURE", TUNNEL_CONFIG) ?? false,
     storage: storage.mode,
     sqlitePath: storage.sqlitePath,
@@ -423,6 +436,7 @@ export class AuthGatePlugin extends Plugin<AuthGateConfig> {
       gate: this.exports(),
       publicDomain: this.resolved.publicDomain,
       forwardHeaders: this.resolved.forwardHeaders,
+      gatePaths: this.resolved.gatePaths,
     });
   }