@baanish/hydra-cli 0.1.0

package/dist/web/server.js

@@ -0,0 +1,864 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createServer, } from "node:http";
+import { dirname, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { clampInt, loadConfig, maskConfigValue } from "../config.js";
+import { getRun, getRunAgentRuns, listRuns, removeRun } from "../db/queries.js";
+import { HydraPipeline } from "../engine/pipeline.js";
+import { formatErrorMessage, isLoopbackHostname } from "../security.js";
+const APP_HTML_TEMPLATE = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "app.html"), "utf8");
+const API_SESSION_HEADER = "x-hydra-session";
+const SESSION_TOKEN_PLACEHOLDER = "__HYDRA_WEB_TOKEN__";
+const MAX_WEB_QUERY_CHARS = 20_000;
+const activeRunPipelines = new Map();
+const activeRunClients = new Map();
+const pipelineEventTypes = [
+    "run-created",
+    "run-status-changed",
+    "agent-progress",
+    "agent-complete",
+    "run-complete",
+];
+function createSecurityHeaders(contentType) {
+    const headers = new Headers();
+    headers.set("Cache-Control", "no-store");
+    headers.set("Content-Security-Policy", "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'; object-src 'none'");
+    headers.set("Cross-Origin-Resource-Policy", "same-origin");
+    headers.set("Referrer-Policy", "no-referrer");
+    headers.set("X-Content-Type-Options", "nosniff");
+    headers.set("X-Frame-Options", "DENY");
+    if (contentType) {
+        headers.set("Content-Type", contentType);
+    }
+    return headers;
+}
+function buildAppHtml(sessionToken) {
+    return APP_HTML_TEMPLATE.replaceAll(SESSION_TOKEN_PLACEHOLDER, sessionToken);
+}
+function createSseResponse() {
+    const encoder = new TextEncoder();
+    const stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+    let closed = false;
+    const send = async (event) => {
+        if (closed) {
+            return;
+        }
+        const payload = `data: ${JSON.stringify(event)}\n\n`;
+        await writer.ready;
+        await writer.write(encoder.encode(payload));
+    };
+    const close = async () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        try {
+            await writer.close();
+        }
+        catch {
+            // stream already closed.
+        }
+    };
+    return {
+        response: new Response(stream.readable, {
+            headers: createSecurityHeaders("text/event-stream"),
+        }),
+        send,
+        close,
+    };
+}
+function addRunClient(runId, client) {
+    let clients = activeRunClients.get(runId);
+    if (!clients) {
+        clients = new Set();
+        activeRunClients.set(runId, clients);
+    }
+    clients.add(client);
+    return () => {
+        const current = activeRunClients.get(runId);
+        if (!current) {
+            return;
+        }
+        current.delete(client);
+        if (current.size === 0) {
+            activeRunClients.delete(runId);
+        }
+    };
+}
+function broadcastRunEvent(runId, event) {
+    const clients = activeRunClients.get(runId);
+    if (!clients || clients.size === 0) {
+        return;
+    }
+    for (const client of [...clients]) {
+        void client.send(event).catch(() => {
+            const current = activeRunClients.get(runId);
+            if (!current) {
+                return;
+            }
+            current.delete(client);
+            if (current.size === 0) {
+                activeRunClients.delete(runId);
+            }
+        });
+    }
+}
+async function closeRunSubscribers(runId) {
+    const clients = activeRunClients.get(runId);
+    if (!clients || clients.size === 0) {
+        return;
+    }
+    activeRunClients.delete(runId);
+    await Promise.allSettled([...clients].map(async (client) => {
+        try {
+            await client.send({ type: "done", runId });
+        }
+        catch {
+            // ignore failed stream writes while closing.
+        }
+        try {
+            await client.close();
+        }
+        catch {
+            // ignore failed stream closes while closing.
+        }
+    }));
+}
+function resolveLlmApiKey(config) {
+    return config.apiKey || config.syntheticApiKey || "";
+}
+function resolveSearchConfig(config) {
+    return {
+        provider: config.searchProvider,
+        syntheticApiKey: config.syntheticApiKey || "",
+        exaApiKey: config.exaApiKey || "",
+        braveApiKey: config.braveApiKey || "",
+    };
+}
+function toMaskedConfig(config) {
+    return {
+        ...config,
+        apiKey: maskConfigValue(config.apiKey),
+        syntheticApiKey: maskConfigValue(config.syntheticApiKey),
+        exaApiKey: maskConfigValue(config.exaApiKey),
+        braveApiKey: maskConfigValue(config.braveApiKey),
+    };
+}
+function phaseProgress(agentRuns) {
+    const counts = {
+        decompose: { completed: 0, total: 0 },
+        research: { completed: 0, total: 0 },
+        debate: { completed: 0, total: 0 },
+        synthesis: { completed: 0, total: 0 },
+    };
+    for (const item of agentRuns) {
+        if (!counts[item.phase]) {
+            counts[item.phase] = { completed: 0, total: 0 };
+        }
+        counts[item.phase].total += 1;
+        if (item.status === "complete" || item.status === "error") {
+            counts[item.phase].completed += 1;
+        }
+    }
+    return counts;
+}
+function toState(agentRun) {
+    return {
+        runId: agentRun.runId,
+        phase: agentRun.phase,
+        persona: agentRun.persona,
+        status: agentRun.status,
+        startedAt: agentRun.startedAt,
+        completedAt: agentRun.completedAt,
+        promptTokens: agentRun.promptTokens,
+        completionTokens: agentRun.completionTokens,
+        output: agentRun.output,
+    };
+}
+function toPublicAgentRun(agentRun) {
+    return {
+        id: agentRun.id,
+        runId: agentRun.runId,
+        phase: agentRun.phase,
+        persona: agentRun.persona,
+        status: agentRun.status,
+        promptTokens: agentRun.promptTokens,
+        completionTokens: agentRun.completionTokens,
+        startedAt: agentRun.startedAt,
+        completedAt: agentRun.completedAt,
+        output: agentRun.output,
+    };
+}
+async function replayFromDb(runId, send) {
+    const run = getRun(runId);
+    if (!run) {
+        return;
+    }
+    await send({
+        type: "run-created",
+        runId: run.id,
+        query: run.query,
+        agentCount: run.agentCount,
+        timestamp: run.createdAt,
+    });
+    const records = getRunAgentRuns(run.id).sort((left, right) => left.startedAt - right.startedAt);
+    const stats = phaseProgress(records);
+    for (const [phase, summary] of Object.entries(stats)) {
+        if (summary.total === 0) {
+            continue;
+        }
+        await send({
+            type: "agent-progress",
+            runId: run.id,
+            phase: phase,
+            completedAgents: summary.completed,
+            totalAgents: summary.total,
+            timestamp: run.createdAt,
+        });
+    }
+    for (const item of records) {
+        if (item.status !== "complete" && item.status !== "error") {
+            continue;
+        }
+        await send({
+            type: "agent-complete",
+            runId: run.id,
+            agentRunId: item.id,
+            persona: item.persona,
+            phase: item.phase,
+            state: toState(item),
+            timestamp: item.completedAt ?? item.startedAt,
+        });
+    }
+    await send({
+        type: "run-status-changed",
+        runId: run.id,
+        status: run.status,
+        timestamp: run.completedAt ?? run.createdAt,
+    });
+    if (run.status === "complete") {
+        await send({
+            type: "run-complete",
+            runId: run.id,
+            elapsedMs: run.elapsedMs ?? 0,
+            totalPromptTokens: run.totalPromptTokens,
+            totalCompletionTokens: run.totalCompletionTokens,
+            timestamp: run.completedAt ?? run.createdAt,
+        });
+    }
+}
+function parseJsonBody(body) {
+    if (typeof body !== "object" || body === null) {
+        return null;
+    }
+    const payload = body;
+    if (typeof payload.query !== "string") {
+        return null;
+    }
+    const query = payload.query.trim();
+    if (!query || query.length > MAX_WEB_QUERY_CHARS) {
+        return null;
+    }
+    return {
+        query,
+        agentCount: typeof payload.agentCount === "number" ||
+            typeof payload.agentCount === "string"
+            ? Number(payload.agentCount)
+            : undefined,
+        searchEnabled: typeof payload.searchEnabled === "boolean"
+            ? payload.searchEnabled
+            : undefined,
+    };
+}
+function jsonResponse(payload, status = 200) {
+    return new Response(JSON.stringify(payload), {
+        status,
+        headers: createSecurityHeaders("application/json"),
+    });
+}
+function textResponse(message, status = 200) {
+    return new Response(message, {
+        status,
+        headers: createSecurityHeaders("text/plain; charset=utf-8"),
+    });
+}
+function isEventStreamRequest(req) {
+    return req.headers.get("accept")?.includes("text/event-stream") ?? false;
+}
+function isSseEventsRoute(pathname) {
+    return pathname.endsWith("/events") && parseRunId(pathname) !== null;
+}
+function readProvidedSessionToken(req, url, pathname) {
+    const headerToken = req.headers.get(API_SESSION_HEADER)?.trim();
+    if (headerToken) {
+        return headerToken;
+    }
+    if (!isEventStreamRequest(req) || !isSseEventsRoute(pathname)) {
+        return "";
+    }
+    return url.searchParams.get("session")?.trim() ?? "";
+}
+function isAuthorizedSessionToken(expectedToken, providedToken) {
+    if (!providedToken) {
+        return false;
+    }
+    const expected = Buffer.from(expectedToken);
+    const provided = Buffer.from(providedToken);
+    if (expected.length !== provided.length) {
+        return false;
+    }
+    return timingSafeEqual(expected, provided);
+}
+function authorizeApiRequest(req, url, pathname, sessionToken) {
+    if (!isLoopbackHostname(url.hostname)) {
+        return jsonResponse({ error: "forbidden host" }, 403);
+    }
+    const secFetchSite = req.headers.get("sec-fetch-site");
+    if (secFetchSite &&
+        secFetchSite !== "same-origin" &&
+        secFetchSite !== "same-site" &&
+        secFetchSite !== "none") {
+        return jsonResponse({ error: "forbidden request origin" }, 403);
+    }
+    const origin = req.headers.get("origin");
+    if (origin && origin !== url.origin) {
+        return jsonResponse({ error: "forbidden request origin" }, 403);
+    }
+    const providedToken = readProvidedSessionToken(req, url, pathname);
+    if (!isAuthorizedSessionToken(sessionToken, providedToken)) {
+        return jsonResponse({ error: "unauthorized" }, 401);
+    }
+    return null;
+}
+function parseRunId(pathname) {
+    const match = /^\/api\/runs\/([^/]+)(?:\/events)?$/.exec(pathname);
+    if (!match) {
+        return null;
+    }
+    try {
+        return decodeURIComponent(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
+function isRunFinal(status) {
+    return status === "complete" || status === "error";
+}
+function routeRunEvents(runId, req) {
+    const run = getRun(runId);
+    if (!run) {
+        return jsonResponse({ error: "run not found" }, 404);
+    }
+    const { response, send, close } = createSseResponse();
+    const bufferedEvents = [];
+    const client = { send, close };
+    const bufferedClient = {
+        send: async (event) => {
+            bufferedEvents.push(event);
+        },
+        close: async () => { },
+    };
+    let removeClient = () => { };
+    const activePipeline = activeRunPipelines.get(runId);
+    const onTerminalEvent = (event) => {
+        if (event.type === "run-complete" ||
+            (event.type === "run-status-changed" && event.status === "error")) {
+            void closeRunSubscribers(runId);
+        }
+    };
+    const closeSafely = async () => {
+        try {
+            await close();
+        }
+        catch {
+            // ignore close failures when stream is already closed.
+        }
+    };
+    let finalized = false;
+    const finalize = () => {
+        if (finalized) {
+            return;
+        }
+        finalized = true;
+        if (activePipeline) {
+            activePipeline.off("run-complete", onTerminalEvent);
+            activePipeline.off("run-status-changed", onTerminalEvent);
+        }
+        removeClient();
+    };
+    const sendDone = async () => {
+        try {
+            await send({ type: "done", runId });
+        }
+        catch {
+            // ignore failed terminal done sends during disconnects.
+        }
+    };
+    const flushBufferedEvents = async () => {
+        let hadDone = false;
+        for (const event of bufferedEvents) {
+            if (event.type === "done") {
+                hadDone = true;
+            }
+            await send(event);
+        }
+        bufferedEvents.length = 0;
+        return hadDone;
+    };
+    if (activePipeline) {
+        activePipeline.on("run-complete", onTerminalEvent);
+        activePipeline.on("run-status-changed", onTerminalEvent);
+    }
+    req.signal.addEventListener("abort", () => {
+        finalize();
+        void closeSafely();
+    }, { once: true });
+    void (async () => {
+        try {
+            if (req.signal.aborted) {
+                finalize();
+                await closeSafely();
+                return;
+            }
+            removeClient = addRunClient(runId, bufferedClient);
+            await replayFromDb(runId, send);
+            if (req.signal.aborted) {
+                finalize();
+                await closeSafely();
+                return;
+            }
+            const latestRun = getRun(runId);
+            if (!latestRun) {
+                finalize();
+                await closeSafely();
+                return;
+            }
+            if (isRunFinal(latestRun.status)) {
+                const hadDone = await flushBufferedEvents();
+                if (!hadDone) {
+                    await sendDone();
+                }
+                finalize();
+                await closeSafely();
+                return;
+            }
+            removeClient();
+            removeClient = addRunClient(runId, client);
+            for (const event of bufferedEvents) {
+                await send(event);
+            }
+            bufferedEvents.length = 0;
+            if (req.signal.aborted) {
+                finalize();
+                await closeSafely();
+                return;
+            }
+            if (!activeRunPipelines.has(runId)) {
+                const initialAgentRuns = getRunAgentRuns(runId);
+                const completedAgentRuns = new Set(initialAgentRuns
+                    .filter((agentRun) => agentRun.status === "complete" || agentRun.status === "error")
+                    .map((agentRun) => agentRun.id));
+                const lastProgress = new Map();
+                for (const [phase, summary] of Object.entries(phaseProgress(initialAgentRuns))) {
+                    lastProgress.set(phase, {
+                        completedAgents: summary.completed,
+                        totalAgents: summary.total,
+                    });
+                }
+                let lastRunStatus = latestRun.status;
+                while (!req.signal.aborted) {
+                    const polledRun = getRun(runId);
+                    if (!polledRun) {
+                        finalize();
+                        await closeSafely();
+                        return;
+                    }
+                    if (activeRunPipelines.has(runId)) {
+                        return;
+                    }
+                    if (polledRun.status !== lastRunStatus) {
+                        lastRunStatus = polledRun.status;
+                        await send({
+                            type: "run-status-changed",
+                            runId: polledRun.id,
+                            status: polledRun.status,
+                            timestamp: polledRun.completedAt ?? polledRun.createdAt,
+                        });
+                    }
+                    const polledAgentRuns = getRunAgentRuns(runId);
+                    for (const [phase, summary] of Object.entries(phaseProgress(polledAgentRuns))) {
+                        const previous = lastProgress.get(phase);
+                        if (!previous ||
+                            previous.completedAgents !== summary.completed ||
+                            previous.totalAgents !== summary.total) {
+                            lastProgress.set(phase, {
+                                completedAgents: summary.completed,
+                                totalAgents: summary.total,
+                            });
+                            await send({
+                                type: "agent-progress",
+                                runId: polledRun.id,
+                                phase: phase,
+                                completedAgents: summary.completed,
+                                totalAgents: summary.total,
+                                timestamp: polledRun.completedAt ?? polledRun.createdAt,
+                            });
+                        }
+                    }
+                    for (const agentRun of polledAgentRuns) {
+                        if (agentRun.status !== "complete" && agentRun.status !== "error") {
+                            continue;
+                        }
+                        if (completedAgentRuns.has(agentRun.id)) {
+                            continue;
+                        }
+                        completedAgentRuns.add(agentRun.id);
+                        await send({
+                            type: "agent-complete",
+                            runId: polledRun.id,
+                            agentRunId: agentRun.id,
+                            persona: agentRun.persona,
+                            phase: agentRun.phase,
+                            state: toState(agentRun),
+                            timestamp: agentRun.completedAt ?? agentRun.startedAt,
+                        });
+                    }
+                    if (isRunFinal(polledRun.status)) {
+                        if (polledRun.status === "complete") {
+                            await send({
+                                type: "run-complete",
+                                runId: polledRun.id,
+                                elapsedMs: polledRun.elapsedMs ?? 0,
+                                totalPromptTokens: polledRun.totalPromptTokens,
+                                totalCompletionTokens: polledRun.totalCompletionTokens,
+                                timestamp: polledRun.completedAt ?? polledRun.createdAt,
+                            });
+                        }
+                        await sendDone();
+                        finalize();
+                        await closeSafely();
+                        return;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+            }
+        }
+        catch {
+            finalize();
+            await closeSafely();
+        }
+    })();
+    return response;
+}
+async function handleWebRequest(req, sessionToken) {
+    const method = req.method;
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const apiRequest = pathname.startsWith("/api/");
+    if (!isLoopbackHostname(url.hostname)) {
+        return textResponse("forbidden host", 403);
+    }
+    if (method === "OPTIONS") {
+        return new Response(null, {
+            status: 204,
+            headers: createSecurityHeaders("text/plain; charset=utf-8"),
+        });
+    }
+    if (apiRequest) {
+        const authFailure = authorizeApiRequest(req, url, pathname, sessionToken);
+        if (authFailure) {
+            return authFailure;
+        }
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+        return new Response(buildAppHtml(sessionToken), {
+            headers: createSecurityHeaders("text/html; charset=utf-8"),
+        });
+    }
+    if (pathname === "/api/config") {
+        if (method !== "GET") {
+            return jsonResponse({ error: "method not allowed" }, 405);
+        }
+        return jsonResponse(toMaskedConfig(loadConfig()));
+    }
+    if (pathname === "/api/runs") {
+        if (method !== "GET") {
+            return jsonResponse({ error: "method not allowed" }, 405);
+        }
+        return jsonResponse(listRuns(50));
+    }
+    const runId = parseRunId(pathname);
+    if (runId) {
+        if (pathname.endsWith("/events")) {
+            if (method !== "GET") {
+                return jsonResponse({ error: "method not allowed" }, 405);
+            }
+            return routeRunEvents(runId, req);
+        }
+        if (method === "GET") {
+            const run = getRun(runId);
+            if (!run) {
+                return jsonResponse({ error: "run not found" }, 404);
+            }
+            return jsonResponse({
+                run,
+                agentRuns: getRunAgentRuns(runId).map(toPublicAgentRun),
+            });
+        }
+        if (method === "DELETE") {
+            const run = getRun(runId);
+            if (!run) {
+                return jsonResponse({ error: "run not found" }, 404);
+            }
+            if (activeRunPipelines.has(runId)) {
+                return jsonResponse({ error: "run is still executing" }, 409);
+            }
+            if (!isRunFinal(run.status)) {
+                return jsonResponse({ error: "run is still executing" }, 409);
+            }
+            const removed = removeRun(runId);
+            if (!removed) {
+                return jsonResponse({ error: "run not found" }, 404);
+            }
+            return jsonResponse({ ok: true });
+        }
+        return jsonResponse({ error: "method not allowed" }, 405);
+    }
+    if (pathname === "/api/run") {
+        if (method !== "POST") {
+            return jsonResponse({ error: "method not allowed" }, 405);
+        }
+        let parsedPayload;
+        try {
+            parsedPayload = parseJsonBody(await req.json());
+        }
+        catch {
+            parsedPayload = null;
+        }
+        if (!parsedPayload) {
+            return jsonResponse({ error: "invalid run payload" }, 400);
+        }
+        const config = loadConfig();
+        const resolvedAgentCount = clampInt(parsedPayload.agentCount ?? config.defaultAgentCount, 1, 20, config.defaultAgentCount);
+        const resolvedSearchEnabled = parsedPayload.searchEnabled ?? config.searchEnabled;
+        const pipelineConfig = {
+            apiKey: resolveLlmApiKey(config),
+            baseUrl: config.baseUrl,
+            model: config.model,
+            orchestratorModel: config.orchestratorModel ?? config.model,
+            researchModel: config.researchModel ?? config.model,
+            searchConfig: resolveSearchConfig(config),
+            agentCount: resolvedAgentCount,
+            maxConcurrency: config.maxConcurrency,
+            debateRounds: config.debateRounds,
+            searchEnabled: resolvedSearchEnabled,
+            customPersonasOnly: config.customPersonasOnly,
+        };
+        const pipeline = new HydraPipeline(pipelineConfig);
+        const { response, send, close } = createSseResponse();
+        const client = { send, close };
+        let runId = null;
+        let removeClient = () => { };
+        let terminalEventHandled = false;
+        let terminalClose = null;
+        const onPipelineEvent = (event) => {
+            if (event.type === "run-created") {
+                runId = event.runId;
+                activeRunPipelines.set(runId, pipeline);
+                removeClient();
+                removeClient = addRunClient(runId, client);
+            }
+            broadcastRunEvent(event.runId, event);
+            if (event.type === "run-complete") {
+                if (event.runId && !terminalEventHandled) {
+                    terminalEventHandled = true;
+                    activeRunPipelines.delete(event.runId);
+                    terminalClose = closeRunSubscribers(event.runId).catch(() => {
+                        // ignore terminal cleanup failures while stream is closing.
+                    });
+                }
+            }
+            else if (event.type === "run-status-changed" &&
+                event.status === "error") {
+                if (!terminalEventHandled) {
+                    terminalEventHandled = true;
+                    activeRunPipelines.delete(event.runId);
+                    terminalClose = closeRunSubscribers(event.runId).catch(() => {
+                        // ignore terminal cleanup failures while stream is closing.
+                    });
+                }
+            }
+        };
+        for (const eventType of pipelineEventTypes) {
+            pipeline.on(eventType, onPipelineEvent);
+        }
+        const cleanupListeners = () => {
+            for (const eventType of pipelineEventTypes) {
+                pipeline.off(eventType, onPipelineEvent);
+            }
+        };
+        req.signal.addEventListener("abort", () => {
+            removeClient();
+            void close();
+        }, { once: true });
+        void (async () => {
+            try {
+                await pipeline.run(parsedPayload.query);
+            }
+            catch (error) {
+                console.error(`[hydra] pipeline failed to start run ${runId ?? "unknown"}: ${formatErrorMessage(error)}`);
+                if (runId && !terminalEventHandled) {
+                    activeRunPipelines.delete(runId);
+                    try {
+                        await send({
+                            type: "run-status-changed",
+                            runId,
+                            status: "error",
+                            timestamp: Date.now(),
+                        });
+                    }
+                    catch {
+                        // ignore write failures for aborted bootstrap streams.
+                    }
+                    terminalClose = closeRunSubscribers(runId).catch(() => {
+                        // ignore terminal cleanup failures while stream is closing.
+                    });
+                }
+                if (!runId) {
+                    try {
+                        await send({ type: "done", runId: "" });
+                    }
+                    catch {
+                        // ignore done writes for interrupted streams.
+                    }
+                    return;
+                }
+                if (terminalClose) {
+                    await terminalClose;
+                    return;
+                }
+                try {
+                    await send({ type: "done", runId });
+                }
+                catch {
+                    // ignore done writes for interrupted streams.
+                }
+            }
+            finally {
+                cleanupListeners();
+                removeClient();
+                await close();
+            }
+        })();
+        return response;
+    }
+    return new Response("not found", {
+        status: 404,
+        headers: createSecurityHeaders("text/plain; charset=utf-8"),
+    });
+}
+async function readRequestBody(req) {
+    if (req.method === "GET" || req.method === "HEAD") {
+        return undefined;
+    }
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return chunks.length > 0 ? Buffer.concat(chunks) : undefined;
+}
+async function toWebRequest(req, port) {
+    const body = await readRequestBody(req);
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                headers.append(name, item);
+            }
+        }
+        else {
+            headers.set(name, value);
+        }
+    }
+    const abortController = new AbortController();
+    req.once("close", () => {
+        if (!req.complete) {
+            abortController.abort();
+        }
+    });
+    const host = headers.get("host") ?? `127.0.0.1:${port}`;
+    const url = new URL(req.url ?? "/", `http://${host}`);
+    const requestInit = {
+        method: req.method ?? "GET",
+        headers,
+        body: body ? new Blob([new Uint8Array(body)]) : undefined,
+        duplex: body ? "half" : undefined,
+        signal: abortController.signal,
+    };
+    return new Request(url, requestInit);
+}
+async function sendNodeResponse(response, res) {
+    res.statusCode = response.status;
+    if (response.statusText) {
+        res.statusMessage = response.statusText;
+    }
+    for (const [name, value] of response.headers) {
+        res.setHeader(name, value);
+    }
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    const body = Readable.fromWeb(response.body);
+    await new Promise((resolve, reject) => {
+        body.once("error", reject);
+        res.once("finish", resolve);
+        res.once("close", resolve);
+        body.pipe(res);
+    }).catch(() => {
+        if (!res.writableEnded) {
+            res.end();
+        }
+    });
+}
+export async function startWebServer(port) {
+    const sessionToken = randomBytes(24).toString("base64url");
+    const server = createServer(async (nodeReq, nodeRes) => {
+        try {
+            const request = await toWebRequest(nodeReq, port);
+            const response = await handleWebRequest(request, sessionToken);
+            await sendNodeResponse(response, nodeRes);
+        }
+        catch (error) {
+            console.error(`[hydra] web request failed: ${formatErrorMessage(error)}`);
+            if (!nodeRes.headersSent) {
+                nodeRes.statusCode = 500;
+                const headers = createSecurityHeaders("text/plain; charset=utf-8");
+                for (const [name, value] of headers) {
+                    nodeRes.setHeader(name, value);
+                }
+            }
+            if (!nodeRes.writableEnded) {
+                nodeRes.end("internal server error");
+            }
+        }
+    });
+    server.requestTimeout = 0;
+    server.keepAliveTimeout = 0;
+    server.timeout = 0;
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", resolve);
+    });
+    console.log(`[hydra] web UI starting at http://localhost:${port}`);
+    console.log(`[hydra] open http://localhost:${port} in your browser`);
+    await new Promise(() => { });
+}
+//# sourceMappingURL=server.js.map