@dbx-tools/tunnel 0.6.89 → 0.6.91

package/lib/src/gate.js

@@ -6,8 +6,8 @@
  * nothing to forward to. It either short-circuits (401, or answers the open login
  * routes) or calls `next()` to let the app's real handlers run. It is the
  * "stands in for AppKit auth" path:
- * a portr caller proves an email via OTP, and on success the gate injects the
- * identity headers AppKit reads, so a gated request runs like a front-door one.
+ * a portr caller authenticates with Better Auth OTP or a passkey, and on
+ * success the gate injects the identity headers AppKit reads.
  *
  * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client
  * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that
@@ -21,11 +21,9 @@
  *
  * @module
  */
-import { http, json, log, token } from "@dbx-tools/shared-core";
-import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
+import { log, token } from "@dbx-tools/shared-core";
 import { toHeaderPolicy } from "./headers.js";
 const logger = log.logger("tunnel:gate");
-/** Route prefix the login flow lives under (open, answered in-process). */
 export const AUTH_PREFIX = "/api/email/auth";
 /**
  * True when the request's `Host` is the tunnel's public domain - i.e. it came in
@@ -38,21 +36,6 @@ export function isTunnelHost(req, publicDomain) {
     const host = (req.headers.host ?? "").toLowerCase().split(":")[0];
     return host === publicDomain.toLowerCase().split(":")[0];
 }
-/** The session cookie for a verified email, as a Set-Cookie string. */
-function sessionCookie(value, maxAgeSeconds) {
-    return [
-        `${SESSION_COOKIE_NAME}=${value}`,
-        "Path=/",
-        "HttpOnly",
-        "SameSite=Lax",
-        `Max-Age=${maxAgeSeconds}`,
-        // Real enforcement in production: the session cookie must be Secure so it is
-        // never sent over plaintext. Local dev (http) omits it so the cookie works.
-        process.env.NODE_ENV === "production" ? "Secure" : "",
-    ]
-        .filter(Boolean)
-        .join("; ");
-}
 /**
  * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value
  * the nearest trusted hop - portr - wrote), else the socket address. Reading the
@@ -79,19 +62,19 @@ function stripSessionCookie(req) {
     const kept = raw
         .split(";")
         .map((c) => c.trim())
-        .filter((c) => c && !c.startsWith(`${SESSION_COOKIE_NAME}=`));
+        .filter((c) => c && !c.startsWith("dbx-tools-auth=") && !c.startsWith("dbx-tools-passkey="));
     if (kept.length)
         req.headers.cookie = kept.join("; ");
     else
         delete req.headers.cookie;
 }
 /**
- * Present an OTP-authenticated caller to the app the SAME way a platform front
+ * Present a passwordless-authenticated caller to the app the SAME way a platform front
  * door does: set the front-door identity headers to the verified address (AppKit
  * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no
  * gate-specific code path.
  *
- * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session
+ * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an auth session
  * proves an email, not possession of a Databricks credential. Its absence is what
  * `@dbx-tools/appkit`'s `identity: "auto"` detects, so a gated request runs as the
  * app service principal instead of throwing.
@@ -100,11 +83,6 @@ function injectIdentity(req, email) {
     req.headers[token.USER_ID_HEADER] = email;
     req.headers[token.USER_EMAIL_HEADER] = email;
 }
-function sendJson(res, status, body, setCookie) {
-    if (setCookie)
-        res.setHeader("set-cookie", setCookie);
-    res.status(status).json(body);
-}
 /** Read the raw request body as text (AppKit parses JSON, but the gate routes
  * are mounted before that runs for tunnel traffic, so read defensively). */
 function readBody(req) {
@@ -119,6 +97,43 @@ function readBody(req) {
         req.on("error", () => resolve(data));
     });
 }
+export function webHeaders(req) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(name, item);
+        }
+        else if (value !== undefined) {
+            headers.set(name, value);
+        }
+    }
+    headers.set("x-real-ip", clientIp(req));
+    return headers;
+}
+export async function webRequest(req) {
+    const host = req.headers.host ?? "localhost";
+    const hostname = host.split(":")[0]?.toLowerCase();
+    const protocol = hostname === "localhost" || hostname === "127.0.0.1" ? "http" : "https";
+    const method = (req.method ?? "GET").toUpperCase();
+    const body = method === "GET" || method === "HEAD" ? undefined : await readBody(req);
+    return new globalThis.Request(`${protocol}://${host}${req.originalUrl || req.url}`, {
+        method,
+        headers: webHeaders(req),
+        ...(body ? { body } : {}),
+    });
+}
+export async function sendWebResponse(res, response) {
+    for (const [name, value] of response.headers.entries()) {
+        if (name.toLowerCase() !== "set-cookie")
+            res.setHeader(name, value);
+    }
+    const cookies = response.headers.getSetCookie();
+    if (cookies.length)
+        res.setHeader("set-cookie", cookies);
+    const body = Buffer.from(await response.arrayBuffer());
+    res.status(response.status).send(body);
+}
 /**
  * THE gating decision, for one request, independent of how it will be answered.
  *
@@ -154,9 +169,8 @@ export async function gateRequest(req, options) {
         stripSessionCookie(req);
         return "pass";
     }
-    // Every other /api/* needs a valid OTP session.
-    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-    const email = await gate.session(cookie);
+    // Every other /api/* needs a valid Better Auth session.
+    const email = await gate.session(webHeaders(req));
     if (!email)
         return "deny";
     injectIdentity(req, email);
@@ -168,12 +182,6 @@ export const UNAUTHORIZED_BODY = {
     error: "authentication required",
     loginPath: AUTH_PREFIX,
 };
-/** The `Set-Cookie` value that issues a verified session. */
-export function sessionSetCookie(sessionToken, maxAgeSeconds) {
-    return sessionCookie(sessionToken, maxAgeSeconds);
-}
-/** The `Set-Cookie` value that clears the session. */
-export const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`;
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
@@ -183,64 +191,34 @@ export const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max
  * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),
  * not under the plugin's `/api/authGate` base.
  */
-export function mountGate(opts, addRoute, addMiddleware) {
+export function mountGate(opts, _addRoute, addMiddleware) {
     const { gate, publicDomain, forwardHeaders } = opts;
     const headerPolicy = toHeaderPolicy(forwardHeaders);
     logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
-    // --- Login routes (open on tunnel traffic; answered in-process) ---
-    const statusHandler = (async (req, res) => {
-        // A local or front-door caller is never gated, so the honest answer is that
-        // the gate does not apply - not the session state of a cookie it would never
-        // check. Without this, a browser on `localhost` renders the OTP login screen
-        // for a request that would have passed through untouched.
-        if (!isTunnelHost(req, publicDomain)) {
-            sendJson(res, 200, { authenticated: false, enabled: false });
-            return;
-        }
-        const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-        sendJson(res, 200, await gate.status(cookie));
-    });
-    const requestHandler = (async (req, res) => {
-        if (!isTunnelHost(req, publicDomain)) {
-            sendJson(res, 404, { error: "not found" });
-            return;
-        }
-        const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));
-        if (!parsed.success)
-            return sendJson(res, 200, { ok: true }); // anti-enumeration
-        sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));
-    });
-    const verifyHandler = (async (req, res) => {
-        if (!isTunnelHost(req, publicDomain)) {
-            sendJson(res, 404, { error: "not found" });
-            return;
-        }
-        const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));
-        if (!parsed.success)
-            return sendJson(res, 200, { ok: false });
-        const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));
-        const cookie = result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;
-        sendJson(res, 200, { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) }, cookie);
-    });
-    const logoutHandler = ((req, res) => {
+    // Better Auth and the compatibility routes share one fetch-compatible
+    // handler in both hosting modes.
+    const authHandler = (async (req, res) => {
         if (!isTunnelHost(req, publicDomain)) {
-            sendJson(res, 404, { error: "not found" });
+            const path = (req.url ?? "/").split("?")[0] ?? "/";
+            if (path.endsWith("/status")) {
+                res.status(200).json({ authenticated: false, enabled: false, passkeysEnabled: false });
+            }
+            else {
+                res.status(404).json({ error: "not found" });
+            }
             return;
         }
-        sendJson(res, 200, { ok: true }, LOGOUT_SET_COOKIE);
+        await sendWebResponse(res, await gate.handler(await webRequest(req)));
     });
-    addRoute("get", `${AUTH_PREFIX}/status`, statusHandler);
-    addRoute("post", `${AUTH_PREFIX}/request`, requestHandler);
-    addRoute("post", `${AUTH_PREFIX}/verify`, verifyHandler);
-    addRoute("post", `${AUTH_PREFIX}/logout`, logoutHandler);
+    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 });
         if (action === "deny")
-            sendJson(res, 401, UNAUTHORIZED_BODY);
+            res.status(401).json(UNAUTHORIZED_BODY);
         else
             next();
     });
     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 proves an email via OTP, and on success the gate injects the\n * identity headers AppKit reads, so a gated request runs like a front-door one.\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 { http, json, log, token } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport type { Request, 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\n/** Route prefix the login flow lives under (open, answered in-process). */\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/** The session cookie for a verified email, as a Set-Cookie string. */\nfunction sessionCookie(value: string, maxAgeSeconds: number): string {\n  return [\n    `${SESSION_COOKIE_NAME}=${value}`,\n    \"Path=/\",\n    \"HttpOnly\",\n    \"SameSite=Lax\",\n    `Max-Age=${maxAgeSeconds}`,\n    // Real enforcement in production: the session cookie must be Secure so it is\n    // never sent over plaintext. Local dev (http) omits it so the cookie works.\n    process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n  ]\n    .filter(Boolean)\n    .join(\"; \");\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(`${SESSION_COOKIE_NAME}=`));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present an OTP-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 OTP 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\nfunction sendJson(res: Response, status: number, body: unknown, setCookie?: string): void {\n  if (setCookie) res.setHeader(\"set-cookie\", setCookie);\n  res.status(status).json(body);\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: Request): 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\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 OTP session.\n  const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n  const email = await gate.session(cookie);\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/** The `Set-Cookie` value that issues a verified session. */\nexport function sessionSetCookie(sessionToken: string, maxAgeSeconds: number): string {\n  return sessionCookie(sessionToken, maxAgeSeconds);\n}\n\n/** The `Set-Cookie` value that clears the session. */\nexport const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`;\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  // --- Login routes (open on tunnel traffic; answered in-process) ---\n\n  const statusHandler = (async (req, res) => {\n    // A local or front-door caller is never gated, so the honest answer is that\n    // the gate does not apply - not the session state of a cookie it would never\n    // check. Without this, a browser on `localhost` renders the OTP login screen\n    // for a request that would have passed through untouched.\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 200, { authenticated: false, enabled: false });\n      return;\n    }\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    sendJson(res, 200, await gate.status(cookie));\n  }) as RequestHandler;\n\n  const requestHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n    sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n  }) as RequestHandler;\n\n  const verifyHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: false });\n    const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));\n    const cookie =\n      result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;\n    sendJson(\n      res,\n      200,\n      { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n      cookie,\n    );\n  }) as RequestHandler;\n\n  const logoutHandler = ((req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    sendJson(res, 200, { ok: true }, LOGOUT_SET_COOKIE);\n  }) as RequestHandler;\n\n  addRoute(\"get\", `${AUTH_PREFIX}/status`, statusHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/request`, requestHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/verify`, verifyHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/logout`, logoutHandler);\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\") sendJson(res, 401, 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":"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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"]}

package/lib/src/interceptor.d.ts

@@ -9,7 +9,7 @@
  * app's public port, binds the child process to the app, and stops portr during an
  * orderly AppKit shutdown.
  *
- * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
+ * The passwordless GATE is a separate concern: it is the `authGate` AppKit plugin,
  * which registers the login routes + a gating middleware on the app's own server.
  * Register it in the app's `plugins` for gated traffic. This interceptor is only
  * the portr half - "update the host, bind portr" - the smallest useful unit.

package/lib/src/interceptor.js

@@ -9,7 +9,7 @@
  * app's public port, binds the child process to the app, and stops portr during an
  * orderly AppKit shutdown.
  *
- * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
+ * The passwordless GATE is a separate concern: it is the `authGate` AppKit plugin,
  * which registers the login routes + a gating middleware on the app's own server.
  * Register it in the app's `plugins` for gated traffic. This interceptor is only
  * the portr half - "update the host, bind portr" - the smallest useful unit.
@@ -65,4 +65,4 @@ export function tunnelInterceptor(options = {}) {
         logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/plugin.d.ts

@@ -1,12 +1,11 @@
 /**
- * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.
+ * `authGate()` - the AppKit adapter around `@dbx-tools/auth`.
  *
  * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the
  * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin
- * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed
- * one-time-code store, and the session JWT. `createApp` (with no `server()`) is
- * used only to auto-init `CacheManager` + prime the sibling `email` transport;
- * this plugin is where the gate logic lives.
+ * owns tunnel authorization, AppKit Lakebase discovery, email delivery, and
+ * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and
+ * passkeys. `createApp` can run this plugin with or without `server()`.
  *
  * Options come from CLI flags OR env, with sensible defaults - see
  * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't
@@ -15,8 +14,9 @@
  *
  * @module
  */
-import { Plugin, type BasePluginConfig } from "@databricks/appkit";
-import type { AuthStatus } from "@dbx-tools/shared-email";
+import { Plugin, type BasePluginConfig, type ResourceRequirement, ResourceType } from "@databricks/appkit";
+import { type AuthorizeIdentity, type AuthStorageConfig, type AuthStorageMode } from "@dbx-tools/auth";
+import type { AuthStatus } from "@dbx-tools/shared-auth";
 import type { RequestHandler } from "express";
 import { type GateOptions } from "./gate.ts";
 interface GateMountContext {
@@ -26,7 +26,7 @@ interface GateMountContext {
 }
 export declare function mountGateOnContext(context: GateMountContext, options: GateOptions): void;
 /** Options for the {@link authGate} plugin (all resolvable from env - see below). */
-export interface AuthGateConfig extends BasePluginConfig {
+export interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {
     /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */
     allow?: string | string[];
     /**
@@ -86,6 +86,11 @@ export interface AuthGateConfig extends BasePluginConfig {
      * different delivery path.
      */
     sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;
+    /**
+     * Identity authorization independent of authentication. Defaults to the
+     * configured allow-list and is re-evaluated for every accepted session.
+     */
+    authorizeIdentity?: AuthorizeIdentity;
     /**
      * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`
      * header. Only requests whose `Host` matches this are gated; everything else
@@ -136,31 +141,26 @@ export interface ResolvedAuthGateConfig {
     forwardHeaders: string[];
     /** Run OPEN with no gate. */
     insecure: boolean;
+    storage: AuthStorageMode;
+    sqlitePath?: string;
 }
 /** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
 export declare function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig;
 /** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */
 export interface AuthGateApi {
-    /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */
-    request(email: string, ip: string): Promise<{
-        ok: true;
-        retryAfter?: number;
-    }>;
-    /** Handle a code verification. On success returns the session token to cookie. */
-    verify(email: string, code: string, ip: string): Promise<{
-        ok: boolean;
-        token?: string;
-        retryAfter?: number;
-    }>;
-    /** Resolve the authenticated email for a session token, or undefined. */
-    session(token: string | undefined): Promise<string | undefined>;
-    /** Session TTL in seconds (for the cookie Max-Age). */
-    readonly sessionTtlSeconds: number;
-    /** The gate status payload (`enabled` is always true when this plugin runs). */
-    status(token: string | undefined): Promise<AuthStatus>;
+    /** Better Auth and compatibility routes under `/api/email/auth/*`. */
+    handler(request: Request): Promise<Response>;
+    /** Resolve the authorized email for request headers, or undefined. */
+    session(headers: Headers): Promise<string | undefined>;
+    /** The gate status payload. */
+    status(headers: Headers): Promise<AuthStatus>;
+    /** Whether the runtime exposes passkey enrollment and authentication. */
+    readonly passkeysEnabled: boolean;
+    /** Close auth storage owned by this runtime. */
+    close(): Promise<void>;
 }
 /**
- * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login
+ * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login
  * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express
  * server via `this.context`, so a public portr caller must prove an email before
  * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and
@@ -174,14 +174,28 @@ export declare class AuthGatePlugin extends Plugin<AuthGateConfig> {
         stability: "beta";
         resources: {
             required: never[];
-            optional: never[];
+            optional: {
+                type: ResourceType.POSTGRES;
+                alias: string;
+                resourceKey: string;
+                description: string;
+                permission: "CAN_CONNECT_AND_CREATE";
+                fields: {
+                    instance_name: {
+                        env: string;
+                    };
+                    database_name: {
+                        env: string;
+                    };
+                };
+            }[];
         };
     };
     private resolved;
-    private codes;
-    private readonly requestLimiter;
-    private readonly verifyLimiter;
+    private runtime?;
+    static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[];
     setup(): Promise<void>;
+    shutdown(): Promise<void>;
     /**
      * Register the login routes (`/api/email/auth/*`) and the gating middleware on
      * the app's OWN Express server. At `setup:complete`, the deferred server plugin
@@ -192,9 +206,8 @@ export declare class AuthGatePlugin extends Plugin<AuthGateConfig> {
     private mountGateRoutes;
     /** The code sender: the configured `sendCode`, else the shared-transport default. */
     private get sendCode();
+    private authorizeIdentity;
     exports(): AuthGateApi;
-    private handleRequest;
-    private handleVerify;
 }
 /** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
 export declare const authGate: import("@databricks/appkit").ToPlugin<typeof AuthGatePlugin, AuthGateConfig, "authGate">;