@dbx-tools/tunnel 0.6.114 → 0.6.116

package/README.md

@@ -357,6 +357,12 @@ the cookie, because that request was never going to be gated. So the same runnin
 app shows the OTP screen to a portr visitor and no login at all to a browser on
 `localhost` or the platform front door.
 
+When the hosted login page interrupts a navigation, it carries the original
+same-origin path through the login flow and replaces the page with that path
+after OTP verification. API denials expose the hosted login URL in `loginPath`;
+its `returnTo` query value comes from a same-origin referrer and is normalized
+to an application path, so it cannot become an external redirect.
+
 `POST /api/email/auth/logout` clears the current session and returns
 `{ ok, redirectTo }`. `GET` on the same path clears the session and answers with
 a `303` redirect. `logoutRedirectPath` or

package/lib/src/gate.d.ts

@@ -107,6 +107,21 @@ export declare const UNAUTHORIZED_BODY: {
     readonly error: "authentication required";
     readonly loginPath: "/api/email/auth";
 };
+/** Restrict a post-login destination to one same-origin application path. */
+export declare function normalizeReturnTo(value: string | undefined): string;
+/** Resolve the page a browser should return to after tunnel authentication. */
+export declare function requestReturnTo(req: IncomingMessage): string;
+/** Build the hosted login URL with a validated same-origin return path. */
+export declare function loginPath(req: IncomingMessage): string;
+/** Build a denied JSON response that preserves the calling page. */
+export declare function unauthorizedBody(req: IncomingMessage): {
+    error: typeof UNAUTHORIZED_BODY.error;
+    loginPath: string;
+};
+/** Return the validated destination carried by a hosted login URL. */
+export declare function loginReturnTo(req: IncomingMessage): string;
+/** Whether this request asks for the hosted login document itself. */
+export declare function wantsHostedLogin(req: IncomingMessage): boolean;
 /**
  * Whether a denied request is a top-level BROWSER NAVIGATION that should be
  * answered with the hosted login page rather than a 401.

package/lib/src/gate.js

@@ -196,6 +196,56 @@ export const UNAUTHORIZED_BODY = {
     error: "authentication required",
     loginPath: AUTH_PREFIX,
 };
+/** Restrict a post-login destination to one same-origin application path. */
+export function normalizeReturnTo(value) {
+    const candidate = value?.trim();
+    if (!candidate?.startsWith("/") || candidate.startsWith("//") || candidate.includes("\\")) {
+        return "/";
+    }
+    const parsed = new URL(candidate, "http://app.local");
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
+/** Resolve the page a browser should return to after tunnel authentication. */
+export function requestReturnTo(req) {
+    if (wantsLoginPage(req)) {
+        const originalUrl = req.originalUrl;
+        return normalizeReturnTo(originalUrl || req.url);
+    }
+    const referer = String(req.headers.referer ?? "").trim();
+    if (!referer)
+        return "/";
+    try {
+        const parsed = new URL(referer);
+        const host = String(req.headers.host ?? "").toLowerCase();
+        if (parsed.host.toLowerCase() !== host)
+            return "/";
+        return normalizeReturnTo(`${parsed.pathname}${parsed.search}${parsed.hash}`);
+    }
+    catch {
+        return "/";
+    }
+}
+/** Build the hosted login URL with a validated same-origin return path. */
+export function loginPath(req) {
+    return `${AUTH_PREFIX}?returnTo=${encodeURIComponent(requestReturnTo(req))}`;
+}
+/** Build a denied JSON response that preserves the calling page. */
+export function unauthorizedBody(req) {
+    return { ...UNAUTHORIZED_BODY, loginPath: loginPath(req) };
+}
+/** Return the validated destination carried by a hosted login URL. */
+export function loginReturnTo(req) {
+    const url = new URL(req.url ?? AUTH_PREFIX, "http://app.local");
+    return normalizeReturnTo(url.searchParams.get("returnTo") ?? "/");
+}
+/** Whether this request asks for the hosted login document itself. */
+export function wantsHostedLogin(req) {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD")
+        return false;
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    return path === AUTH_PREFIX && String(req.headers.accept ?? "").includes("text/html");
+}
 /**
  * Whether a denied request is a top-level BROWSER NAVIGATION that should be
  * answered with the hosted login page rather than a 401.
@@ -243,6 +293,16 @@ export function mountGate(opts, _addRoute, addMiddleware) {
             }
             return;
         }
+        if (wantsHostedLogin(req)) {
+            res
+                .status(200)
+                .type("html")
+                .send(loginPageHtml({
+                brandName: brandName ?? "Databricks App",
+                returnTo: loginReturnTo(req),
+            }));
+            return;
+        }
         await sendWebResponse(res, await gate.handler(await webRequest(req)));
     });
     addMiddleware(AUTH_PREFIX, authHandler);
@@ -250,13 +310,21 @@ export function mountGate(opts, _addRoute, addMiddleware) {
     const gateMiddleware = (async (req, res, next) => {
         const action = await gateRequest(req, { gate, publicDomain, headerPolicy, gatePaths });
         if (action === "deny" && wantsLoginPage(req)) {
-            res.status(401).type("html").send(loginPageHtml({ brandName: brandName ?? "Databricks App" }));
+            res
+                .status(401)
+                .type("html")
+                .send(loginPageHtml({
+                brandName: brandName ?? "Databricks App",
+                returnTo: requestReturnTo(req),
+            }));
         }
-        else if (action === "deny")
-            res.status(401).json(UNAUTHORIZED_BODY);
-        else
+        else if (action === "deny") {
+            res.status(401).json(unauthorizedBody(req));
+        }
+        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 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 { loginPageHtml } from \"./login-page.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 | readonly 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  /** Product name displayed by the hosted login page. */\n  brandName?: string;\n}\n\n/**\n * True when the request's `Host` is one of the tunnel's public domains - i.e. it\n * came in over Portr or FRP. Case-insensitive; the optional `:port` is ignored.\n * When no public domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(\n  req: IncomingMessage,\n  publicDomain: string | readonly string[] | undefined,\n): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  const domains = typeof publicDomain === \"string\" ? [publicDomain] : publicDomain;\n  return domains.some((domain) => host === domain.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, brandName } = 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\" && wantsLoginPage(req)) {\n      res.status(401).type(\"html\").send(loginPageHtml({ brandName: brandName ?? \"Databricks App\" }));\n    } else 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":"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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 { loginPageHtml } from \"./login-page.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 | readonly 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  /** Product name displayed by the hosted login page. */\n  brandName?: string;\n}\n\n/**\n * True when the request's `Host` is one of the tunnel's public domains - i.e. it\n * came in over Portr or FRP. Case-insensitive; the optional `:port` is ignored.\n * When no public domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(\n  req: IncomingMessage,\n  publicDomain: string | readonly string[] | undefined,\n): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  const domains = typeof publicDomain === \"string\" ? [publicDomain] : publicDomain;\n  return domains.some((domain) => host === domain.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/** Restrict a post-login destination to one same-origin application path. */\nexport function normalizeReturnTo(value: string | undefined): string {\n  const candidate = value?.trim();\n  if (!candidate?.startsWith(\"/\") || candidate.startsWith(\"//\") || candidate.includes(\"\\\\\")) {\n    return \"/\";\n  }\n  const parsed = new URL(candidate, \"http://app.local\");\n  return `${parsed.pathname}${parsed.search}${parsed.hash}`;\n}\n\n/** Resolve the page a browser should return to after tunnel authentication. */\nexport function requestReturnTo(req: IncomingMessage): string {\n  if (wantsLoginPage(req)) {\n    const originalUrl = (req as IncomingMessage & { originalUrl?: string }).originalUrl;\n    return normalizeReturnTo(originalUrl || req.url);\n  }\n  const referer = String(req.headers.referer ?? \"\").trim();\n  if (!referer) return \"/\";\n  try {\n    const parsed = new URL(referer);\n    const host = String(req.headers.host ?? \"\").toLowerCase();\n    if (parsed.host.toLowerCase() !== host) return \"/\";\n    return normalizeReturnTo(`${parsed.pathname}${parsed.search}${parsed.hash}`);\n  } catch {\n    return \"/\";\n  }\n}\n\n/** Build the hosted login URL with a validated same-origin return path. */\nexport function loginPath(req: IncomingMessage): string {\n  return `${AUTH_PREFIX}?returnTo=${encodeURIComponent(requestReturnTo(req))}`;\n}\n\n/** Build a denied JSON response that preserves the calling page. */\nexport function unauthorizedBody(req: IncomingMessage): {\n  error: typeof UNAUTHORIZED_BODY.error;\n  loginPath: string;\n} {\n  return { ...UNAUTHORIZED_BODY, loginPath: loginPath(req) };\n}\n\n/** Return the validated destination carried by a hosted login URL. */\nexport function loginReturnTo(req: IncomingMessage): string {\n  const url = new URL(req.url ?? AUTH_PREFIX, \"http://app.local\");\n  return normalizeReturnTo(url.searchParams.get(\"returnTo\") ?? \"/\");\n}\n\n/** Whether this request asks for the hosted login document itself. */\nexport function wantsHostedLogin(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  return path === AUTH_PREFIX && String(req.headers.accept ?? \"\").includes(\"text/html\");\n}\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, brandName } = 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    if (wantsHostedLogin(req)) {\n      res\n        .status(200)\n        .type(\"html\")\n        .send(\n          loginPageHtml({\n            brandName: brandName ?? \"Databricks App\",\n            returnTo: loginReturnTo(req),\n          }),\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\" && wantsLoginPage(req)) {\n      res\n        .status(401)\n        .type(\"html\")\n        .send(\n          loginPageHtml({\n            brandName: brandName ?? \"Databricks App\",\n            returnTo: requestReturnTo(req),\n          }),\n        );\n    } else if (action === \"deny\") {\n      res.status(401).json(unauthorizedBody(req));\n    } else {\n      next();\n    }\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}

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

@@ -16,6 +16,8 @@
 export interface LoginPageOptions {
     /** Product/brand name shown in the heading. */
     brandName: string;
+    /** Validated same-origin path loaded after authentication succeeds. */
+    returnTo: 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

@@ -17,9 +17,8 @@ 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);
+    const prefix = jsonForInlineScript(AUTH_PREFIX);
+    const returnTo = jsonForInlineScript(options.returnTo);
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -99,6 +98,11 @@ export function loginPageHtml(options) {
 <script>
 (function () {
   var PREFIX = ${prefix};
+  var RETURN_TO = ${returnTo};
+  // An in-place login can preserve browser-only hash state that never reached the server.
+  if (window.location.pathname !== PREFIX) {
+    RETURN_TO = window.location.pathname + window.location.search + window.location.hash;
+  }
   var emailForm = document.getElementById("email-form");
   var codeForm = document.getElementById("code-form");
   var emailInput = document.getElementById("email");
@@ -172,9 +176,7 @@ export function loginPageHtml(options) {
       });
       if (r.ok) {
         say("Signed in. Loading…");
-        // The session cookie is set; reload so the now-authenticated request
-        // reaches the app.
-        window.location.reload();
+        window.location.replace(RETURN_TO);
       } else {
         say(errorText(r.data, "That code was not accepted. Try again."), true);
         submit.disabled = false;
@@ -207,4 +209,13 @@ const HTML_ESCAPES = {
 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEA+C2C,KAAK;;;;;qBAKnD,KAAK;;;;;;;;;;;;;;;;;;;;;iBAqBT,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiGf,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: #FF3621; --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: #FF5A46; --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  .logo { width: 40px; height: 40px; display: block; margin: 0 0 14px; }\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    <!-- dbx.tools pixel-brick \"stache\" mark (Lava palette), matching the Kanna UI logo. -->\n    <svg class=\"logo\" viewBox=\"0 0 64 64\" role=\"img\" aria-label=\"${brand}\" shape-rendering=\"crispEdges\">\n      <rect x=\"19\" y=\"20\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"37\" y=\"20\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/>\n      <rect x=\"1\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#D92D18\"/><rect x=\"10\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"19\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF5A46\"/><rect x=\"28\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF8974\"/><rect x=\"37\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF5A46\"/><rect x=\"46\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"55\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#D92D18\"/>\n      <rect x=\"10\" y=\"38\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"46\" y=\"38\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/>\n    </svg>\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  function errorText(data, fallback) {\n    // better-auth error shape: { message } or { error: { message } }.\n    if (data && data.error && data.error.message) return data.error.message;\n    if (data && data.message) return data.message;\n    return fallback;\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      // better-auth emailOTP native endpoint.\n      var r = await post(\"/email-otp/send-verification-otp\", { email: email, type: \"sign-in\" });\n      if (r.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(errorText(r.data, \"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      // better-auth sign-in with the OTP; sets the session cookie on success.\n      var r = await post(\"/sign-in/email-otp\", {\n        email: email,\n        otp: code,\n        name: email.split(\"@\")[0],\n      });\n      if (r.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(errorText(r.data, \"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"]}
+/** Encode a string literal without allowing it to terminate the surrounding script. */
+function jsonForInlineScript(value) {
+    return JSON.stringify(value)
+        .replaceAll("<", "\\u003c")
+        .replaceAll(">", "\\u003e")
+        .replaceAll("&", "\\u0026")
+        .replaceAll("\u2028", "\\u2028")
+        .replaceAll("\u2029", "\\u2029");
+}
+//# 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;AASxC,qFAAqF;AACrF,MAAM,UAAU,aAAa,CAAC,OAAyB;IACrD,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvD,OAAO;;;;;mBAKU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEA+C2C,KAAK;;;;;qBAKnD,KAAK;;;;;;;;;;;;;;;;;;;;;iBAqBT,MAAM;oBACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmGpB,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;AAED,uFAAuF;AACvF,SAAS,mBAAmB,CAAC,KAAa;IACxC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;SACzB,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;SAC1B,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;SAC1B,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;SAC1B,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC;SAC/B,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrC,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  /** Validated same-origin path loaded after authentication succeeds. */\n  returnTo: 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  const prefix = jsonForInlineScript(AUTH_PREFIX);\n  const returnTo = jsonForInlineScript(options.returnTo);\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: #FF3621; --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: #FF5A46; --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  .logo { width: 40px; height: 40px; display: block; margin: 0 0 14px; }\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    <!-- dbx.tools pixel-brick \"stache\" mark (Lava palette), matching the Kanna UI logo. -->\n    <svg class=\"logo\" viewBox=\"0 0 64 64\" role=\"img\" aria-label=\"${brand}\" shape-rendering=\"crispEdges\">\n      <rect x=\"19\" y=\"20\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"37\" y=\"20\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/>\n      <rect x=\"1\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#D92D18\"/><rect x=\"10\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"19\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF5A46\"/><rect x=\"28\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF8974\"/><rect x=\"37\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF5A46\"/><rect x=\"46\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"55\" y=\"29\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#D92D18\"/>\n      <rect x=\"10\" y=\"38\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/><rect x=\"46\" y=\"38\" width=\"8\" height=\"8\" rx=\"1\" fill=\"#FF3621\"/>\n    </svg>\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 RETURN_TO = ${returnTo};\n  // An in-place login can preserve browser-only hash state that never reached the server.\n  if (window.location.pathname !== PREFIX) {\n    RETURN_TO = window.location.pathname + window.location.search + window.location.hash;\n  }\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  function errorText(data, fallback) {\n    // better-auth error shape: { message } or { error: { message } }.\n    if (data && data.error && data.error.message) return data.error.message;\n    if (data && data.message) return data.message;\n    return fallback;\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      // better-auth emailOTP native endpoint.\n      var r = await post(\"/email-otp/send-verification-otp\", { email: email, type: \"sign-in\" });\n      if (r.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(errorText(r.data, \"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      // better-auth sign-in with the OTP; sets the session cookie on success.\n      var r = await post(\"/sign-in/email-otp\", {\n        email: email,\n        otp: code,\n        name: email.split(\"@\")[0],\n      });\n      if (r.ok) {\n        say(\"Signed in. Loading…\");\n        window.location.replace(RETURN_TO);\n      } else {\n        say(errorText(r.data, \"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\n/** Encode a string literal without allowing it to terminate the surrounding script. */\nfunction jsonForInlineScript(value: string): string {\n  return JSON.stringify(value)\n    .replaceAll(\"<\", \"\\\\u003c\")\n    .replaceAll(\">\", \"\\\\u003e\")\n    .replaceAll(\"&\", \"\\\\u0026\")\n    .replaceAll(\"\\u2028\", \"\\\\u2028\")\n    .replaceAll(\"\\u2029\", \"\\\\u2029\");\n}\n"]}

package/package.json

@@ -18,21 +18,21 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.114",
+    "@dbx-tools/email": "0.6.116",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.114"
+    "@dbx-tools/email": "0.6.116"
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.114",
-    "@dbx-tools/auth": "0.6.114",
-    "@dbx-tools/core": "0.6.114",
-    "@dbx-tools/shared-auth": "0.6.114",
-    "@dbx-tools/shared-core": "0.6.114",
+    "@dbx-tools/appkit": "0.6.116",
+    "@dbx-tools/auth": "0.6.116",
+    "@dbx-tools/core": "0.6.116",
+    "@dbx-tools/shared-auth": "0.6.116",
+    "@dbx-tools/shared-core": "0.6.116",
     "http-proxy-3": "^1.23.1"
   },
   "main": "./lib/index.js",
@@ -49,7 +49,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.114",
+  "version": "0.6.116",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/gate.ts

@@ -258,6 +258,61 @@ export const UNAUTHORIZED_BODY = {
   loginPath: AUTH_PREFIX,
 } as const;
 
+/** Restrict a post-login destination to one same-origin application path. */
+export function normalizeReturnTo(value: string | undefined): string {
+  const candidate = value?.trim();
+  if (!candidate?.startsWith("/") || candidate.startsWith("//") || candidate.includes("\\")) {
+    return "/";
+  }
+  const parsed = new URL(candidate, "http://app.local");
+  return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
+
+/** Resolve the page a browser should return to after tunnel authentication. */
+export function requestReturnTo(req: IncomingMessage): string {
+  if (wantsLoginPage(req)) {
+    const originalUrl = (req as IncomingMessage & { originalUrl?: string }).originalUrl;
+    return normalizeReturnTo(originalUrl || req.url);
+  }
+  const referer = String(req.headers.referer ?? "").trim();
+  if (!referer) return "/";
+  try {
+    const parsed = new URL(referer);
+    const host = String(req.headers.host ?? "").toLowerCase();
+    if (parsed.host.toLowerCase() !== host) return "/";
+    return normalizeReturnTo(`${parsed.pathname}${parsed.search}${parsed.hash}`);
+  } catch {
+    return "/";
+  }
+}
+
+/** Build the hosted login URL with a validated same-origin return path. */
+export function loginPath(req: IncomingMessage): string {
+  return `${AUTH_PREFIX}?returnTo=${encodeURIComponent(requestReturnTo(req))}`;
+}
+
+/** Build a denied JSON response that preserves the calling page. */
+export function unauthorizedBody(req: IncomingMessage): {
+  error: typeof UNAUTHORIZED_BODY.error;
+  loginPath: string;
+} {
+  return { ...UNAUTHORIZED_BODY, loginPath: loginPath(req) };
+}
+
+/** Return the validated destination carried by a hosted login URL. */
+export function loginReturnTo(req: IncomingMessage): string {
+  const url = new URL(req.url ?? AUTH_PREFIX, "http://app.local");
+  return normalizeReturnTo(url.searchParams.get("returnTo") ?? "/");
+}
+
+/** Whether this request asks for the hosted login document itself. */
+export function wantsHostedLogin(req: IncomingMessage): boolean {
+  const method = (req.method ?? "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") return false;
+  const path = (req.url ?? "/").split("?")[0] ?? "/";
+  return path === AUTH_PREFIX && String(req.headers.accept ?? "").includes("text/html");
+}
+
 /**
  * Whether a denied request is a top-level BROWSER NAVIGATION that should be
  * answered with the hosted login page rather than a 401.
@@ -308,6 +363,18 @@ export function mountGate(
       }
       return;
     }
+    if (wantsHostedLogin(req)) {
+      res
+        .status(200)
+        .type("html")
+        .send(
+          loginPageHtml({
+            brandName: brandName ?? "Databricks App",
+            returnTo: loginReturnTo(req),
+          }),
+        );
+      return;
+    }
     await sendWebResponse(res, await gate.handler(await webRequest(req)));
   }) as RequestHandler;
   addMiddleware(AUTH_PREFIX, authHandler);
@@ -317,9 +384,20 @@ export function mountGate(
   const gateMiddleware = (async (req, res, next) => {
     const action = await gateRequest(req, { gate, publicDomain, headerPolicy, gatePaths });
     if (action === "deny" && wantsLoginPage(req)) {
-      res.status(401).type("html").send(loginPageHtml({ brandName: brandName ?? "Databricks App" }));
-    } else if (action === "deny") res.status(401).json(UNAUTHORIZED_BODY);
-    else next();
+      res
+        .status(401)
+        .type("html")
+        .send(
+          loginPageHtml({
+            brandName: brandName ?? "Databricks App",
+            returnTo: requestReturnTo(req),
+          }),
+        );
+    } else if (action === "deny") {
+      res.status(401).json(unauthorizedBody(req));
+    } else {
+      next();
+    }
   }) as RequestHandler;
 
   addMiddleware("/", gateMiddleware);

package/src/login-page.ts

@@ -19,14 +19,15 @@ import { AUTH_PREFIX } from "./gate.ts";
 export interface LoginPageOptions {
   /** Product/brand name shown in the heading. */
   brandName: string;
+  /** Validated same-origin path loaded after authentication succeeds. */
+  returnTo: 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);
+  const prefix = jsonForInlineScript(AUTH_PREFIX);
+  const returnTo = jsonForInlineScript(options.returnTo);
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -106,6 +107,11 @@ export function loginPageHtml(options: LoginPageOptions): string {
 <script>
 (function () {
   var PREFIX = ${prefix};
+  var RETURN_TO = ${returnTo};
+  // An in-place login can preserve browser-only hash state that never reached the server.
+  if (window.location.pathname !== PREFIX) {
+    RETURN_TO = window.location.pathname + window.location.search + window.location.hash;
+  }
   var emailForm = document.getElementById("email-form");
   var codeForm = document.getElementById("code-form");
   var emailInput = document.getElementById("email");
@@ -179,9 +185,7 @@ export function loginPageHtml(options: LoginPageOptions): string {
       });
       if (r.ok) {
         say("Signed in. Loading…");
-        // The session cookie is set; reload so the now-authenticated request
-        // reaches the app.
-        window.location.reload();
+        window.location.replace(RETURN_TO);
       } else {
         say(errorText(r.data, "That code was not accepted. Try again."), true);
         submit.disabled = false;
@@ -216,3 +220,13 @@ const HTML_ESCAPES: Record<string, string> = {
 function escapeHtml(value: string): string {
   return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
 }
+
+/** Encode a string literal without allowing it to terminate the surrounding script. */
+function jsonForInlineScript(value: string): string {
+  return JSON.stringify(value)
+    .replaceAll("<", "\\u003c")
+    .replaceAll(">", "\\u003e")
+    .replaceAll("&", "\\u0026")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}