@rynx-ai/daemon 0.1.0 → 0.1.10-beta.2

package/dist/chrome-inspection-gateway.js

@@ -0,0 +1,806 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer, } from "node:http";
+import { createConnection, } from "node:net";
+import WebSocket, { WebSocketServer } from "ws";
+const LOOPBACK_HOST = "127.0.0.1";
+const DEFAULT_PORT = 9_333;
+const DEFAULT_OPEN_TIMEOUT_MS = 10_000;
+const DEFAULT_MAX_CONNECTIONS = 64;
+const DEFAULT_MAX_PENDING_OPENINGS = 16;
+const MAX_CDP_MESSAGE_BYTES = 16 * 1024 * 1024;
+const MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+const MAX_HANDSHAKE_BYTES = 64 * 1024;
+const SHUTDOWN_TIMEOUT_MS = 1_000;
+const ROUTE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,128}$/;
+const PAGE_ROUTE_PREFIX = "/devtools/page/";
+const WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+/**
+ * Stable loopback discovery endpoint consumed by stock Chrome.
+ *
+ * This gateway owns no Browser. It rewrites only discovery metadata and then
+ * bridges each DevTools WebSocket to an exact target supplied by the daemon.
+ */
+export async function startChromeInspectionGateway(options) {
+    const requestedPort = options.port ?? DEFAULT_PORT;
+    if (!Number.isInteger(requestedPort) || requestedPort < 0 || requestedPort > 65_535) {
+        throw new Error("Chrome inspection port must be an integer between 0 and 65535");
+    }
+    const openTimeoutMs = boundedPositiveInteger(options.openTimeoutMs ?? DEFAULT_OPEN_TIMEOUT_MS, "openTimeoutMs");
+    const maxConnections = boundedPositiveInteger(options.maxConnections ?? DEFAULT_MAX_CONNECTIONS, "maxConnections");
+    const maxPendingOpenings = boundedPositiveInteger(options.maxPendingOpenings ?? DEFAULT_MAX_PENDING_OPENINGS, "maxPendingOpenings");
+    if (maxPendingOpenings > maxConnections) {
+        throw new Error("maxPendingOpenings must not exceed maxConnections");
+    }
+    const randomToken = options.randomToken ?? (() => randomBytes(24).toString("base64url"));
+    const byKey = new Map();
+    const byToken = new Map();
+    const peerByClient = new Map();
+    const tokenByClient = new Map();
+    const tunnelPeerByClient = new Map();
+    const tunnelTokenByClient = new Map();
+    const pendingOpenings = new Map();
+    const upgradeTasks = new Set();
+    const closingPeers = new Set();
+    let stopping = false;
+    const server = createServer((request, response) => {
+        void handleHttp(request, response).catch((error) => {
+            options.onError?.(asError(error), "HTTP request");
+            if (!response.headersSent) {
+                response.statusCode = 500;
+                setCommonHeaders(response);
+            }
+            response.end("internal error\n");
+        });
+    });
+    const webSocketServer = new WebSocketServer({
+        noServer: true,
+        clientTracking: true,
+        perMessageDeflate: false,
+        maxPayload: MAX_CDP_MESSAGE_BYTES,
+    });
+    server.on("upgrade", (request, socket, head) => {
+        const task = handleUpgrade(request, socket, head).catch((error) => {
+            options.onError?.(asError(error), "WebSocket upgrade");
+            rejectUpgrade(socket, 502, "Chrome inspection target is unavailable");
+        });
+        upgradeTasks.add(task);
+        void task.finally(() => upgradeTasks.delete(task)).catch(() => undefined);
+    });
+    server.on("error", (error) => options.onError?.(error, "listener"));
+    await listen(server, requestedPort);
+    const address = server.address();
+    const port = address.port;
+    const authority = `${LOOPBACK_HOST}:${port}`;
+    const httpEndpoint = `http://${authority}`;
+    async function handleHttp(request, response) {
+        setCommonHeaders(response);
+        if (stopping)
+            return respond(response, 503, "stopping\n");
+        if (!isTrustedRequest(request, authority))
+            return respond(response, 403, "forbidden\n");
+        if (request.method !== "GET") {
+            response.setHeader("allow", "GET");
+            return respond(response, 405, "method not allowed\n");
+        }
+        const url = requestUrl(request);
+        if (!url)
+            return respond(response, 400, "bad request\n");
+        if (url.pathname === "/json/version") {
+            return respondJson(response, 200, {
+                Browser: "Chrome/145.0.0.0",
+                "Protocol-Version": "1.3",
+                "User-Agent": "Rynx Chrome Inspection Gateway",
+            });
+        }
+        if (url.pathname === "/json" || url.pathname === "/json/list") {
+            const targets = await refreshTargets();
+            return respondJson(response, 200, targets.map(({ token, target }) => {
+                const path = `${PAGE_ROUTE_PREFIX}${token}`;
+                const ws = `ws://${authority}${path}`;
+                return {
+                    description: target.description,
+                    devtoolsFrontendUrl: `/devtools/inspector.html?ws=${authority}${path}`,
+                    id: token,
+                    title: target.title,
+                    type: "page",
+                    url: target.url,
+                    webSocketDebuggerUrl: ws,
+                };
+            }));
+        }
+        const action = actionRoute(url.pathname);
+        if (action) {
+            const registered = byToken.get(action.token);
+            if (!registered)
+                return respond(response, 404, "no such target\n");
+            if (action.action === "activate") {
+                if (!options.source.activate)
+                    return respond(response, 405, "activation unsupported\n");
+                await options.source.activate(registered.target);
+                return respond(response, 200, "target activated\n");
+            }
+            if (!options.source.close)
+                return respond(response, 405, "close unsupported\n");
+            await options.source.close(registered.target);
+            return respond(response, 200, "target is closing\n");
+        }
+        return respond(response, 404, "not found\n");
+    }
+    async function handleUpgrade(request, socket, head) {
+        socket.pause();
+        if (stopping)
+            return rejectUpgrade(socket, 503, "Chrome inspection is stopping");
+        if (!isTrustedRequest(request, authority)) {
+            return rejectUpgrade(socket, 403, "Chrome inspection request is forbidden");
+        }
+        if (!isValidWebSocketHandshake(request)) {
+            return rejectUpgrade(socket, 400, "Invalid Chrome inspection WebSocket upgrade");
+        }
+        const url = requestUrl(request);
+        const token = url && exactPageRouteToken(url);
+        const registered = token ? byToken.get(token) : undefined;
+        if (!registered)
+            return rejectUpgrade(socket, 404, "Chrome inspection target was not found");
+        if (pendingOpenings.size >= maxPendingOpenings ||
+            peerByClient.size + tunnelPeerByClient.size + pendingOpenings.size >= maxConnections) {
+            return rejectUpgrade(socket, 503, "Chrome inspection connection capacity reached");
+        }
+        if (pendingOpenings.has(token) ||
+            [...tokenByClient.values()].some((activeToken) => activeToken === token) ||
+            [...tunnelTokenByClient.values()].some((activeToken) => activeToken === token)) {
+            return rejectUpgrade(socket, 409, "Chrome inspection target is already inspected");
+        }
+        const opening = new AbortController();
+        const abortOpening = () => {
+            opening.abort(new Error("Chrome inspection client disconnected during opening"));
+        };
+        socket.once("close", abortOpening);
+        socket.once("end", abortOpening);
+        socket.once("error", abortOpening);
+        pendingOpenings.set(token, opening);
+        let upstream;
+        let claimed = false;
+        try {
+            upstream = await openTargetConnection(options.source, registered.target, request, openTimeoutMs, opening.signal);
+            if (stopping || socket.destroyed || byToken.get(token) !== registered) {
+                return rejectUpgrade(socket, 404, "Chrome inspection target became stale");
+            }
+            if (upstream.kind === "tunnel") {
+                bridgeRawTunnel(socket, upstream.socket, head, upstream.handshake, token);
+                claimed = true;
+                return;
+            }
+            const connection = upstream.connection;
+            const closeUpstream = upstream.close;
+            webSocketServer.handleUpgrade(request, socket, head, (client) => {
+                claimed = true;
+                tokenByClient.set(client, token);
+                const placeholder = {
+                    close: async () => {
+                        if (client.readyState !== WebSocket.CLOSED)
+                            client.terminate();
+                        peerByClient.delete(client);
+                        tokenByClient.delete(client);
+                        await closeUpstream().catch(() => undefined);
+                    },
+                };
+                peerByClient.set(client, placeholder);
+                const peer = bridgeConnection(client, connection);
+                if (peerByClient.get(client) === placeholder) {
+                    peerByClient.set(client, peer);
+                }
+                else {
+                    void peer.close("Chrome inspection bridge closed during registration").catch(() => undefined);
+                }
+                webSocketServer.emit("connection", client, request);
+                socket.resume();
+            });
+        }
+        finally {
+            socket.removeListener("close", abortOpening);
+            socket.removeListener("end", abortOpening);
+            socket.removeListener("error", abortOpening);
+            if (pendingOpenings.get(token) === opening) {
+                pendingOpenings.delete(token);
+            }
+            if (!claimed && upstream) {
+                await upstream.close().catch(() => undefined);
+            }
+        }
+    }
+    async function refreshTargets() {
+        const projected = await options.source.listTargets();
+        const seen = new Set();
+        const registered = [];
+        for (const target of projected) {
+            validateTarget(target);
+            if (seen.has(target.key))
+                throw new Error("Chrome inspection source returned duplicate target keys");
+            seen.add(target.key);
+            let entry = byKey.get(target.key);
+            if (!entry) {
+                const token = uniqueToken(randomToken, byToken);
+                entry = { token, target: { ...target } };
+                byKey.set(target.key, entry);
+                byToken.set(token, entry);
+            }
+            else {
+                entry.target = { ...target };
+            }
+            registered.push(entry);
+        }
+        for (const [key, entry] of byKey) {
+            if (seen.has(key))
+                continue;
+            byKey.delete(key);
+            byToken.delete(entry.token);
+            // Discovery controls only new routes. An established DevTools socket
+            // stays attached until either endpoint closes its actual transport.
+            pendingOpenings.get(entry.token)?.abort(new Error("Chrome inspection target disappeared"));
+        }
+        return registered;
+    }
+    function bridgeRawTunnel(client, upstream, clientHead, upstreamHandshake, token) {
+        if (client.destroyed || upstream.destroyed) {
+            throw new Error("Chrome inspection tunnel closed during handoff");
+        }
+        let closed = false;
+        let peer;
+        const finish = () => {
+            if (closed)
+                return;
+            closed = true;
+            if (tunnelPeerByClient.get(client) === peer) {
+                tunnelPeerByClient.delete(client);
+                tunnelTokenByClient.delete(client);
+            }
+            client.unpipe(upstream);
+            upstream.unpipe(client);
+            if (!client.destroyed)
+                client.destroy();
+            if (!upstream.destroyed)
+                upstream.destroy();
+        };
+        peer = {
+            close: async () => {
+                finish();
+            },
+        };
+        tunnelPeerByClient.set(client, peer);
+        tunnelTokenByClient.set(client, token);
+        client.once("close", finish);
+        client.once("error", finish);
+        upstream.once("close", finish);
+        upstream.once("error", finish);
+        try {
+            client.write(upstreamHandshake);
+            if (clientHead.byteLength > 0)
+                upstream.write(clientHead);
+            client.pipe(upstream);
+            upstream.pipe(client);
+            client.resume();
+            upstream.resume();
+        }
+        catch (error) {
+            finish();
+            throw error;
+        }
+        return peer;
+    }
+    function bridgeConnection(client, connection) {
+        let closed = false;
+        let connectionClosePromise;
+        const closeConnection = () => {
+            if (connectionClosePromise)
+                return connectionClosePromise;
+            const closing = Promise.resolve()
+                .then(() => connection.close())
+                .catch(() => undefined);
+            connectionClosePromise = closing;
+            closingPeers.add(closing);
+            void closing.finally(() => closingPeers.delete(closing)).catch(() => undefined);
+            return closing;
+        };
+        const finish = (code, reason, terminateClient = false) => {
+            if (closed)
+                return;
+            closed = true;
+            peerByClient.delete(client);
+            tokenByClient.delete(client);
+            void closeConnection();
+            if (terminateClient && client.readyState !== WebSocket.CLOSED) {
+                client.terminate();
+            }
+            else if (client.readyState === WebSocket.OPEN) {
+                client.close(code, reason.slice(0, 120));
+            }
+            else if (client.readyState !== WebSocket.CLOSED) {
+                client.terminate();
+            }
+        };
+        client.on("message", (data, isBinary) => {
+            if (closed)
+                return;
+            void connection.send(isBinary
+                ? { binary: true, data: rawDataBytes(data) }
+                : { binary: false, data: rawDataText(data) }).catch(() => {
+                finish(1_011, "Chrome inspection upstream failed", true);
+            });
+        });
+        client.on("close", () => finish(1_001, "Chrome inspection client closed"));
+        client.on("error", () => finish(1_011, "Chrome inspection client error"));
+        void (async () => {
+            try {
+                for await (const message of connection) {
+                    if (closed)
+                        break;
+                    await forwardFrame(client, message.data, message.binary);
+                }
+                finish(1_001, "Chrome inspection upstream closed");
+            }
+            catch {
+                finish(1_011, "Chrome inspection upstream failed");
+            }
+        })();
+        return {
+            close: async (reason) => {
+                finish(1_001, reason, true);
+                await closeConnection();
+            },
+        };
+    }
+    let shutdownPromise;
+    const shutdown = () => {
+        if (shutdownPromise)
+            return shutdownPromise;
+        stopping = true;
+        shutdownPromise = (async () => {
+            for (const opening of pendingOpenings.values())
+                opening.abort();
+            pendingOpenings.clear();
+            await Promise.allSettled([...upgradeTasks]);
+            const activeClosures = [
+                ...peerByClient.values(),
+                ...tunnelPeerByClient.values(),
+            ].map((peer) => peer.close("Chrome inspection gateway stopped"));
+            peerByClient.clear();
+            tokenByClient.clear();
+            tunnelPeerByClient.clear();
+            tunnelTokenByClient.clear();
+            await Promise.allSettled(activeClosures);
+            await Promise.allSettled([...closingPeers]);
+            await Promise.all([
+                closeWebSocketServer(webSocketServer),
+                closeHttpServer(server),
+            ]);
+        })();
+        return shutdownPromise;
+    };
+    return {
+        host: LOOPBACK_HOST,
+        port,
+        httpEndpoint,
+        shutdown,
+    };
+}
+function isTrustedRequest(request, authority) {
+    return request.headers.host === authority && isTrustedOrigin(request.headers.origin);
+}
+function isValidWebSocketHandshake(request) {
+    const key = request.headers["sec-websocket-key"];
+    return request.method === "GET" &&
+        request.httpVersion === "1.1" &&
+        headerHasToken(request.headers.connection, "upgrade") &&
+        request.headers.upgrade?.toLowerCase() === "websocket" &&
+        request.headers["sec-websocket-version"] === "13" &&
+        typeof key === "string" &&
+        /^[+/0-9A-Za-z]{22}==$/.test(key) &&
+        Buffer.from(key, "base64").byteLength === 16;
+}
+function isTrustedOrigin(origin) {
+    return origin === undefined ||
+        origin === "devtools://devtools" ||
+        origin === "chrome-devtools://devtools";
+}
+function requestUrl(request) {
+    try {
+        return new URL(request.url ?? "", "http://127.0.0.1");
+    }
+    catch {
+        return undefined;
+    }
+}
+function exactPageRouteToken(url) {
+    if (url.search || url.hash || !url.pathname.startsWith(PAGE_ROUTE_PREFIX))
+        return undefined;
+    const token = url.pathname.slice(PAGE_ROUTE_PREFIX.length);
+    return ROUTE_TOKEN_PATTERN.test(token) ? token : undefined;
+}
+function actionRoute(pathname) {
+    const match = /^\/json\/(activate|close)\/([A-Za-z0-9_-]{32,128})$/.exec(pathname);
+    if (!match)
+        return undefined;
+    return { action: match[1], token: match[2] };
+}
+function uniqueToken(factory, existing) {
+    for (let attempt = 0; attempt < 64; attempt += 1) {
+        const token = factory();
+        if (ROUTE_TOKEN_PATTERN.test(token) && !existing.has(token))
+            return token;
+    }
+    throw new Error("Chrome inspection route token factory did not produce a unique token");
+}
+function validateTarget(target) {
+    if (!target.key || target.key.length > 2_048) {
+        throw new Error("Chrome inspection target key is invalid");
+    }
+    for (const [field, value, limit] of [
+        ["title", target.title, 4_096],
+        ["url", target.url, 16 * 1_024],
+        ["description", target.description, 4_096],
+        ["engineVersion", target.engineVersion, 256],
+    ]) {
+        if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > limit) {
+            throw new Error(`Chrome inspection target ${field} is invalid`);
+        }
+    }
+}
+function parseLoopbackWebSocketEndpoint(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("Chrome inspection upstream endpoint is invalid");
+    }
+    if (url.protocol !== "ws:" ||
+        url.hostname !== LOOPBACK_HOST ||
+        !url.port ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        !url.pathname.startsWith("/devtools/")) {
+        throw new Error("Chrome inspection upstream endpoint must be a loopback CDP WebSocket URL");
+    }
+    return url;
+}
+async function openTargetConnection(source, target, request, openTimeoutMs, signal) {
+    const timeout = new AbortController();
+    const timeoutHandle = setTimeout(() => {
+        timeout.abort(new Error("Chrome inspection attachment opening timed out"));
+    }, openTimeoutMs);
+    timeoutHandle.unref?.();
+    const openingSignal = AbortSignal.any([signal, timeout.signal]);
+    try {
+        if (source.openConnection) {
+            const opening = source.openConnection(target, { signal: openingSignal });
+            let connection;
+            try {
+                connection = await waitForValue(opening, openTimeoutMs, openingSignal, "Chrome inspection attachment opening timed out");
+            }
+            catch (error) {
+                void opening.then((late) => late?.close()).catch(() => undefined);
+                throw error;
+            }
+            if (connection) {
+                return {
+                    kind: "connection",
+                    connection,
+                    close: async () => {
+                        await connection.close();
+                    },
+                };
+            }
+        }
+        if (!source.resolveWebSocketEndpoint) {
+            throw new Error("Chrome inspection target source cannot open attachments");
+        }
+        const endpoint = parseLoopbackWebSocketEndpoint(await waitForValue(source.resolveWebSocketEndpoint(target), openTimeoutMs, openingSignal, "Chrome inspection endpoint resolution timed out"));
+        return await openRawWebSocketUpstream(request, endpoint, openingSignal);
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+function openRawWebSocketUpstream(request, endpoint, signal) {
+    const key = request.headers["sec-websocket-key"];
+    if (typeof key !== "string") {
+        return Promise.reject(new Error("Chrome inspection WebSocket key is missing"));
+    }
+    const expectedAccept = createHash("sha1")
+        .update(`${key}${WEBSOCKET_GUID}`)
+        .digest("base64");
+    const socket = createConnection({
+        host: endpoint.hostname,
+        port: Number(endpoint.port),
+    });
+    socket.setNoDelay(true);
+    // Keep errors handled after the opening listeners are removed and before the
+    // active tunnel installs its own lifecycle listeners.
+    socket.on("error", () => undefined);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let response = Buffer.alloc(0);
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+            socket.removeListener("connect", onConnect);
+            socket.removeListener("data", onData);
+            socket.removeListener("close", onClose);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            socket.destroy();
+            reject(error);
+        };
+        const onAbort = () => {
+            fail(signal.reason instanceof Error
+                ? signal.reason
+                : new Error("Chrome inspection opening was cancelled"));
+        };
+        const onConnect = () => {
+            socket.write(serializeUpstreamHandshake(request, endpoint));
+        };
+        const onData = (chunk) => {
+            response = Buffer.concat([response, chunk]);
+            const headerEnd = response.indexOf("\r\n\r\n");
+            if (headerEnd < 0) {
+                if (response.byteLength > MAX_HANDSHAKE_BYTES) {
+                    fail(new Error("Chrome inspection upstream handshake is too large"));
+                }
+                return;
+            }
+            if (headerEnd + 4 > MAX_HANDSHAKE_BYTES) {
+                fail(new Error("Chrome inspection upstream handshake is too large"));
+                return;
+            }
+            try {
+                validateUpstreamHandshake(response.subarray(0, headerEnd + 4), expectedAccept);
+            }
+            catch (error) {
+                fail(asError(error));
+                return;
+            }
+            settled = true;
+            socket.pause();
+            cleanup();
+            resolve({
+                kind: "tunnel",
+                socket,
+                handshake: response,
+                close: async () => {
+                    if (!socket.destroyed)
+                        socket.destroy();
+                },
+            });
+        };
+        const onClose = () => {
+            fail(new Error("Chrome inspection upstream closed during handshake"));
+        };
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        socket.once("connect", onConnect);
+        socket.on("data", onData);
+        socket.once("close", onClose);
+    });
+}
+function serializeUpstreamHandshake(request, endpoint) {
+    const lines = [`GET ${endpoint.pathname} HTTP/1.1`];
+    let hostRewritten = false;
+    for (let index = 0; index < request.rawHeaders.length; index += 2) {
+        const name = request.rawHeaders[index];
+        const value = request.rawHeaders[index + 1];
+        const lowerName = name.toLowerCase();
+        if (lowerName === "origin" || lowerName === "sec-websocket-origin") {
+            // The gateway validates the browser Origin. Forwarding it would make
+            // Chromium's loopback DevTools endpoint reject this trusted proxy hop.
+            continue;
+        }
+        if (lowerName === "host") {
+            if (!hostRewritten) {
+                lines.push(`${name}: ${endpoint.host}`);
+                hostRewritten = true;
+            }
+            continue;
+        }
+        lines.push(`${name}: ${value}`);
+    }
+    if (!hostRewritten)
+        lines.push(`Host: ${endpoint.host}`);
+    lines.push("", "");
+    return Buffer.from(lines.join("\r\n"), "latin1");
+}
+function validateUpstreamHandshake(handshake, expectedAccept) {
+    const lines = handshake.toString("latin1").split("\r\n");
+    if (!/^HTTP\/1\.1 101(?:[ \t].*)?$/.test(lines.shift() ?? "")) {
+        throw new Error("Chrome inspection upstream did not switch protocols");
+    }
+    const headers = new Map();
+    for (const line of lines) {
+        if (line === "")
+            break;
+        const separator = line.indexOf(":");
+        if (separator <= 0) {
+            throw new Error("Chrome inspection upstream returned malformed headers");
+        }
+        const name = line.slice(0, separator).trim().toLowerCase();
+        const value = line.slice(separator + 1).trim();
+        const values = headers.get(name);
+        if (values)
+            values.push(value);
+        else
+            headers.set(name, [value]);
+    }
+    if (!headerHasToken(headers.get("connection"), "upgrade") ||
+        !headerHasToken(headers.get("upgrade"), "websocket") ||
+        headers.get("sec-websocket-accept")?.length !== 1 ||
+        headers.get("sec-websocket-accept")?.[0] !== expectedAccept) {
+        throw new Error("Chrome inspection upstream returned an invalid WebSocket handshake");
+    }
+}
+function headerHasToken(value, expected) {
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    return values.some((entry) => entry.split(",").some((token) => token.trim().toLowerCase() === expected));
+}
+async function forwardFrame(destination, data, isBinary) {
+    if (destination.readyState !== WebSocket.OPEN)
+        throw new Error("destination is not open");
+    const bytes = rawDataBytes(data);
+    if (bytes.byteLength > MAX_CDP_MESSAGE_BYTES ||
+        destination.bufferedAmount + bytes.byteLength > MAX_BUFFERED_BYTES) {
+        throw new Error("Chrome inspection forwarding capacity exceeded");
+    }
+    await new Promise((resolve, reject) => {
+        destination.send(bytes, { binary: isBinary, compress: false }, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+function rawDataBytes(data) {
+    if (typeof data === "string")
+        return Buffer.from(data, "utf8");
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function rawDataText(data) {
+    return Buffer.from(rawDataBytes(data)).toString("utf8");
+}
+function waitForValue(promise, timeoutMs, signal, timeoutMessage) {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? new Error("Chrome inspection opening was cancelled"));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            callback();
+        };
+        const timer = setTimeout(() => {
+            finish(() => reject(new Error(timeoutMessage)));
+        }, timeoutMs);
+        timer.unref?.();
+        const onAbort = () => {
+            finish(() => reject(signal.reason ?? new Error("Chrome inspection opening was cancelled")));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+    });
+}
+function setCommonHeaders(response) {
+    response.setHeader("cache-control", "no-store");
+    response.setHeader("x-content-type-options", "nosniff");
+}
+function respond(response, status, body) {
+    response.statusCode = status;
+    response.setHeader("content-type", "text/plain; charset=utf-8");
+    response.end(body);
+}
+function respondJson(response, status, value) {
+    response.statusCode = status;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(`${JSON.stringify(value)}\n`);
+}
+function rejectUpgrade(socket, status, reason) {
+    if (socket.destroyed)
+        return;
+    socket.once("error", () => undefined);
+    socket.once("finish", () => socket.destroy());
+    socket.end(`HTTP/1.1 ${status} ${httpStatusText(status)}\r\n` +
+        "Connection: close\r\n" +
+        "Content-Type: text/plain; charset=utf-8\r\n" +
+        "Cache-Control: no-store\r\n" +
+        `Content-Length: ${Buffer.byteLength(reason, "utf8")}\r\n\r\n${reason}`);
+}
+function httpStatusText(status) {
+    if (status === 400)
+        return "Bad Request";
+    if (status === 403)
+        return "Forbidden";
+    if (status === 404)
+        return "Not Found";
+    if (status === 409)
+        return "Conflict";
+    if (status === 502)
+        return "Bad Gateway";
+    if (status === 503)
+        return "Service Unavailable";
+    return "Error";
+}
+function listen(server, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.removeListener("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.removeListener("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, LOOPBACK_HOST);
+    });
+}
+function closeHttpServer(server) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            server.closeAllConnections?.();
+            finish();
+        }, SHUTDOWN_TIMEOUT_MS);
+        timer.unref?.();
+        server.close(() => finish());
+        server.closeIdleConnections?.();
+    });
+}
+function closeWebSocketServer(server) {
+    for (const client of server.clients) {
+        if (client.readyState !== WebSocket.CLOSED)
+            client.terminate();
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(finish, SHUTDOWN_TIMEOUT_MS);
+        timer.unref?.();
+        server.close(() => finish());
+    });
+}
+function boundedPositiveInteger(value, field) {
+    if (!Number.isInteger(value) || value < 1 || value > 120_000) {
+        throw new Error(`${field} must be an integer between 1 and 120000`);
+    }
+    return value;
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}