humanish 0.105.0 → 0.106.0

package/dist/observer/render.js

@@ -0,0 +1,350 @@
+import { spawn } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { createServer } from "node:http";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { projectShareCheckedAnalysis } from "../analysis/sharing.js";
+import { loadStudyAnalysis } from "../analysis/load.js";
+import { physicalCwdOf, runIdOf, bindExistingRunArtifactPaths, isSafeRunIdSegment, resolveLatestRunDirectory, validatePreparedRunArtifactPaths, } from "../run/paths.js";
+import { writeContainedOutputFile } from "../run/contained-output.js";
+import { loadRunBundlePrepared } from "../run/locate.js";
+import { verifyRunPrepared } from "../verify/verify.js";
+import { renderObserverHtml } from "./artifact.js";
+import { buildObserverData } from "./data.js";
+import { buildServeSecurityHeaders, hostAllowed, parsePublicOrigin } from "./http.js";
+import { listenOnLoopback } from "./listen.js";
+import { pinDirectChildDirectory, pinDirectory, readContainedFile, } from "./pinned-files.js";
+import { buildHistoryIndex, matchRunRoute, serveRunPath, writeResponse, } from "./run-routes.js";
+const OBSERVER_SCHEMA = "humanish.observer-result.v1";
+const observerRuntimeStreamUrls = new WeakMap();
+const observerPreparedRunPaths = new WeakMap();
+export function attachObserverRuntimeStreamUrls(result, streams) {
+    observerRuntimeStreamUrls.set(result, streams.filter((stream) => stream.streamId && stream.url));
+}
+export async function renderObserver(cwdInput, runInput, options = {}) {
+    const cwd = path.resolve(cwdInput);
+    let selection;
+    try {
+        if (options.expectedRun) {
+            const prepared = options.expectedRun;
+            if (runInput !== runIdOf(prepared) || (await realpath(cwd)) !== physicalCwdOf(prepared)) {
+                throw new Error("Observer source pin does not match the selected run.");
+            }
+            await validatePreparedRunArtifactPaths(prepared);
+            selection = {
+                runId: runInput,
+                runRoot: { ...prepared.runRootIdentity, physicalPath: prepared.physicalRunRoot },
+                runsRoot: { ...prepared.runsRootIdentity, physicalPath: prepared.physicalRunsRoot },
+            };
+        }
+        else {
+            selection = await resolveObserverRunSelection(cwd, runInput);
+        }
+    }
+    catch {
+        selection = null;
+    }
+    if (!selection) {
+        return observerRunError(cwd, runInput, "HUMANISH_RUN_NOT_FOUND", `Run not found: ${runInput}`);
+    }
+    let preparedRunPaths;
+    try {
+        const selectedPhysicalCwd = path.dirname(path.dirname(selection.runsRoot.physicalPath));
+        preparedRunPaths =
+            options.expectedRun ??
+                (await bindExistingRunArtifactPaths(selectedPhysicalCwd, selection.runId));
+        if (preparedRunPaths.physicalRunsRoot !== selection.runsRoot.physicalPath ||
+            preparedRunPaths.physicalRunRoot !== selection.runRoot.physicalPath ||
+            preparedRunPaths.runsRootIdentity.birthtimeNs !== selection.runsRoot.birthtimeNs ||
+            preparedRunPaths.runsRootIdentity.dev !== selection.runsRoot.dev ||
+            preparedRunPaths.runsRootIdentity.ino !== selection.runsRoot.ino ||
+            preparedRunPaths.runRootIdentity.birthtimeNs !== selection.runRoot.birthtimeNs ||
+            preparedRunPaths.runRootIdentity.dev !== selection.runRoot.dev ||
+            preparedRunPaths.runRootIdentity.ino !== selection.runRoot.ino) {
+            throw new Error("Observer run selection changed physical identity.");
+        }
+    }
+    catch {
+        return observerRunError(cwd, runInput, "HUMANISH_INVALID_RUN_BUNDLE", "Observer run storage is unavailable or unsafe.");
+    }
+    await validatePreparedRunArtifactPaths(preparedRunPaths);
+    const selectedPhysicalCwd = path.dirname(path.dirname(selection.runsRoot.physicalPath));
+    const verified = await verifyRunPrepared(selectedPhysicalCwd, selection.runId, preparedRunPaths);
+    await validatePreparedRunArtifactPaths(preparedRunPaths);
+    if (!verified.ok && verified.recordingOk !== true) {
+        return observerRunError(cwd, runInput, verified.error?.code === "HUMANISH_RUN_NOT_FOUND"
+            ? "HUMANISH_RUN_NOT_FOUND"
+            : "HUMANISH_INVALID_RUN_BUNDLE", verified.error?.message ?? "Run bundle failed verification.");
+    }
+    const loaded = await loadRunBundlePrepared(selectedPhysicalCwd, preparedRunPaths);
+    await validatePreparedRunArtifactPaths(preparedRunPaths);
+    if (!loaded) {
+        return observerRunError(cwd, runInput, "HUMANISH_RUN_NOT_FOUND", `Run not found: ${runInput}`);
+    }
+    if (loaded.bundle.runId !== selection.runId ||
+        (await realpath(loaded.runDir)) !== preparedRunPaths.physicalRunRoot) {
+        throw new Error("Observer output directory does not match the selected run.");
+    }
+    const observerPath = path.join(preparedRunPaths.physicalRunRoot, "observer", "index.html");
+    const analysis = projectShareCheckedAnalysis(await loadStudyAnalysis(preparedRunPaths));
+    const observerData = buildObserverData(loaded.bundle);
+    observerData.publicSafety.share = {
+        status: verified.shareSafety.status,
+        verifiedAt: new Date().toISOString(),
+        reasons: verified.shareSafety.reasons.map((reason) => reason.code),
+    };
+    await writeContainedOutputFile(preparedRunPaths, path.join("observer", "observer-data.json"), `${JSON.stringify(observerData, null, 2)}\n`, "utf8");
+    await writeContainedOutputFile(preparedRunPaths, path.join("observer", "study-analysis.json"), `${JSON.stringify(analysis, null, 2)}\n`, "utf8");
+    await writeContainedOutputFile(preparedRunPaths, path.join("observer", "index.html"), renderObserverHtml(observerData, { analysis }), "utf8");
+    await validatePreparedRunArtifactPaths(preparedRunPaths);
+    const relativeObserverPath = path.join(preparedRunPaths.relativeRunRoot, "observer", "index.html");
+    const relativeObserverDataPath = path.join(preparedRunPaths.relativeRunRoot, "observer", "observer-data.json");
+    const relativeEventsPath = path.join(preparedRunPaths.relativeRunRoot, "events.ndjson");
+    const observerUrl = pathToFileURL(observerPath).href;
+    const openResult = options.open === true ? openTarget(observerPath) : { opened: false };
+    const result = {
+        schema: OBSERVER_SCHEMA,
+        ok: true,
+        cwd,
+        run: loaded.bundle.runId,
+        observerPath: relativeObserverPath,
+        observerDataPath: relativeObserverDataPath,
+        eventsPath: relativeEventsPath,
+        observerUrl,
+        bundlePath: loaded.bundlePath,
+        opened: openResult.opened,
+        ...(openResult.command ? { openCommand: openResult.command } : {}),
+        warnings: [
+            loaded.bundle.mode === "live"
+                ? "Observer renders verified local evidence artifacts; runtime stream auth URLs are not persisted."
+                : "Observer renders local contract evidence only; dry-run participants do not claim product behavior proof.",
+            "Before filing public feedback, use `humanish feedback issue` so redaction and public-safety checks gate the payload.",
+            ...(openResult.warning ? [openResult.warning] : []),
+        ],
+    };
+    observerPreparedRunPaths.set(result, preparedRunPaths);
+    return result;
+}
+function observerRunError(cwd, run, code, message) {
+    return {
+        schema: OBSERVER_SCHEMA,
+        ok: false,
+        cwd,
+        run,
+        warnings: [],
+        error: { code, message },
+    };
+}
+async function resolveObserverRunSelection(cwd, runInput) {
+    const runsRoot = await pinDirectory(path.join(cwd, ".humanish", "runs"));
+    if (runInput !== "latest") {
+        const runRoot = isSafeRunIdSegment(runInput)
+            ? await pinDirectChildDirectory(runsRoot, runInput)
+            : null;
+        return runRoot ? { runId: runInput, runRoot, runsRoot } : null;
+    }
+    const latestBytes = await readContainedFile(runsRoot, path.join(runsRoot.physicalPath, "latest.json"));
+    if (!latestBytes)
+        return null;
+    const pointer = JSON.parse(latestBytes.toString("utf8"));
+    if (typeof pointer.runId !== "string" ||
+        typeof pointer.path !== "string" ||
+        !isSafeRunIdSegment(pointer.runId)) {
+        return null;
+    }
+    const declared = resolveLatestRunDirectory(cwd, { path: pointer.path, runId: pointer.runId });
+    if (!declared)
+        return null;
+    const expected = path.join(runsRoot.physicalPath, pointer.runId);
+    const runRoot = await pinDirectChildDirectory(runsRoot, pointer.runId);
+    if (!runRoot || runRoot.physicalPath !== expected)
+        return null;
+    return { runId: pointer.runId, runRoot, runsRoot };
+}
+export async function serveObserver(result, options = {}) {
+    if (!result.ok || !result.observerPath) {
+        throw new Error("Cannot serve an observer result that did not render successfully.");
+    }
+    const cwd = path.resolve(result.cwd);
+    const retainedRunPaths = observerPreparedRunPaths.get(result);
+    const preparedRunPaths = retainedRunPaths
+        ? await validatePreparedRunArtifactPaths(retainedRunPaths)
+        : await bindExistingRunArtifactPaths(cwd, result.run);
+    const runRoot = await pinDirectory(preparedRunPaths.physicalRunRoot);
+    const proofRoot = await pinDirectory(preparedRunPaths.physicalRunsRoot);
+    const expectedRelativeObserverPath = path.join(preparedRunPaths.relativeRunRoot, "observer", "index.html");
+    if (result.observerPath !== expectedRelativeObserverPath) {
+        throw new Error("Observer path does not match the selected run.");
+    }
+    // The live server renders observer/index.html from the pinned run bundle on
+    // each request, so an attached in-progress Observer legitimately has no
+    // static index file yet. The exact lexical result path was checked above;
+    // keep serving from the identity-bound physical run root.
+    const observerPath = path.join(preparedRunPaths.physicalRunRoot, "observer", "index.html");
+    if (observerPath !== path.join(runRoot.physicalPath, "observer", "index.html")) {
+        throw new Error("Observer path does not match the selected run.");
+    }
+    const runtimeStreamUrls = () => observerRuntimeStreamUrls.get(result) ?? [];
+    const exposed = options.exposed === true;
+    const scopedToRun = exposed || options.scope === "run";
+    // Host allowlist for exposed mode (DNS-rebinding defense, identical to the run-library surface).
+    // Seeded with the loopback names after bind; addPublicOrigin extends it with the tunnel/public-url
+    // host. Never consulted in loopback (non-exposed) mode.
+    const hostAllowlist = new Set();
+    const handleRequest = async (request, response) => {
+        try {
+            // Every response, including run HTML artifacts, must refuse framing. A provider iframe
+            // with its own origin intact must not navigate back here and gain the Observer's origin.
+            for (const [name, value] of Object.entries(buildServeSecurityHeaders())) {
+                response.setHeader(name, value);
+            }
+            if (exposed) {
+                if (!hostAllowed(request.headers.host, hostAllowlist)) {
+                    writeResponse(response, 421, "Misdirected Request", "text/plain; charset=utf-8");
+                    return;
+                }
+            }
+            const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
+            if (url.pathname === "/") {
+                response.writeHead(302, { location: "/observer/index.html" });
+                response.end();
+                return;
+            }
+            if (url.pathname === "/_humanish/history.json") {
+                const history = await buildHistoryIndex(proofRoot);
+                // Exposed watch and selected-run viewers cannot enumerate other runs. Full-library
+                // loopback viewers retain the complete project index.
+                if (scopedToRun) {
+                    const attachedRuns = history.runs.filter((entry) => entry.runId === result.run);
+                    writeResponse(response, 200, JSON.stringify({ latestRunId: attachedRuns.length > 0 ? result.run : null, runs: attachedRuns }, null, 2), "application/json; charset=utf-8");
+                    return;
+                }
+                writeResponse(response, 200, JSON.stringify(history, null, 2), "application/json; charset=utf-8");
+                return;
+            }
+            if (url.pathname.startsWith("/_humanish/runs/")) {
+                const runRoute = matchRunRoute(url.pathname);
+                if (!runRoute) {
+                    writeResponse(response, 404, "Run not found", "text/plain; charset=utf-8");
+                    return;
+                }
+                // Scoped viewers cannot distinguish another run from a nonexistent one.
+                if (scopedToRun && runRoute.runId !== result.run) {
+                    writeResponse(response, 404, "Run not found", "text/plain; charset=utf-8");
+                    return;
+                }
+                const targetRoot = await pinDirectChildDirectory(proofRoot, runRoute.runId);
+                if (!targetRoot) {
+                    writeResponse(response, 404, "Run not found", "text/plain; charset=utf-8");
+                    return;
+                }
+                await serveRunPath(targetRoot, runRoute.relativePath || "observer/index.html", response, runRoute.runId === result.run ? runtimeStreamUrls() : [], request);
+                return;
+            }
+            await serveRunPath(runRoot, decodeURIComponent(url.pathname.slice(1)), response, runtimeStreamUrls(), request);
+        }
+        catch {
+            writeResponse(response, 500, "Observer request failed", "text/plain; charset=utf-8");
+        }
+    };
+    const server = createServer((request, response) => {
+        void handleRequest(request, response);
+    });
+    const port = await listenOnLoopback(server, options.port ?? 0);
+    if (exposed) {
+        hostAllowlist.add(`127.0.0.1:${port}`);
+        hostAllowlist.add(`localhost:${port}`);
+        hostAllowlist.add(`[::1]:${port}`);
+    }
+    const url = `http://127.0.0.1:${port}/observer/index.html`;
+    const openResult = options.open === true ? openTarget(url) : { opened: false };
+    return {
+        url,
+        port,
+        opened: openResult.opened,
+        ...(openResult.command ? { openCommand: openResult.command } : {}),
+        ...(openResult.warning ? { warning: openResult.warning } : {}),
+        // A tunnel's public origin is only known after it starts (post bind). Declaring it here extends
+        // the Host allowlist so the authenticated edge is admitted; a no-op in loopback mode (the
+        // allowlist is never consulted) and for an unparseable origin.
+        addPublicOrigin(origin) {
+            if (!exposed) {
+                return;
+            }
+            const parsed = parsePublicOrigin(origin);
+            if (parsed) {
+                hostAllowlist.add(parsed.host);
+            }
+        },
+        close: () => closeServer(server),
+    };
+}
+/**
+ * The command that opens a target in the desktop browser, or why this host has none. Linux needs
+ * a display and xdg-open; without them the opener would exit quietly and nothing would appear.
+ */
+export function desktopOpener(target, host) {
+    if (host.platform === "darwin")
+        return { command: "open", args: [target] };
+    if (host.platform === "win32")
+        return { command: "cmd", args: ["/c", "start", "", target] };
+    if (!host.env.DISPLAY && !host.env.WAYLAND_DISPLAY)
+        return { reason: "no display is available (DISPLAY and WAYLAND_DISPLAY are unset)" };
+    if (!host.onPath("xdg-open"))
+        return { reason: "xdg-open is not installed" };
+    return { command: "xdg-open", args: [target] };
+}
+function onProcessPath(name) {
+    return (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .filter(Boolean)
+        .some((directory) => {
+        try {
+            accessSync(path.join(directory, name), constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export function openTarget(target, host = { platform: process.platform, env: process.env, onPath: onProcessPath }) {
+    const opener = desktopOpener(target, host);
+    if ("reason" in opener)
+        return {
+            opened: false,
+            warning: `Could not open observer automatically: ${opener.reason}. Open ${target} in a browser.`,
+        };
+    const { command, args } = opener;
+    try {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        // An opener that disappears after the PATH check still fails asynchronously (ENOENT). The
+        // served URL remains usable; an opener must never crash its server.
+        child.on("error", () => { });
+        child.unref();
+        return { opened: true, command: [command, ...args].join(" ") };
+    }
+    catch (error) {
+        return {
+            opened: false,
+            command: [command, ...args].join(" "),
+            warning: `Could not open observer automatically: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}

package/dist/observer/run-inventory.d.ts

@@ -0,0 +1,35 @@
+import { type PinnedDirectory } from "./pinned-files.js";
+/** internal: consumed by src/observer/serve.ts */
+export interface RunInventory {
+    /** Each entry under the run directory, keyed by its posix path relative to the run. */
+    readonly entries: ReadonlyMap<string, string>;
+    /** The run directory's own device, inode and birth time. */
+    readonly root: string;
+    /** Equal for two walks only when every entry and the run directory are unchanged. */
+    readonly signature: string;
+}
+/**
+ * Walks the run without following symlinks. Null when the run directory or its run.json is
+ * missing, or the walk fails.
+ */
+export declare function readRunInventory(runDirectory: string): Promise<RunInventory | null>;
+/**
+ * The sha256 of each regular file in the inventory. Null when a file cannot be read or no longer
+ * has its inventoried identity.
+ */
+export declare function hashRunInventory(runDirectory: string, inventory: RunInventory): Promise<ReadonlyMap<string, string> | null>;
+/** internal: consumed by src/observer/serve.ts */
+export interface AdmittedRun {
+    readonly inventory: RunInventory;
+    /** The sha256 of each regular file, equal before and after verify read the run. */
+    readonly hashes: ReadonlyMap<string, string>;
+    /** Drops the cached admission, so the next request verifies the run again. */
+    readonly forget: () => void;
+}
+/**
+ * The served run root, narrowed to the admitted run: a file opens only when its path is in the
+ * inventory with the same identity, and its bytes are served only when their sha256 matches.
+ * A store through a shared mmap changes the bytes without changing any stat field, so a hash
+ * mismatch also drops the admission. Null when the pinned directory is not the one walked.
+ */
+export declare function inventoryRoot(pinned: PinnedDirectory, admitted: AdmittedRun): PinnedDirectory | null;

package/dist/observer/run-inventory.js

@@ -0,0 +1,95 @@
+// The files a share-safety verdict covers. Serve's --safe mode walks and hashes a run before and
+// after verifying it, and serves a file only while its stat identity and its bytes match.
+import { constants as fsConstants } from "node:fs";
+import { lstat, open, readdir } from "node:fs/promises";
+import path from "node:path";
+import { sha256OfOpenedFile } from "./pinned-files.js";
+/**
+ * Walks the run without following symlinks. Null when the run directory or its run.json is
+ * missing, or the walk fails.
+ */
+export async function readRunInventory(runDirectory) {
+    try {
+        const rootStats = await lstat(runDirectory, { bigint: true });
+        if (!rootStats.isDirectory())
+            return null;
+        const entries = new Map();
+        const pending = [""];
+        for (let directory = pending.pop(); directory !== undefined; directory = pending.pop()) {
+            const parent = directory;
+            const listed = await Promise.all((await readdir(path.join(runDirectory, parent))).map(async (name) => ({
+                key: parent === "" ? name : `${parent}/${name}`,
+                stats: await lstat(path.join(runDirectory, parent, name), { bigint: true }),
+            })));
+            for (const { key, stats } of listed) {
+                entries.set(key, entryIdentity(stats));
+                if (stats.isDirectory())
+                    pending.push(key);
+            }
+        }
+        if (!entries.get("run.json")?.startsWith("file:"))
+            return null;
+        const root = `${rootStats.dev}:${rootStats.ino}:${rootStats.birthtimeNs}`;
+        // NUL cannot occur in a file name, so the joined form is unambiguous.
+        const signature = [
+            root,
+            ...[...entries.keys()].sort().map((key) => key + "\0" + entries.get(key)),
+        ].join("\0");
+        return { entries, root, signature };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The sha256 of each regular file in the inventory. Null when a file cannot be read or no longer
+ * has its inventoried identity.
+ */
+export async function hashRunInventory(runDirectory, inventory) {
+    const hashes = new Map();
+    for (const [key, identity] of inventory.entries) {
+        if (!identity.startsWith("file:"))
+            continue;
+        let handle;
+        try {
+            // O_NONBLOCK keeps a FIFO swapped in after the walk from blocking the open.
+            handle = await open(path.join(runDirectory, key), fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | fsConstants.O_NONBLOCK);
+            if (entryIdentity(await handle.stat({ bigint: true })) !== identity)
+                return null;
+            hashes.set(key, await sha256OfOpenedFile(handle));
+        }
+        catch {
+            return null;
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    return hashes;
+}
+/**
+ * The served run root, narrowed to the admitted run: a file opens only when its path is in the
+ * inventory with the same identity, and its bytes are served only when their sha256 matches.
+ * A store through a shared mmap changes the bytes without changing any stat field, so a hash
+ * mismatch also drops the admission. Null when the pinned directory is not the one walked.
+ */
+export function inventoryRoot(pinned, admitted) {
+    const { inventory, hashes } = admitted;
+    if (`${pinned.dev}:${pinned.ino}:${pinned.birthtimeNs}` !== inventory.root)
+        return null;
+    return Object.freeze({
+        ...pinned,
+        admitsFile: (relativePath, stats) => stats.isFile() && inventory.entries.get(relativePath) === entryIdentity(stats),
+        admitsContent: (relativePath, sha256) => {
+            if (hashes.get(relativePath) === sha256)
+                return true;
+            admitted.forget();
+            return false;
+        },
+    });
+}
+// A write changes size, mtime or ctime; a rename or replacement changes the inode or ctime.
+function entryIdentity(stats) {
+    const kind = stats.isFile() ? "file" : stats.isDirectory() ? "dir" : "other";
+    return `${kind}:${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeNs}:${stats.ctimeNs}`;
+}

package/dist/observer/run-routes.d.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type ObserverData } from "./data.js";
+import { type PinnedDirectory } from "./pinned-files.js";
+export interface ObserverRuntimeStreamUrl {
+    streamId: string;
+    url: string;
+    /** Set when the lane's sandbox is gone (finished or torn down). An ended stream's live URL is a
+     *  dead noVNC page — the overlay stops injecting it so the tile falls back to the recorded
+     *  evidence (keyframe replay/screenshot) instead of rendering "sandbox not found" (#357). */
+    ended?: boolean;
+}
+/** internal: consumed by src/observer/serve.ts */
+export declare function serveRunPath(runRoot: PinnedDirectory, relativePath: string, response: ServerResponse, runtimeStreamUrls?: ObserverRuntimeStreamUrl[], request?: Pick<IncomingMessage, "method" | "headers">): Promise<void>;
+/** internal: exported for the #357 lifecycle tests. */
+export declare function withRuntimeStreamUrls(data: ObserverData, runtimeStreamUrls: ObserverRuntimeStreamUrl[]): ObserverData;
+/** internal: consumed by src/observer/serve.ts */
+export declare function buildHistoryIndex(proofRoot: PinnedDirectory, admitRun?: (runId: string, pinned: PinnedDirectory) => Promise<PinnedDirectory | null>): Promise<{
+    latestRunId: string | null;
+    runs: Array<{
+        runId: string;
+        createdAt: string | null;
+        mode: string | null;
+        href: string;
+        status: string;
+        runtimeState?: NonNullable<ObserverData["runtime"]>["state"];
+        streamCount: number;
+        estimatedCostUsd: number | null;
+        costRatesAsOf: string | null;
+        costPlaceholder: boolean;
+    }>;
+}>;
+/** internal: consumed by src/observer/serve.ts */
+export declare function matchRunRoute(pathname: string): {
+    runId: string;
+    relativePath: string;
+} | null;
+export declare function writeResponse(response: ServerResponse, status: number, body: string, contentType: string): void;