@dbx-tools/appkit-lakebox 0.0.0-stage → 0.9.131

package/lib/src/routes.js

@@ -0,0 +1,441 @@
+import { createServer } from "node:net";
+import { PassThrough, Readable } from "node:stream";
+import { ACCESS_TOKEN_HEADER, USER_EMAIL_HEADER, USER_ID_HEADER } from "@dbx-tools/appkit";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import ProxyModule from "http-proxy-3";
+const MAX_PENDING_BYTES = 1024 * 1024;
+const FORWARDING_READY_TIMEOUT_MS = 15_000;
+const logger = log.logger("appkit-lakebox:routes");
+/**
+ * Proxies `<prefix>/<user-hash>/<service>` to that user's service port.
+ *
+ * The user hash is the only routing key. A request is forwarded only when its
+ * authenticated identity hashes to the same value, and the port is derived from
+ * the hash and service name, so there is no stored route table. Requests
+ * without an identity are rejected with 404, including WebSocket upgrades.
+ */
+export class LakeboxRouteRegistry {
+    prefix;
+    resolver;
+    forwardingReadyTimeoutMs;
+    bridges = new Map();
+    upgrades = new Set();
+    pending = new WeakMap();
+    proxy = ProxyModule.createProxyServer({ ws: true, xfwd: true });
+    shuttingDown = false;
+    /** Creates a registry beneath one AppKit route prefix. */
+    constructor(prefix, resolver, forwardingReadyTimeoutMs = FORWARDING_READY_TIMEOUT_MS) {
+        this.prefix = prefix;
+        this.resolver = resolver;
+        this.forwardingReadyTimeoutMs = forwardingReadyTimeoutMs;
+        this.proxy.on("error", (error, request, response) => {
+            if (this.shuttingDown && isConnectionClosureError(error)) {
+                response.destroy();
+                return;
+            }
+            const pending = this.pending.get(request);
+            if (pending && "writeHead" in response && !response.headersSent) {
+                this.resolver.unavailable(pending.user, pending.service);
+                sendLoadingResponse(request.headers.accept, response);
+                return;
+            }
+            logger.warn("Lakebox route proxy failed", {
+                method: request.method,
+                path: request.url,
+                error,
+            });
+            if ("writeHead" in response) {
+                if (response.headersSent) {
+                    response.destroy();
+                }
+                else {
+                    response.writeHead(502);
+                    response.end("Lakebox route unavailable");
+                }
+            }
+            else if (!response.destroyed) {
+                response.destroy();
+            }
+        });
+        this.proxy.on("proxyRes", (proxyResponse, request, response) => {
+            const pending = this.pending.get(request);
+            if (pending && [502, 503, 504].includes(proxyResponse.statusCode ?? 0)) {
+                proxyResponse.resume();
+                this.resolver.unavailable(pending.user, pending.service);
+                sendLoadingResponse(request.headers.accept, response);
+                return;
+            }
+            if (pending?.head) {
+                void injectHtmlHead(proxyResponse, response, pending.head);
+                return;
+            }
+            pipeProxyResponse(proxyResponse, response);
+        });
+    }
+    /** Returns the route path segment match for a request path. */
+    match(path) {
+        const root = this.prefix.replace(/\/+$/, "");
+        if (!path.startsWith(`${root}/`))
+            return undefined;
+        const [userHash, service] = path.slice(root.length + 1).split("/");
+        if (!userHash || !service)
+            return undefined;
+        return { userHash, service, mount: `${root}/${userHash}/${service}` };
+    }
+    /** Express middleware that authorizes, rewrites, and proxies matching requests. */
+    middleware() {
+        return async (request, response, next) => {
+            const match = this.match(request.path);
+            if (!match)
+                return next();
+            const user = this.authorize(request.headers, match);
+            if (!user) {
+                response.statusCode = 404;
+                response.end("Not Found");
+                return;
+            }
+            if (request.path === match.mount) {
+                response.statusCode = 308;
+                response.setHeader("location", routeRedirectUrl(request.url, match.mount));
+                response.end();
+                return;
+            }
+            let resolution;
+            try {
+                resolution = await this.resolver.resolve(user, match.service);
+            }
+            catch (error) {
+                return next(error);
+            }
+            if (resolution.kind === "missing") {
+                response.statusCode = 404;
+                response.end("Not Found");
+                return;
+            }
+            if (resolution.kind === "loading") {
+                sendLoadingResponse(request.header("accept"), response);
+                return;
+            }
+            if (resolution.kind === "failed") {
+                response.statusCode = 502;
+                response.setHeader("content-type", "text/plain; charset=utf-8");
+                response.end(`Lakebox service failed: ${resolution.message}`);
+                return;
+            }
+            const bridge = await this.bridge(resolution.session, resolution.route.port);
+            const head = request.method === "GET" && request.path === `${match.mount}/`
+                ? resolution.route.htmlHead
+                : undefined;
+            if (head)
+                request.headers["accept-encoding"] = "identity";
+            this.pending.set(request, { user, service: match.service, ...(head ? { head } : {}) });
+            const replayBody = replayParsedJsonBody(request);
+            if (resolution.route.stripPrefix)
+                request.url = outboundPath(request.url, match.mount);
+            stripIdentityHeaders(request);
+            this.proxy.web(request, response, {
+                target: bridge.target,
+                changeOrigin: true,
+                selfHandleResponse: true,
+                ...(replayBody ? { buffer: replayBody } : {}),
+            });
+        };
+    }
+    /** Number of open forwarded HTTP and WebSocket connections. */
+    activeConnections() {
+        let count = this.upgrades.size;
+        for (const bridge of this.bridges.values())
+            count += bridge.sockets.size;
+        return count;
+    }
+    /** Returns whether an upgrade path belongs to the Lakebox route prefix. */
+    canHandleUpgrade(path) {
+        return Boolean(this.match(path));
+    }
+    /** Proxies an authorized WebSocket upgrade. Returns false when it was not handled. */
+    async handleUpgrade(request, socket, head) {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        const match = this.match(url.pathname);
+        if (!match)
+            return false;
+        const user = this.authorize(request.headers, match);
+        if (!user)
+            return false;
+        const resolution = await this.resolver.resolve(user, match.service);
+        if (resolution.kind !== "ready")
+            return false;
+        if (resolution.route.stripPrefix)
+            request.url = outboundPath(request.url, match.mount);
+        this.upgrades.add(socket);
+        socket.once("close", () => this.upgrades.delete(socket));
+        proxyWebSocket(request, socket, head, resolution.session, resolution.route.port, this.forwardingReadyTimeoutMs);
+        return true;
+    }
+    /** Closes every forwarding bridge, for example after the Lakebox stops. */
+    async closeBridges() {
+        this.upgrades.forEach((socket) => socket.destroy());
+        this.upgrades.clear();
+        const bridges = [...this.bridges.values()];
+        this.bridges.clear();
+        await Promise.all(bridges.map(closeBridge));
+    }
+    /** Suppresses expected proxy errors once shutdown begins. */
+    beginShutdown() {
+        this.shuttingDown = true;
+    }
+    /** Closes bridges and the shared proxy. */
+    async close() {
+        this.beginShutdown();
+        await this.closeBridges();
+        this.proxy.close();
+    }
+    authorize(headers, match) {
+        const user = this.resolver.user(headers);
+        return user?.hash === match.userHash ? user : undefined;
+    }
+    async bridge(session, port) {
+        const existing = this.bridges.get(port);
+        if (existing?.session === session)
+            return existing;
+        if (existing) {
+            this.bridges.delete(port);
+            void closeBridge(existing);
+        }
+        const sockets = new Set();
+        const server = createServer((socket) => {
+            sockets.add(socket);
+            socket.once("close", () => sockets.delete(socket));
+            bridgeSocket(socket, session.forwardOut("127.0.0.1", port), this.forwardingReadyTimeoutMs);
+        });
+        const target = await listenTarget(server);
+        const bridge = { session, server, target, sockets };
+        const raced = this.bridges.get(port);
+        if (raced?.session === session) {
+            void closeBridge(bridge);
+            return raced;
+        }
+        this.bridges.set(port, bridge);
+        return bridge;
+    }
+}
+async function closeBridge(bridge) {
+    bridge.sockets.forEach((socket) => socket.destroy());
+    await closeServer(bridge.server);
+}
+function stripIdentityHeaders(request) {
+    for (const name of [ACCESS_TOKEN_HEADER, "authorization", "cookie"])
+        delete request.headers[name];
+}
+function sendLoadingResponse(accept, response) {
+    response.statusCode = 202;
+    response.setHeader("cache-control", "no-store");
+    response.setHeader("retry-after", "2");
+    const acceptsHtml = (Array.isArray(accept) ? accept.join(",") : (accept ?? ""))
+        .toLowerCase()
+        .includes("text/html");
+    if (!acceptsHtml) {
+        response.setHeader("content-type", "application/json; charset=utf-8");
+        response.end(JSON.stringify({ status: "loading", message: "Starting Lakebox service" }));
+        return;
+    }
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.end(`<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta http-equiv="refresh" content="2">
+<title>Starting Lakebox service</title>
+<style>
+html{color-scheme:light dark;font-family:system-ui,sans-serif}body{min-height:100vh;margin:0;display:grid;place-items:center;background:Canvas;color:CanvasText}.loading{display:flex;align-items:center;gap:.75rem}.spinner{width:1.25rem;height:1.25rem;border:.2rem solid color-mix(in srgb,CanvasText 20%,transparent);border-top-color:CanvasText;border-radius:50%;animation:spin .8s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}
+</style>
+</head>
+<body><div class="loading" role="status"><span class="spinner" aria-hidden="true"></span><span>Starting Lakebox service</span></div></body>
+</html>`);
+}
+function isConnectionClosureError(error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? String(error.code)
+        : undefined;
+    return (code === "ECONNRESET" ||
+        code === "EPIPE" ||
+        code === "ERR_STREAM_PREMATURE_CLOSE" ||
+        code === "ERR_STREAM_DESTROYED");
+}
+function replayParsedJsonBody(request) {
+    if (!request.readableEnded || request.body === undefined)
+        return undefined;
+    if (!request.header("content-type")?.toLowerCase().includes("json"))
+        return undefined;
+    const body = Buffer.from(JSON.stringify(request.body));
+    request.headers["content-length"] = String(body.byteLength);
+    delete request.headers["transfer-encoding"];
+    return Readable.from(body);
+}
+async function injectHtmlHead(proxyResponse, response, head) {
+    try {
+        const chunks = [];
+        for await (const chunk of proxyResponse) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        const source = Buffer.concat(chunks).toString("utf8");
+        const body = source.includes("<head>")
+            ? source.replace("<head>", `<head>${head}`)
+            : source.includes("</head>")
+                ? source.replace("</head>", `${head}</head>`)
+                : source;
+        for (const [name, value] of Object.entries(proxyResponse.headers)) {
+            if (value === undefined || name === "content-length" || name === "transfer-encoding") {
+                continue;
+            }
+            response.setHeader(name, value);
+        }
+        response.statusCode = proxyResponse.statusCode ?? 200;
+        if (proxyResponse.statusMessage)
+            response.statusMessage = proxyResponse.statusMessage;
+        response.setHeader("content-length", Buffer.byteLength(body));
+        response.end(body);
+    }
+    catch (error) {
+        logger.warn("Lakebox route HTML injection failed", {
+            error: errorUtils.toError(error),
+        });
+        if (!response.headersSent)
+            response.writeHead(502);
+        response.end("Lakebox route unavailable");
+    }
+}
+function pipeProxyResponse(proxyResponse, response) {
+    for (const [name, value] of Object.entries(proxyResponse.headers)) {
+        if (value !== undefined)
+            response.setHeader(name, value);
+    }
+    response.statusCode = proxyResponse.statusCode ?? 200;
+    if (proxyResponse.statusMessage)
+        response.statusMessage = proxyResponse.statusMessage;
+    proxyResponse.pipe(response);
+}
+async function closeServer(server) {
+    await new Promise((resolve) => server.close(() => resolve()));
+}
+function routeRedirectUrl(url, routePath) {
+    const parsed = new URL(url, "http://localhost");
+    parsed.pathname = `${routePath}/`;
+    return `${parsed.pathname}${parsed.search}`;
+}
+/**
+ * Keep the AppKit request URL on the inbound IncomingMessage so AppKit's
+ * request logging and tracing see the public route. Prefix
+ * stripping is applied only on the outbound proxy request.
+ */
+function outboundPath(requestUrl, stripPrefix) {
+    const url = requestUrl && requestUrl.length > 0 ? requestUrl : "/";
+    const queryIndex = url.indexOf("?");
+    const pathname = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
+    const query = queryIndex >= 0 ? url.slice(queryIndex) : "";
+    if (!stripPrefix)
+        return url.startsWith("/") ? url : `/${url}`;
+    return `${pathname.slice(stripPrefix.length) || "/"}${query}`;
+}
+async function listenTarget(server) {
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to bind Lakebox route bridge");
+    }
+    return { host: "127.0.0.1", port: address.port, protocol: "http:" };
+}
+function bridgeSocket(socket, channelPromise, readyTimeoutMs, initialData) {
+    const pending = new PassThrough({ highWaterMark: MAX_PENDING_BYTES });
+    let channel;
+    let timedOut = false;
+    const readyTimeout = setTimeout(() => {
+        timedOut = true;
+        pending.destroy();
+        channel?.destroy();
+        if (!socket.destroyed) {
+            socket.end("HTTP/1.1 504 Gateway Timeout\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+        }
+    }, readyTimeoutMs);
+    readyTimeout.unref?.();
+    const clearReadyTimeout = () => clearTimeout(readyTimeout);
+    if (initialData)
+        pending.write(initialData);
+    socket.once("error", () => {
+        clearReadyTimeout();
+        pending.destroy();
+        channel?.destroy();
+    });
+    socket.pipe(pending);
+    socket.once("close", () => {
+        clearReadyTimeout();
+        pending.destroy();
+        channel?.destroy();
+    });
+    void channelPromise.then((openedChannel) => {
+        if (timedOut || socket.destroyed) {
+            pending.destroy();
+            openedChannel.destroy();
+            return;
+        }
+        channel = openedChannel;
+        clearReadyTimeout();
+        let channelEnded = false;
+        channel.once("end", () => {
+            channelEnded = true;
+        });
+        channel.once("close", () => {
+            if (!channelEnded && !socket.destroyed)
+                socket.destroy();
+        });
+        channel.once("error", () => socket.destroy());
+        channel.pipe(socket);
+        pending.pipe(channel);
+    }, (error) => {
+        clearReadyTimeout();
+        if (!timedOut && !socket.destroyed) {
+            logger.warn("Lakebox route forwarding channel failed", {
+                error: errorUtils.toError(error),
+            });
+            socket.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+        }
+        pending.destroy();
+        if (timedOut || socket.destroyed)
+            socket.destroy();
+    });
+}
+function proxyWebSocket(request, socket, head, session, port, readyTimeoutMs) {
+    stripWebsocketIdentityHeaders(request);
+    request.headers.origin = `http://127.0.0.1:${port}`;
+    request.headers.host = `127.0.0.1:${port}`;
+    bridgeSocket(socket, session.forwardOut("127.0.0.1", port), readyTimeoutMs, serializeUpgradeRequest(request, head));
+}
+function stripWebsocketIdentityHeaders(request) {
+    for (const name of [
+        "authorization",
+        "cookie",
+        ACCESS_TOKEN_HEADER,
+        USER_EMAIL_HEADER,
+        USER_ID_HEADER,
+    ]) {
+        delete request.headers[name];
+    }
+}
+function serializeUpgradeRequest(request, head) {
+    const lines = [
+        `${request.method ?? "GET"} ${request.url ?? "/"} HTTP/${request.httpVersion || "1.1"}`,
+    ];
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (value === undefined)
+            continue;
+        for (const item of Array.isArray(value) ? value : [value]) {
+            lines.push(`${name}: ${item}`);
+        }
+    }
+    lines.push("", "");
+    return Buffer.concat([Buffer.from(lines.join("\r\n")), head]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routes.js","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from \"node:http\";\nimport { createServer, type Server, type Socket } from \"node:net\";\nimport { type Duplex, PassThrough, Readable } from \"node:stream\";\nimport { ACCESS_TOKEN_HEADER, USER_EMAIL_HEADER, USER_ID_HEADER } from \"@dbx-tools/appkit\";\nimport type { SshSession } from \"@dbx-tools/lakebox/session\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport type { LakeboxUser } from \"@dbx-tools/shared-lakebox\";\nimport type { NextFunction, Request, Response } from \"express\";\nimport ProxyModule from \"http-proxy-3\";\nimport type { LakeboxServiceRoute } from \"./services.ts\";\n\nconst MAX_PENDING_BYTES = 1024 * 1024;\nconst FORWARDING_READY_TIMEOUT_MS = 15_000;\nconst logger = log.logger(\"appkit-lakebox:routes\");\n\n/** Result of resolving one user's service for a routed request. */\nexport type LakeboxRouteResolution =\n  | { kind: \"ready\"; session: SshSession; route: LakeboxServiceRoute }\n  | { kind: \"loading\" }\n  | { kind: \"failed\"; message: string }\n  | { kind: \"missing\" };\n\n/** Runtime callbacks that authorize and resolve deterministic routes. */\nexport interface LakeboxRouteResolver {\n  /** Returns the authenticated Lakebox user for request headers, or `undefined`. */\n  user(headers: IncomingHttpHeaders): LakeboxUser | undefined;\n  /**\n   * Resolves a running service. Returns `loading` after starting the Lakebox\n   * or service in the background, and `missing` for an unknown service.\n   */\n  resolve(user: LakeboxUser, service: string): Promise<LakeboxRouteResolution>;\n  /** Reports that a ready service refused a forwarded connection. */\n  unavailable(user: LakeboxUser, service: string): void;\n}\n\ninterface RouteMatch {\n  userHash: string;\n  service: string;\n  mount: string;\n}\n\ninterface Bridge {\n  session: SshSession;\n  server: Server;\n  target: { host: string; port: number; protocol: string };\n  sockets: Set<Socket>;\n}\n\ninterface PendingResponse {\n  user: LakeboxUser;\n  service: string;\n  head?: string;\n}\n\n/**\n * Proxies `<prefix>/<user-hash>/<service>` to that user's service port.\n *\n * The user hash is the only routing key. A request is forwarded only when its\n * authenticated identity hashes to the same value, and the port is derived from\n * the hash and service name, so there is no stored route table. Requests\n * without an identity are rejected with 404, including WebSocket upgrades.\n */\nexport class LakeboxRouteRegistry {\n  private readonly bridges = new Map<number, Bridge>();\n  private readonly upgrades = new Set<Socket>();\n  private readonly pending = new WeakMap<IncomingMessage, PendingResponse>();\n  private readonly proxy = ProxyModule.createProxyServer({ ws: true, xfwd: true });\n  private shuttingDown = false;\n\n  /** Creates a registry beneath one AppKit route prefix. */\n  constructor(\n    private readonly prefix: string,\n    private readonly resolver: LakeboxRouteResolver,\n    private readonly forwardingReadyTimeoutMs = FORWARDING_READY_TIMEOUT_MS,\n  ) {\n    this.proxy.on(\"error\", (error, request, response) => {\n      if (this.shuttingDown && isConnectionClosureError(error)) {\n        response.destroy();\n        return;\n      }\n      const pending = this.pending.get(request);\n      if (pending && \"writeHead\" in response && !response.headersSent) {\n        this.resolver.unavailable(pending.user, pending.service);\n        sendLoadingResponse(request.headers.accept, response);\n        return;\n      }\n      logger.warn(\"Lakebox route proxy failed\", {\n        method: request.method,\n        path: request.url,\n        error,\n      });\n      if (\"writeHead\" in response) {\n        if (response.headersSent) {\n          response.destroy();\n        } else {\n          response.writeHead(502);\n          response.end(\"Lakebox route unavailable\");\n        }\n      } else if (!response.destroyed) {\n        response.destroy();\n      }\n    });\n    this.proxy.on(\"proxyRes\", (proxyResponse, request, response) => {\n      const pending = this.pending.get(request);\n      if (pending && [502, 503, 504].includes(proxyResponse.statusCode ?? 0)) {\n        proxyResponse.resume();\n        this.resolver.unavailable(pending.user, pending.service);\n        sendLoadingResponse(request.headers.accept, response);\n        return;\n      }\n      if (pending?.head) {\n        void injectHtmlHead(proxyResponse, response, pending.head);\n        return;\n      }\n      pipeProxyResponse(proxyResponse, response);\n    });\n  }\n\n  /** Returns the route path segment match for a request path. */\n  match(path: string): RouteMatch | undefined {\n    const root = this.prefix.replace(/\\/+$/, \"\");\n    if (!path.startsWith(`${root}/`)) return undefined;\n    const [userHash, service] = path.slice(root.length + 1).split(\"/\");\n    if (!userHash || !service) return undefined;\n    return { userHash, service, mount: `${root}/${userHash}/${service}` };\n  }\n\n  /** Express middleware that authorizes, rewrites, and proxies matching requests. */\n  middleware() {\n    return async (request: Request, response: Response, next: NextFunction) => {\n      const match = this.match(request.path);\n      if (!match) return next();\n      const user = this.authorize(request.headers, match);\n      if (!user) {\n        response.statusCode = 404;\n        response.end(\"Not Found\");\n        return;\n      }\n      if (request.path === match.mount) {\n        response.statusCode = 308;\n        response.setHeader(\"location\", routeRedirectUrl(request.url, match.mount));\n        response.end();\n        return;\n      }\n      let resolution: LakeboxRouteResolution;\n      try {\n        resolution = await this.resolver.resolve(user, match.service);\n      } catch (error) {\n        return next(error);\n      }\n      if (resolution.kind === \"missing\") {\n        response.statusCode = 404;\n        response.end(\"Not Found\");\n        return;\n      }\n      if (resolution.kind === \"loading\") {\n        sendLoadingResponse(request.header(\"accept\"), response);\n        return;\n      }\n      if (resolution.kind === \"failed\") {\n        response.statusCode = 502;\n        response.setHeader(\"content-type\", \"text/plain; charset=utf-8\");\n        response.end(`Lakebox service failed: ${resolution.message}`);\n        return;\n      }\n      const bridge = await this.bridge(resolution.session, resolution.route.port);\n      const head =\n        request.method === \"GET\" && request.path === `${match.mount}/`\n          ? resolution.route.htmlHead\n          : undefined;\n      if (head) request.headers[\"accept-encoding\"] = \"identity\";\n      this.pending.set(request, { user, service: match.service, ...(head ? { head } : {}) });\n      const replayBody = replayParsedJsonBody(request);\n      if (resolution.route.stripPrefix) request.url = outboundPath(request.url, match.mount);\n      stripIdentityHeaders(request);\n      this.proxy.web(request, response, {\n        target: bridge.target,\n        changeOrigin: true,\n        selfHandleResponse: true,\n        ...(replayBody ? { buffer: replayBody } : {}),\n      });\n    };\n  }\n\n  /** Number of open forwarded HTTP and WebSocket connections. */\n  activeConnections(): number {\n    let count = this.upgrades.size;\n    for (const bridge of this.bridges.values()) count += bridge.sockets.size;\n    return count;\n  }\n\n  /** Returns whether an upgrade path belongs to the Lakebox route prefix. */\n  canHandleUpgrade(path: string): boolean {\n    return Boolean(this.match(path));\n  }\n\n  /** Proxies an authorized WebSocket upgrade. Returns false when it was not handled. */\n  async handleUpgrade(request: IncomingMessage, socket: Socket, head: Buffer): Promise<boolean> {\n    const url = new URL(request.url ?? \"/\", \"http://localhost\");\n    const match = this.match(url.pathname);\n    if (!match) return false;\n    const user = this.authorize(request.headers, match);\n    if (!user) return false;\n    const resolution = await this.resolver.resolve(user, match.service);\n    if (resolution.kind !== \"ready\") return false;\n    if (resolution.route.stripPrefix) request.url = outboundPath(request.url, match.mount);\n    this.upgrades.add(socket);\n    socket.once(\"close\", () => this.upgrades.delete(socket));\n    proxyWebSocket(\n      request,\n      socket,\n      head,\n      resolution.session,\n      resolution.route.port,\n      this.forwardingReadyTimeoutMs,\n    );\n    return true;\n  }\n\n  /** Closes every forwarding bridge, for example after the Lakebox stops. */\n  async closeBridges(): Promise<void> {\n    this.upgrades.forEach((socket) => socket.destroy());\n    this.upgrades.clear();\n    const bridges = [...this.bridges.values()];\n    this.bridges.clear();\n    await Promise.all(bridges.map(closeBridge));\n  }\n\n  /** Suppresses expected proxy errors once shutdown begins. */\n  beginShutdown(): void {\n    this.shuttingDown = true;\n  }\n\n  /** Closes bridges and the shared proxy. */\n  async close(): Promise<void> {\n    this.beginShutdown();\n    await this.closeBridges();\n    this.proxy.close();\n  }\n\n  private authorize(headers: IncomingHttpHeaders, match: RouteMatch): LakeboxUser | undefined {\n    const user = this.resolver.user(headers);\n    return user?.hash === match.userHash ? user : undefined;\n  }\n\n  private async bridge(session: SshSession, port: number): Promise<Bridge> {\n    const existing = this.bridges.get(port);\n    if (existing?.session === session) return existing;\n    if (existing) {\n      this.bridges.delete(port);\n      void closeBridge(existing);\n    }\n    const sockets = new Set<Socket>();\n    const server = createServer((socket) => {\n      sockets.add(socket);\n      socket.once(\"close\", () => sockets.delete(socket));\n      bridgeSocket(socket, session.forwardOut(\"127.0.0.1\", port), this.forwardingReadyTimeoutMs);\n    });\n    const target = await listenTarget(server);\n    const bridge = { session, server, target, sockets };\n    const raced = this.bridges.get(port);\n    if (raced?.session === session) {\n      void closeBridge(bridge);\n      return raced;\n    }\n    this.bridges.set(port, bridge);\n    return bridge;\n  }\n}\n\nasync function closeBridge(bridge: Bridge): Promise<void> {\n  bridge.sockets.forEach((socket) => socket.destroy());\n  await closeServer(bridge.server);\n}\n\nfunction stripIdentityHeaders(request: IncomingMessage): void {\n  for (const name of [ACCESS_TOKEN_HEADER, \"authorization\", \"cookie\"]) delete request.headers[name];\n}\n\nfunction sendLoadingResponse(\n  accept: string | string[] | undefined,\n  response: Pick<ServerResponse, \"statusCode\" | \"setHeader\" | \"end\">,\n): void {\n  response.statusCode = 202;\n  response.setHeader(\"cache-control\", \"no-store\");\n  response.setHeader(\"retry-after\", \"2\");\n  const acceptsHtml = (Array.isArray(accept) ? accept.join(\",\") : (accept ?? \"\"))\n    .toLowerCase()\n    .includes(\"text/html\");\n  if (!acceptsHtml) {\n    response.setHeader(\"content-type\", \"application/json; charset=utf-8\");\n    response.end(JSON.stringify({ status: \"loading\", message: \"Starting Lakebox service\" }));\n    return;\n  }\n  response.setHeader(\"content-type\", \"text/html; charset=utf-8\");\n  response.end(`<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">\n<meta http-equiv=\"refresh\" content=\"2\">\n<title>Starting Lakebox service</title>\n<style>\nhtml{color-scheme:light dark;font-family:system-ui,sans-serif}body{min-height:100vh;margin:0;display:grid;place-items:center;background:Canvas;color:CanvasText}.loading{display:flex;align-items:center;gap:.75rem}.spinner{width:1.25rem;height:1.25rem;border:.2rem solid color-mix(in srgb,CanvasText 20%,transparent);border-top-color:CanvasText;border-radius:50%;animation:spin .8s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}\n</style>\n</head>\n<body><div class=\"loading\" role=\"status\"><span class=\"spinner\" aria-hidden=\"true\"></span><span>Starting Lakebox service</span></div></body>\n</html>`);\n}\n\nfunction isConnectionClosureError(error: unknown): boolean {\n  const code =\n    error && typeof error === \"object\" && \"code\" in error\n      ? String((error as { code?: unknown }).code)\n      : undefined;\n  return (\n    code === \"ECONNRESET\" ||\n    code === \"EPIPE\" ||\n    code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n    code === \"ERR_STREAM_DESTROYED\"\n  );\n}\n\nfunction replayParsedJsonBody(request: Request): Readable | undefined {\n  if (!request.readableEnded || request.body === undefined) return undefined;\n  if (!request.header(\"content-type\")?.toLowerCase().includes(\"json\")) return undefined;\n  const body = Buffer.from(JSON.stringify(request.body));\n  request.headers[\"content-length\"] = String(body.byteLength);\n  delete request.headers[\"transfer-encoding\"];\n  return Readable.from(body);\n}\n\nasync function injectHtmlHead(\n  proxyResponse: IncomingMessage,\n  response: ServerResponse,\n  head: string,\n): Promise<void> {\n  try {\n    const chunks: Buffer[] = [];\n    for await (const chunk of proxyResponse) {\n      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));\n    }\n    const source = Buffer.concat(chunks).toString(\"utf8\");\n    const body = source.includes(\"<head>\")\n      ? source.replace(\"<head>\", `<head>${head}`)\n      : source.includes(\"</head>\")\n        ? source.replace(\"</head>\", `${head}</head>`)\n        : source;\n    for (const [name, value] of Object.entries(proxyResponse.headers)) {\n      if (value === undefined || name === \"content-length\" || name === \"transfer-encoding\") {\n        continue;\n      }\n      response.setHeader(name, value);\n    }\n    response.statusCode = proxyResponse.statusCode ?? 200;\n    if (proxyResponse.statusMessage) response.statusMessage = proxyResponse.statusMessage;\n    response.setHeader(\"content-length\", Buffer.byteLength(body));\n    response.end(body);\n  } catch (error) {\n    logger.warn(\"Lakebox route HTML injection failed\", {\n      error: errorUtils.toError(error),\n    });\n    if (!response.headersSent) response.writeHead(502);\n    response.end(\"Lakebox route unavailable\");\n  }\n}\n\nfunction pipeProxyResponse(proxyResponse: IncomingMessage, response: ServerResponse): void {\n  for (const [name, value] of Object.entries(proxyResponse.headers)) {\n    if (value !== undefined) response.setHeader(name, value);\n  }\n  response.statusCode = proxyResponse.statusCode ?? 200;\n  if (proxyResponse.statusMessage) response.statusMessage = proxyResponse.statusMessage;\n  proxyResponse.pipe(response);\n}\n\nasync function closeServer(server: Server): Promise<void> {\n  await new Promise<void>((resolve) => server.close(() => resolve()));\n}\n\nfunction routeRedirectUrl(url: string, routePath: string): string {\n  const parsed = new URL(url, \"http://localhost\");\n  parsed.pathname = `${routePath}/`;\n  return `${parsed.pathname}${parsed.search}`;\n}\n\n/**\n * Keep the AppKit request URL on the inbound IncomingMessage so AppKit's\n * request logging and tracing see the public route. Prefix\n * stripping is applied only on the outbound proxy request.\n */\nfunction outboundPath(requestUrl: string | undefined, stripPrefix?: string): string {\n  const url = requestUrl && requestUrl.length > 0 ? requestUrl : \"/\";\n  const queryIndex = url.indexOf(\"?\");\n  const pathname = queryIndex >= 0 ? url.slice(0, queryIndex) : url;\n  const query = queryIndex >= 0 ? url.slice(queryIndex) : \"\";\n  if (!stripPrefix) return url.startsWith(\"/\") ? url : `/${url}`;\n  return `${pathname.slice(stripPrefix.length) || \"/\"}${query}`;\n}\n\nasync function listenTarget(\n  server: Server,\n): Promise<{ host: string; port: number; protocol: string }> {\n  await new Promise<void>((resolve, reject) => {\n    server.once(\"error\", reject);\n    server.listen(0, \"127.0.0.1\", resolve);\n  });\n  const address = server.address();\n  if (!address || typeof address === \"string\") {\n    throw new Error(\"Failed to bind Lakebox route bridge\");\n  }\n  return { host: \"127.0.0.1\", port: address.port, protocol: \"http:\" };\n}\n\nfunction bridgeSocket(\n  socket: Socket,\n  channelPromise: Promise<Duplex>,\n  readyTimeoutMs: number,\n  initialData?: Buffer,\n): void {\n  const pending = new PassThrough({ highWaterMark: MAX_PENDING_BYTES });\n  let channel: Duplex | undefined;\n  let timedOut = false;\n  const readyTimeout = setTimeout(() => {\n    timedOut = true;\n    pending.destroy();\n    channel?.destroy();\n    if (!socket.destroyed) {\n      socket.end(\"HTTP/1.1 504 Gateway Timeout\\r\\nConnection: close\\r\\nContent-Length: 0\\r\\n\\r\\n\");\n    }\n  }, readyTimeoutMs);\n  readyTimeout.unref?.();\n  const clearReadyTimeout = () => clearTimeout(readyTimeout);\n  if (initialData) pending.write(initialData);\n  socket.once(\"error\", () => {\n    clearReadyTimeout();\n    pending.destroy();\n    channel?.destroy();\n  });\n  socket.pipe(pending);\n  socket.once(\"close\", () => {\n    clearReadyTimeout();\n    pending.destroy();\n    channel?.destroy();\n  });\n\n  void channelPromise.then(\n    (openedChannel) => {\n      if (timedOut || socket.destroyed) {\n        pending.destroy();\n        openedChannel.destroy();\n        return;\n      }\n      channel = openedChannel;\n      clearReadyTimeout();\n      let channelEnded = false;\n      channel.once(\"end\", () => {\n        channelEnded = true;\n      });\n      channel.once(\"close\", () => {\n        if (!channelEnded && !socket.destroyed) socket.destroy();\n      });\n      channel.once(\"error\", () => socket.destroy());\n      channel.pipe(socket);\n      pending.pipe(channel);\n    },\n    (error) => {\n      clearReadyTimeout();\n      if (!timedOut && !socket.destroyed) {\n        logger.warn(\"Lakebox route forwarding channel failed\", {\n          error: errorUtils.toError(error),\n        });\n        socket.end(\"HTTP/1.1 502 Bad Gateway\\r\\nConnection: close\\r\\nContent-Length: 0\\r\\n\\r\\n\");\n      }\n      pending.destroy();\n      if (timedOut || socket.destroyed) socket.destroy();\n    },\n  );\n}\n\nfunction proxyWebSocket(\n  request: IncomingMessage,\n  socket: Socket,\n  head: Buffer,\n  session: SshSession,\n  port: number,\n  readyTimeoutMs: number,\n): void {\n  stripWebsocketIdentityHeaders(request);\n  request.headers.origin = `http://127.0.0.1:${port}`;\n  request.headers.host = `127.0.0.1:${port}`;\n  bridgeSocket(\n    socket,\n    session.forwardOut(\"127.0.0.1\", port),\n    readyTimeoutMs,\n    serializeUpgradeRequest(request, head),\n  );\n}\n\nfunction stripWebsocketIdentityHeaders(request: IncomingMessage): void {\n  for (const name of [\n    \"authorization\",\n    \"cookie\",\n    ACCESS_TOKEN_HEADER,\n    USER_EMAIL_HEADER,\n    USER_ID_HEADER,\n  ]) {\n    delete request.headers[name];\n  }\n}\n\nfunction serializeUpgradeRequest(request: IncomingMessage, head: Buffer): Buffer {\n  const lines = [\n    `${request.method ?? \"GET\"} ${request.url ?? \"/\"} HTTP/${request.httpVersion || \"1.1\"}`,\n  ];\n  for (const [name, value] of Object.entries(request.headers)) {\n    if (value === undefined) continue;\n    for (const item of Array.isArray(value) ? value : [value]) {\n      lines.push(`${name}: ${item}`);\n    }\n  }\n  lines.push(\"\", \"\");\n  return Buffer.concat([Buffer.from(lines.join(\"\\r\\n\")), head]);\n}\n"]}