@dbx-tools/tunnel 0.6.60 → 0.6.61

package/lib/src/gate.js

@@ -0,0 +1,196 @@
+/**
+ * The tunnel's in-app AUTH GATE - Express middleware + login routes the
+ * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.
+ *
+ * This replaces the old standalone reverse-proxy (`proxy.ts`): the app is now the
+ * process, so there is nothing to forward to. Instead the gate is middleware that
+ * either short-circuits (401, or answers the open login routes) or calls `next()`
+ * to let the app's real handlers run. It is the "stands in for AppKit auth" path:
+ * a portr caller proves an email via OTP, and on success the gate injects the
+ * identity headers AppKit reads, so a gated request runs like a front-door one.
+ *
+ * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client
+ * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that
+ * PRESERVES the original `Host`, so tunnel requests arrive with
+ * `Host: <subdomain>.<server>` (the public domain). A local process hitting the
+ * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose
+ * `Host` matches the configured public domain are gated; the platform front door
+ * and any other local client pass through untouched. There is no portr-injected
+ * identifying header and no TCP/source-IP signal to use instead (the client dials
+ * the target over plain loopback).
+ *
+ * @module
+ */
+import { http, json, log, token } from "@dbx-tools/shared-core";
+import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
+import { toHeaderPolicy } from "./headers.js";
+const logger = log.logger("tunnel:gate");
+/** Route prefix the login flow lives under (open, answered in-process). */
+export const AUTH_PREFIX = "/api/email/auth";
+/**
+ * True when the request's `Host` is the tunnel's public domain - i.e. it came in
+ * over portr. Case-insensitive; the optional `:port` is ignored. When no public
+ * domain is configured, nothing is tunnel traffic.
+ */
+export function isTunnelHost(req, publicDomain) {
+    if (!publicDomain)
+        return false;
+    const host = (req.headers.host ?? "").toLowerCase().split(":")[0];
+    return host === publicDomain.toLowerCase().split(":")[0];
+}
+/** The session cookie for a verified email, as a Set-Cookie string. */
+function sessionCookie(value, maxAgeSeconds) {
+    return [
+        `${SESSION_COOKIE_NAME}=${value}`,
+        "Path=/",
+        "HttpOnly",
+        "SameSite=Lax",
+        `Max-Age=${maxAgeSeconds}`,
+        // Real enforcement in production: the session cookie must be Secure so it is
+        // never sent over plaintext. Local dev (http) omits it so the cookie works.
+        process.env.NODE_ENV === "production" ? "Secure" : "",
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
+/**
+ * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value
+ * the nearest trusted hop - portr - wrote), else the socket address. Reading the
+ * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by
+ * varying the header. Called before {@link stripHeaders}.
+ */
+function clientIp(req) {
+    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 the app's
+ * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).
+ * Preserves other cookies; deletes the header when it becomes empty.
+ */
+function stripSessionCookie(req) {
+    const raw = req.headers.cookie;
+    if (!raw)
+        return;
+    const kept = raw
+        .split(";")
+        .map((c) => c.trim())
+        .filter((c) => c && !c.startsWith(`${SESSION_COOKIE_NAME}=`));
+    if (kept.length)
+        req.headers.cookie = kept.join("; ");
+    else
+        delete req.headers.cookie;
+}
+/**
+ * Present an OTP-authenticated caller to the app the SAME way a platform front
+ * door does: set the front-door identity headers to the verified address (AppKit
+ * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no
+ * gate-specific code path.
+ *
+ * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session
+ * proves an email, not possession of a Databricks credential. Its absence is what
+ * `@dbx-tools/appkit`'s `identity: "auto"` detects, so a gated request runs as the
+ * app service principal instead of throwing.
+ */
+function injectIdentity(req, email) {
+    req.headers[token.USER_ID_HEADER] = email;
+    req.headers[token.USER_EMAIL_HEADER] = email;
+}
+function sendJson(res, status, body, setCookie) {
+    if (setCookie)
+        res.setHeader("set-cookie", setCookie);
+    res.status(status).json(body);
+}
+/** Read the raw request body as text (AppKit parses JSON, but the gate routes
+ * are mounted before that runs for tunnel traffic, so read defensively). */
+function readBody(req) {
+    // AppKit's json body-parser may have already populated req.body; prefer it.
+    if (req.body !== undefined && req.body !== null) {
+        return Promise.resolve(typeof req.body === "string" ? req.body : JSON.stringify(req.body));
+    }
+    return new Promise((resolve) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => resolve(data));
+        req.on("error", () => resolve(data));
+    });
+}
+/**
+ * Register the login routes and the gating middleware on the app's Express
+ * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
+ * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.
+ *
+ * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login
+ * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),
+ * not under the plugin's `/api/authGate` base.
+ */
+export function mountGate(opts, addRoute, addMiddleware) {
+    const { gate, publicDomain, forwardHeaders } = opts;
+    const headerPolicy = toHeaderPolicy(forwardHeaders);
+    logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
+    const applyHeaderPolicy = (req) => {
+        const removed = headerPolicy.apply(req.headers);
+        if (removed.length)
+            logger.debug("stripped inbound headers", { removed });
+    };
+    // --- Login routes (open on tunnel traffic; answered in-process) ---
+    const statusHandler = (async (req, res) => {
+        const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
+        sendJson(res, 200, await gate.status(cookie));
+    });
+    const requestHandler = (async (req, res) => {
+        const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));
+        if (!parsed.success)
+            return sendJson(res, 200, { ok: true }); // anti-enumeration
+        sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));
+    });
+    const verifyHandler = (async (req, res) => {
+        const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));
+        if (!parsed.success)
+            return sendJson(res, 200, { ok: false });
+        const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));
+        const cookie = result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;
+        sendJson(res, 200, { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) }, cookie);
+    });
+    const logoutHandler = ((_req, res) => {
+        sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);
+    });
+    addRoute("get", `${AUTH_PREFIX}/status`, statusHandler);
+    addRoute("post", `${AUTH_PREFIX}/request`, requestHandler);
+    addRoute("post", `${AUTH_PREFIX}/verify`, verifyHandler);
+    addRoute("post", `${AUTH_PREFIX}/logout`, logoutHandler);
+    // --- The gate middleware (runs before static + the app's /api handlers) ---
+    const gateMiddleware = (async (req, res, next) => {
+        // Not tunnel traffic (platform front door, or any other local caller): the
+        // request is already authenticated (or is not ours to gate). Pass through.
+        if (!isTunnelHost(req, publicDomain))
+            return next();
+        const path = (req.url ?? "/").split("?")[0] ?? "/";
+        // The login flow is open so the browser can render <AuthGate> and sign in.
+        if (path.startsWith(AUTH_PREFIX))
+            return next();
+        // Anti-spoof: only the gate may assert identity on tunnel traffic.
+        applyHeaderPolicy(req);
+        // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
+        if (!path.startsWith("/api/")) {
+            stripSessionCookie(req);
+            return next();
+        }
+        // Every other /api/* needs a valid OTP session.
+        const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
+        const email = await gate.session(cookie);
+        if (!email) {
+            sendJson(res, 401, { error: "authentication required", loginPath: AUTH_PREFIX });
+            return;
+        }
+        injectIdentity(req, email);
+        stripSessionCookie(req);
+        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 * This replaces the old standalone reverse-proxy (`proxy.ts`): the app is now the\n * process, so there is nothing to forward to. Instead the gate is middleware that\n * either short-circuits (401, or answers the open login routes) or calls `next()`\n * to let the app's real handlers run. It is the \"stands in for AppKit auth\" path:\n * a portr caller proves an email via OTP, and on success the gate injects the\n * identity headers AppKit reads, so a gated request runs like a front-door one.\n *\n * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client\n * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that\n * PRESERVES the original `Host`, so tunnel requests arrive with\n * `Host: <subdomain>.<server>` (the public domain). A local process hitting the\n * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose\n * `Host` matches the configured public domain are gated; the platform front door\n * and any other local client pass through untouched. There is no portr-injected\n * identifying header and no TCP/source-IP signal to use instead (the client dials\n * the target over plain loopback).\n *\n * @module\n */\n\nimport { http, json, log, token } from \"@dbx-tools/shared-core\";\nimport type { Request, RequestHandler, Response } from \"express\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport { toHeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:gate\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nexport const AUTH_PREFIX = \"/api/email/auth\";\n\n/** Options for {@link mountGate}. */\nexport interface GateOptions {\n  /** The in-process gate API (session/request/verify/status). */\n  gate: AuthGateApi;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.\n   * When absent, no request is ever classified as tunnel traffic and the gate is\n   * inert (everything passes through) - a tunnel with no public domain gates\n   * nothing.\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (unioned with the\n   * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.\n   */\n  forwardHeaders?: readonly string[];\n}\n\n/**\n * True when the request's `Host` is the tunnel's public domain - i.e. it came in\n * over portr. Case-insensitive; the optional `:port` is ignored. When no public\n * domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(req: Request, publicDomain: string | undefined): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  return host === publicDomain.toLowerCase().split(\":\")[0];\n}\n\n/** The session cookie for a verified email, as a Set-Cookie string. */\nfunction sessionCookie(value: string, maxAgeSeconds: number): string {\n  return [\n    `${SESSION_COOKIE_NAME}=${value}`,\n    \"Path=/\",\n    \"HttpOnly\",\n    \"SameSite=Lax\",\n    `Max-Age=${maxAgeSeconds}`,\n    // Real enforcement in production: the session cookie must be Secure so it is\n    // never sent over plaintext. Local dev (http) omits it so the cookie works.\n    process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n  ]\n    .filter(Boolean)\n    .join(\"; \");\n}\n\n/**\n * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value\n * the nearest trusted hop - portr - wrote), else the socket address. Reading the\n * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by\n * varying the header. Called before {@link stripHeaders}.\n */\nfunction clientIp(req: Request): 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: Request): void {\n  const raw = req.headers.cookie;\n  if (!raw) return;\n  const kept = raw\n    .split(\";\")\n    .map((c) => c.trim())\n    .filter((c) => c && !c.startsWith(`${SESSION_COOKIE_NAME}=`));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present an OTP-authenticated caller to the app the SAME way a platform front\n * door does: set the front-door identity headers to the verified address (AppKit\n * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no\n * gate-specific code path.\n *\n * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session\n * proves an email, not possession of a Databricks credential. Its absence is what\n * `@dbx-tools/appkit`'s `identity: \"auto\"` detects, so a gated request runs as the\n * app service principal instead of throwing.\n */\nfunction injectIdentity(req: Request, email: string): void {\n  req.headers[token.USER_ID_HEADER] = email;\n  req.headers[token.USER_EMAIL_HEADER] = email;\n}\n\nfunction sendJson(res: Response, status: number, body: unknown, setCookie?: string): void {\n  if (setCookie) res.setHeader(\"set-cookie\", setCookie);\n  res.status(status).json(body);\n}\n\n/** Read the raw request body as text (AppKit parses JSON, but the gate routes\n * are mounted before that runs for tunnel traffic, so read defensively). */\nfunction readBody(req: Request): Promise<string> {\n  // AppKit's json body-parser may have already populated req.body; prefer it.\n  if (req.body !== undefined && req.body !== null) {\n    return Promise.resolve(typeof req.body === \"string\" ? req.body : JSON.stringify(req.body));\n  }\n  return new Promise((resolve) => {\n    let data = \"\";\n    req.on(\"data\", (chunk) => (data += chunk));\n    req.on(\"end\", () => resolve(data));\n    req.on(\"error\", () => resolve(data));\n  });\n}\n\n/**\n * Register the login routes and the gating middleware on the app's Express\n * instance. Called from {@link AuthGatePlugin} with the router AppKit hands\n * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.\n *\n * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login\n * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),\n * not under the plugin's `/api/authGate` base.\n */\nexport function mountGate(\n  opts: GateOptions,\n  addRoute: (method: \"get\" | \"post\", path: string, handler: RequestHandler) => void,\n  addMiddleware: (path: string, handler: RequestHandler) => void,\n): void {\n  const { gate, publicDomain, forwardHeaders } = opts;\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"gate mounted\", { publicDomain, forward: headerPolicy.patterns });\n\n  const applyHeaderPolicy = (req: Request): 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  // --- Login routes (open on tunnel traffic; answered in-process) ---\n\n  const statusHandler = (async (req, res) => {\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    sendJson(res, 200, await gate.status(cookie));\n  }) as RequestHandler;\n\n  const requestHandler = (async (req, res) => {\n    const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n    sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n  }) as RequestHandler;\n\n  const verifyHandler = (async (req, res) => {\n    const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: false });\n    const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));\n    const cookie =\n      result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;\n    sendJson(\n      res,\n      200,\n      { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n      cookie,\n    );\n  }) as RequestHandler;\n\n  const logoutHandler = ((_req, res) => {\n    sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);\n  }) as RequestHandler;\n\n  addRoute(\"get\", `${AUTH_PREFIX}/status`, statusHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/request`, requestHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/verify`, verifyHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/logout`, logoutHandler);\n\n  // --- The gate middleware (runs before static + the app's /api handlers) ---\n\n  const gateMiddleware = (async (req, res, next) => {\n    // Not tunnel traffic (platform front door, or any other local caller): the\n    // request is already authenticated (or is not ours to gate). Pass through.\n    if (!isTunnelHost(req, publicDomain)) return next();\n\n    const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n\n    // The login flow is open so the browser can render <AuthGate> and sign in.\n    if (path.startsWith(AUTH_PREFIX)) return next();\n\n    // Anti-spoof: only the gate may assert identity on tunnel traffic.\n    applyHeaderPolicy(req);\n\n    // Static (non-API) loads freely so the SPA can render; drop the gate cookie.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      return next();\n    }\n\n    // Every other /api/* needs a valid OTP session.\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(cookie);\n    if (!email) {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n      return;\n    }\n    injectIdentity(req, email);\n    stripSessionCookie(req);\n    next();\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}

package/lib/src/interceptor.d.ts

@@ -16,10 +16,10 @@
  *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown
  *      also stops portr.
  *
- * The email-OTP GATE is a separate concern: it is the {@link authGate} AppKit
- * plugin plus the {@link startProxy} reverse-proxy, both exported from this package
- * for an app that wants to gate the tunnelled traffic. This interceptor is only the
- * portr half - "update the host, bind portr" - matching the smallest useful unit.
+ * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
+ * which registers the login routes + a gating middleware on the app's own server.
+ * Register it in the app's `plugins` for gated traffic. This interceptor is only
+ * the portr half - "update the host, bind portr" - the smallest useful unit.
  *
  * @module
  */

package/lib/src/interceptor.js

@@ -16,10 +16,10 @@
  *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown
  *      also stops portr.
  *
- * The email-OTP GATE is a separate concern: it is the {@link authGate} AppKit
- * plugin plus the {@link startProxy} reverse-proxy, both exported from this package
- * for an app that wants to gate the tunnelled traffic. This interceptor is only the
- * portr half - "update the host, bind portr" - matching the smallest useful unit.
+ * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
+ * which registers the login routes + a gating middleware on the app's own server.
+ * Register it in the app's `plugins` for gated traffic. This interceptor is only
+ * the portr half - "update the host, bind portr" - the smallest useful unit.
  *
  * @module
  */
@@ -81,4 +81,4 @@ export function tunnelInterceptor(options = {}) {
         logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE5F,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAgBhD,qFAAqF;AACrF,SAAS,iBAAiB,CAAC,IAAa;IACtC,OAAO,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,IAAI,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAoC,EAAE;IACtE,OAAO,CAAC,GAAuB,EAAQ,EAAE;QACvC,6EAA6E;QAC7E,8EAA8E;QAC9E,6DAA6D;QAC7D,IAAI,GAAG,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,eAAe,KAAK,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC;QACzD,CAAC;QAED,gFAAgF;QAChF,gFAAgF;QAChF,qDAAqD;QACrD,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,kBAAkB,CAAC;YACrC,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,IAAI;SACL,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,4EAA4E,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QAED,+EAA+E;QAC/E,MAAM,QAAQ,GAAG,YAAY,EAAE,CAAC;QAChC,gBAAgB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAChD,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAEvB,+EAA+E;QAC/E,2DAA2D;QAC3D,GAAG,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE;YAC/B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,2BAA2B,IAAI,KAAK,WAAW,CAAC,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IAClG,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.\n * Instead of the tunnel being the main process that spawns the app as a child, the\n * APP is the main process and hands this interceptor its context. The interceptor:\n *\n *   1. applies the workspace host the context computed to `process.env`\n *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;\n *   2. installs + launches portr, pointed at the app's PUBLIC port;\n *   3. `bindProcess`es portr so the app and the tunnel live and die as one -\n *      signals pass through and either death tears the pair down (the\n *      concurrently-style supervision that used to be `superviseExit`);\n *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown\n *      also stops portr.\n *\n * The email-OTP GATE is a separate concern: it is the {@link authGate} AppKit\n * plugin plus the {@link startProxy} reverse-proxy, both exported from this package\n * for an app that wants to gate the tunnelled traffic. This interceptor is only the\n * portr half - \"update the host, bind portr\" - matching the smallest useful unit.\n *\n * @module\n */\n\nimport type { Interceptor, InterceptorContext } from \"@dbx-tools/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** portr `<subdomain>.<server>` to serve on. Env `TUNNEL_PUBLIC_DOMAIN`. */\n  publicDomain?: string;\n  /** portr subdomain (else derived from {@link publicDomain}). */\n  subdomain?: string;\n  /**\n   * The PUBLIC port portr forwards to - the port the app itself listens on.\n   * Defaults to the Databricks Apps runtime contract `DATABRICKS_APP_PORT`\n   * (then `8000`), which is the port the platform routes to.\n   */\n  port?: number;\n}\n\n/** Resolve the public port portr should target: explicit, else the Apps contract. */\nfunction resolvePublicPort(port?: number): number {\n  return port ?? Number(process.env.DATABRICKS_APP_PORT ?? 8000);\n}\n\n/**\n * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.\n *\n * A no-op (logs and returns) when no portr tunnel is configured - no `PORTR_TOKEN`\n * or no resolvable `<subdomain>.<server>` - so an app can register it\n * unconditionally and only actually tunnels where the deployment wired portr.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {\n  return (ctx: InterceptorContext): void => {\n    // 1. Apply the computed workspace host so portr + the SDK agree. The context\n    //    already resolved it (from the env / auto-config); set it only when it is\n    //    known and not already present, so an explicit env wins.\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    // 2. Resolve portr wiring. No token / domain -> no tunnel; leave the app alone.\n    //    `resolvePortrConfig` already falls back to TUNNEL_PUBLIC_DOMAIN itself, so\n    //    the explicit option is passed straight through.\n    const port = resolvePublicPort(options.port);\n    const portrConfig = resolvePortrConfig({\n      publicDomain: options.publicDomain,\n      subdomain: options.subdomain,\n      port,\n    });\n    if (!portrConfig) {\n      logger.info(\"no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - the app runs without a public tunnel\");\n      return;\n    }\n\n    // 3. Install + launch portr, then bind it: the app and portr now share a fate.\n    const portrEnv = installPortr();\n    writePortrConfig(portrConfig, portrEnv);\n    const portr = startPortr(portrConfig, portrEnv);\n    ctx.bindProcess(portr);\n\n    // 4. An orderly AppKit shutdown also stops portr (belt-and-suspenders with the\n    //    signal pass-through `bindProcess` already installed).\n    ctx.onLifecycle(\"shutdown\", () => {\n      if (!portr.killed) portr.kill(\"SIGTERM\");\n    });\n\n    logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE5F,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAgBhD,qFAAqF;AACrF,SAAS,iBAAiB,CAAC,IAAa;IACtC,OAAO,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,IAAI,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAoC,EAAE;IACtE,OAAO,CAAC,GAAuB,EAAQ,EAAE;QACvC,6EAA6E;QAC7E,8EAA8E;QAC9E,6DAA6D;QAC7D,IAAI,GAAG,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,eAAe,KAAK,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC;QACzD,CAAC;QAED,gFAAgF;QAChF,gFAAgF;QAChF,qDAAqD;QACrD,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,kBAAkB,CAAC;YACrC,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,IAAI;SACL,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,4EAA4E,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QAED,+EAA+E;QAC/E,MAAM,QAAQ,GAAG,YAAY,EAAE,CAAC;QAChC,gBAAgB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAChD,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAEvB,+EAA+E;QAC/E,2DAA2D;QAC3D,GAAG,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE;YAC/B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,2BAA2B,IAAI,KAAK,WAAW,CAAC,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IAClG,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.\n * Instead of the tunnel being the main process that spawns the app as a child, the\n * APP is the main process and hands this interceptor its context. The interceptor:\n *\n *   1. applies the workspace host the context computed to `process.env`\n *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;\n *   2. installs + launches portr, pointed at the app's PUBLIC port;\n *   3. `bindProcess`es portr so the app and the tunnel live and die as one -\n *      signals pass through and either death tears the pair down (the\n *      concurrently-style supervision that used to be `superviseExit`);\n *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown\n *      also stops portr.\n *\n * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,\n * which registers the login routes + a gating middleware on the app's own server.\n * Register it in the app's `plugins` for gated traffic. This interceptor is only\n * the portr half - \"update the host, bind portr\" - the smallest useful unit.\n *\n * @module\n */\n\nimport type { Interceptor, InterceptorContext } from \"@dbx-tools/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** portr `<subdomain>.<server>` to serve on. Env `TUNNEL_PUBLIC_DOMAIN`. */\n  publicDomain?: string;\n  /** portr subdomain (else derived from {@link publicDomain}). */\n  subdomain?: string;\n  /**\n   * The PUBLIC port portr forwards to - the port the app itself listens on.\n   * Defaults to the Databricks Apps runtime contract `DATABRICKS_APP_PORT`\n   * (then `8000`), which is the port the platform routes to.\n   */\n  port?: number;\n}\n\n/** Resolve the public port portr should target: explicit, else the Apps contract. */\nfunction resolvePublicPort(port?: number): number {\n  return port ?? Number(process.env.DATABRICKS_APP_PORT ?? 8000);\n}\n\n/**\n * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.\n *\n * A no-op (logs and returns) when no portr tunnel is configured - no `PORTR_TOKEN`\n * or no resolvable `<subdomain>.<server>` - so an app can register it\n * unconditionally and only actually tunnels where the deployment wired portr.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {\n  return (ctx: InterceptorContext): void => {\n    // 1. Apply the computed workspace host so portr + the SDK agree. The context\n    //    already resolved it (from the env / auto-config); set it only when it is\n    //    known and not already present, so an explicit env wins.\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    // 2. Resolve portr wiring. No token / domain -> no tunnel; leave the app alone.\n    //    `resolvePortrConfig` already falls back to TUNNEL_PUBLIC_DOMAIN itself, so\n    //    the explicit option is passed straight through.\n    const port = resolvePublicPort(options.port);\n    const portrConfig = resolvePortrConfig({\n      publicDomain: options.publicDomain,\n      subdomain: options.subdomain,\n      port,\n    });\n    if (!portrConfig) {\n      logger.info(\"no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - the app runs without a public tunnel\");\n      return;\n    }\n\n    // 3. Install + launch portr, then bind it: the app and portr now share a fate.\n    const portrEnv = installPortr();\n    writePortrConfig(portrConfig, portrEnv);\n    const portr = startPortr(portrConfig, portrEnv);\n    ctx.bindProcess(portr);\n\n    // 4. An orderly AppKit shutdown also stops portr (belt-and-suspenders with the\n    //    signal pass-through `bindProcess` already installed).\n    ctx.onLifecycle(\"shutdown\", () => {\n      if (!portr.killed) portr.kill(\"SIGTERM\");\n    });\n\n    logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);\n  };\n}\n"]}

package/lib/src/plugin.d.ts

@@ -17,6 +17,14 @@
  */
 import { Plugin, type BasePluginConfig } from "@databricks/appkit";
 import type { AuthStatus } from "@dbx-tools/shared-email";
+import type { RequestHandler } from "express";
+import { type GateOptions } from "./gate.ts";
+interface GateMountContext {
+    addRoute(method: string, path: string, handler: RequestHandler): void;
+    addMiddleware(path: string, handler: RequestHandler): void;
+    getPlugins(): ReadonlyMap<string, unknown>;
+}
+export declare function mountGateOnContext(context: GateMountContext, options: GateOptions): void;
 /** Options for the {@link authGate} plugin (all resolvable from env - see below). */
 export interface AuthGateConfig extends BasePluginConfig {
     /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */
@@ -72,8 +80,31 @@ export interface AuthGateConfig extends BasePluginConfig {
      * means no cutoff.
      */
     sessionCutoff?: string | number | Date;
-    /** Deliver a code to an address. Wired by the app to the email plugin. */
+    /**
+     * Deliver a code to an address. Defaults to sending through the host app's
+     * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a
+     * different delivery path.
+     */
     sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;
+    /**
+     * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`
+     * header. Only requests whose `Host` matches this are gated; everything else
+     * (the platform front door, other local callers) passes through. Env
+     * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel
+     * traffic).
+     */
+    publicDomain?: string;
+    /**
+     * Extra `x-` request headers tunnel traffic may forward (literal / glob /
+     * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.
+     */
+    forwardHeaders?: string | string[];
+    /**
+     * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate
+     * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when
+     * the tunnel is deliberately public.
+     */
+    insecure?: boolean;
 }
 /** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */
 export interface SendCodeOptions {
@@ -99,10 +130,16 @@ export interface ResolvedAuthGateConfig {
     maxAttempts: number;
     /** Force-clear cutoff in epoch ms; `0` when unset. */
     sessionCutoffMs: number;
+    /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */
+    publicDomain?: string;
+    /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */
+    forwardHeaders: string[];
+    /** Run OPEN with no gate. */
+    insecure: boolean;
 }
 /** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
 export declare function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig;
-/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */
+/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */
 export interface AuthGateApi {
     /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */
     request(email: string, ip: string): Promise<{
@@ -122,7 +159,13 @@ export interface AuthGateApi {
     /** The gate status payload (`enabled` is always true when this plugin runs). */
     status(token: string | undefined): Promise<AuthStatus>;
 }
-/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */
+/**
+ * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login
+ * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express
+ * server via `this.context`, so a public portr caller must prove an email before
+ * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and
+ * other local callers pass through untouched (the gate keys on the `Host` header).
+ */
 export declare class AuthGatePlugin extends Plugin<AuthGateConfig> {
     static manifest: {
         name: "authGate";
@@ -139,9 +182,20 @@ export declare class AuthGatePlugin extends Plugin<AuthGateConfig> {
     private readonly requestLimiter;
     private readonly verifyLimiter;
     setup(): Promise<void>;
+    /**
+     * Register the login routes (`/api/email/auth/*`) and the gating middleware on
+     * the app's OWN Express server. At `setup:complete`, the deferred server plugin
+     * has constructed its Express app but has not injected plugin routes or static
+     * handling, so direct registration puts the gate first. The context's buffered
+     * route API remains a fallback for compatible non-standard server plugins.
+     */
+    private mountGateRoutes;
+    /** The code sender: the configured `sendCode`, else the shared-transport default. */
+    private get sendCode();
     exports(): AuthGateApi;
     private handleRequest;
     private handleVerify;
 }
 /** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
 export declare const authGate: import("@databricks/appkit").ToPlugin<typeof AuthGatePlugin, AuthGateConfig, "authGate">;
+export {};