@relauts/spotcheck-service 1.0.0

package/dist/api/server.js

@@ -0,0 +1,852 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import http from "node:http";
+import path from "node:path";
+import { AgentRunError, runAgent } from "../computer-use/index.js";
+import { confirmSafetyForWeb } from "../computer-use/safety.js";
+import { launchLightChromium } from "../playwright/chromium.js";
+import { getLatestWebpPath, getSavedRunItemScreenshotRelPaths, getSavedRunScreenshotRelPath, } from "../playwright/processed.js";
+import { BrowserClosedError, createBrowserSession, } from "../playwright/session.js";
+import { loadConfig, requireApiToken } from "../shared/config.js";
+import { computeCostUsd, EMPTY_USAGE } from "../shared/cost.js";
+import { logger } from "../shared/logger.js";
+import { isMainModule } from "../shared/main-module.js";
+import { assertAllowedModel, getModelEntry, loadModels, } from "../shared/models.js";
+import { createAutomationReporter } from "../shared/telemetry.js";
+import { isAuthorized } from "./auth.js";
+import { findLatestHistory, listHistoryRuns, readHistoryFile, serializeHistoryDetailItem } from "./history.js";
+import { CREATE_DEFAULT_FILE, SavedExistsError, SavedNameError, SavedNotFoundError, deleteSavedFile, ensureCreateDefaultFile, isCreateDefaultFileName, listSavedFiles, normalizeSavedFileName, overwriteSavedFile, parseCreateItems, parseSavedItems, readSavedFile, upsertSavedFile, writeSavedFile, } from "./saved.js";
+import { SavedRunBusyError, SavedRunFinishedError, SavedRunLimitError, SavedRunNotRunningError, createSavedRunManager, } from "./saved-run.js";
+const MAX_AGENT_BODY_BYTES = 16_384;
+const MAX_CREATE_BODY_BYTES = 262_144;
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const serverSessions = new WeakMap();
+const serverSavedRuns = new WeakMap();
+let activeServer;
+let shuttingDown = false;
+const pendingSafetyConfirmations = new Map();
+async function loadAgentStreamExtras(session, processedDir) {
+    const status = session.getStatus();
+    let imageName = "";
+    try {
+        const filePath = await getLatestWebpPath(processedDir);
+        if (filePath) {
+            imageName = path.basename(filePath);
+        }
+    }
+    catch {
+        // Same as GET /v1/screenshot with no file: do not fail the event.
+    }
+    return {
+        session: { open: status.open, url: status.url },
+        screenshot: { imageName },
+    };
+}
+async function writeAgentEvent(response, session, processedDir, body) {
+    writeNdjson(response, {
+        ...body,
+        ...(await loadAgentStreamExtras(session, processedDir)),
+    });
+}
+/**
+ * Builds a per-request SafetyConfirmer that pushes a "safety_confirm" event down
+ * the open NDJSON stream and waits for POST /v1/agent/safety.
+ */
+function createWebSafetyConfirmer(response, signal, session, processedDir) {
+    return async (explanation, actionName) => {
+        const extras = await loadAgentStreamExtras(session, processedDir);
+        return new Promise((resolve) => {
+            const id = randomUUID();
+            function onAbort() {
+                pendingSafetyConfirmations.delete(id);
+                resolve(false);
+            }
+            function settle(confirmed) {
+                if (signal.aborted) {
+                    pendingSafetyConfirmations.delete(id);
+                    signal.removeEventListener("abort", onAbort);
+                    resolve(false);
+                    return;
+                }
+                signal.removeEventListener("abort", onAbort);
+                resolve(confirmed);
+            }
+            pendingSafetyConfirmations.set(id, settle);
+            signal.addEventListener("abort", onAbort);
+            writeNdjson(response, {
+                type: "safety_confirm",
+                id,
+                action: actionName,
+                explanation,
+                ...extras,
+            });
+        });
+    };
+}
+function requestPath(request) {
+    return new URL(request.url ?? "/", "http://localhost").pathname;
+}
+function send(response, status, body, headers) {
+    response.writeHead(status, headers);
+    response.end(body);
+}
+function sendJson(response, status, body, extraHeaders = {}) {
+    send(response, status, JSON.stringify(body), {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        ...extraHeaders,
+    });
+}
+function sendMethodNotAllowed(response, allow, cors) {
+    send(response, 405, "Method not allowed", {
+        "Content-Type": "text/plain; charset=utf-8",
+        Allow: allow,
+        ...cors,
+    });
+}
+function beginNdjson(response, extraHeaders = {}) {
+    response.writeHead(200, {
+        "Content-Type": "application/x-ndjson; charset=utf-8",
+        "Cache-Control": "no-store",
+        "X-Accel-Buffering": "no",
+        ...extraHeaders,
+    });
+    response.flushHeaders();
+}
+function writeNdjson(response, body) {
+    if (response.writableEnded || response.destroyed) {
+        return;
+    }
+    response.write(`${JSON.stringify(body)}\n`);
+}
+function endNdjson(response) {
+    if (!response.writableEnded && !response.destroyed) {
+        response.end();
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function corsHeadersFor(request, allowedOrigins) {
+    const origin = request.headers.origin;
+    if (!origin || !allowedOrigins.includes(origin)) {
+        return {};
+    }
+    return {
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Authorization, Content-Type",
+        "Access-Control-Max-Age": "86400",
+        Vary: "Origin",
+    };
+}
+function applyCors(request, response, allowedOrigins) {
+    const headers = corsHeadersFor(request, allowedOrigins);
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined) {
+            response.setHeader(key, value);
+        }
+    }
+    return headers;
+}
+async function readJsonBody(request, maxBytes = MAX_AGENT_BODY_BYTES) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > maxBytes) {
+            request.destroy();
+            throw new HttpError(413, "Request body too large");
+        }
+        chunks.push(buffer);
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        throw new HttpError(400, "Request body is required");
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new HttpError(400, "Body must be valid JSON");
+    }
+}
+function parseSavedItemsBody(body, models) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    try {
+        return parseSavedItems(body.items).map((item) => ({
+            ...item,
+            model: assertAllowedModel(item.model, models),
+        }));
+    }
+    catch (error) {
+        throw new HttpError(400, errorMessage(error));
+    }
+}
+function parseSavedRequest(body, models) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    const payload = body;
+    if (typeof payload.fileName !== "string" || !payload.fileName.trim()) {
+        throw new HttpError(400, "fileName is required");
+    }
+    const items = parseSavedItemsBody(body, models);
+    return { fileName: payload.fileName.trim(), items };
+}
+async function handleSavedList(request, response, savedDir, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET, POST", cors);
+        return;
+    }
+    const files = (await listSavedFiles(savedDir)).filter((name) => name.toLowerCase() !== CREATE_DEFAULT_FILE);
+    sendJson(response, 200, { files }, cors);
+}
+async function handleSavedItem(request, response, pathname, savedDir, cors) {
+    const rawName = decodeURIComponent(pathname.slice("/v1/saved/".length));
+    if (request.method === "GET") {
+        try {
+            sendJson(response, 200, await readSavedFile(rawName, savedDir), cors);
+        }
+        catch (error) {
+            if (error instanceof SavedNotFoundError) {
+                throw new HttpError(404, error.message);
+            }
+            if (error instanceof SavedNameError) {
+                throw new HttpError(400, error.message);
+            }
+            throw error;
+        }
+        return;
+    }
+    if (request.method === "PUT") {
+        const models = await loadModels();
+        const items = parseSavedItemsBody(await readJsonBody(request), models);
+        try {
+            const name = await overwriteSavedFile(rawName, items, savedDir);
+            sendJson(response, 200, { fileName: name }, cors);
+        }
+        catch (error) {
+            if (error instanceof SavedNotFoundError) {
+                throw new HttpError(404, error.message);
+            }
+            if (error instanceof SavedNameError) {
+                throw new HttpError(400, error.message);
+            }
+            throw error;
+        }
+        return;
+    }
+    if (request.method === "DELETE") {
+        try {
+            const name = await deleteSavedFile(rawName, savedDir);
+            sendJson(response, 200, { fileName: name }, cors);
+        }
+        catch (error) {
+            if (error instanceof SavedNotFoundError) {
+                throw new HttpError(404, error.message);
+            }
+            if (error instanceof SavedNameError) {
+                throw new HttpError(400, error.message);
+            }
+            throw error;
+        }
+        return;
+    }
+    sendMethodNotAllowed(response, "GET, PUT, DELETE", cors);
+}
+async function handleSavedCreate(request, response, savedDir, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "GET, POST", cors);
+        return;
+    }
+    const models = await loadModels();
+    const { fileName, items } = parseSavedRequest(await readJsonBody(request), models);
+    try {
+        if (isCreateDefaultFileName(fileName)) {
+            throw new SavedNameError(`${CREATE_DEFAULT_FILE} is reserved`);
+        }
+        const name = await writeSavedFile(fileName, items, savedDir);
+        sendJson(response, 201, { fileName: name }, cors);
+    }
+    catch (error) {
+        if (error instanceof SavedExistsError) {
+            throw new HttpError(409, error.message);
+        }
+        if (error instanceof SavedNameError) {
+            throw new HttpError(400, error.message);
+        }
+        throw error;
+    }
+}
+function parseCreateRequest(body, models) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    try {
+        return parseCreateItems(body.items).map((item) => ({
+            ...item,
+            model: assertAllowedModel(item.model, models),
+        }));
+    }
+    catch (error) {
+        throw new HttpError(400, errorMessage(error));
+    }
+}
+async function handleCreateDefault(request, response, savedDir, cors) {
+    if (request.method === "GET") {
+        try {
+            sendJson(response, 200, await readSavedFile(CREATE_DEFAULT_FILE, savedDir), cors);
+        }
+        catch (error) {
+            if (error instanceof SavedNotFoundError) {
+                sendJson(response, 200, { fileName: CREATE_DEFAULT_FILE, items: [] }, cors);
+                return;
+            }
+            if (error instanceof SavedNameError) {
+                throw new HttpError(400, error.message);
+            }
+            throw error;
+        }
+        return;
+    }
+    if (request.method !== "PUT") {
+        sendMethodNotAllowed(response, "GET, PUT", cors);
+        return;
+    }
+    const models = await loadModels();
+    const items = parseCreateRequest(await readJsonBody(request, MAX_CREATE_BODY_BYTES), models);
+    const name = await upsertSavedFile(CREATE_DEFAULT_FILE, items, savedDir);
+    sendJson(response, 200, { fileName: name }, cors);
+}
+function parseAgentRequest(body, models) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    const payload = body;
+    const task = payload.task;
+    if (typeof task !== "string" || !task.trim()) {
+        throw new HttpError(400, "task is required");
+    }
+    if (typeof payload.model !== "string" || !payload.model.trim()) {
+        throw new HttpError(400, "model is required");
+    }
+    try {
+        return {
+            task: task.trim(),
+            model: assertAllowedModel(payload.model, models),
+        };
+    }
+    catch (error) {
+        throw new HttpError(400, errorMessage(error));
+    }
+}
+async function handleModelsRequest(request, response, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    const models = await loadModels();
+    send(response, 200, JSON.stringify(models), {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        ...cors,
+    });
+}
+async function handleScreenshotRequest(request, response, processedDir, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    const filePath = await getLatestWebpPath(processedDir);
+    if (!filePath) {
+        throw new HttpError(404, "No processed webp yet");
+    }
+    sendJson(response, 200, { imageName: path.basename(filePath) }, cors);
+}
+async function handleAgentRequest(request, response, runTask, session, busy, processedDir, cors, reportAutomation) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    if (busy.current) {
+        throw new HttpError(409, "Agent already running");
+    }
+    busy.current = true;
+    try {
+        const models = await loadModels();
+        const { task, model } = parseAgentRequest(await readJsonBody(request), models);
+        const prices = getModelEntry(model, models);
+        const abort = new AbortController();
+        let finished = false;
+        const stopOnDisconnect = () => {
+            if (!finished) {
+                abort.abort();
+            }
+        };
+        response.once("close", stopOnDisconnect);
+        beginNdjson(response, cors);
+        try {
+            const startedAt = new Date();
+            const result = await runTask(task, model, {
+                signal: abort.signal,
+                onIntent: async (label) => {
+                    await writeAgentEvent(response, session, processedDir, { type: "intent", label });
+                },
+                confirmSafety: createWebSafetyConfirmer(response, abort.signal, session, processedDir),
+            });
+            reportAutomation(startedAt, new Date());
+            await writeAgentEvent(response, session, processedDir, {
+                type: "done",
+                text: result.text,
+                sessionReset: result.sessionReset,
+                browserOpen: session.isOpen(),
+                costUsd: computeCostUsd(result.usage ?? EMPTY_USAGE, prices),
+            });
+        }
+        catch (error) {
+            await writeAgentEvent(response, session, processedDir, {
+                type: "error",
+                error: errorMessage(error),
+                costUsd: computeCostUsd(error instanceof AgentRunError ? error.usage : EMPTY_USAGE, prices),
+            });
+            if (!(error instanceof AgentRunError)) {
+                logger.error("Failed to run agent", error);
+            }
+        }
+        finally {
+            finished = true;
+            response.off("close", stopOnDisconnect);
+            endNdjson(response);
+        }
+    }
+    finally {
+        busy.current = false;
+    }
+}
+async function handleAgentSafety(request, response, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    const body = await readJsonBody(request);
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    const payload = body;
+    if (typeof payload.id !== "string" || !payload.id.trim()) {
+        throw new HttpError(400, "id is required");
+    }
+    if (typeof payload.confirmed !== "boolean") {
+        throw new HttpError(400, "confirmed must be a boolean");
+    }
+    const settle = pendingSafetyConfirmations.get(payload.id);
+    if (!settle) {
+        throw new HttpError(404, "No pending confirmation for id");
+    }
+    settle(payload.confirmed);
+    sendJson(response, 200, { ok: true }, cors);
+}
+function handleSessionStatus(request, response, session, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    const status = session.getStatus();
+    sendJson(response, 200, { open: status.open, url: status.url }, cors);
+}
+async function handleSessionNavigate(request, response, session, busy, action, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    if (busy.current) {
+        throw new HttpError(409, "Agent already running");
+    }
+    try {
+        let status;
+        if (action === "back") {
+            status = await session.goBack();
+        }
+        else if (action === "forward") {
+            status = await session.goForward();
+        }
+        else {
+            status = await session.reload();
+        }
+        sendJson(response, 200, { open: status.open, url: status.url }, cors);
+    }
+    catch (error) {
+        if (error instanceof BrowserClosedError) {
+            throw new HttpError(409, error.message);
+        }
+        throw error;
+    }
+}
+function handleHealth(request, response, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    sendJson(response, 200, { ok: true }, cors);
+}
+function parseRequiredName(body, field = "fileName") {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new HttpError(400, "Body must be a JSON object");
+    }
+    const value = body[field];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new HttpError(400, `${field} is required`);
+    }
+    return value.trim();
+}
+async function handleSavedRunStart(request, response, savedRun, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    const fileName = parseRequiredName(await readJsonBody(request), "fileName");
+    try {
+        const historyFile = await savedRun.start(fileName);
+        sendJson(response, 202, { historyFile }, cors);
+    }
+    catch (error) {
+        if (error instanceof SavedRunBusyError || error instanceof SavedRunLimitError) {
+            throw new HttpError(409, error.message);
+        }
+        if (error instanceof SavedNotFoundError) {
+            throw new HttpError(404, error.message);
+        }
+        if (error instanceof SavedNameError) {
+            throw new HttpError(400, error.message);
+        }
+        throw error;
+    }
+}
+async function handleHistoryList(request, response, historyDir, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    sendJson(response, 200, { runs: await listHistoryRuns(historyDir) }, cors);
+}
+async function handleHistoryDetail(request, response, historyDir, processedDir, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    const historyFile = parseRequiredName(await readJsonBody(request), "historyFile");
+    try {
+        const name = normalizeSavedFileName(historyFile);
+        const document = await readHistoryFile(name, historyDir);
+        const items = await Promise.all(document.items.map(async (item) => {
+            const screenshots = await getSavedRunItemScreenshotRelPaths(processedDir, name, item.sequence, item.id);
+            return serializeHistoryDetailItem(item, screenshots);
+        }));
+        sendJson(response, 200, {
+            historyFile: name,
+            status: document.status,
+            items,
+        }, cors);
+    }
+    catch (error) {
+        if (error instanceof SavedNotFoundError) {
+            throw new HttpError(404, error.message);
+        }
+        if (error instanceof SavedNameError) {
+            throw new HttpError(400, error.message);
+        }
+        throw error;
+    }
+}
+function handleSavedRunningList(request, response, savedRun, cors) {
+    if (request.method !== "GET") {
+        sendMethodNotAllowed(response, "GET", cors);
+        return;
+    }
+    sendJson(response, 200, { files: savedRun.listRunning() }, cors);
+}
+async function handleHistoryStatus(request, response, historyDir, processedDir, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    const fileName = parseRequiredName(await readJsonBody(request));
+    try {
+        const latest = await findLatestHistory(fileName, historyDir);
+        const screenshotPath = await getSavedRunScreenshotRelPath(processedDir, latest.historyFile);
+        sendJson(response, 200, {
+            fileName: latest.document.fileName,
+            historyFile: latest.historyFile,
+            status: latest.document.status,
+            current: latest.document.current,
+            total: latest.document.total,
+            screenshotPath,
+            items: [...latest.document.items],
+        }, cors);
+    }
+    catch (error) {
+        if (error instanceof SavedNotFoundError) {
+            throw new HttpError(404, error.message);
+        }
+        if (error instanceof SavedNameError) {
+            throw new HttpError(400, error.message);
+        }
+        throw error;
+    }
+}
+async function handleHistoryStop(request, response, savedRun, historyDir, cors) {
+    if (request.method !== "POST") {
+        sendMethodNotAllowed(response, "POST", cors);
+        return;
+    }
+    const fileName = parseRequiredName(await readJsonBody(request));
+    try {
+        const latest = await findLatestHistory(fileName, historyDir);
+        await savedRun.stop(latest.historyFile);
+        sendJson(response, 200, { ok: true }, cors);
+    }
+    catch (error) {
+        if (error instanceof SavedRunNotRunningError) {
+            throw new HttpError(404, error.message);
+        }
+        if (error instanceof SavedRunFinishedError) {
+            throw new HttpError(409, error.message);
+        }
+        if (error instanceof SavedNotFoundError) {
+            throw new HttpError(404, error.message);
+        }
+        if (error instanceof SavedNameError) {
+            throw new HttpError(400, error.message);
+        }
+        throw error;
+    }
+}
+export async function startServiceServer(port, deps = {}) {
+    const config = deps.config ?? loadConfig();
+    const listenPort = port ?? config.webPort;
+    const apiToken = deps.apiToken ?? requireApiToken(config);
+    const corsOrigins = deps.corsOrigins ?? config.corsOrigins;
+    const processedDir = deps.processedDir ?? config.processedDir;
+    const savedDir = deps.savedDir ?? config.savedDir;
+    const historyDir = deps.historyDir ?? config.historyDir;
+    const busy = { current: false };
+    const session = deps.session ??
+        createBrowserSession({
+            launch: launchLightChromium,
+            screenshotDir: processedDir,
+        });
+    await ensureCreateDefaultFile(savedDir);
+    const runTask = deps.runTask ??
+        ((task, model, extras) => runAgent(task, config, confirmSafetyForWeb, session, model, extras));
+    const reportAutomation = deps.reportAutomation ?? createAutomationReporter(config);
+    const savedRun = createSavedRunManager({
+        savedDir,
+        historyDir,
+        processedDir,
+        config,
+        runTask: deps.savedRunTask,
+        createSession: deps.createSavedRunSession,
+        reportAutomation,
+    });
+    const server = http.createServer((request, response) => {
+        void (async () => {
+            const pathname = requestPath(request);
+            const method = request.method ?? "GET";
+            logger.info(`${method} ${pathname}`);
+            const cors = applyCors(request, response, corsOrigins);
+            try {
+                if (method === "OPTIONS") {
+                    send(response, 204, "", {
+                        ...cors,
+                        "Access-Control-Allow-Methods": cors["Access-Control-Allow-Methods"] ??
+                            "GET, POST, PUT, DELETE, OPTIONS",
+                        "Access-Control-Allow-Headers": cors["Access-Control-Allow-Headers"] ??
+                            "Authorization, Content-Type",
+                    });
+                    return;
+                }
+                if (pathname === "/v1/health") {
+                    handleHealth(request, response, cors);
+                    return;
+                }
+                if (!isAuthorized(request.headers.authorization, apiToken)) {
+                    sendJson(response, 401, { error: "Unauthorized" }, cors);
+                    return;
+                }
+                if (pathname === "/v1/screenshot") {
+                    await handleScreenshotRequest(request, response, processedDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/models") {
+                    await handleModelsRequest(request, response, cors);
+                    return;
+                }
+                if (pathname === "/v1/agent") {
+                    await handleAgentRequest(request, response, runTask, session, busy, processedDir, cors, reportAutomation);
+                    return;
+                }
+                if (pathname === "/v1/agent/safety") {
+                    await handleAgentSafety(request, response, cors);
+                    return;
+                }
+                if (pathname === "/v1/saved") {
+                    if (request.method === "GET") {
+                        await handleSavedList(request, response, savedDir, cors);
+                        return;
+                    }
+                    await handleSavedCreate(request, response, savedDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/saved/run") {
+                    await handleSavedRunStart(request, response, savedRun, cors);
+                    return;
+                }
+                if (pathname === "/v1/saved/running") {
+                    handleSavedRunningList(request, response, savedRun, cors);
+                    return;
+                }
+                if (pathname === "/v1/saved/create-default.json" ||
+                    pathname === "/v1/saved/create-default") {
+                    await handleCreateDefault(request, response, savedDir, cors);
+                    return;
+                }
+                if (pathname.startsWith("/v1/saved/")) {
+                    await handleSavedItem(request, response, pathname, savedDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/history") {
+                    await handleHistoryList(request, response, historyDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/history/detail") {
+                    await handleHistoryDetail(request, response, historyDir, processedDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/history/status") {
+                    await handleHistoryStatus(request, response, historyDir, processedDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/history/stop") {
+                    await handleHistoryStop(request, response, savedRun, historyDir, cors);
+                    return;
+                }
+                if (pathname === "/v1/session") {
+                    handleSessionStatus(request, response, session, cors);
+                    return;
+                }
+                if (pathname === "/v1/session/back") {
+                    await handleSessionNavigate(request, response, session, busy, "back", cors);
+                    return;
+                }
+                if (pathname === "/v1/session/forward") {
+                    await handleSessionNavigate(request, response, session, busy, "forward", cors);
+                    return;
+                }
+                if (pathname === "/v1/session/reload") {
+                    await handleSessionNavigate(request, response, session, busy, "reload", cors);
+                    return;
+                }
+                sendJson(response, 404, { error: "Not found" }, cors);
+            }
+            catch (error) {
+                if (error instanceof HttpError) {
+                    sendJson(response, error.status, { error: error.message }, cors);
+                    return;
+                }
+                logger.error("Failed to handle request", error);
+                sendJson(response, 500, { error: errorMessage(error) }, cors);
+            }
+        })();
+    });
+    serverSessions.set(server, session);
+    serverSavedRuns.set(server, savedRun);
+    try {
+        await new Promise((resolve, reject) => {
+            const onError = (error) => reject(error);
+            server.once("error", onError);
+            server.listen(listenPort, "127.0.0.1", () => {
+                server.removeListener("error", onError);
+                const address = server.address();
+                const actualPort = typeof address === "object" && address ? address.port : listenPort;
+                logger.info(`Spotcheck service listening at http://127.0.0.1:${actualPort}`);
+                resolve();
+            });
+        });
+    }
+    catch (error) {
+        serverSessions.delete(server);
+        serverSavedRuns.delete(server);
+        await session.close();
+        throw error;
+    }
+    activeServer = server;
+    return server;
+}
+export async function closeServiceServer(server) {
+    if (!server) {
+        return;
+    }
+    const session = serverSessions.get(server);
+    serverSessions.delete(server);
+    const savedRun = serverSavedRuns.get(server);
+    serverSavedRuns.delete(server);
+    if (savedRun) {
+        try {
+            await savedRun.close();
+        }
+        catch (error) {
+            logger.error("Failed to close saved run", error);
+        }
+    }
+    if (session) {
+        try {
+            await session.close();
+        }
+        catch (error) {
+            logger.error("Failed to close browser session", error);
+        }
+    }
+    await new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+async function shutdown(exitCode, reason) {
+    if (shuttingDown) {
+        process.exit(exitCode);
+    }
+    shuttingDown = true;
+    logger.info(reason);
+    await closeServiceServer(activeServer);
+    activeServer = undefined;
+    process.exit(exitCode);
+}
+function registerShutdownHandlers() {
+    const onSignal = (signal) => {
+        void shutdown(0, `Received ${signal}, shutting down`);
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+}
+async function main() {
+    registerShutdownHandlers();
+    const config = loadConfig();
+    requireApiToken(config);
+    await startServiceServer(config.webPort, { config });
+}
+if (isMainModule(import.meta.url)) {
+    main().catch((error) => {
+        logger.error("Fatal error", error);
+        void shutdown(1, "Exiting after fatal error");
+    });
+}
+//# sourceMappingURL=server.js.map