signalk-questdb 2.1.0 → 2.1.1

package/dist/test/console-proxy.test.js

@@ -1,664 +0,0 @@
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import http from "node:http";
-import { createConsoleProxy } from "../console-proxy.js";
-let upstream;
-let upstreamUrl;
-let seen = [];
-const MOUNT = "/plugins/signalk-questdb/console";
-before(async () => {
-    upstream = http.createServer((req, res) => {
-        let body = "";
-        req.on("data", (c) => (body += c));
-        req.on("end", () => {
-            seen.push({
-                method: req.method,
-                url: req.url,
-                headers: req.headers,
-                body,
-            });
-            if (req.url?.startsWith("/teapot")) {
-                res.writeHead(418, { "content-type": "text/plain" });
-                res.end("no coffee");
-                return;
-            }
-            res.writeHead(200, { "content-type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
-        });
-    });
-    await new Promise((r) => upstream.listen(0, "127.0.0.1", r));
-    const { port } = upstream.address();
-    upstreamUrl = `http://127.0.0.1:${port}`;
-});
-after(async () => {
-    await new Promise((r) => upstream.close(() => r()));
-});
-// Drive the proxy through a real server so req/res are genuine streams —
-// piping is the part most likely to break, and a hand-rolled mock would not
-// exercise it.
-async function throughProxy(path, init = {}) {
-    seen = [];
-    const proxy = createConsoleProxy({
-        baseUrl: init.baseUrl ?? (() => upstreamUrl),
-        debug: () => { },
-        mountPath: MOUNT,
-    });
-    const front = http.createServer((req, res) => proxy(req, res));
-    await new Promise((r) => front.listen(0, "127.0.0.1", r));
-    const { port } = front.address();
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}${path}`, {
-            method: init.method ?? "GET",
-            body: init.body,
-        });
-        return {
-            status: res.status,
-            text: await res.text(),
-            csp: res.headers.get("content-security-policy"),
-            nosniff: res.headers.get("x-content-type-options"),
-            seen,
-        };
-    }
-    finally {
-        await new Promise((r) => front.close(() => r()));
-    }
-}
-describe("console proxy forwarding", () => {
-    it("forwards the path to the upstream", async () => {
-        const r = await throughProxy("/index.html");
-        assert.equal(r.status, 200);
-        assert.equal(r.seen[0].url, "/index.html");
-    });
-    it("preserves the query string", async () => {
-        // The console's whole API is query-driven (`exec?query=...`); dropping the
-        // query would leave every request syntactically valid and useless.
-        const r = await throughProxy("/exec?query=SELECT%201&limit=0%2C1000");
-        assert.equal(r.seen[0].url, "/exec?query=SELECT%201&limit=0%2C1000");
-    });
-    it("forwards the method and body", async () => {
-        const r = await throughProxy("/imp", { method: "POST", body: "csvdata" });
-        assert.equal(r.seen[0].method, "POST");
-        assert.equal(r.seen[0].body, "csvdata");
-    });
-    it("passes the upstream status and content-type through", async () => {
-        const r = await throughProxy("/teapot");
-        assert.equal(r.status, 418);
-        assert.equal(r.text, "no coffee");
-    });
-    it("rewrites Host so it names the upstream, not Signal K", async () => {
-        const r = await throughProxy("/");
-        const host = r.seen[0].headers.host;
-        assert.ok(host?.startsWith("127.0.0.1:"), `expected the upstream host, got ${host}`);
-    });
-    it("does not leak Signal K credentials to QuestDB", async () => {
-        // The admin session cookie authenticates the caller to Signal K. QuestDB
-        // has no use for it and should never see it.
-        const proxy = createConsoleProxy({
-            baseUrl: () => upstreamUrl,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        seen = [];
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            await fetch(`http://127.0.0.1:${port}/`, {
-                headers: {
-                    cookie: "JAUTHENTICATION=secret",
-                    authorization: "Bearer x",
-                },
-            });
-        }
-        finally {
-            await new Promise((r) => front.close(() => r()));
-        }
-        assert.equal(seen[0].headers.cookie, undefined);
-        assert.equal(seen[0].headers.authorization, undefined);
-    });
-});
-describe("console proxy header hygiene", () => {
-    it("drops headers nominated by Connection, not just the fixed set", async () => {
-        // RFC 7230 §6.1: Connection may list ADDITIONAL single-hop headers. A
-        // fixed blocklist forwards those, leaking connection-scoped state across
-        // the hop.
-        const proxy = createConsoleProxy({
-            baseUrl: () => upstreamUrl,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        seen = [];
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            // Raw socket: fetch() refuses to set Connection.
-            await new Promise((resolve) => {
-                const r = http.request({
-                    // Explicit host. `http.request` defaults to `localhost`, which
-                    // resolves differently inside the plugin registry's firejail
-                    // sandbox and failed with ECONNREFUSED — while `fetch`, used by
-                    // every other test here, was unaffected. The server listens on
-                    // 127.0.0.1, so name it.
-                    host: "127.0.0.1",
-                    port,
-                    path: "/",
-                    // `close`, not `keep-alive`: the header still nominates
-                    // x-hop-secret (which is what this test is about), but the socket
-                    // is not held open afterwards. With keep-alive the agent keeps it
-                    // alive, server.close() waits for it, and the test hangs — which
-                    // it did, but only under the registry's sandbox where the timing
-                    // differed enough to expose it.
-                    headers: {
-                        connection: "close, x-hop-secret",
-                        "x-hop-secret": "must-not-travel",
-                        "x-normal": "must-travel",
-                    },
-                }, (res) => {
-                    res.resume();
-                    res.on("end", () => resolve());
-                });
-                r.end();
-            });
-        }
-        finally {
-            // closeAllConnections() so a lingering socket cannot stall teardown.
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-        }
-        assert.equal(seen[0].headers["x-hop-secret"], undefined);
-        assert.equal(seen[0].headers["x-normal"], "must-travel");
-    });
-    it("sends a CSP narrowing what the same-origin console may do", async () => {
-        const r = await throughProxy("/");
-        assert.match(r.csp ?? "", /form-action 'self'/);
-        assert.match(r.csp ?? "", /frame-ancestors 'self'/);
-        assert.match(r.csp ?? "", /base-uri 'self'/);
-    });
-    it("does not send connect-src, which would break the SQL editor", async () => {
-        // Monaco is loaded from a CDN path baked into QuestDB's bundle. A
-        // `connect-src 'self'` here reads as safer but blanks out the query
-        // editor — the console's entire purpose. Pinned so a future tightening is
-        // a deliberate decision, taken with the Monaco question re-checked.
-        const r = await throughProxy("/");
-        assert.doesNotMatch(r.csp ?? "", /connect-src/);
-    });
-    it("does not let QuestDB set cookies on the Signal K origin", async () => {
-        // The console shares Signal K's origin, so a proxied Set-Cookie would be
-        // applied to it — a `Path=/` cookie from QuestDB could collide with Signal
-        // K's own session handling. The request side already strips `cookie`, so
-        // no QuestDB cookie could complete a round trip regardless.
-        const cookieUpstream = http.createServer((_req, res) => {
-            res.writeHead(200, {
-                "set-cookie": "questdb_session=abc; Path=/",
-                "content-type": "text/plain",
-            });
-            res.end("ok");
-        });
-        await new Promise((r) => cookieUpstream.listen(0, "127.0.0.1", r));
-        const upPort = cookieUpstream.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                headers: { connection: "close" },
-            });
-            assert.equal(res.headers.get("set-cookie"), null);
-        }
-        finally {
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => cookieUpstream.close(() => r()));
-        }
-    });
-    it("marks responses nosniff", async () => {
-        const r = await throughProxy("/");
-        assert.equal(r.nosniff, "nosniff");
-    });
-});
-describe("console proxy redirect rewriting", () => {
-    // QuestDB answers `/` with `301 Location: /index.html` — an ABSOLUTE path.
-    // Relayed unchanged it escapes the mount and lands on the Signal K root,
-    // which 404s. That is what made the webapp report "console unavailable"
-    // while the console itself was serving fine. My own testing missed it
-    // because `curl -L` follows the redirect and papers over the escape.
-    function redirectingUpstream(location) {
-        return http.createServer((_req, res) => {
-            res.writeHead(301, { location });
-            res.end();
-        });
-    }
-    async function locationThrough(upstreamLocation) {
-        const up = redirectingUpstream(upstreamLocation);
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            // `Connection: close` so no keep-alive socket survives the request —
-            // server.close() waits for open connections and would otherwise hang.
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                redirect: "manual",
-                headers: { connection: "close" },
-            });
-            return res.headers.get("location");
-        }
-        finally {
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    }
-    it("does not announce a chunked body on a bodyless redirect", async () => {
-        // QuestDB's 301 states NEITHER content-length nor transfer-encoding, so
-        // Node falls back to chunked framing — announcing a body that never
-        // arrives. The browser waits on a redirect that never completes, which is
-        // how a working console still reported "console unavailable" even after
-        // the Location rewrite was correct. Rewriting Location was necessary but
-        // not sufficient; this is the other half.
-        // Exactly QuestDB's shape: no content-length, no transfer-encoding, no
-        // body. `res.writeHead(...); res.end()` will NOT do — Node adds
-        // `chunked` for an empty body, which the real origin does not send, and a
-        // stand-in that declares framing is not the case under test. Write the
-        // raw response so the bytes match what QuestDB actually emits.
-        const up = http.createServer((_req, res) => {
-            res.socket?.end("HTTP/1.1 301 Moved Permanently\r\n" +
-                "Location: /index.html\r\n" +
-                "Connection: close\r\n" +
-                "\r\n");
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            // Raw client: fetch() normalises framing away, hiding the very header
-            // this test exists to check.
-            const headers = await new Promise((resolve, reject) => {
-                const r = http.request({
-                    host: "127.0.0.1",
-                    port,
-                    path: "/",
-                    headers: { connection: "close" },
-                }, (res) => {
-                    res.resume();
-                    res.on("end", () => resolve(res.headers));
-                });
-                r.on("error", reject);
-                r.end();
-            });
-            assert.equal(headers["transfer-encoding"], undefined, "a bodyless redirect must not be chunked");
-            assert.equal(headers["content-length"], "0");
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-    it("passes a 304 through without inventing a content-length", async () => {
-        // QuestDB really does serve 304 for the console's assets, so this is the
-        // browser-caching path, not a hypothetical. RFC 9110 §6.4.1: a 304 must
-        // not carry content-length — adding one here would be a protocol error on
-        // every cached asset load.
-        const up = http.createServer((_req, res) => {
-            res.writeHead(304, { etag: '"abc"' });
-            res.end();
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const headers = await new Promise((resolve, reject) => {
-                const r = http.request({
-                    host: "127.0.0.1",
-                    port,
-                    path: "/",
-                    headers: { connection: "close" },
-                }, (res) => {
-                    res.resume();
-                    res.on("end", () => resolve(res.headers));
-                });
-                r.on("error", reject);
-                r.end();
-            });
-            assert.equal(headers["content-length"], undefined);
-            assert.equal(headers["transfer-encoding"], undefined);
-            assert.equal(headers.etag, '"abc"');
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-    it("preserves a redirect that legitimately carries a body", async () => {
-        // Self-audit catch. A 3xx MAY carry a body (RFC 9110 §15.4) and browsers
-        // render it. The first version of the bodyless fix keyed purely on status,
-        // so it dropped that body AND overwrote a correct content-length with 0 —
-        // trading one framing bug for a worse, silent one.
-        const body = "<html>Moved. <a href='/x'>here</a></html>";
-        const up = http.createServer((_req, res) => {
-            res.writeHead(302, {
-                location: "/x",
-                "content-type": "text/html",
-                "content-length": String(Buffer.byteLength(body)),
-            });
-            res.end(body);
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                redirect: "manual",
-                headers: { connection: "close" },
-            });
-            assert.equal(res.status, 302);
-            assert.equal(await res.text(), body, "a redirect body must not be dropped");
-            assert.equal(res.headers.get("content-length"), String(body.length));
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-    it("preserves a redirect body sent with chunked encoding", async () => {
-        // Second self-audit catch. Keying "bodyless" on the absence of
-        // content-length alone still dropped a redirect body streamed with
-        // chunked encoding, which carries no length. Both framing headers have to
-        // be absent before a 3xx can be treated as empty.
-        const body = "<html>Moved chunked</html>";
-        const up = http.createServer((_req, res) => {
-            // No content-length: Node frames this as chunked.
-            res.writeHead(302, { location: "/x", "content-type": "text/html" });
-            res.end(body);
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                redirect: "manual",
-                headers: { connection: "close" },
-            });
-            assert.equal(await res.text(), body, "a chunked redirect body must survive");
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-    it("keeps a root-relative redirect inside the mount", async () => {
-        assert.equal(await locationThrough("/index.html"), `${MOUNT}/index.html`);
-    });
-    it("preserves the query string on a redirect", async () => {
-        assert.equal(await locationThrough("/index.html?a=1"), `${MOUNT}/index.html?a=1`);
-    });
-    it("leaves a relative redirect alone", async () => {
-        // Already resolves against the proxied URL; rewriting would break it.
-        assert.equal(await locationThrough("other.html"), "other.html");
-    });
-    it("does not retarget an absolute redirect to another host", async () => {
-        const target = "https://questdb.io/docs";
-        assert.equal(await locationThrough(target), target);
-    });
-    it("does not treat a protocol-relative target as root-relative", async () => {
-        // `//evil.example.com/` starts with "/" but names another host; prefixing
-        // the mount would silently rewrite it into a path on this origin.
-        assert.equal(await locationThrough("//evil.example.com/"), "//evil.example.com/");
-    });
-});
-describe("console proxy upstream failure mid-response", () => {
-    it("does not leave the client hanging when the upstream dies mid-body", async () => {
-        // Self-audit catch. `proxied.pipe(res)` had no error/abort handler, so an
-        // upstream that dies after headers were sent never ended our response —
-        // the browser tab sat on a request that would never complete. Node signals
-        // truncation to a direct client by aborting; the proxy must do the same.
-        const up = http.createServer((_req, res) => {
-            res.writeHead(200, {
-                "content-type": "text/plain",
-                "content-length": "100",
-            });
-            res.write("partial");
-            setTimeout(() => res.socket?.destroy(), 30);
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const outcome = await new Promise((resolve) => {
-                const timer = setTimeout(() => resolve("HUNG"), 4000);
-                const settle = (v) => {
-                    clearTimeout(timer);
-                    resolve(v);
-                };
-                const r = http.request({
-                    host: "127.0.0.1",
-                    port,
-                    path: "/",
-                    headers: { connection: "close" },
-                }, (res) => {
-                    res.resume();
-                    res.on("aborted", () => settle("aborted"));
-                    res.on("end", () => settle("ended"));
-                });
-                r.on("error", () => settle("error"));
-                r.end();
-            });
-            assert.notEqual(outcome, "HUNG", "a truncated response must not hang");
-            assert.notEqual(outcome, "ended", "a truncated response must not look like a clean end");
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-});
-describe("console proxy HEAD content-length", () => {
-    it("reports the resource's real length, not zero", async () => {
-        // Third self-audit catch. A HEAD response must carry the headers a GET
-        // would return (RFC 9110 §9.3.2), so overwriting a stated
-        // `content-length: 12345` with 0 misreports the resource's size — a
-        // client sizing a download from HEAD would read it as empty.
-        const up = http.createServer((_req, res) => {
-            res.writeHead(200, {
-                "content-type": "text/plain",
-                "content-length": "12345",
-            });
-            res.end();
-        });
-        await new Promise((r) => up.listen(0, "127.0.0.1", r));
-        const upPort = up.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${upPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                method: "HEAD",
-                headers: { connection: "close" },
-            });
-            assert.equal(res.headers.get("content-length"), "12345");
-        }
-        finally {
-            front.closeAllConnections?.();
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => up.close(() => r()));
-        }
-    });
-});
-describe("console proxy HEAD handling", () => {
-    it("answers HEAD without hanging", async () => {
-        // QuestDB replies to HEAD with `405 Transfer-Encoding: chunked` AND a
-        // body, which is protocol-illegal. Piping that through left the client
-        // waiting for chunks that never legally arrive, so the connection died
-        // with an empty reply — every HEAD probe of the console reported it broken
-        // while the console itself worked perfectly.
-        const badHead = http.createServer((req, res) => {
-            res.writeHead(405, {
-                "transfer-encoding": "chunked",
-                "content-type": "text/plain",
-            });
-            res.end("Method HEAD not supported");
-        });
-        await new Promise((r) => badHead.listen(0, "127.0.0.1", r));
-        const badPort = badHead.address().port;
-        const proxy = createConsoleProxy({
-            baseUrl: () => `http://127.0.0.1:${badPort}`,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        const front = http.createServer((req, res) => proxy(req, res));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/`, {
-                method: "HEAD",
-                signal: AbortSignal.timeout(4000),
-            });
-            assert.equal(res.status, 405);
-            assert.equal(await res.text(), "", "a HEAD response carries no body");
-        }
-        finally {
-            await new Promise((r) => front.close(() => r()));
-            await new Promise((r) => badHead.close(() => r()));
-        }
-    });
-});
-describe("console proxy failure handling", () => {
-    it("returns 503 when QuestDB is not running", async () => {
-        const r = await throughProxy("/", { baseUrl: () => null });
-        assert.equal(r.status, 503);
-        assert.match(r.text, /not running/i);
-    });
-    it("returns a readable 502 when the upstream refuses", async () => {
-        // Port 1 is reserved and never listening: a stopped container in practice.
-        // Bind an ephemeral port and immediately release it: guarantees a closed
-        // port on this host, rather than assuming a well-known one (port 1) is
-        // free — on a machine where something holds it, the test would silently
-        // stop testing refusal.
-        const probe = http.createServer();
-        await new Promise((r) => probe.listen(0, "127.0.0.1", r));
-        const deadPort = probe.address().port;
-        await new Promise((r) => probe.close(() => r()));
-        const r = await throughProxy("/", {
-            baseUrl: () => `http://127.0.0.1:${deadPort}`,
-        });
-        assert.equal(r.status, 502);
-        assert.match(r.text, /not reachable/i);
-        assert.doesNotMatch(r.text, /ECONNREFUSED/, "must not leak a raw error");
-    });
-});
-describe("console mount gating", () => {
-    // Regression: the enableConsole check first sat AROUND the router.use(...)
-    // call. registerWithRouter runs at plugin registration, before start() has
-    // loaded any config, so currentConfig was still null and a saved
-    // `enableConsole: false` was ignored — the console stayed reachable. Caught
-    // only by end-to-end testing against a real server; every unit test passed.
-    //
-    // This models the mount as index.ts now does it: always registered, decided
-    // per request against live config.
-    function mountedHandler(getConfig) {
-        const proxy = createConsoleProxy({
-            baseUrl: () => upstreamUrl,
-            debug: () => { },
-            mountPath: MOUNT,
-        });
-        return (req, res) => {
-            if (getConfig()?.enableConsole === false) {
-                // Express would fall through to the 404 handler here.
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            proxy(req, res);
-        };
-    }
-    async function callMount(getConfig) {
-        const front = http.createServer(mountedHandler(getConfig));
-        await new Promise((r) => front.listen(0, "127.0.0.1", r));
-        const { port } = front.address();
-        try {
-            return (await fetch(`http://127.0.0.1:${port}/`)).status;
-        }
-        finally {
-            await new Promise((r) => front.close(() => r()));
-        }
-    }
-    it("serves the console when config has not loaded yet", async () => {
-        // null config == registration time. Must not 404: the default is on, and
-        // the request will be re-evaluated once config arrives.
-        assert.equal(await callMount(() => null), 200);
-    });
-    it("serves the console when the key is absent", async () => {
-        assert.equal(await callMount(() => ({})), 200);
-    });
-    it("does NOT serve the console when explicitly disabled", async () => {
-        assert.equal(await callMount(() => ({ enableConsole: false })), 404);
-    });
-    it("serves the console when explicitly enabled", async () => {
-        assert.equal(await callMount(() => ({ enableConsole: true })), 200);
-    });
-});
-describe("console proxy target confinement", () => {
-    it("refuses a path that would re-target another origin", async () => {
-        // `new URL("//evil.example.com/", base)` resolves to that host — without
-        // an origin check the admin-only route becomes an open relay.
-        const r = await throughProxy("//example.com/exec");
-        assert.equal(r.status, 400);
-        assert.equal(r.seen.length, 0, "nothing may reach the upstream");
-    });
-});
-//# sourceMappingURL=console-proxy.test.js.map