@dbx-tools/tunnel 0.6.60

package/lib/src/proxy.js

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

package/lib/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,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

package/lib/src/signing-key.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ *
+ * The key decides whether a session COOKIE still verifies. Before this module the
+ * fallback was `randomBytes(32)` per process, so every restart invalidated every
+ * outstanding cookie and each signed-in user had to request a new code - painful
+ * for a tunnel, which restarts whenever the app it wraps does. Now the key is
+ * stored in the cache AppKit already configured (memory, or Lakebase when the
+ * host wires a persistent `CacheStorage`), so with persistent storage a restart
+ * keeps sessions alive for {@link KEY_TTL_SECONDS}.
+ *
+ * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is
+ * the right answer for a fleet: an operator-held secret needs no shared cache and
+ * no convergence, and it survives a cache flush.
+ *
+ * ## get / generate / get
+ *
+ * Two instances booting at once both miss, so both would generate - and the loser
+ * would sign cookies with a key the winner rejects. Resolution is a re-READ after
+ * the write: whatever the cache holds afterwards is the key everyone adopts, so
+ * the instances converge on ONE value instead of trusting the one they minted.
+ * (`set` is not conditional in the cache API - there is no `setnx` to lean on -
+ * and this runs once per process, so the extra round-trip is free.)
+ *
+ * A pathological interleave can still cost a key: if A writes between B's write
+ * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -
+ * a cookie minted in that window fails to verify and the holder signs in again -
+ * and it cannot produce a key one instance TRUSTS but another rejects for longer
+ * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race
+ * entirely.
+ *
+ * ## Forcing every session to end
+ *
+ * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or
+ * `--session-cutoff`), and that date is part of the cache KEY. Moving it forward
+ * makes every prior key unreachable, so every cookie signed against it stops
+ * verifying - the log-everyone-out switch, without having to find and flush a
+ * cache entry. The cutoff is also asserted against each token's `iat`, so a
+ * cookie that predates it is refused even if it was signed with the key that is
+ * somehow still current.
+ *
+ * @module
+ */
+/**
+ * How long a cached signing key lives: 30 days.
+ *
+ * This is the ceiling on how long a session cookie can stay valid across
+ * restarts, so it is deliberately >= the default session TTL - a key that expired
+ * before the cookies it signed would log everyone out for no reason.
+ */
+export declare const KEY_TTL_SECONDS: number;
+/**
+ * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO
+ * instant, epoch seconds or millis from `date +%s`, or a relative duration
+ * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this
+ * usually wants: sign out everyone who signed in more than a month ago.
+ *
+ * An UNPARSEABLE value is ignored with a warning rather than throwing: this is
+ * the switch that logs a fleet back in, and failing to boot over a typo is worse
+ * than not rotating.
+ */
+export declare function resolveSessionCutoff(configured?: string | number | Date): number;
+/** A resolved key plus the cutoff it is scoped to. */
+export interface SigningKey {
+    key: Uint8Array;
+    /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */
+    cutoffMs: number;
+}
+/**
+ * The signing key for this gate, resolved once per process.
+ *
+ * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the
+ * plugin's `setup()` passes its resolved value there, before any request can
+ * reach the lazy path.
+ *
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * unavailable degrades to an ephemeral per-process key (the previous behaviour)
+ * rather than refusing to sign: the key only validates an ALREADY-issued session,
+ * so losing it costs sessions, never admission - a caller still needs a code
+ * delivered to an allow-listed address.
+ */
+export declare function signingKey(configuredCutoff?: string | number | Date): Promise<SigningKey>;
+/** Reset the per-process key (tests, or after changing the env in-process). */
+export declare function resetSigningKey(): void;