@dbx-tools/cli-tunnel 0.6.59 → 0.6.85

package/lib/src/proxy.js

@@ -1,247 +1,142 @@
 /**
- * The tunnel gate reverse-proxy.
+ * The reverse proxy that makes the wrapper path possible.
  *
- * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to
- * the real app on a private loopback port. It is the single front door for both
- * traffic paths into the container:
+ * The wrapper claims the PUBLIC port and the wrapped app runs as a child process
+ * on a private loopback port, so - unlike the in-process plugin - there is no
+ * middleware chain to insert the gate into. This proxy is that insertion point: it
+ * answers the login routes itself, applies the gate to everything else, and
+ * forwards what survives to the child.
  *
- *   - **portr client** (same container, connects over LOOPBACK) - the public
- *     tunnel. This is what the gate protects.
- *   - **the hosting platform's front door** (Databricks Apps' control plane, or
- *     any other host reaching the `0.0.0.0` port from a NON-loopback
- *     container-network address) - passed through UNGATED, per the rule "if it's
- *     not from the portr client, let it in". The platform already authenticates
- *     that path; the gate exists for the tunnel, which nothing else protects.
- *
- * The distinguisher is the connection's source address: a loopback
- * `req.socket.remoteAddress` is the portr client; anything else is the platform.
- *
- * For portr traffic the gate is a standard SPA gate: static assets + the login
- * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the
- * {@link AuthGateApi}) are open so the browser can load the client and render the
- * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.
- * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.
+ * The gating DECISION is not reimplemented here. `@dbx-tools/tunnel`'s
+ * `gate.gateRequest` makes it - the same function the Express middleware calls -
+ * and this module only differs in how the outcome is written: a proxied request
+ * instead of `next()`, a `writeHead` instead of `res.json`. That is deliberate:
+ * two independent implementations of "which requests are gated and which headers
+ * are stripped" is the one way this package could become a security bug.
  *
  * @module
  */
 import { createServer } from "node:http";
-import { http, json, log, token } from "@dbx-tools/shared-core";
+import { http, json, log } from "@dbx-tools/shared-core";
 import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
+import { gate as gateModule, headers as headersModule } from "@dbx-tools/tunnel";
 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";
-/** True when a socket address is loopback (the portr client, same container). */
-function isLoopback(addr) {
-    if (!addr)
-        return false;
-    // Normalize IPv4-mapped IPv6 (`::ffff:127.0.0.1`) and bare IPv6 loopback.
-    const a = addr.replace(/^::ffff:/, "");
-    return a === "127.0.0.1" || a.startsWith("127.") || a === "::1" || a === "localhost";
-}
-/** Read the whole request body as text (small JSON payloads only). */
-function readBody(req) {
+/** Read a request body as text; a transport error yields whatever arrived. */
+function readBody(request) {
     return new Promise((resolve) => {
-        let data = "";
-        req.on("data", (chunk) => (data += chunk));
-        req.on("end", () => resolve(data));
-        req.on("error", () => resolve(data));
+        let body = "";
+        request.on("data", (chunk) => (body += chunk));
+        request.on("end", () => resolve(body));
+        request.on("error", () => resolve(body));
+    });
+}
+function sendJson(response, status, body, setCookie) {
+    response.writeHead(status, {
+        "content-type": "application/json",
+        ...(setCookie ? { "set-cookie": setCookie } : {}),
     });
+    response.end(JSON.stringify(body));
 }
-function sendJson(res, status, body, setCookie) {
-    const headers = { "content-type": "application/json" };
-    if (setCookie)
-        headers["set-cookie"] = setCookie;
-    res.writeHead(status, headers);
-    res.end(JSON.stringify(body));
+function sessionCookieValue(request) {
+    return http.parseCookies(request.headers.cookie ?? null)[SESSION_COOKIE_NAME];
 }
-/** Start the gate proxy. Resolves once it is listening. */
-export function startProxy({ publicPort, appPort, gate, forwardHeaders, }) {
+/**
+ * Answer one of the four login routes, or return `false` when the request is not
+ * one of them. Mirrors the plugin's route handlers: `request` always reports
+ * success (anti-enumeration) and `verify` sets the session cookie on success.
+ */
+async function handleAuthRoute(request, response, path, gate) {
+    const prefix = gateModule.AUTH_PREFIX;
+    const ip = gateModule.clientIp(request);
+    if (path === `${prefix}/status`) {
+        sendJson(response, 200, await gate.status(sessionCookieValue(request)));
+        return true;
+    }
+    if (path === `${prefix}/request` && request.method === "POST") {
+        const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(request)));
+        sendJson(response, 200, parsed.success ? await gate.request(parsed.data.email, ip) : { ok: true });
+        return true;
+    }
+    if (path === `${prefix}/verify` && request.method === "POST") {
+        const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(request)));
+        if (!parsed.success) {
+            sendJson(response, 200, { ok: false });
+            return true;
+        }
+        const result = await gate.verify(parsed.data.email, parsed.data.code, ip);
+        const cookie = result.ok && result.token
+            ? gateModule.sessionSetCookie(result.token, gate.sessionTtlSeconds)
+            : undefined;
+        sendJson(response, 200, { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) }, cookie);
+        return true;
+    }
+    if (path === `${prefix}/logout` && request.method === "POST") {
+        sendJson(response, 200, { ok: true }, gateModule.LOGOUT_SET_COOKIE);
+        return true;
+    }
+    return false;
+}
+/**
+ * Start the proxy and resolve once it is listening.
+ *
+ * `publicDomain` is intentionally NOT passed to `gateRequest`: on this path every
+ * request arrived on the public port, so it IS tunnel traffic by construction -
+ * whereas the in-process gate shares a port with the platform front door and has
+ * to tell them apart by `Host`. Passing the request's own host keeps the shared
+ * decision function's contract satisfied without weakening it.
+ */
+export function startProxy(options) {
     const proxy = ProxyModule.createProxyServer({
-        target: { host: "127.0.0.1", port: appPort },
+        target: `http://127.0.0.1:${options.appPort}`,
         ws: true,
         xfwd: true,
     });
-    proxy.on("error", (err, _req, res) => {
-        logger.warn("upstream proxy error", { error: err.message });
-        const r = res;
-        if (r && "writeHead" in r && !r.headersSent) {
-            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}`,
-        "Path=/",
-        "HttpOnly",
-        "SameSite=Lax",
-        `Max-Age=${maxAgeSeconds}`,
-        process.env.NODE_ENV === "production" ? "Secure" : "",
-    ]
-        .filter(Boolean)
-        .join("; ");
-    /**
-     * 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 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,
-     * so the app never sees `dbx_auth` (it is the proxy's concern, not the app's).
-     * Preserves any other cookies. Removes the header entirely when it becomes empty.
-     */
-    const 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'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[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];
-        // Insecure/open mode (no gate) OR non-loopback traffic (the hosting
-        // platform's front door / control plane): forward ungated.
-        if (!gate || !isLoopback(req.socket.remoteAddress)) {
-            proxy.web(req, res);
-            return;
-        }
-        // --- portr traffic: the gate applies ---
-        // The login flow is answered IN-PROCESS (the app has no server to forward to).
-        if (path === `${AUTH_PREFIX}/status`) {
-            const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-            sendJson(res, 200, await gate.status(token));
-            return;
-        }
-        if (path === `${AUTH_PREFIX}/request` && req.method === "POST") {
-            const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));
-            if (!parsed.success)
-                return sendJson(res, 200, { ok: true }); // anti-enumeration
-            return sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));
-        }
-        if (path === `${AUTH_PREFIX}/verify` && req.method === "POST") {
-            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;
-            return sendJson(res, 200, { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) }, cookie);
-        }
-        if (path === `${AUTH_PREFIX}/logout` && req.method === "POST") {
-            return sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);
-        }
-        // 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/")) {
-            stripSessionCookie(req);
-            proxy.web(req, res);
-            return;
-        }
-        // Every other /api/* requires a valid session.
-        const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-        const email = await gate.session(token);
-        if (email) {
-            // Present the OTP user like a platform front door, and drop the gate
-            // cookie so the app sees a clean, front-door-shaped request.
-            injectIdentity(req, email);
-            stripSessionCookie(req);
-            proxy.web(req, res);
-        }
-        else {
-            sendJson(res, 401, { error: "authentication required", loginPath: AUTH_PREFIX });
-        }
-    });
-    // WebSocket upgrades: forward front-door traffic untouched; gate loopback
-    // (portr) API upgrades the same way as HTTP (strip cookie + inject identity).
-    server.on("upgrade", (req, socket, head) => {
-        if (!gate || !isLoopback(req.socket.remoteAddress)) {
-            proxy.ws(req, socket, head);
-            return;
-        }
-        applyHeaderPolicy(req);
-        if (!(req.url ?? "").startsWith("/api/")) {
-            stripSessionCookie(req);
-            proxy.ws(req, socket, head);
-            return;
-        }
-        const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-        void gate.session(token).then((email) => {
-            if (!email) {
-                socket.destroy();
+    const headerPolicy = headersModule.toHeaderPolicy(options.forwardHeaders);
+    const gate = options.gate;
+    const decide = (request) => gate
+        ? gateModule.gateRequest(request, {
+            gate,
+            publicDomain: (request.headers.host ?? "").split(":")[0] || "localhost",
+            headerPolicy,
+        })
+        : Promise.resolve("pass");
+    const server = createServer((request, response) => {
+        void (async () => {
+            const path = (request.url ?? "/").split("?")[0] ?? "/";
+            if (gate && (await handleAuthRoute(request, response, path, gate)))
+                return;
+            if ((await decide(request)) === "deny") {
+                sendJson(response, 401, gateModule.UNAUTHORIZED_BODY);
                 return;
             }
-            injectIdentity(req, email);
-            stripSessionCookie(req);
-            proxy.ws(req, socket, head);
+            proxy.web(request, response);
+        })().catch((error) => {
+            logger.error("proxy request failed", { error });
+            if (!response.headersSent)
+                sendJson(response, 502, { error: "bad gateway" });
+            else
+                response.end();
         });
     });
+    // A websocket upgrade cannot be answered with a 401 body, so a denied one is
+    // destroyed - the client sees the handshake fail, which is what a browser's
+    // WebSocket error handler expects.
+    server.on("upgrade", (request, socket, head) => {
+        void decide(request)
+            .then((action) => {
+            if (action === "deny")
+                socket.destroy();
+            else
+                proxy.ws(request, socket, head);
+        })
+            .catch(() => socket.destroy());
+    });
     return new Promise((resolve) => {
-        server.listen(publicPort, "0.0.0.0", () => {
-            logger.info(`gate proxy on 0.0.0.0:${publicPort} -> app 127.0.0.1:${appPort}`);
+        server.listen(options.publicPort, "0.0.0.0", () => {
+            logger.info("proxy listening", { publicPort: options.publicPort, appPort: options.appPort });
             resolve();
         });
     });
 }
-//# 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The reverse proxy that makes the wrapper path possible.\n *\n * The wrapper claims the PUBLIC port and the wrapped app runs as a child process\n * on a private loopback port, so - unlike the in-process plugin - there is no\n * middleware chain to insert the gate into. This proxy is that insertion point: it\n * answers the login routes itself, applies the gate to everything else, and\n * forwards what survives to the child.\n *\n * The gating DECISION is not reimplemented here. `@dbx-tools/tunnel`'s\n * `gate.gateRequest` makes it - the same function the Express middleware calls -\n * and this module only differs in how the outcome is written: a proxied request\n * instead of `next()`, a `writeHead` instead of `res.json`. That is deliberate:\n * two independent implementations of \"which requests are gated and which headers\n * are stripped\" is the one way this package could become a security bug.\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 { gate as gateModule, headers as headersModule, type AuthGateApi } from \"@dbx-tools/tunnel\";\nimport ProxyModule from \"http-proxy-3\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\nexport interface ProxyOptions {\n  /** The port this proxy listens on - the port portr and the platform route to. */\n  publicPort: number;\n  /** The private loopback port the wrapped app listens on. */\n  appPort: number;\n  /** The gate handlers. Omitted (an `--insecure` run) forwards everything. */\n  gate?: AuthGateApi;\n  /** Extra `x-` headers tunnel traffic may forward. */\n  forwardHeaders?: readonly string[];\n}\n\n/** Read a request body as text; a transport error yields whatever arrived. */\nfunction readBody(request: IncomingMessage): Promise<string> {\n  return new Promise((resolve) => {\n    let body = \"\";\n    request.on(\"data\", (chunk) => (body += chunk));\n    request.on(\"end\", () => resolve(body));\n    request.on(\"error\", () => resolve(body));\n  });\n}\n\nfunction sendJson(\n  response: ServerResponse,\n  status: number,\n  body: unknown,\n  setCookie?: string,\n): void {\n  response.writeHead(status, {\n    \"content-type\": \"application/json\",\n    ...(setCookie ? { \"set-cookie\": setCookie } : {}),\n  });\n  response.end(JSON.stringify(body));\n}\n\nfunction sessionCookieValue(request: IncomingMessage): string | undefined {\n  return http.parseCookies(request.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n}\n\n/**\n * Answer one of the four login routes, or return `false` when the request is not\n * one of them. Mirrors the plugin's route handlers: `request` always reports\n * success (anti-enumeration) and `verify` sets the session cookie on success.\n */\nasync function handleAuthRoute(\n  request: IncomingMessage,\n  response: ServerResponse,\n  path: string,\n  gate: AuthGateApi,\n): Promise<boolean> {\n  const prefix = gateModule.AUTH_PREFIX;\n  const ip = gateModule.clientIp(request);\n\n  if (path === `${prefix}/status`) {\n    sendJson(response, 200, await gate.status(sessionCookieValue(request)));\n    return true;\n  }\n  if (path === `${prefix}/request` && request.method === \"POST\") {\n    const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(request)));\n    sendJson(response, 200, parsed.success ? await gate.request(parsed.data.email, ip) : { ok: true });\n    return true;\n  }\n  if (path === `${prefix}/verify` && request.method === \"POST\") {\n    const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(request)));\n    if (!parsed.success) {\n      sendJson(response, 200, { ok: false });\n      return true;\n    }\n    const result = await gate.verify(parsed.data.email, parsed.data.code, ip);\n    const cookie =\n      result.ok && result.token\n        ? gateModule.sessionSetCookie(result.token, gate.sessionTtlSeconds)\n        : undefined;\n    sendJson(\n      response,\n      200,\n      { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n      cookie,\n    );\n    return true;\n  }\n  if (path === `${prefix}/logout` && request.method === \"POST\") {\n    sendJson(response, 200, { ok: true }, gateModule.LOGOUT_SET_COOKIE);\n    return true;\n  }\n  return false;\n}\n\n/**\n * Start the proxy and resolve once it is listening.\n *\n * `publicDomain` is intentionally NOT passed to `gateRequest`: on this path every\n * request arrived on the public port, so it IS tunnel traffic by construction -\n * whereas the in-process gate shares a port with the platform front door and has\n * to tell them apart by `Host`. Passing the request's own host keeps the shared\n * decision function's contract satisfied without weakening it.\n */\nexport function startProxy(options: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: `http://127.0.0.1:${options.appPort}`,\n    ws: true,\n    xfwd: true,\n  });\n  const headerPolicy = headersModule.toHeaderPolicy(options.forwardHeaders);\n  const gate = options.gate;\n\n  const decide = (request: IncomingMessage): Promise<gateModule.GateAction> =>\n    gate\n      ? gateModule.gateRequest(request, {\n          gate,\n          publicDomain: (request.headers.host ?? \"\").split(\":\")[0] || \"localhost\",\n          headerPolicy,\n        })\n      : Promise.resolve<gateModule.GateAction>(\"pass\");\n\n  const server = createServer((request, response) => {\n    void (async () => {\n      const path = (request.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n      if (gate && (await handleAuthRoute(request, response, path, gate))) return;\n      if ((await decide(request)) === \"deny\") {\n        sendJson(response, 401, gateModule.UNAUTHORIZED_BODY);\n        return;\n      }\n      proxy.web(request, response);\n    })().catch((error: unknown) => {\n      logger.error(\"proxy request failed\", { error });\n      if (!response.headersSent) sendJson(response, 502, { error: \"bad gateway\" });\n      else response.end();\n    });\n  });\n\n  // A websocket upgrade cannot be answered with a 401 body, so a denied one is\n  // destroyed - the client sees the handshake fail, which is what a browser's\n  // WebSocket error handler expects.\n  server.on(\"upgrade\", (request: IncomingMessage, socket: Socket, head: Buffer) => {\n    void decide(request)\n      .then((action) => {\n        if (action === \"deny\") socket.destroy();\n        else proxy.ws(request, socket, head);\n      })\n      .catch(() => socket.destroy());\n  });\n\n  return new Promise((resolve) => {\n    server.listen(options.publicPort, \"0.0.0.0\", () => {\n      logger.info(\"proxy listening\", { publicPort: options.publicPort, appPort: options.appPort });\n      resolve();\n    });\n  });\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"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","../src/signing-key.ts","../index.ts","../bin/dbx-tools-tunnel.ts"],"version":"5.9.3"}
+{"root":["../src/app.ts","../src/cli.ts","../src/options.ts","../src/proxy.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -3,11 +3,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reggie-db/dbx-tools.git",
-    "directory": "packages/cli/tunnel"
-  },
-  "bin": {
-    "dbx-tools-tunnel": "./lib/bin/dbx-tools-tunnel.js",
-    "dbxt-tunnel": "./lib/bin/dbx-tools-tunnel.js"
+    "directory": "packages/js/cli/tunnel"
   },
   "scripts": {
     "build": "projen build",
@@ -27,16 +23,14 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@clack/prompts": "^1.7.0",
-    "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.59",
-    "@dbx-tools/core": "0.6.59",
-    "@dbx-tools/email": "0.6.59",
-    "@dbx-tools/shared-core": "0.6.59",
-    "@dbx-tools/shared-email": "0.6.59",
+    "@dbx-tools/appkit": "0.6.85",
+    "@dbx-tools/core": "0.6.85",
+    "@dbx-tools/email": "0.6.85",
+    "@dbx-tools/shared-core": "0.6.85",
+    "@dbx-tools/shared-email": "0.6.85",
+    "@dbx-tools/tunnel": "0.6.85",
     "commander": "^15.0.0",
-    "http-proxy-3": "^1.23.3",
-    "jose": "^6.2.3"
+    "http-proxy-3": "^1.23.1"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -44,19 +38,11 @@
     "access": "public",
     "main": "./lib/index.js",
     "types": "./lib/index.d.ts",
-    "bin": {
-      "dbx-tools-tunnel": "./lib/bin/dbx-tools-tunnel.js",
-      "dbxt-tunnel": "./lib/bin/dbx-tools-tunnel.js"
-    },
     "exports": {
       ".": {
         "types": "./lib/index.d.ts",
         "default": "./lib/index.js"
       },
-      "./allowlist": {
-        "types": "./lib/src/allowlist.d.ts",
-        "default": "./lib/src/allowlist.js"
-      },
       "./app": {
         "types": "./lib/src/app.d.ts",
         "default": "./lib/src/app.js"
@@ -65,42 +51,18 @@
         "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"
-      },
-      "./plugin": {
-        "types": "./lib/src/plugin.d.ts",
-        "default": "./lib/src/plugin.js"
-      },
-      "./portr": {
-        "types": "./lib/src/portr.d.ts",
-        "default": "./lib/src/portr.js"
+      "./options": {
+        "types": "./lib/src/options.d.ts",
+        "default": "./lib/src/options.js"
       },
       "./proxy": {
         "types": "./lib/src/proxy.d.ts",
         "default": "./lib/src/proxy.js"
       },
-      "./rate-limit": {
-        "types": "./lib/src/rate-limit.d.ts",
-        "default": "./lib/src/rate-limit.js"
-      },
-      "./signing-key": {
-        "types": "./lib/src/signing-key.d.ts",
-        "default": "./lib/src/signing-key.js"
-      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.59",
+  "version": "0.6.85",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -108,10 +70,6 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./allowlist": {
-      "types": "./lib/src/allowlist.d.ts",
-      "default": "./lib/src/allowlist.js"
-    },
     "./app": {
       "types": "./lib/src/app.d.ts",
       "default": "./lib/src/app.js"
@@ -120,38 +78,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"
-    },
-    "./plugin": {
-      "types": "./lib/src/plugin.d.ts",
-      "default": "./lib/src/plugin.js"
-    },
-    "./portr": {
-      "types": "./lib/src/portr.d.ts",
-      "default": "./lib/src/portr.js"
+    "./options": {
+      "types": "./lib/src/options.d.ts",
+      "default": "./lib/src/options.js"
     },
     "./proxy": {
       "types": "./lib/src/proxy.d.ts",
       "default": "./lib/src/proxy.js"
     },
-    "./rate-limit": {
-      "types": "./lib/src/rate-limit.d.ts",
-      "default": "./lib/src/rate-limit.js"
-    },
-    "./signing-key": {
-      "types": "./lib/src/signing-key.d.ts",
-      "default": "./lib/src/signing-key.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [