@shibbirweb/mcp-db-read-only 0.1.0 → 1.0.0

package/dist/logging/store/FolderLogChannel.js

@@ -0,0 +1,56 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { JsonSerializer } from "../../formatting/JsonSerializer.js";
+import { RecordJson } from "../RecordJson.js";
+import { LogFileNames } from "./LogFileNames.js";
+/**
+ * Saves every entry as its own JSON file in the permanent log folder.
+ *
+ * Each file is written under a temporary name and renamed into place, which
+ * is atomic on one filesystem, so a reader (this process's viewer, another
+ * copy's, or a person with `ls`) never sees a half-written file. Temporaries
+ * end in `.tmp` and are ignored by LogFileNames.
+ *
+ * The folder is created readable by the owner only, and each file likewise:
+ * with logging on they hold every query and every result.
+ *
+ * Synchronous for the same reason as FileSink: shutdown ends with
+ * `process.exit`, which would lose buffered writes.
+ *
+ * Nothing is ever deleted or rotated here. The folder is permanent by design.
+ */
+export class FolderLogChannel {
+    directory;
+    onWritten;
+    serializer;
+    sequence = 0;
+    /**
+     * @param onWritten told of each entry just saved, so this process's own
+     *   viewer can show it at once instead of waiting for its next scan.
+     */
+    constructor(directory, onWritten = () => undefined, serializer = new JsonSerializer()) {
+        this.directory = directory;
+        this.onWritten = onWritten;
+        this.serializer = serializer;
+    }
+    get description() {
+        return this.directory;
+    }
+    onCall(call) {
+        const name = LogFileNames.build(call.at, call.pid, "call", ++this.sequence, call.tool, call.failed);
+        this.save(name, "call", RecordJson.call(call));
+    }
+    onStatement(statement) {
+        const name = LogFileNames.build(statement.at, statement.pid, "statement", ++this.sequence, null, statement.failed);
+        this.save(name, "statement", RecordJson.statement(statement));
+    }
+    save(relativePath, kind, data) {
+        const target = join(this.directory, relativePath);
+        const day = join(this.directory, relativePath.split("/")[0]);
+        mkdirSync(day, { recursive: true, mode: 0o700 });
+        const temporary = `${target}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${this.serializer.stringify(data)}\n`, { mode: 0o600 });
+        renameSync(temporary, target);
+        this.onWritten({ key: relativePath, kind, data });
+    }
+}

package/dist/logging/store/FolderLogStore.js

@@ -0,0 +1,214 @@
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { LogFileNames } from "./LogFileNames.js";
+import { Paging } from "./LogStore.js";
+/**
+ * Reads the permanent log folder for the viewer: every entry saved by every
+ * copy of the server that shares it, newest first.
+ *
+ * **An index of file names, not contents.** On first use the folder is
+ * listed once, and each name parsed (LogFileNames puts time, pid, tool and
+ * outcome in it), so paging, the tool filter and "failed only" never open a
+ * file. Only the entries on the page being shown are read, plus, for a text
+ * search, the candidates it has to look inside.
+ *
+ * **New entries.** This process's own writes arrive at once through
+ * `noteWritten`. Other copies' writes are found by rescanning today's folder
+ * once a second: one small directory listing, dependable on every platform,
+ * where `fs.watch` is not (it drops and duplicates events, and behaves
+ * differently on network and bind-mounted folders). The timer is unref'd, so
+ * it never keeps the process alive.
+ *
+ * Files deleted by hand disappear from the index the next time they would
+ * have been read.
+ */
+export class FolderLogStore {
+    directory;
+    static SCAN_INTERVAL_MS = 1000;
+    index = null;
+    known = new Set();
+    /** Entries already pushed to the viewer, so the scan and noteWritten never push one twice. */
+    emitted = new Set();
+    listeners = new Set();
+    timer = null;
+    constructor(directory) {
+        this.directory = directory;
+    }
+    start() {
+        if (this.timer) {
+            return;
+        }
+        this.load();
+        this.timer = setInterval(() => void this.scanRecent(), FolderLogStore.SCAN_INTERVAL_MS);
+        this.timer.unref();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** An entry this process has just saved: index it and tell the viewer now. */
+    noteWritten(entry) {
+        const [day, file] = entry.key.split("/");
+        const info = LogFileNames.parse(day, file);
+        if (!info) {
+            return;
+        }
+        // Loaded first, so a write before the first query cannot leave the index
+        // holding only this one entry and the rest of the folder unscanned.
+        this.load();
+        this.add(info);
+        this.emit(entry);
+    }
+    async tools() {
+        const names = new Set();
+        for (const info of this.load()) {
+            if (info.tool) {
+                names.add(info.tool);
+            }
+        }
+        return Array.from(names).sort();
+    }
+    async query(query) {
+        let candidates = this.load().filter((info) => (!query.tool || info.tool === query.tool) && (!query.failedOnly || info.failed));
+        const needle = query.text?.trim().toLowerCase();
+        if (needle) {
+            const matching = [];
+            for (const info of candidates) {
+                const text = await this.readText(info);
+                if (text !== null && text.toLowerCase().includes(needle)) {
+                    matching.push(info);
+                }
+            }
+            candidates = matching;
+        }
+        const paged = Paging.page(candidates, query);
+        const entries = [];
+        for (const info of paged.slice) {
+            const entry = await this.read(info);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return { entries, total: paged.total, page: paged.page, size: paged.size, pages: paged.pages };
+    }
+    /** The index, built on first use: every day folder, every file, newest first. */
+    load() {
+        if (this.index) {
+            return this.index;
+        }
+        // Collected, then sorted once: inserting one at a time would be
+        // quadratic in a folder that has been filling for months.
+        const all = [];
+        for (const day of this.listDays()) {
+            for (const info of this.listDay(day)) {
+                if (!this.known.has(info.relativePath)) {
+                    this.known.add(info.relativePath);
+                    all.push(info);
+                }
+            }
+        }
+        this.index = all.sort((a, b) => (this.newer(a, b) ? -1 : 1));
+        return this.index;
+    }
+    /**
+     * Today's folder, and yesterday's around midnight UTC, since a copy may
+     * still be finishing a call dated the day before.
+     */
+    async scanRecent() {
+        const now = new Date();
+        const days = new Set([LogFileNames.dayFolder(now), LogFileNames.dayFolder(new Date(now.getTime() - 60000))]);
+        for (const day of days) {
+            for (const info of this.listDay(day)) {
+                if (this.add(info)) {
+                    const entry = await this.read(info);
+                    if (entry) {
+                        this.emit(entry);
+                    }
+                }
+            }
+        }
+    }
+    /** @returns true when the entry was new. Keeps the index newest first. */
+    add(info) {
+        if (this.known.has(info.relativePath)) {
+            return false;
+        }
+        this.known.add(info.relativePath);
+        const index = this.load();
+        let at = 0;
+        while (at < index.length && this.newer(index[at], info)) {
+            at += 1;
+        }
+        index.splice(at, 0, info);
+        return true;
+    }
+    /** Newest first by time; the name breaks ties, so the order is total and stable. */
+    newer(a, b) {
+        const difference = a.at.getTime() - b.at.getTime();
+        return difference !== 0 ? difference > 0 : a.relativePath > b.relativePath;
+    }
+    listDays() {
+        if (!existsSync(this.directory)) {
+            return [];
+        }
+        return readdirSync(this.directory).filter((name) => LogFileNames.isDayFolder(name));
+    }
+    listDay(day) {
+        const folder = join(this.directory, day);
+        if (!existsSync(folder)) {
+            return [];
+        }
+        const found = [];
+        for (const file of readdirSync(folder)) {
+            const info = LogFileNames.parse(day, file);
+            if (info) {
+                found.push(info);
+            }
+        }
+        return found;
+    }
+    async read(info) {
+        const text = await this.readText(info);
+        if (text === null) {
+            return null;
+        }
+        try {
+            return { key: info.relativePath, kind: info.kind, data: JSON.parse(text) };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** A file that has gone, deleted by hand, is dropped from the index. */
+    async readText(info) {
+        try {
+            return await readFile(join(this.directory, info.relativePath), "utf8");
+        }
+        catch {
+            this.forget(info);
+            return null;
+        }
+    }
+    forget(info) {
+        this.known.delete(info.relativePath);
+        if (this.index) {
+            this.index = this.index.filter((entry) => entry.relativePath !== info.relativePath);
+        }
+    }
+    emit(entry) {
+        if (this.emitted.has(entry.key)) {
+            return;
+        }
+        this.emitted.add(entry.key);
+        for (const listener of this.listeners) {
+            listener(entry);
+        }
+    }
+}

package/dist/logging/store/LogFileNames.js

@@ -0,0 +1,57 @@
+/**
+ * Names log files so that everything the viewer lists and filters on is in
+ * the name itself.
+ *
+ * `YYYY-MM-DD/HHMMSS-mmmZ_p<pid>_<c|s><sequence>_<tool>_<ok|failed>.json`
+ *
+ * - **A folder per UTC day**, so no single folder grows to tens of thousands
+ *   of entries, and old days can be archived or deleted as a whole.
+ * - **Time first**, so names sort chronologically; the `Z` says it is UTC.
+ * - **The pid and a per-process sequence**, so several copies of the server
+ *   writing to one folder can never produce the same name.
+ * - **The tool and outcome last**, so paging, the tool filter and "failed
+ *   only" read directory listings and never open a file. Only a text search
+ *   reads contents.
+ */
+export class LogFileNames {
+    static DAY = /^\d{4}-\d{2}-\d{2}$/;
+    static FILE = /^(\d{2})(\d{2})(\d{2})-(\d{3})Z_p(\d+)_([cs])(\d+)_([A-Za-z0-9_-]+?)_(ok|failed)\.json$/;
+    static dayFolder(at) {
+        return at.toISOString().slice(0, 10);
+    }
+    static build(at, pid, kind, sequence, tool, failed) {
+        const iso = at.toISOString();
+        const time = `${iso.slice(11, 13)}${iso.slice(14, 16)}${iso.slice(17, 19)}-${iso.slice(20, 23)}Z`;
+        const marker = kind === "call" ? "c" : "s";
+        const label = kind === "call" ? LogFileNames.safe(tool ?? "call") : "statement";
+        return `${LogFileNames.dayFolder(at)}/${time}_p${pid}_${marker}${String(sequence).padStart(6, "0")}_${label}_${failed ? "failed" : "ok"}.json`;
+    }
+    static isDayFolder(name) {
+        return LogFileNames.DAY.test(name);
+    }
+    /** @returns null for anything that is not one of our files, including half-written temporaries. */
+    static parse(day, file) {
+        const match = LogFileNames.FILE.exec(file);
+        if (!match || !LogFileNames.isDayFolder(day)) {
+            return null;
+        }
+        const [, hh, mm, ss, ms, pid, marker, , label, outcome] = match;
+        const at = new Date(`${day}T${hh}:${mm}:${ss}.${ms}Z`);
+        if (Number.isNaN(at.getTime())) {
+            return null;
+        }
+        const kind = marker === "c" ? "call" : "statement";
+        return {
+            relativePath: `${day}/${file}`,
+            at,
+            pid: Number(pid),
+            kind,
+            tool: kind === "call" ? label : null,
+            failed: outcome === "failed",
+        };
+    }
+    /** Tool names are already safe; this keeps any future one from reaching the path as-is. */
+    static safe(name) {
+        return name.replace(/[^A-Za-z0-9_-]/g, "-") || "call";
+    }
+}

package/dist/logging/store/LogStore.js

@@ -0,0 +1,18 @@
+/** Pages and page counts, shared by both stores so they cannot disagree. */
+export class Paging {
+    static DEFAULT_SIZE = 20;
+    static MAX_SIZE = 100;
+    static normalise(query) {
+        const size = Math.min(Math.max(Math.trunc(query.size) || Paging.DEFAULT_SIZE, 1), Paging.MAX_SIZE);
+        const page = Math.max(Math.trunc(query.page) || 1, 1);
+        return { page, size };
+    }
+    static page(matching, query) {
+        const { page, size } = Paging.normalise(query);
+        const total = matching.length;
+        const pages = Math.max(Math.ceil(total / size), 1);
+        const current = Math.min(page, pages);
+        const start = (current - 1) * size;
+        return { slice: matching.slice(start, start + size), total, page: current, size, pages };
+    }
+}

package/dist/logging/store/MemoryLogStore.js

@@ -0,0 +1,70 @@
+import { RecordJson } from "../RecordJson.js";
+import { Paging } from "./LogStore.js";
+/**
+ * The viewer's store when no log folder is configured: this process's most
+ * recent entries, in memory only, oldest dropped first past the capacity.
+ *
+ * A LogChannel as well, since without a folder there is nothing else to read
+ * entries back from: it is fed directly by the call logger.
+ */
+export class MemoryLogStore {
+    capacity;
+    description = "the live viewer's memory";
+    entries = [];
+    listeners = new Set();
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    onCall(call) {
+        this.add({ key: `m:${call.pid}:c${call.id}`, kind: "call", data: RecordJson.call(call) });
+    }
+    onStatement(statement) {
+        this.add({ key: `m:${statement.pid}:s${statement.at.getTime()}:${this.entries.length}`, kind: "statement", data: RecordJson.statement(statement) });
+    }
+    start() {
+        return;
+    }
+    stop() {
+        return;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async tools() {
+        const names = new Set();
+        for (const entry of this.entries) {
+            if (entry.kind === "call") {
+                names.add(String(entry.data.tool));
+            }
+        }
+        return Array.from(names).sort();
+    }
+    async query(query) {
+        const needle = query.text?.trim().toLowerCase();
+        const matching = this.entries
+            .filter((entry) => (!query.tool || (entry.kind === "call" && entry.data.tool === query.tool)) &&
+            (!query.failedOnly || entry.data.failed === true) &&
+            (!needle || entry.search.includes(needle)))
+            .reverse();
+        const paged = Paging.page(matching, query);
+        return {
+            entries: paged.slice.map(({ key, kind, data }) => ({ key, kind, data })),
+            total: paged.total,
+            page: paged.page,
+            size: paged.size,
+            pages: paged.pages,
+        };
+    }
+    add(entry) {
+        if (this.capacity > 0) {
+            this.entries.push({ ...entry, search: JSON.stringify(entry.data).toLowerCase() });
+            if (this.entries.length > this.capacity) {
+                this.entries.splice(0, this.entries.length - this.capacity);
+            }
+        }
+        for (const listener of this.listeners) {
+            listener(entry);
+        }
+    }
+}

package/dist/logging/viewer/LiveLogViewer.js

@@ -0,0 +1,264 @@
+import { execFile } from "node:child_process";
+import { createServer } from "node:http";
+import { JsonSerializer } from "../../formatting/JsonSerializer.js";
+import { Paging } from "../store/LogStore.js";
+import { ViewerAssets } from "./ViewerAssets.js";
+/**
+ * `lsof`, present on macOS and most Linux hosts. Absent in the Alpine image,
+ * where the message simply says the port is in use without naming anyone.
+ */
+export const lsofPortOwner = (port) => new Promise((resolve) => {
+    execFile("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fpc"], { timeout: 2000 }, (error, stdout) => {
+        if (error) {
+            resolve(null);
+            return;
+        }
+        const pid = /^p(\d+)$/m.exec(stdout)?.[1];
+        const command = /^c(.+)$/m.exec(stdout)?.[1];
+        resolve(pid ? `${command ?? "a process"} (pid ${pid})` : null);
+    });
+});
+/**
+ * The live log viewer: a page in the browser listing logged calls, a page at
+ * a time, newest first, and updating as new ones arrive.
+ *
+ * It reads a LogStore: the permanent log folder when DB_LOG_DIR is set, which
+ * holds the calls of every copy of the server sharing it, or this process's
+ * recent calls in memory otherwise. It never sees a record that has not been
+ * through the redactor, because the stores only ever hold what the call
+ * logger produced.
+ *
+ * It serves, read-only, with Node's own `http` module:
+ *
+ * - `/`, `/viewer.js`, `/viewer.css`: the page, self-contained, fetching
+ *   nothing from anywhere else;
+ * - `/api/entries?page=&size=&tool=&failed=1&q=`: one page of entries, with
+ *   the filters applied across everything stored;
+ * - `/api/tools`: the tool names present, for the tool filter;
+ * - `/events`: Server-Sent Events announcing each new entry.
+ *
+ * It binds its port **on the first tool call, not at startup**. An MCP client
+ * such as Claude Desktop starts one copy of the server per chat surface, and
+ * most of those copies never receive a call. Binding lazily means the copy
+ * actually in use gets the port, and idle copies never hold one.
+ *
+ * It must never become the reason the process misbehaves:
+ *
+ * - **A port that is taken is reported, not fatal.** `ensureRunning` returns
+ *   why, naming the process that holds the port where it can, and every
+ *   later call retries, so freeing the port brings the viewer up without a
+ *   restart.
+ * - **It never keeps the process alive.** The listening socket and every
+ *   connected browser are unref'd, so the process lives exactly as long as it
+ *   would with no viewer. Without this, a client that died without sending
+ *   SIGTERM would leave an orphan holding the port, and the next session's
+ *   viewer would find it taken.
+ */
+export class LiveLogViewer {
+    host;
+    port;
+    store;
+    logger;
+    portOwner;
+    assets;
+    serializer;
+    /** Keeps idle connections open through proxies and sleeping laptops. */
+    static HEARTBEAT_MS = 15000;
+    clients = new Set();
+    server = null;
+    heartbeat = null;
+    unsubscribe = null;
+    current = { state: "idle" };
+    binding = null;
+    stopped = false;
+    constructor(host, port, store, logger, portOwner = lsofPortOwner, assets = new ViewerAssets(), serializer = new JsonSerializer()) {
+        this.host = host;
+        this.port = port;
+        this.store = store;
+        this.logger = logger;
+        this.portOwner = portOwner;
+        this.assets = assets;
+        this.serializer = serializer;
+    }
+    get status() {
+        return this.current;
+    }
+    /** The port actually bound, which differs from the requested one only when that was 0. */
+    get boundPort() {
+        const address = this.server?.address();
+        return address && typeof address === "object" ? address.port : null;
+    }
+    /** Binding is deferred to the first tool call; see the class comment. */
+    async start() {
+        return;
+    }
+    /**
+     * Serve, if not already serving. Called before every tool call; cheap once
+     * running, and a quick retry while the port is taken. Never throws.
+     * Concurrent calls share one attempt.
+     */
+    ensureRunning() {
+        if (this.stopped || this.current.state === "running") {
+            return Promise.resolve(this.current);
+        }
+        if (!this.binding) {
+            this.binding = this.bind().finally(() => {
+                this.binding = null;
+            });
+        }
+        return this.binding;
+    }
+    /**
+     * Keep the process alive for as long as the viewer listens. Only the
+     * standalone `viewer` command wants this; inside an MCP server the viewer
+     * must never be what keeps the process running.
+     */
+    holdProcessOpen() {
+        this.server?.ref();
+    }
+    /** Never throws: shutdown calls it. */
+    async stop() {
+        this.stopped = true;
+        if (this.heartbeat) {
+            clearInterval(this.heartbeat);
+            this.heartbeat = null;
+        }
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        this.store.stop();
+        for (const client of this.clients) {
+            client.end();
+        }
+        this.clients.clear();
+        const server = this.server;
+        this.server = null;
+        if (server) {
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+    }
+    async bind() {
+        const server = createServer((request, response) => void this.handle(request, response));
+        const failure = await new Promise((resolve) => {
+            server.once("error", (error) => resolve(error));
+            server.listen(this.port, this.host, () => resolve(null));
+        });
+        if (failure) {
+            server.close();
+            this.current = { state: "unavailable", port: this.port, reason: await this.describeFailure(failure) };
+            return this.current;
+        }
+        server.unref();
+        server.on("error", (error) => this.logger(`live log viewer: ${error.message}`));
+        this.server = server;
+        this.store.start();
+        this.unsubscribe = this.store.subscribe((entry) => this.broadcast(this.frame(entry)));
+        this.heartbeat = setInterval(() => this.broadcast(": heartbeat\n\n"), LiveLogViewer.HEARTBEAT_MS);
+        this.heartbeat.unref();
+        this.current = { state: "running", url: `http://${this.displayHost()}:${this.boundPort}/` };
+        // Said plainly, because with no access control anyone who can reach
+        // this address can read every query and every result.
+        this.logger(`live log viewer at ${this.current.url} (listening on ${this.host}, no access control: anyone who can reach this port can read the full call log)`);
+        return this.current;
+    }
+    async describeFailure(error) {
+        if (error.code !== "EADDRINUSE") {
+            return `port ${this.port} could not be opened: ${error.message}`;
+        }
+        const owner = await this.portOwner(this.port).catch(() => null);
+        return owner ? `port ${this.port} is used by ${owner}` : `port ${this.port} is already in use`;
+    }
+    broadcast(frame) {
+        for (const client of this.clients) {
+            client.write(frame);
+        }
+    }
+    /**
+     * One SSE message. The data is compact JSON, which escapes every newline
+     * inside its strings, so it is always a single `data:` line and cannot be
+     * split or spoofed by content containing blank lines.
+     */
+    frame(entry) {
+        return `event: entry\ndata: ${this.serializer.stringify(entry, 0)}\n\n`;
+    }
+    async handle(request, response) {
+        // Reads only. Nothing on this server accepts input.
+        if (request.method !== "GET" && request.method !== "HEAD") {
+            this.send(response, 405, "text/plain; charset=utf-8", "Method not allowed", { allow: "GET, HEAD" });
+            return;
+        }
+        const url = new URL(request.url ?? "/", "http://viewer.invalid");
+        try {
+            switch (url.pathname) {
+                case "/":
+                    this.send(response, 200, "text/html; charset=utf-8", this.assets.html);
+                    return;
+                case "/viewer.js":
+                    this.send(response, 200, "text/javascript; charset=utf-8", this.assets.script);
+                    return;
+                case "/viewer.css":
+                    this.send(response, 200, "text/css; charset=utf-8", this.assets.stylesheet);
+                    return;
+                case "/api/entries":
+                    this.sendJson(response, await this.store.query(this.parseQuery(url.searchParams)));
+                    return;
+                case "/api/tools":
+                    this.sendJson(response, { tools: await this.store.tools() });
+                    return;
+                case "/events":
+                    this.subscribe(request, response);
+                    return;
+                default:
+                    this.send(response, 404, "text/plain; charset=utf-8", "Not found");
+            }
+        }
+        catch (error) {
+            this.send(response, 500, "text/plain; charset=utf-8", `Could not read the log: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    parseQuery(params) {
+        return {
+            page: Number(params.get("page") ?? 1),
+            size: Number(params.get("size") ?? Paging.DEFAULT_SIZE),
+            tool: params.get("tool") || undefined,
+            failedOnly: params.get("failed") === "1",
+            text: params.get("q") || undefined,
+        };
+    }
+    subscribe(request, response) {
+        response.writeHead(200, {
+            ...this.securityHeaders(),
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-store",
+            connection: "keep-alive",
+        });
+        response.socket?.unref();
+        // Tell the browser to retry after 2 s if the server restarts.
+        response.write("retry: 2000\n\nevent: ready\ndata: {}\n\n");
+        this.clients.add(response);
+        request.on("close", () => this.clients.delete(response));
+    }
+    sendJson(response, value) {
+        this.send(response, 200, "application/json; charset=utf-8", this.serializer.stringify(value, 0));
+    }
+    send(response, status, contentType, body, extra = {}) {
+        response.writeHead(status, { ...this.securityHeaders(), "content-type": contentType, ...extra });
+        response.end(body);
+    }
+    /**
+     * The page runs with a policy allowing only its own script, stylesheet,
+     * API and event stream, so even a result that somehow reached the page as
+     * markup could not load or run anything.
+     */
+    securityHeaders() {
+        return {
+            "content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'",
+            "x-content-type-options": "nosniff",
+            "referrer-policy": "no-referrer",
+            "cache-control": "no-store",
+        };
+    }
+    /** 0.0.0.0 is where it listens, not an address a browser can open. */
+    displayHost() {
+        return this.host === "0.0.0.0" || this.host === "::" ? "127.0.0.1" : this.host;
+    }
+}