@dbx-tools/cli-tunnel 0.6.48 → 0.6.49

package/lib/src/portr.d.ts

@@ -5,7 +5,7 @@
  * on cold start, so the portr binary and its config are placed under a writable,
  * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
  * The install is idempotent (the installer skips when the on-PATH binary is
- * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)
+ * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)
  * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
  *
  * @module
@@ -19,8 +19,8 @@ export interface PortrConfig {
     port: number;
 }
 /**
- * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit
- * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.
+ * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an
+ * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.
  * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a
  * usable domain is absent.
  */

package/lib/src/portr.js

@@ -5,7 +5,7 @@
  * on cold start, so the portr binary and its config are placed under a writable,
  * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
  * The install is idempotent (the installer skips when the on-PATH binary is
- * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)
+ * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)
  * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
  *
  * @module
@@ -13,17 +13,19 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { delimiter, join } from "node:path";
-import { log } from "@dbx-tools/shared-core";
+import { env, log } from "@dbx-tools/shared-core";
+import { PUBLIC_DOMAIN_ENV } from "./env.js";
 const logger = log.logger("tunnel:portr");
 /**
- * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit
- * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.
+ * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an
+ * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.
  * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a
  * usable domain is absent.
  */
 export function resolvePortrConfig(opts) {
-    const token = opts.token ?? process.env.PORTR_TOKEN;
-    const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;
+    // PORTR_* is upstream portr's own namespace, so it keeps its name.
+    const token = env.string(opts.token, "PORTR_TOKEN");
+    const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);
     if (!token)
         return undefined;
     let subdomain = opts.subdomain;
@@ -32,7 +34,7 @@ export function resolvePortrConfig(opts) {
         subdomain ??= domain.split(".")[0];
         server = domain.slice(domain.indexOf(".") + 1);
     }
-    server ??= process.env.PORTR_SERVER;
+    server ??= env.text("PORTR_SERVER") ?? undefined;
     if (!subdomain || !server || server === domain)
         return undefined;
     return { subdomain, server, token, port: opts.port };
@@ -88,4 +90,4 @@ export function startPortr(config, env) {
 export function portrInstalled(env) {
     return existsSync(join(env.HOME, ".portr", "bin", "portr"));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install + config + launch for the tunnel CLI.\n *\n * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only\n * on cold start, so the portr binary and its config are placed under a writable,\n * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)\n * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).\n *\n * @module\n */\n\nimport { spawn, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\nimport { log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"tunnel:portr\");\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit\n * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  const token = opts.token ?? process.env.PORTR_TOKEN;\n  const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= process.env.PORTR_SERVER;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */\nfunction portrHome(): string {\n  const home = join(process.cwd(), \".home\");\n  mkdirSync(join(home, \".portr\", \"bin\"), { recursive: true });\n  return home;\n}\n\n/** Install portr (idempotent) into the cwd-rooted home and return the child env. */\nexport function installPortr(): NodeJS.ProcessEnv {\n  const home = portrHome();\n  const env: NodeJS.ProcessEnv = {\n    ...process.env,\n    HOME: home,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [join(home, \".portr\", \"bin\"), process.env.PATH ?? \"\"].join(delimiter),\n  };\n  logger.info(\"installing portr (idempotent)\");\n  const res = spawnSync(\"bash\", [\"-c\", \"curl -sSf https://install.portr.dev | sh\"], {\n    env,\n    stdio: \"inherit\",\n  });\n  if (res.status !== 0) throw new Error(\"portr install failed\");\n  return env;\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {\n  const path = join(env.HOME!, \".portr\", \"config.yaml\");\n  writeFileSync(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  spawnSync(\"pkill\", [\"-x\", \"portr\"], { stdio: \"ignore\" });\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env, stdio: \"inherit\" });\n}\n\n/** True when the installed portr binary path exists (post-install sanity). */\nexport function portrInstalled(env: NodeJS.ProcessEnv): boolean {\n  return existsSync(join(env.HOME!, \".portr\", \"bin\", \"portr\"));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install + config + launch for the tunnel CLI.\n *\n * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only\n * on cold start, so the portr binary and its config are placed under a writable,\n * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)\n * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).\n *\n * @module\n */\n\nimport { spawn, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { PUBLIC_DOMAIN_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an\n * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  // PORTR_* is upstream portr's own namespace, so it keeps its name.\n  const token = env.string(opts.token, \"PORTR_TOKEN\");\n  const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= env.text(\"PORTR_SERVER\") ?? undefined;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */\nfunction portrHome(): string {\n  const home = join(process.cwd(), \".home\");\n  mkdirSync(join(home, \".portr\", \"bin\"), { recursive: true });\n  return home;\n}\n\n/** Install portr (idempotent) into the cwd-rooted home and return the child env. */\nexport function installPortr(): NodeJS.ProcessEnv {\n  const home = portrHome();\n  const env: NodeJS.ProcessEnv = {\n    ...process.env,\n    HOME: home,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [join(home, \".portr\", \"bin\"), process.env.PATH ?? \"\"].join(delimiter),\n  };\n  logger.info(\"installing portr (idempotent)\");\n  const res = spawnSync(\"bash\", [\"-c\", \"curl -sSf https://install.portr.dev | sh\"], {\n    env,\n    stdio: \"inherit\",\n  });\n  if (res.status !== 0) throw new Error(\"portr install failed\");\n  return env;\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {\n  const path = join(env.HOME!, \".portr\", \"config.yaml\");\n  writeFileSync(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  spawnSync(\"pkill\", [\"-x\", \"portr\"], { stdio: \"ignore\" });\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env, stdio: \"inherit\" });\n}\n\n/** True when the installed portr binary path exists (post-install sanity). */\nexport function portrInstalled(env: NodeJS.ProcessEnv): boolean {\n  return existsSync(join(env.HOME!, \".portr\", \"bin\", \"portr\"));\n}\n"]}

package/lib/src/proxy.d.ts

@@ -37,6 +37,13 @@ export interface ProxyOptions {
      * operator passed `--insecure` / `TUNNEL_INSECURE=true`.
      */
     gate?: AuthGateApi;
+    /**
+     * Extra `x-` request headers tunnel traffic may forward, as literals, globs, or
+     * `/regex/`es - unioned with {@link DEFAULT_FORWARD_HEADERS}. Every other `x-`
+     * header is stripped, and {@link PROTECTED_HEADERS} is stripped regardless. See
+     * `./headers.ts` for why the policy is an allow-list.
+     */
+    forwardHeaders?: readonly string[];
 }
 /** Start the gate proxy. Resolves once it is listening. */
-export declare function startProxy({ publicPort, appPort, gate }: ProxyOptions): Promise<void>;
+export declare function startProxy({ publicPort, appPort, gate, forwardHeaders, }: ProxyOptions): Promise<void>;

package/lib/src/proxy.js

@@ -25,9 +25,10 @@
  * @module
  */
 import { createServer } from "node:http";
-import { http, json, log } from "@dbx-tools/shared-core";
+import { http, json, log, token } from "@dbx-tools/shared-core";
 import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
 import ProxyModule from "http-proxy-3";
+import { toHeaderPolicy } from "./headers.js";
 const logger = log.logger("tunnel:proxy");
 /** Route prefix the login flow lives under (open, answered in-process). */
 const AUTH_PREFIX = "/api/email/auth";
@@ -56,7 +57,7 @@ function sendJson(res, status, body, setCookie) {
     res.end(JSON.stringify(body));
 }
 /** Start the gate proxy. Resolves once it is listening. */
-export function startProxy({ publicPort, appPort, gate }) {
+export function startProxy({ publicPort, appPort, gate, forwardHeaders, }) {
     const proxy = ProxyModule.createProxyServer({
         target: { host: "127.0.0.1", port: appPort },
         ws: true,
@@ -69,6 +70,9 @@ export function startProxy({ publicPort, appPort, gate }) {
             sendJson(r, 502, { error: "upstream unavailable" });
         }
     });
+    // Compiled once: the inbound-header allow-list applied to every gated request.
+    const headerPolicy = toHeaderPolicy(forwardHeaders);
+    logger.debug("inbound header policy", { forward: headerPolicy.patterns });
     /** The session cookie for a verified email, as a Set-Cookie string. */
     const sessionCookie = (token, maxAgeSeconds) => [
         `${SESSION_COOKIE_NAME}=${token}`,
@@ -80,11 +84,25 @@ export function startProxy({ publicPort, appPort, gate }) {
     ]
         .filter(Boolean)
         .join("; ");
-    /** Client IP for rate-limiting: the portr-forwarded XFF, else the socket. */
+    /**
+     * Client IP for rate-limiting: the portr client's forwarded XFF, else the socket.
+     *
+     * Deliberately the RIGHTMOST `x-forwarded-for` entry, not the leftmost. The
+     * list grows left-to-right as each hop appends, so the last entry is the one
+     * the nearest trusted proxy (portr) wrote and every earlier entry is a value
+     * the caller could have sent. Reading the leftmost lets a client vary one
+     * header to get a fresh rate-limit bucket per request, which defeats both the
+     * per-IP code-request and verify-attempt limiters. Called BEFORE
+     * {@link HeaderPolicy.apply} strips the header, so the honest hop value is
+     * still available here.
+     */
     const clientIp = (req) => {
-        const fwd = req.headers["x-forwarded-for"];
-        const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(",")[0];
-        return (first ?? req.socket.remoteAddress ?? "unknown").trim();
+        const forwarded = req.headers["x-forwarded-for"];
+        const chain = (Array.isArray(forwarded) ? forwarded.join(",") : (forwarded ?? ""))
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        return chain.at(-1) ?? req.socket.remoteAddress ?? "unknown";
     };
     /**
      * Remove the gate's session cookie from the `Cookie` header before forwarding,
@@ -106,14 +124,38 @@ export function startProxy({ publicPort, appPort, gate }) {
     };
     /**
      * Present an OTP-authenticated caller to the app the SAME way a platform front
-     * door does: set `x-forwarded-user` / `x-forwarded-email` to the verified
-     * address (AppKit reads `x-forwarded-user` for the OBO user id), so the app
-     * needs no gate-specific code path. Any inbound copies are overwritten so a
-     * client can't spoof identity through the gate.
+     * door does: set the front door's own 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. The names come from
+     * `@dbx-tools/shared-core`'s `token` module - the same constants AppKit-side
+     * code reads them by - rather than being re-spelled here.
+     *
+     * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session
+     * proves an email address, not possession of a Databricks credential, and
+     * there is no way to mint one for the caller. Its absence is exactly what
+     * `@dbx-tools/appkit`'s `identity` `"auto"` mode detects, so a gated request
+     * runs as the app's service principal instead of throwing.
      */
     const injectIdentity = (req, email) => {
-        req.headers["x-forwarded-user"] = email;
-        req.headers["x-forwarded-email"] = email;
+        req.headers[token.USER_ID_HEADER] = email;
+        req.headers[token.USER_EMAIL_HEADER] = email;
+    };
+    /**
+     * Apply the inbound-header policy to a tunnel request: every `x-` header the
+     * allow-list does not name is deleted, and the platform identity/transport set
+     * is deleted regardless. See `./headers.ts` for the reasoning; the
+     * security-critical case is {@link token.ACCESS_TOKEN_HEADER}, which the gate
+     * never sets but an app running `identity: "auto"` treats as proof the request
+     * can do OBO.
+     *
+     * `xfwd: true` on the proxy re-adds `x-forwarded-for`/`-proto`/`-port`/`-host`
+     * afterwards from the real socket, so the app still sees those - it just sees
+     * the honest values rather than the caller's claim.
+     */
+    const applyHeaderPolicy = (req) => {
+        const removed = headerPolicy.apply(req.headers);
+        if (removed.length)
+            logger.debug("stripped inbound headers", { removed });
     };
     const server = createServer(async (req, res) => {
         const path = (req.url ?? "/").split("?")[0];
@@ -147,10 +189,9 @@ export function startProxy({ publicPort, appPort, gate }) {
         if (path === `${AUTH_PREFIX}/logout` && req.method === "POST") {
             return sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);
         }
-        // Anti-spoof: strip any inbound identity headers on portr traffic - only the
-        // gate may set them, below, for a verified session.
-        delete req.headers["x-forwarded-user"];
-        delete req.headers["x-forwarded-email"];
+        // Anti-spoof: apply the inbound-header allow-list to portr traffic - only the
+        // gate may assert identity, and it does so below for a verified session.
+        applyHeaderPolicy(req);
         // Static (non-API) loads freely so the SPA + <AuthGate> can render. Strip the
         // session cookie so it never leaks to the static handler.
         if (!path.startsWith("/api/")) {
@@ -179,8 +220,7 @@ export function startProxy({ publicPort, appPort, gate }) {
             proxy.ws(req, socket, head);
             return;
         }
-        delete req.headers["x-forwarded-user"];
-        delete req.headers["x-forwarded-email"];
+        applyHeaderPolicy(req);
         if (!(req.url ?? "").startsWith("/api/")) {
             stripSessionCookie(req);
             proxy.ws(req, socket, head);
@@ -204,4 +244,4 @@ export function startProxy({ publicPort, appPort, gate }) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate reverse-proxy.\n *\n * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to\n * the real app on a private loopback port. It is the single front door for both\n * traffic paths into the container:\n *\n *   - **portr client** (same container, connects over LOOPBACK) - the public\n *     tunnel. This is what the gate protects.\n *   - **the hosting platform's front door** (Databricks Apps' control plane, or\n *     any other host reaching the `0.0.0.0` port from a NON-loopback\n *     container-network address) - passed through UNGATED, per the rule \"if it's\n *     not from the portr client, let it in\". The platform already authenticates\n *     that path; the gate exists for the tunnel, which nothing else protects.\n *\n * The distinguisher is the connection's source address: a loopback\n * `req.socket.remoteAddress` is the portr client; anything else is the platform.\n *\n * For portr traffic the gate is a standard SPA gate: static assets + the login\n * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the\n * {@link AuthGateApi}) are open so the browser can load the client and render the\n * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.\n * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport { http, json, log } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport ProxyModule from \"http-proxy-3\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nconst AUTH_PREFIX = \"/api/email/auth\";\n\n/** True when a socket address is loopback (the portr client, same container). */\nfunction isLoopback(addr: string | undefined): boolean {\n  if (!addr) return false;\n  // Normalize IPv4-mapped IPv6 (`::ffff:127.0.0.1`) and bare IPv6 loopback.\n  const a = addr.replace(/^::ffff:/, \"\");\n  return a === \"127.0.0.1\" || a.startsWith(\"127.\") || a === \"::1\" || a === \"localhost\";\n}\n\n/** Read the whole request body as text (small JSON payloads only). */\nfunction readBody(req: IncomingMessage): Promise<string> {\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\nfunction sendJson(res: ServerResponse, status: number, body: unknown, setCookie?: string): void {\n  const headers: Record<string, string> = { \"content-type\": \"application/json\" };\n  if (setCookie) headers[\"set-cookie\"] = setCookie;\n  res.writeHead(status, headers);\n  res.end(JSON.stringify(body));\n}\n\n/** Options for {@link startProxy}. */\nexport interface ProxyOptions {\n  /** Public port to listen on (the container's DATABRICKS_APP_PORT). */\n  publicPort: number;\n  /** Private port the real app listens on (loopback). */\n  appPort: number;\n  /**\n   * The in-process gate API, or `undefined` to run OPEN (insecure mode): every\n   * request - including portr traffic - is forwarded ungated. Used when the\n   * operator passed `--insecure` / `TUNNEL_INSECURE=true`.\n   */\n  gate?: AuthGateApi;\n}\n\n/** Start the gate proxy. Resolves once it is listening. */\nexport function startProxy({ publicPort, appPort, gate }: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: { host: \"127.0.0.1\", port: appPort },\n    ws: true,\n    xfwd: true,\n  });\n  proxy.on(\"error\", (err: Error, _req: unknown, res: unknown) => {\n    logger.warn(\"upstream proxy error\", { error: err.message });\n    const r = res as ServerResponse | undefined;\n    if (r && \"writeHead\" in r && !r.headersSent) {\n      sendJson(r, 502, { error: \"upstream unavailable\" });\n    }\n  });\n\n  /** The session cookie for a verified email, as a Set-Cookie string. */\n  const sessionCookie = (token: string, maxAgeSeconds: number): string =>\n    [\n      `${SESSION_COOKIE_NAME}=${token}`,\n      \"Path=/\",\n      \"HttpOnly\",\n      \"SameSite=Lax\",\n      `Max-Age=${maxAgeSeconds}`,\n      process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\"; \");\n\n  /** Client IP for rate-limiting: the portr-forwarded XFF, else the socket. */\n  const clientIp = (req: IncomingMessage): string => {\n    const fwd = req.headers[\"x-forwarded-for\"];\n    const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(\",\")[0];\n    return (first ?? req.socket.remoteAddress ?? \"unknown\").trim();\n  };\n\n  /**\n   * Remove the gate's session cookie from the `Cookie` header before forwarding,\n   * so the app never sees `dbx_auth` (it is the proxy's concern, not the app's).\n   * Preserves any other cookies. Removes the header entirely when it becomes empty.\n   */\n  const 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 `x-forwarded-user` / `x-forwarded-email` to the verified\n   * address (AppKit reads `x-forwarded-user` for the OBO user id), so the app\n   * needs no gate-specific code path. Any inbound copies are overwritten so a\n   * client can't spoof identity through the gate.\n   */\n  const injectIdentity = (req: IncomingMessage, email: string): void => {\n    req.headers[\"x-forwarded-user\"] = email;\n    req.headers[\"x-forwarded-email\"] = email;\n  };\n\n  const server = createServer(async (req, res) => {\n    const path = (req.url ?? \"/\").split(\"?\")[0]!;\n\n    // Insecure/open mode (no gate) OR non-loopback traffic (the hosting\n    // platform's front door / control plane): forward ungated.\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.web(req, res);\n      return;\n    }\n\n    // --- portr traffic: the gate applies ---\n\n    // The login flow is answered IN-PROCESS (the app has no server to forward to).\n    if (path === `${AUTH_PREFIX}/status`) {\n      const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n      sendJson(res, 200, await gate.status(token));\n      return;\n    }\n    if (path === `${AUTH_PREFIX}/request` && req.method === \"POST\") {\n      const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n      if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n      return sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n    }\n    if (path === `${AUTH_PREFIX}/verify` && req.method === \"POST\") {\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      return sendJson(\n        res,\n        200,\n        { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n        cookie,\n      );\n    }\n    if (path === `${AUTH_PREFIX}/logout` && req.method === \"POST\") {\n      return sendJson(\n        res,\n        200,\n        { ok: true },\n        `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`,\n      );\n    }\n\n    // Anti-spoof: strip any inbound identity headers on portr traffic - only the\n    // gate may set them, below, for a verified session.\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n\n    // Static (non-API) loads freely so the SPA + <AuthGate> can render. Strip the\n    // session cookie so it never leaks to the static handler.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.web(req, res);\n      return;\n    }\n\n    // Every other /api/* requires a valid session.\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(token);\n    if (email) {\n      // Present the OTP user like a platform front door, and drop the gate\n      // cookie so the app sees a clean, front-door-shaped request.\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.web(req, res);\n    } else {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n    }\n  });\n\n  // WebSocket upgrades: forward front-door traffic untouched; gate loopback\n  // (portr) API upgrades the same way as HTTP (strip cookie + inject identity).\n  server.on(\"upgrade\", (req: IncomingMessage, socket: Socket, head: Buffer) => {\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.ws(req, socket, head);\n      return;\n    }\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n    if (!(req.url ?? \"\").startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n      return;\n    }\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    void gate.session(token).then((email) => {\n      if (!email) {\n        socket.destroy();\n        return;\n      }\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n    });\n  });\n\n  return new Promise((resolve) => {\n    server.listen(publicPort, \"0.0.0.0\", () => {\n      logger.info(`gate proxy on 0.0.0.0:${publicPort} -> app 127.0.0.1:${appPort}`);\n      resolve();\n    });\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate reverse-proxy.\n *\n * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to\n * the real app on a private loopback port. It is the single front door for both\n * traffic paths into the container:\n *\n *   - **portr client** (same container, connects over LOOPBACK) - the public\n *     tunnel. This is what the gate protects.\n *   - **the hosting platform's front door** (Databricks Apps' control plane, or\n *     any other host reaching the `0.0.0.0` port from a NON-loopback\n *     container-network address) - passed through UNGATED, per the rule \"if it's\n *     not from the portr client, let it in\". The platform already authenticates\n *     that path; the gate exists for the tunnel, which nothing else protects.\n *\n * The distinguisher is the connection's source address: a loopback\n * `req.socket.remoteAddress` is the portr client; anything else is the platform.\n *\n * For portr traffic the gate is a standard SPA gate: static assets + the login\n * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the\n * {@link AuthGateApi}) are open so the browser can load the client and render the\n * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.\n * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport { http, json, log, token } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport ProxyModule from \"http-proxy-3\";\nimport { toHeaderPolicy, type HeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nconst AUTH_PREFIX = \"/api/email/auth\";\n\n/** True when a socket address is loopback (the portr client, same container). */\nfunction isLoopback(addr: string | undefined): boolean {\n  if (!addr) return false;\n  // Normalize IPv4-mapped IPv6 (`::ffff:127.0.0.1`) and bare IPv6 loopback.\n  const a = addr.replace(/^::ffff:/, \"\");\n  return a === \"127.0.0.1\" || a.startsWith(\"127.\") || a === \"::1\" || a === \"localhost\";\n}\n\n/** Read the whole request body as text (small JSON payloads only). */\nfunction readBody(req: IncomingMessage): Promise<string> {\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\nfunction sendJson(res: ServerResponse, status: number, body: unknown, setCookie?: string): void {\n  const headers: Record<string, string> = { \"content-type\": \"application/json\" };\n  if (setCookie) headers[\"set-cookie\"] = setCookie;\n  res.writeHead(status, headers);\n  res.end(JSON.stringify(body));\n}\n\n/** Options for {@link startProxy}. */\nexport interface ProxyOptions {\n  /** Public port to listen on (the container's DATABRICKS_APP_PORT). */\n  publicPort: number;\n  /** Private port the real app listens on (loopback). */\n  appPort: number;\n  /**\n   * The in-process gate API, or `undefined` to run OPEN (insecure mode): every\n   * request - including portr traffic - is forwarded ungated. Used when the\n   * operator passed `--insecure` / `TUNNEL_INSECURE=true`.\n   */\n  gate?: AuthGateApi;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward, as literals, globs, or\n   * `/regex/`es - unioned with {@link DEFAULT_FORWARD_HEADERS}. Every other `x-`\n   * header is stripped, and {@link PROTECTED_HEADERS} is stripped regardless. See\n   * `./headers.ts` for why the policy is an allow-list.\n   */\n  forwardHeaders?: readonly string[];\n}\n\n/** Start the gate proxy. Resolves once it is listening. */\nexport function startProxy({\n  publicPort,\n  appPort,\n  gate,\n  forwardHeaders,\n}: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: { host: \"127.0.0.1\", port: appPort },\n    ws: true,\n    xfwd: true,\n  });\n  proxy.on(\"error\", (err: Error, _req: unknown, res: unknown) => {\n    logger.warn(\"upstream proxy error\", { error: err.message });\n    const r = res as ServerResponse | undefined;\n    if (r && \"writeHead\" in r && !r.headersSent) {\n      sendJson(r, 502, { error: \"upstream unavailable\" });\n    }\n  });\n\n  // Compiled once: the inbound-header allow-list applied to every gated request.\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"inbound header policy\", { forward: headerPolicy.patterns });\n\n  /** The session cookie for a verified email, as a Set-Cookie string. */\n  const sessionCookie = (token: string, maxAgeSeconds: number): string =>\n    [\n      `${SESSION_COOKIE_NAME}=${token}`,\n      \"Path=/\",\n      \"HttpOnly\",\n      \"SameSite=Lax\",\n      `Max-Age=${maxAgeSeconds}`,\n      process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\"; \");\n\n  /**\n   * Client IP for rate-limiting: the portr client's forwarded XFF, else the socket.\n   *\n   * Deliberately the RIGHTMOST `x-forwarded-for` entry, not the leftmost. The\n   * list grows left-to-right as each hop appends, so the last entry is the one\n   * the nearest trusted proxy (portr) wrote and every earlier entry is a value\n   * the caller could have sent. Reading the leftmost lets a client vary one\n   * header to get a fresh rate-limit bucket per request, which defeats both the\n   * per-IP code-request and verify-attempt limiters. Called BEFORE\n   * {@link HeaderPolicy.apply} strips the header, so the honest hop value is\n   * still available here.\n   */\n  const 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 forwarding,\n   * so the app never sees `dbx_auth` (it is the proxy's concern, not the app's).\n   * Preserves any other cookies. Removes the header entirely when it becomes empty.\n   */\n  const 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's own identity headers to the verified address\n   * (AppKit reads {@link token.USER_ID_HEADER} for the OBO user id), so the app\n   * needs no gate-specific code path. The names come from\n   * `@dbx-tools/shared-core`'s `token` module - the same constants AppKit-side\n   * code reads them by - rather than being re-spelled here.\n   *\n   * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session\n   * proves an email address, not possession of a Databricks credential, and\n   * there is no way to mint one for the caller. Its absence is exactly what\n   * `@dbx-tools/appkit`'s `identity` `\"auto\"` mode detects, so a gated request\n   * runs as the app's service principal instead of throwing.\n   */\n  const 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  /**\n   * Apply the inbound-header policy to a tunnel request: every `x-` header the\n   * allow-list does not name is deleted, and the platform identity/transport set\n   * is deleted regardless. See `./headers.ts` for the reasoning; the\n   * security-critical case is {@link token.ACCESS_TOKEN_HEADER}, which the gate\n   * never sets but an app running `identity: \"auto\"` treats as proof the request\n   * can do OBO.\n   *\n   * `xfwd: true` on the proxy re-adds `x-forwarded-for`/`-proto`/`-port`/`-host`\n   * afterwards from the real socket, so the app still sees those - it just sees\n   * the honest values rather than the caller's claim.\n   */\n  const applyHeaderPolicy = (req: IncomingMessage): void => {\n    const removed = headerPolicy.apply(req.headers as Record<string, unknown>);\n    if (removed.length) logger.debug(\"stripped inbound headers\", { removed });\n  };\n\n  const server = createServer(async (req, res) => {\n    const path = (req.url ?? \"/\").split(\"?\")[0]!;\n\n    // Insecure/open mode (no gate) OR non-loopback traffic (the hosting\n    // platform's front door / control plane): forward ungated.\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.web(req, res);\n      return;\n    }\n\n    // --- portr traffic: the gate applies ---\n\n    // The login flow is answered IN-PROCESS (the app has no server to forward to).\n    if (path === `${AUTH_PREFIX}/status`) {\n      const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n      sendJson(res, 200, await gate.status(token));\n      return;\n    }\n    if (path === `${AUTH_PREFIX}/request` && req.method === \"POST\") {\n      const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n      if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n      return sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n    }\n    if (path === `${AUTH_PREFIX}/verify` && req.method === \"POST\") {\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      return sendJson(\n        res,\n        200,\n        { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n        cookie,\n      );\n    }\n    if (path === `${AUTH_PREFIX}/logout` && req.method === \"POST\") {\n      return sendJson(\n        res,\n        200,\n        { ok: true },\n        `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`,\n      );\n    }\n\n    // Anti-spoof: apply the inbound-header allow-list to portr traffic - only the\n    // gate may assert identity, and it does so below for a verified session.\n    applyHeaderPolicy(req);\n\n    // Static (non-API) loads freely so the SPA + <AuthGate> can render. Strip the\n    // session cookie so it never leaks to the static handler.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.web(req, res);\n      return;\n    }\n\n    // Every other /api/* requires a valid session.\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(token);\n    if (email) {\n      // Present the OTP user like a platform front door, and drop the gate\n      // cookie so the app sees a clean, front-door-shaped request.\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.web(req, res);\n    } else {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n    }\n  });\n\n  // WebSocket upgrades: forward front-door traffic untouched; gate loopback\n  // (portr) API upgrades the same way as HTTP (strip cookie + inject identity).\n  server.on(\"upgrade\", (req: IncomingMessage, socket: Socket, head: Buffer) => {\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.ws(req, socket, head);\n      return;\n    }\n    applyHeaderPolicy(req);\n    if (!(req.url ?? \"\").startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n      return;\n    }\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    void gate.session(token).then((email) => {\n      if (!email) {\n        socket.destroy();\n        return;\n      }\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n    });\n  });\n\n  return new Promise((resolve) => {\n    server.listen(publicPort, \"0.0.0.0\", () => {\n      logger.info(`gate proxy on 0.0.0.0:${publicPort} -> app 127.0.0.1:${appPort}`);\n      resolve();\n    });\n  });\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/allowlist.ts","../src/app.ts","../src/cli.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/proxy.ts","../src/rate-limit.ts","../index.ts","../bin/dbx-tools-tunnel.ts"],"version":"5.9.3"}
+{"root":["../src/allowlist.ts","../src/app.ts","../src/cli.ts","../src/env.ts","../src/headers.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/proxy.ts","../src/rate-limit.ts","../index.ts","../bin/dbx-tools-tunnel.ts"],"version":"5.9.3"}

package/package.json

@@ -29,11 +29,11 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.48",
-    "@dbx-tools/core": "0.6.48",
-    "@dbx-tools/email": "0.6.48",
-    "@dbx-tools/shared-core": "0.6.48",
-    "@dbx-tools/shared-email": "0.6.48",
+    "@dbx-tools/appkit": "0.6.49",
+    "@dbx-tools/core": "0.6.49",
+    "@dbx-tools/email": "0.6.49",
+    "@dbx-tools/shared-core": "0.6.49",
+    "@dbx-tools/shared-email": "0.6.49",
     "commander": "^15.0.0",
     "http-proxy-3": "^1.23.3",
     "jose": "^6.2.3"
@@ -65,6 +65,14 @@
         "types": "./lib/src/cli.d.ts",
         "default": "./lib/src/cli.js"
       },
+      "./env": {
+        "types": "./lib/src/env.d.ts",
+        "default": "./lib/src/env.js"
+      },
+      "./headers": {
+        "types": "./lib/src/headers.d.ts",
+        "default": "./lib/src/headers.js"
+      },
       "./otp": {
         "types": "./lib/src/otp.d.ts",
         "default": "./lib/src/otp.js"
@@ -88,7 +96,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.48",
+  "version": "0.6.49",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -108,6 +116,14 @@
       "types": "./lib/src/cli.d.ts",
       "default": "./lib/src/cli.js"
     },
+    "./env": {
+      "types": "./lib/src/env.d.ts",
+      "default": "./lib/src/env.js"
+    },
+    "./headers": {
+      "types": "./lib/src/headers.d.ts",
+      "default": "./lib/src/headers.js"
+    },
     "./otp": {
       "types": "./lib/src/otp.d.ts",
       "default": "./lib/src/otp.js"

package/src/allowlist.ts

@@ -1,17 +1,22 @@
 /**
  * Unified access allow-list matching for the email-OTP gate.
  *
- * Each pattern in the configured list is one of three shapes, tried in order:
+ * Each pattern in the configured list is one of three shapes:
  *
  *   - **domain shortcut** - `example.com` or `@example.com`: matches any
- *     address whose domain equals it (case-insensitive). The leading `@` is
- *     optional and stripped.
- *   - **glob** - contains `*` or `?`, e.g. `*.example.com` or
- *     `*@example.com`: matched against the WHOLE address with shell-style
- *     wildcards (`*` = any run, `?` = one char).
- *   - **regex** - wrapped in slashes, `/.../ [flags]`: compiled and tested
- *     against the whole address. An invalid regex never matches (it is skipped
- *     with a warning rather than throwing).
+ *     address whose domain equals it. This is the gate's OWN semantic (a bare
+ *     value means "the domain", not "the whole address"), so it is handled here.
+ *   - **glob** - contains `*` or `?`, e.g. `*@example.com`: matched against the
+ *     WHOLE address with shell-style wildcards.
+ *   - **regex** - wrapped in slashes, `/.../ [flags]`: tested against the whole
+ *     address. An invalid regex never matches (it is skipped with a warning
+ *     rather than throwing).
+ *
+ * Only the first shape is this module's business: the glob and regex shapes are
+ * delegated to `@dbx-tools/shared-core`'s {@link pattern.toPattern}, which is
+ * where that compilation lives for every allow-list in the repo (the tunnel's
+ * inbound-header policy uses the same one). Matching is case-insensitive
+ * throughout.
  *
  * An EMPTY list matches nobody (fail closed): an app that enables the gate but
  * configures no patterns lets no one in, which is the safe default.
@@ -19,58 +24,25 @@
  * @module
  */
 
-import { log } from "@dbx-tools/shared-core";
-
-const logger = log.logger("tunnel:allowlist");
-
-/** Escape a string for literal use inside a `RegExp`. */
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/** Compile a shell-style glob (`*`, `?`) into an anchored, case-insensitive RegExp. */
-function globToRegExp(glob: string): RegExp {
-  const body = glob
-    .split(/([*?])/)
-    .map((part) => (part === "*" ? ".*" : part === "?" ? "." : escapeRegExp(part)))
-    .join("");
-  return new RegExp(`^${body}$`, "i");
-}
-
-/** Parse a `/pattern/flags` string into a RegExp, or `undefined` if malformed. */
-function parseRegexLiteral(pattern: string): RegExp | undefined {
-  const match = /^\/(.+)\/([a-z]*)$/is.exec(pattern);
-  if (!match) return undefined;
-  try {
-    const flags = match[2]!.includes("i") ? match[2]! : `${match[2]!}i`;
-    return new RegExp(match[1]!, flags);
-  } catch (error) {
-    logger.warn("ignoring invalid regex allow-list pattern", { pattern, error });
-    return undefined;
-  }
-}
+import { pattern } from "@dbx-tools/shared-core";
 
 /** True when `email` matches a single allow-list `pattern`. */
-function matchesPattern(email: string, pattern: string): boolean {
-  const trimmed = pattern.trim();
+function matchesPattern(email: string, entry: string): boolean {
+  const trimmed = entry.trim();
   if (!trimmed) return false;
   const address = email.trim().toLowerCase();
 
-  // Regex literal: /.../
-  if (trimmed.startsWith("/")) {
-    const re = parseRegexLiteral(trimmed);
-    return re ? re.test(address) : false;
-  }
-
-  // Glob: contains a wildcard.
-  if (trimmed.includes("*") || trimmed.includes("?")) {
-    return globToRegExp(trimmed).test(address);
+  // A bare value with no wildcard and no regex delimiters is a DOMAIN shortcut,
+  // the one shape shared-core cannot infer: there it would mean whole-string
+  // equality against the address, which is never what an operator writing
+  // `example.com` in an access list intends.
+  if (!trimmed.startsWith("/") && !trimmed.includes("*") && !trimmed.includes("?")) {
+    const domain = trimmed.replace(/^@/, "").toLowerCase();
+    const at = address.lastIndexOf("@");
+    return at >= 0 && address.slice(at + 1) === domain;
   }
 
-  // Domain shortcut: `@d.com` or `d.com` -> match the address's domain.
-  const domain = trimmed.replace(/^@/, "").toLowerCase();
-  const at = address.lastIndexOf("@");
-  return at >= 0 && address.slice(at + 1) === domain;
+  return pattern.toPattern(trimmed)?.(address) ?? false;
 }
 
 /**
@@ -79,7 +51,7 @@ function matchesPattern(email: string, pattern: string): boolean {
  */
 export function matchesAllowlist(email: string, patterns: readonly string[] | undefined): boolean {
   if (!email || !patterns || patterns.length === 0) return false;
-  return patterns.some((pattern) => matchesPattern(email, pattern));
+  return patterns.some((entry) => matchesPattern(email, entry));
 }
 
 /** Rough shape check so a clearly-invalid address is rejected before any work. */