@dbx-tools/cli-tunnel 0.6.45

package/lib/src/proxy.js

@@ -0,0 +1,204 @@
+/**
+ * The tunnel gate reverse-proxy.
+ *
+ * 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:
+ *
+ *   - **portr client** (same container, connects over LOOPBACK) - the public
+ *     tunnel. This is what the gate protects.
+ *   - **Databricks control plane / front door** (reaches 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 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`.
+ *
+ * @module
+ */
+import { createServer } from "node:http";
+import { http, json, log } from "@dbx-tools/shared-core";
+import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
+import ProxyModule from "http-proxy-3";
+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) {
+    return new Promise((resolve) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => resolve(data));
+        req.on("error", () => resolve(data));
+    });
+}
+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));
+}
+/** Start the gate proxy. Resolves once it is listening. */
+export function startProxy({ publicPort, appPort, gate }) {
+    const proxy = ProxyModule.createProxyServer({
+        target: { host: "127.0.0.1", port: 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" });
+        }
+    });
+    /** 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-forwarded XFF, else the socket. */
+    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();
+    };
+    /**
+     * 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 the Databricks
+     * front door does: set `x-forwarded-user` / `x-forwarded-email` to the verified
+     * address (AppKit reads `x-forwarded-user` for the OBO user id). Any inbound
+     * copies are overwritten so a client can't spoof identity through the gate.
+     */
+    const injectIdentity = (req, email) => {
+        req.headers["x-forwarded-user"] = email;
+        req.headers["x-forwarded-email"] = email;
+    };
+    const server = createServer(async (req, res) => {
+        const path = (req.url ?? "/").split("?")[0];
+        // Insecure/open mode (no gate) OR non-loopback traffic (the Databricks 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: 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"];
+        // 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 the Databricks 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;
+        }
+        delete req.headers["x-forwarded-user"];
+        delete req.headers["x-forwarded-email"];
+        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();
+                return;
+            }
+            injectIdentity(req, email);
+            stripSessionCookie(req);
+            proxy.ws(req, socket, head);
+        });
+    });
+    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}`);
+            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 *   - **Databricks control plane / front door** (reaches the `0.0.0.0` port from\n *     a NON-loopback container-network address) - passed through UNGATED, per the\n *     rule \"if it's not from the portr client, let it in\".\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 the Databricks\n   * front door does: set `x-forwarded-user` / `x-forwarded-email` to the verified\n   * address (AppKit reads `x-forwarded-user` for the OBO user id). Any inbound\n   * copies are overwritten so a 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 Databricks front\n    // 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 the Databricks 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"]}

package/lib/src/rate-limit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A small in-memory fixed-window rate limiter for the email-OTP gate.
+ *
+ * Keyed by an arbitrary string (an email address or a client IP). Each key gets
+ * `max` hits per `windowMs`; the window resets on first use after it elapses.
+ * `hit()` returns whether the call is allowed and, when not, how many seconds
+ * until the window resets so a caller can surface a cooldown.
+ *
+ * In-memory is intentional and sufficient for a single-app-instance gate: an
+ * app behind a portr tunnel serves from one process. It is NOT a distributed
+ * limiter; a multi-replica deployment would need shared state. Entries are
+ * pruned lazily on access, so an idle key costs nothing after its window.
+ *
+ * @module
+ */
+/** A fixed-window rate limiter over string keys. */
+export declare class RateLimiter {
+    private readonly max;
+    private readonly windowMs;
+    private readonly windows;
+    constructor(max: number, windowMs: number);
+    /**
+     * Record a hit for `key`. Returns `{ allowed }`, plus `retryAfter` (seconds)
+     * when the limit is exceeded. A limit of `<= 0` disables limiting (always
+     * allowed), which lets a config turn it off without special-casing callers.
+     */
+    hit(key: string, now?: number): {
+        allowed: boolean;
+        retryAfter?: number;
+    };
+    /** Forget a key (e.g. clear a caller's window after a successful verify). */
+    reset(key: string): void;
+    /** Drop every window (tests). */
+    clear(): void;
+}

package/lib/src/rate-limit.js

@@ -0,0 +1,53 @@
+/**
+ * A small in-memory fixed-window rate limiter for the email-OTP gate.
+ *
+ * Keyed by an arbitrary string (an email address or a client IP). Each key gets
+ * `max` hits per `windowMs`; the window resets on first use after it elapses.
+ * `hit()` returns whether the call is allowed and, when not, how many seconds
+ * until the window resets so a caller can surface a cooldown.
+ *
+ * In-memory is intentional and sufficient for a single-app-instance gate: an
+ * app behind a portr tunnel serves from one process. It is NOT a distributed
+ * limiter; a multi-replica deployment would need shared state. Entries are
+ * pruned lazily on access, so an idle key costs nothing after its window.
+ *
+ * @module
+ */
+/** A fixed-window rate limiter over string keys. */
+export class RateLimiter {
+    max;
+    windowMs;
+    windows = new Map();
+    constructor(max, windowMs) {
+        this.max = max;
+        this.windowMs = windowMs;
+    }
+    /**
+     * Record a hit for `key`. Returns `{ allowed }`, plus `retryAfter` (seconds)
+     * when the limit is exceeded. A limit of `<= 0` disables limiting (always
+     * allowed), which lets a config turn it off without special-casing callers.
+     */
+    hit(key, now = Date.now()) {
+        if (this.max <= 0)
+            return { allowed: true };
+        const existing = this.windows.get(key);
+        if (!existing || now >= existing.resetAt) {
+            this.windows.set(key, { count: 1, resetAt: now + this.windowMs });
+            return { allowed: true };
+        }
+        if (existing.count < this.max) {
+            existing.count += 1;
+            return { allowed: true };
+        }
+        return { allowed: false, retryAfter: Math.ceil((existing.resetAt - now) / 1000) };
+    }
+    /** Forget a key (e.g. clear a caller's window after a successful verify). */
+    reset(key) {
+        this.windows.delete(key);
+    }
+    /** Drop every window (tests). */
+    clear() {
+        this.windows.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZS1saW1pdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yYXRlLWxpbWl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBT0gsb0RBQW9EO0FBQ3BELE1BQU0sT0FBTyxXQUFXO0lBSUg7SUFDQTtJQUpGLE9BQU8sR0FBRyxJQUFJLEdBQUcsRUFBa0IsQ0FBQztJQUVyRCxZQUNtQixHQUFXLEVBQ1gsUUFBZ0I7UUFEaEIsUUFBRyxHQUFILEdBQUcsQ0FBUTtRQUNYLGFBQVEsR0FBUixRQUFRLENBQVE7SUFDaEMsQ0FBQztJQUVKOzs7O09BSUc7SUFDSCxHQUFHLENBQUMsR0FBVyxFQUFFLE1BQWMsSUFBSSxDQUFDLEdBQUcsRUFBRTtRQUN2QyxJQUFJLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQztZQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7UUFDNUMsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdkMsSUFBSSxDQUFDLFFBQVEsSUFBSSxHQUFHLElBQUksUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ3pDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztZQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDO1FBQzNCLENBQUM7UUFDRCxJQUFJLFFBQVEsQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQzlCLFFBQVEsQ0FBQyxLQUFLLElBQUksQ0FBQyxDQUFDO1lBQ3BCLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7UUFDM0IsQ0FBQztRQUNELE9BQU8sRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sR0FBRyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDO0lBQ3BGLENBQUM7SUFFRCw2RUFBNkU7SUFDN0UsS0FBSyxDQUFDLEdBQVc7UUFDZixJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBRUQsaUNBQWlDO0lBQ2pDLEtBQUs7UUFDSCxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3ZCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQSBzbWFsbCBpbi1tZW1vcnkgZml4ZWQtd2luZG93IHJhdGUgbGltaXRlciBmb3IgdGhlIGVtYWlsLU9UUCBnYXRlLlxuICpcbiAqIEtleWVkIGJ5IGFuIGFyYml0cmFyeSBzdHJpbmcgKGFuIGVtYWlsIGFkZHJlc3Mgb3IgYSBjbGllbnQgSVApLiBFYWNoIGtleSBnZXRzXG4gKiBgbWF4YCBoaXRzIHBlciBgd2luZG93TXNgOyB0aGUgd2luZG93IHJlc2V0cyBvbiBmaXJzdCB1c2UgYWZ0ZXIgaXQgZWxhcHNlcy5cbiAqIGBoaXQoKWAgcmV0dXJucyB3aGV0aGVyIHRoZSBjYWxsIGlzIGFsbG93ZWQgYW5kLCB3aGVuIG5vdCwgaG93IG1hbnkgc2Vjb25kc1xuICogdW50aWwgdGhlIHdpbmRvdyByZXNldHMgc28gYSBjYWxsZXIgY2FuIHN1cmZhY2UgYSBjb29sZG93bi5cbiAqXG4gKiBJbi1tZW1vcnkgaXMgaW50ZW50aW9uYWwgYW5kIHN1ZmZpY2llbnQgZm9yIGEgc2luZ2xlLWFwcC1pbnN0YW5jZSBnYXRlOiBhblxuICogYXBwIGJlaGluZCBhIHBvcnRyIHR1bm5lbCBzZXJ2ZXMgZnJvbSBvbmUgcHJvY2Vzcy4gSXQgaXMgTk9UIGEgZGlzdHJpYnV0ZWRcbiAqIGxpbWl0ZXI7IGEgbXVsdGktcmVwbGljYSBkZXBsb3ltZW50IHdvdWxkIG5lZWQgc2hhcmVkIHN0YXRlLiBFbnRyaWVzIGFyZVxuICogcHJ1bmVkIGxhemlseSBvbiBhY2Nlc3MsIHNvIGFuIGlkbGUga2V5IGNvc3RzIG5vdGhpbmcgYWZ0ZXIgaXRzIHdpbmRvdy5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cblxuaW50ZXJmYWNlIFdpbmRvdyB7XG4gIGNvdW50OiBudW1iZXI7XG4gIHJlc2V0QXQ6IG51bWJlcjtcbn1cblxuLyoqIEEgZml4ZWQtd2luZG93IHJhdGUgbGltaXRlciBvdmVyIHN0cmluZyBrZXlzLiAqL1xuZXhwb3J0IGNsYXNzIFJhdGVMaW1pdGVyIHtcbiAgcHJpdmF0ZSByZWFkb25seSB3aW5kb3dzID0gbmV3IE1hcDxzdHJpbmcsIFdpbmRvdz4oKTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJlYWRvbmx5IG1heDogbnVtYmVyLFxuICAgIHByaXZhdGUgcmVhZG9ubHkgd2luZG93TXM6IG51bWJlcixcbiAgKSB7fVxuXG4gIC8qKlxuICAgKiBSZWNvcmQgYSBoaXQgZm9yIGBrZXlgLiBSZXR1cm5zIGB7IGFsbG93ZWQgfWAsIHBsdXMgYHJldHJ5QWZ0ZXJgIChzZWNvbmRzKVxuICAgKiB3aGVuIHRoZSBsaW1pdCBpcyBleGNlZWRlZC4gQSBsaW1pdCBvZiBgPD0gMGAgZGlzYWJsZXMgbGltaXRpbmcgKGFsd2F5c1xuICAgKiBhbGxvd2VkKSwgd2hpY2ggbGV0cyBhIGNvbmZpZyB0dXJuIGl0IG9mZiB3aXRob3V0IHNwZWNpYWwtY2FzaW5nIGNhbGxlcnMuXG4gICAqL1xuICBoaXQoa2V5OiBzdHJpbmcsIG5vdzogbnVtYmVyID0gRGF0ZS5ub3coKSk6IHsgYWxsb3dlZDogYm9vbGVhbjsgcmV0cnlBZnRlcj86IG51bWJlciB9IHtcbiAgICBpZiAodGhpcy5tYXggPD0gMCkgcmV0dXJuIHsgYWxsb3dlZDogdHJ1ZSB9O1xuICAgIGNvbnN0IGV4aXN0aW5nID0gdGhpcy53aW5kb3dzLmdldChrZXkpO1xuICAgIGlmICghZXhpc3RpbmcgfHwgbm93ID49IGV4aXN0aW5nLnJlc2V0QXQpIHtcbiAgICAgIHRoaXMud2luZG93cy5zZXQoa2V5LCB7IGNvdW50OiAxLCByZXNldEF0OiBub3cgKyB0aGlzLndpbmRvd01zIH0pO1xuICAgICAgcmV0dXJuIHsgYWxsb3dlZDogdHJ1ZSB9O1xuICAgIH1cbiAgICBpZiAoZXhpc3RpbmcuY291bnQgPCB0aGlzLm1heCkge1xuICAgICAgZXhpc3RpbmcuY291bnQgKz0gMTtcbiAgICAgIHJldHVybiB7IGFsbG93ZWQ6IHRydWUgfTtcbiAgICB9XG4gICAgcmV0dXJuIHsgYWxsb3dlZDogZmFsc2UsIHJldHJ5QWZ0ZXI6IE1hdGguY2VpbCgoZXhpc3RpbmcucmVzZXRBdCAtIG5vdykgLyAxMDAwKSB9O1xuICB9XG5cbiAgLyoqIEZvcmdldCBhIGtleSAoZS5nLiBjbGVhciBhIGNhbGxlcidzIHdpbmRvdyBhZnRlciBhIHN1Y2Nlc3NmdWwgdmVyaWZ5KS4gKi9cbiAgcmVzZXQoa2V5OiBzdHJpbmcpOiB2b2lkIHtcbiAgICB0aGlzLndpbmRvd3MuZGVsZXRlKGtleSk7XG4gIH1cblxuICAvKiogRHJvcCBldmVyeSB3aW5kb3cgKHRlc3RzKS4gKi9cbiAgY2xlYXIoKTogdm9pZCB7XG4gICAgdGhpcy53aW5kb3dzLmNsZWFyKCk7XG4gIH1cbn1cbiJdfQ==

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@dbx-tools/cli-tunnel",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/cli/tunnel"
+  },
+  "bin": {
+    "dbx-tools-tunnel": "./bin/dbx-tools-tunnel.ts",
+    "dbxt-tunnel": "./bin/dbx-tools-tunnel.ts"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@databricks/appkit": "^0.43.0",
+    "@dbx-tools/appkit": "0.6.45",
+    "@dbx-tools/email": "0.6.45",
+    "@dbx-tools/shared-core": "0.6.45",
+    "@dbx-tools/shared-email": "0.6.45",
+    "commander": "^15.0.0",
+    "http-proxy-3": "^1.23.3",
+    "jose": "^6.2.3"
+  },
+  "main": "index.ts",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "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"
+      },
+      "./cli": {
+        "types": "./lib/src/cli.d.ts",
+        "default": "./lib/src/cli.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"
+      },
+      "./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"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.6.45",
+  "types": "index.ts",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts",
+    "./allowlist": "./src/allowlist.ts",
+    "./app": "./src/app.ts",
+    "./cli": "./src/cli.ts",
+    "./otp": "./src/otp.ts",
+    "./plugin": "./src/plugin.ts",
+    "./portr": "./src/portr.ts",
+    "./proxy": "./src/proxy.ts",
+    "./rate-limit": "./src/rate-limit.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "bin",
+    "lib"
+  ],
+  "dbxToolsConfig": {
+    "tags": [
+      "cli"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/allowlist.ts

@@ -0,0 +1,88 @@
+/**
+ * Unified access allow-list matching for the email-OTP gate.
+ *
+ * Each pattern in the configured list is one of three shapes, tried in order:
+ *
+ *   - **domain shortcut** - `databricks.com` or `@databricks.com`: matches any
+ *     address whose domain equals it (case-insensitive). The leading `@` is
+ *     optional and stripped.
+ *   - **glob** - contains `*` or `?`, e.g. `*.databricks.com` or
+ *     `*@databricks.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).
+ *
+ * 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.
+ *
+ * @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;
+  }
+}
+
+/** True when `email` matches a single allow-list `pattern`. */
+function matchesPattern(email: string, pattern: string): boolean {
+  const trimmed = pattern.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);
+  }
+
+  // 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;
+}
+
+/**
+ * True when `email` is allowed by ANY pattern in `patterns`. An empty (or
+ * missing) list allows nobody - the gate fails closed.
+ */
+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));
+}
+
+/** Rough shape check so a clearly-invalid address is rejected before any work. */
+export function looksLikeEmail(value: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+}

package/src/app.ts

@@ -0,0 +1,82 @@
+/**
+ * The tunnel gate's tiny AppKit "app" - `createApp` WITHOUT a `server()` plugin.
+ *
+ * There is no HTTP server here: the tunnel proxy is the server, and it calls the
+ * gate handlers in-process. `createApp` is used only for what it auto-wires:
+ *   - `CacheManager` (memory, or Lakebase when the deploy configures persistent
+ *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;
+ *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can
+ *     deliver the one-time code;
+ *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.
+ *
+ * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here
+ * (the plugin can't resolve HOW to send on its own) to the email plugin's
+ * transport, resolving the `From` from the email runtime config (EMAIL_FROM /
+ * EMAIL_DOMAIN) since an OTP request has no on-behalf-of user.
+ *
+ * FAIL FAST: a gate that can't email a code is useless, so if email does not
+ * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set
+ * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the
+ * tunnel OPEN with no gate.
+ *
+ * @module
+ */
+
+import { createApp as createAppNs } from "@dbx-tools/appkit";
+import { email, sender, transport } from "@dbx-tools/email";
+import { log } from "@dbx-tools/shared-core";
+import { authGate, type AuthGateApi, type AuthGateConfig } from "./plugin.ts";
+
+const logger = log.logger("tunnel:app");
+
+const { createApp } = createAppNs;
+const { resolveSenderAddress } = sender;
+const { getEmailRuntime, sendEmail } = transport;
+
+/**
+ * Boot the gate app and return the API the proxy calls. Throws when email is not
+ * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at
+ * startup rather than silently accepting nobody; the caller may catch this and
+ * fall back to insecure/open mode when the operator opted in.
+ */
+export async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi> {
+  // `sendCode` delivers the OTP through the email plugin's SHARED transport, which
+  // the `email()` plugin primes during its `setup()` (awaited by `createApp`
+  // below). Using the module-level `sendEmail` avoids a circular dependency on the
+  // app handle's inferred type. `From` is the app's configured sender (EMAIL_FROM /
+  // EMAIL_DOMAIN); the code email has no OBO user, so it resolves with `undefined`.
+  const sendCode: NonNullable<AuthGateConfig["sendCode"]> = async (to, code, opts) => {
+    const from = resolveSenderAddress(getEmailRuntime().config, undefined);
+    await sendEmail(
+      {
+        to: [to],
+        subject: opts.subject,
+        body: [
+          opts.message,
+          "",
+          `## ${code}`,
+          "",
+          "It expires shortly. If you didn't request this, ignore this email.",
+        ].join("\n"),
+      },
+      from,
+    );
+  };
+
+  // `createApp` namespaces each plugin's exports on the handle by manifest name;
+  // `handle.authGate` is the in-process gate API the proxy drives.
+  const handle = await createApp({ plugins: [email(), authGate({ ...config, sendCode })] });
+
+  // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to
+  // `mode: "file"` (outbox) or throws when no SMTP creds are configured - neither
+  // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.
+  if (getEmailRuntime().config.mode !== "smtp") {
+    throw new Error(
+      "email is not configured for SMTP delivery - the OTP gate cannot send codes. " +
+        "Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true to run the tunnel open.",
+    );
+  }
+
+  logger.info("gate app ready (no server; proxy-driven)");
+  return handle.authGate as AuthGateApi;
+}