@workbench-ai/workbench 0.0.46

package/dist/dev-open-server.d.ts

@@ -0,0 +1,57 @@
+import { type RunSummary, type SurfaceSnapshotFile } from "@workbench-ai/workbench-core";
+export interface LocalWorkbenchDevServer {
+    url: string;
+    close: () => Promise<void>;
+}
+export interface LocalWorkbenchDevServerOptions {
+    workspace: string;
+    host: string;
+    port: number;
+    assetsRoot?: string;
+}
+export declare function startLocalWorkbenchDevServer(options: LocalWorkbenchDevServerOptions): Promise<LocalWorkbenchDevServer>;
+export declare function localRuntimeSnapshot(workspace: string): Promise<{
+    workspaceRoot: string;
+    activeId: string | null;
+    currentBenchmarkFingerprint: string | null;
+    summaries: {
+        id: string;
+        ordinal: number;
+        benchmarkFingerprint: string;
+        subjectFingerprint: string;
+        ownerUserId?: string;
+        ownerUsername?: string;
+        visibility?: "private" | "public";
+        createdAt: string;
+        baseId?: string;
+        referenceIds: string[];
+        status: import("@workbench-ai/workbench-contract").SubjectStatus;
+        fileChanges: string[];
+        metrics?: Record<string, number>;
+        usage?: import("@workbench-ai/workbench-contract").UsageSummary;
+    }[];
+    results: {
+        id: string;
+        runId: string;
+        benchmarkFingerprint: string;
+        subjectFingerprint: string;
+        subjectId: string;
+        createdAt: string;
+        updatedAt: string;
+        status: import("@workbench-ai/workbench-contract").EvaluationStatus;
+        sampleCount: number;
+        completedSampleCount: number;
+        errorSampleCount: number;
+        metrics?: Record<string, import("@workbench-ai/workbench-contract").MetricStats>;
+        durationMs?: import("@workbench-ai/workbench-contract").MetricStats;
+        usage?: import("@workbench-ai/workbench-contract").EvaluationUsageStats;
+        error?: string;
+    }[];
+    events: import("@workbench-ai/workbench-contract").RuntimeEvent[];
+    latestRun: RunSummary | null;
+    runs: RunSummary[];
+}>;
+export declare function localSpecDocument(workspace: string, benchmarkFingerprint?: string | null): Promise<import("@workbench-ai/workbench-contract").AuthoredWorkbenchSourceDocument>;
+export declare function localSourceFiles(workspace: string): Promise<SurfaceSnapshotFile[]>;
+export declare function localBenchmarkMountedFiles(workspace: string, benchmarkFingerprint?: string | null): Promise<SurfaceSnapshotFile[]>;
+//# sourceMappingURL=dev-open-server.d.ts.map

package/dist/dev-open-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-open-server.d.ts","sourceRoot":"","sources":["../src/dev-open-server.ts"],"names":[],"mappings":"AAKA,OAAO,EAUL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAGzB,MAAM,8BAA8B,CAAC;AAgBtC,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAoBD,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,uBAAuB,CAAC,CAoClC;AA0ND,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe3D;AAUD,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,uFA6BrC;AAwBD,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAExF;AAED,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EACjB,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,GACnC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAahC"}

package/dist/dev-open-server.js

@@ -0,0 +1,496 @@
+import { promises as fs } from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildSubjectCasePhaseRefs, buildWorkbenchTracePhases, createSubjectFilePreview, createCaseReview, loadAuthoredWorkbenchSourceDocument, summarizeSubjectFiles, } from "@workbench-ai/workbench-core";
+import { loadLocalArchive, localRuntimeDir, readLocalSubject, readLocalSubjectFiles, readLocalExecutionFiles, } from "./local-archive.js";
+import { readLocalProjectSource, WORKBENCH_BENCHMARK_FILE, } from "./project-source.js";
+import { localBenchmarkFingerprint } from "./benchmark-fingerprint.js";
+class LocalApiError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+    }
+}
+const DEV_OPEN_ASSET_DIR = "dev-open";
+export async function startLocalWorkbenchDevServer(options) {
+    const workspace = path.resolve(options.workspace);
+    const assetsRoot = options.assetsRoot ?? defaultDevOpenAssetsRoot();
+    await assertDevOpenAssets(assetsRoot);
+    const server = http.createServer((request, response) => {
+        void handleLocalWorkbenchRequest({
+            request,
+            response,
+            workspace,
+            assetsRoot,
+        }).catch((error) => {
+            sendError(response, error, request.method);
+        });
+    });
+    server.requestTimeout = 0;
+    server.timeout = 0;
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port, options.host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        await closeServer(server);
+        throw new Error("Workbench local server did not bind a TCP port.");
+    }
+    const host = displayHost(options.host);
+    return {
+        url: `http://${host}:${address.port}/`,
+        close: () => closeServer(server),
+    };
+}
+function defaultDevOpenAssetsRoot() {
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), DEV_OPEN_ASSET_DIR);
+}
+async function assertDevOpenAssets(assetsRoot) {
+    await Promise.all([
+        fs.stat(path.join(assetsRoot, "client.js")),
+        fs.stat(path.join(assetsRoot, "client.css")),
+    ]).catch(() => {
+        throw new Error(`Workbench local browser assets are missing from ${assetsRoot}. Run pnpm --dir products/workbench/packages/cli build.`);
+    });
+}
+async function closeServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+    });
+}
+async function handleLocalWorkbenchRequest(args) {
+    const url = new URL(args.request.url ?? "/", "http://workbench.local");
+    if (args.request.method !== "GET" && args.request.method !== "HEAD") {
+        sendJson(args.response, { message: "Workbench local open is read-only." }, 405, args.request.method);
+        return;
+    }
+    if (url.pathname.startsWith("/api/")) {
+        await handleApiRequest(args.request, args.response, args.workspace, url);
+        return;
+    }
+    if (url.pathname === "/assets/client.js") {
+        await sendFile(args.response, path.join(args.assetsRoot, "client.js"), "text/javascript; charset=utf-8", args.request.method);
+        return;
+    }
+    if (url.pathname === "/assets/client.css") {
+        await sendFile(args.response, path.join(args.assetsRoot, "client.css"), "text/css; charset=utf-8", args.request.method);
+        return;
+    }
+    if (url.pathname.startsWith("/assets/fonts/")) {
+        await sendFontFile(args.response, args.assetsRoot, url, args.request.method);
+        return;
+    }
+    await sendHtml(args.response, args.request.method);
+}
+async function handleApiRequest(request, response, workspace, url) {
+    switch (url.pathname) {
+        case "/api/snapshot":
+            sendJson(response, await localRuntimeSnapshot(workspace), 200, request.method);
+            return;
+        case "/api/spec":
+            sendJson(response, await localSpecDocument(workspace, readOptionalSearchString(url.searchParams, "fingerprint")), 200, request.method);
+            return;
+        case "/api/source/files":
+            sendJson(response, summarizeSubjectFiles(await localBenchmarkMountedFiles(workspace, readOptionalSearchString(url.searchParams, "fingerprint")), []), 200, request.method);
+            return;
+        case "/api/source/preview":
+            sendJson(response, createSubjectFilePreview({
+                files: await localBenchmarkMountedFiles(workspace, readOptionalSearchString(url.searchParams, "fingerprint")),
+                path: readSearchString(url.searchParams, "path"),
+                view: readPreviewMode(url.searchParams),
+            }), 200, request.method);
+            return;
+        case "/api/record":
+            sendJson(response, readSubjectForApi(await loadLocalArchive(workspace), readSearchString(url.searchParams, "id")), 200, request.method);
+            return;
+        case "/api/result":
+            sendJson(response, readResultForApi(await loadLocalArchive(workspace), readSearchString(url.searchParams, "id")), 200, request.method);
+            return;
+        case "/api/subject/files": {
+            const snapshot = await loadLocalArchive(workspace);
+            const subjectId = readSearchString(url.searchParams, "id");
+            const subject = readSubjectForApi(snapshot, subjectId);
+            sendJson(response, summarizeSubjectFiles(readSubjectFilesForApi(snapshot, subjectId), subject.fileChanges), 200, request.method);
+            return;
+        }
+        case "/api/subject/preview": {
+            const snapshot = await loadLocalArchive(workspace);
+            const subjectId = readSearchString(url.searchParams, "id");
+            sendJson(response, createSubjectFilePreview({
+                files: readSubjectFilesForApi(snapshot, subjectId),
+                path: readSearchString(url.searchParams, "path"),
+                view: readPreviewMode(url.searchParams),
+            }), 200, request.method);
+            return;
+        }
+        case "/api/case-review": {
+            const snapshot = await loadLocalArchive(workspace);
+            const subjectId = readSearchString(url.searchParams, "id");
+            const caseId = readSearchString(url.searchParams, "case");
+            const jobs = await loadLocalJobs(workspace);
+            sendJson(response, createCaseReview({
+                subject: readSubjectForApi(snapshot, subjectId),
+                caseId,
+                phases: buildSubjectCasePhaseRefs({ jobs, subjectId, caseId }),
+            }), 200, request.method);
+            return;
+        }
+        case "/api/run":
+            sendJson(response, await localRunDetail(workspace, readSearchString(url.searchParams, "id")), 200, request.method);
+            return;
+        case "/api/traces": {
+            const traceRunId = readSearchString(url.searchParams, "run");
+            const traceJobs = await loadLocalJobs(workspace);
+            sendJson(response, {
+                projectId: "local",
+                runId: traceRunId,
+                phases: buildWorkbenchTracePhases({
+                    jobs: traceJobs.filter((job) => job.runId === traceRunId),
+                    traceIdPrefix: "local-phase",
+                    traceForJob: readLocalTrace,
+                }),
+            }, 200, request.method);
+            return;
+        }
+        case "/api/execution/files": {
+            const execRunId = readSearchString(url.searchParams, "run");
+            const execJobId = readSearchString(url.searchParams, "id");
+            const execFiles = await loadExecutionFiles(workspace, execRunId, execJobId);
+            sendJson(response, execFiles, 200, request.method);
+            return;
+        }
+        case "/api/execution/preview": {
+            const previewRunId = readSearchString(url.searchParams, "run");
+            const previewJobId = readSearchString(url.searchParams, "id");
+            const previewFilePath = readSearchString(url.searchParams, "path");
+            const previewFiles = await readExecutionFilesForRun(workspace, previewRunId, previewJobId);
+            sendJson(response, createSubjectFilePreview({
+                files: previewFiles,
+                path: previewFilePath,
+                view: readPreviewMode(url.searchParams),
+            }), 200, request.method);
+            return;
+        }
+        default:
+            throw new LocalApiError(`Unknown Workbench local API route: ${url.pathname}`, 404);
+    }
+}
+export async function localRuntimeSnapshot(workspace) {
+    const snapshot = await loadLocalArchive(workspace);
+    const summaries = snapshot.subjects.map(subjectSummary);
+    const activeId = snapshot.activeId;
+    const currentBenchmarkFingerprint = await readCurrentBenchmarkFingerprint(workspace);
+    return {
+        workspaceRoot: path.resolve(workspace),
+        activeId,
+        currentBenchmarkFingerprint,
+        summaries,
+        results: snapshot.evaluations.map(resultSummary),
+        events: snapshot.events,
+        latestRun: snapshot.runs.at(-1) ?? null,
+        runs: snapshot.runs,
+    };
+}
+async function readCurrentBenchmarkFingerprint(workspace) {
+    return await readLocalProjectSource(workspace)
+        .then(localBenchmarkFingerprint)
+        .catch(() => null);
+}
+export async function localSpecDocument(workspace, benchmarkFingerprint) {
+    const projectSource = await readLocalProjectSource(workspace).catch(() => null);
+    const requestedFingerprint = normalizeOptionalFingerprint(benchmarkFingerprint);
+    const currentFingerprint = projectSource
+        ? await readCurrentBenchmarkFingerprint(workspace).catch(() => null)
+        : null;
+    if (requestedFingerprint &&
+        currentFingerprint &&
+        requestedFingerprint !== currentFingerprint) {
+        const snapshot = await loadLocalArchive(workspace);
+        const document = localHistoricalBenchmarkDocument(snapshot, requestedFingerprint);
+        if (document) {
+            return document;
+        }
+        throw new LocalApiError(`Benchmark version not found: ${requestedFingerprint}`, 404);
+    }
+    const sourceYaml = projectSource?.specSource ?? "";
+    const cases = projectSource
+        ? caseSummaryFilesFromEngineCases(projectSource.engineCases, projectSource.engineResolveFiles)
+        : [];
+    return loadAuthoredWorkbenchSourceDocument({
+        sourceYaml,
+        path: WORKBENCH_BENCHMARK_FILE,
+        sourceFiles: projectSource?.sourceFiles,
+        cases,
+    });
+}
+function caseSummaryFilesFromEngineCases(engineCases, files) {
+    const existingCaseIds = new Set(files.flatMap((file) => {
+        const normalized = file.path.replace(/\\/gu, "/").replace(/^\/+/u, "");
+        const slash = normalized.indexOf("/");
+        return slash > 0 ? [normalized.slice(0, slash)] : [];
+    }));
+    return [
+        ...files.map((file) => ({ ...file })),
+        ...engineCases
+            .filter((engineCase) => !existingCaseIds.has(engineCase.id))
+            .map((engineCase) => ({
+            path: `${engineCase.id}/.workbench-case.json`,
+            encoding: "utf8",
+            content: `${JSON.stringify({ id: engineCase.id })}\n`,
+            executable: false,
+        })),
+    ];
+}
+export async function localSourceFiles(workspace) {
+    return (await readLocalProjectSource(workspace)).sourceFiles;
+}
+export async function localBenchmarkMountedFiles(workspace, benchmarkFingerprint) {
+    const requestedFingerprint = normalizeOptionalFingerprint(benchmarkFingerprint);
+    const projectSource = await readLocalProjectSource(workspace);
+    const currentFingerprint = await readCurrentBenchmarkFingerprint(workspace).catch(() => null);
+    if (requestedFingerprint &&
+        currentFingerprint &&
+        requestedFingerprint !== currentFingerprint) {
+        const snapshot = await loadLocalArchive(workspace);
+        return localHistoricalBenchmarkFiles(snapshot, requestedFingerprint);
+    }
+    return inspectableEngineCaseFiles(projectSource.engineCases);
+}
+function localHistoricalBenchmarkDocument(snapshot, benchmarkFingerprint) {
+    const subject = snapshot.subjects.find((entry) => entry.benchmarkFingerprint === benchmarkFingerprint);
+    const source = subject ? readBenchmarkSourceMetadata(subject) : null;
+    if (!source?.sourceYaml) {
+        return null;
+    }
+    return loadAuthoredWorkbenchSourceDocument({
+        sourceYaml: source.sourceYaml,
+        path: WORKBENCH_BENCHMARK_FILE,
+        sourceFiles: source.files,
+        cases: localHistoricalBenchmarkFiles(snapshot, benchmarkFingerprint),
+    });
+}
+function localHistoricalBenchmarkFiles(_snapshot, _benchmarkFingerprint) {
+    return [];
+}
+function inspectableEngineCaseFiles(engineCases) {
+    return engineCases.flatMap((bundle) => engineCaseFiles(bundle).map((file) => ({
+        ...file,
+        path: `${bundle.id}/${file.path}`,
+    }))).sort((left, right) => left.path.localeCompare(right.path));
+}
+function engineCaseFiles(bundle) {
+    const buckets = bundle.files;
+    return buckets.source?.length
+        ? buckets.source
+        : [...(buckets.subjectVisible ?? []), ...(buckets.enginePrivate ?? [])];
+}
+function subjectSummary(subject) {
+    const { eval: _eval, prompt: _prompt, meta: _meta, ...summary } = subject;
+    return summary;
+}
+function resultSummary(result) {
+    const { evaluation: _evaluation, ...summary } = result;
+    return summary;
+}
+function readSubjectForApi(snapshot, subjectId) {
+    return readArchiveRecord("Subject", subjectId, () => readLocalSubject(snapshot, subjectId));
+}
+function readResultForApi(snapshot, resultId) {
+    return readArchiveRecord("Evaluation result", resultId, () => {
+        const result = snapshot.evaluations.find((entry) => entry.id === resultId);
+        if (!result) {
+            throw new Error(`Evaluation result not found: ${resultId}`);
+        }
+        return result;
+    });
+}
+function readSubjectFilesForApi(snapshot, subjectId) {
+    return readArchiveRecord("Subject", subjectId, () => readLocalSubjectFiles(snapshot, subjectId));
+}
+function readBenchmarkSourceMetadata(subject) {
+    const benchmark = asRecord(asRecord(subject.meta)?.benchmark);
+    const files = Array.isArray(benchmark?.files)
+        ? benchmark.files
+            .map(readSurfaceSnapshotFile)
+            .filter((file) => file !== null)
+        : [];
+    const sourceYaml = files.find((file) => file.path === WORKBENCH_BENCHMARK_FILE)?.content ?? null;
+    if (!sourceYaml) {
+        return null;
+    }
+    return { sourceYaml, files };
+}
+function readSurfaceSnapshotFile(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const filePath = typeof record?.path === "string" ? record.path : "";
+    const content = typeof record?.content === "string" ? record.content : null;
+    if (!filePath || content === null) {
+        return null;
+    }
+    return {
+        path: filePath,
+        kind: record.kind === "binary" ? "binary" : "text",
+        encoding: record.encoding === "base64" ? "base64" : "utf8",
+        content,
+        executable: record.executable === true,
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function normalizeOptionalFingerprint(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+}
+function readArchiveRecord(kind, id, read) {
+    try {
+        return read();
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === `${kind} not found: ${id}`) {
+            throw new LocalApiError(error.message, 404);
+        }
+        throw error;
+    }
+}
+async function localRunDetail(workspace, runId) {
+    const snapshot = await loadLocalArchive(workspace);
+    const run = snapshot.runs.find((entry) => entry.id === runId);
+    if (!run) {
+        throw new LocalApiError(`Run not found: ${runId}`, 404);
+    }
+    const allJobs = await loadLocalJobs(workspace);
+    const runJobs = allJobs.filter((job) => job.runId === runId);
+    return { run, jobs: runJobs };
+}
+async function loadExecutionFiles(workspace, runId, jobId) {
+    const files = await readExecutionFilesForRun(workspace, runId, jobId);
+    return summarizeSubjectFiles(files);
+}
+async function readExecutionFilesForRun(workspace, runId, jobId) {
+    await assertExecutionJobInRun(workspace, runId, jobId);
+    return await readLocalExecutionFiles(workspace, jobId);
+}
+async function assertExecutionJobInRun(workspace, runId, jobId) {
+    const job = (await loadLocalJobs(workspace)).find((entry) => entry.id === jobId);
+    if (!job || job.runId !== runId) {
+        throw new LocalApiError(`Execution job not found: ${jobId}`, 404);
+    }
+}
+async function loadLocalJobs(workspace) {
+    const jobsDir = path.join(localRuntimeDir(workspace), "jobs");
+    const entries = await fs.readdir(jobsDir, { withFileTypes: true }).catch(() => []);
+    const jobs = [];
+    for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".json")) {
+            const content = await fs.readFile(path.join(jobsDir, entry.name), "utf8");
+            jobs.push(JSON.parse(content));
+        }
+    }
+    return jobs;
+}
+function readLocalTrace(job) {
+    const trace = job.trace;
+    if (!trace || typeof trace !== "object" || Array.isArray(trace)) {
+        return { trace_id: job.id, spans: [], events: [], summaries: [] };
+    }
+    const record = trace;
+    return {
+        trace_id: typeof record.trace_id === "string" ? record.trace_id : job.id,
+        spans: Array.isArray(record.spans) ? record.spans : [],
+        events: Array.isArray(record.events) ? record.events : [],
+        summaries: Array.isArray(record.summaries) ? record.summaries : [],
+    };
+}
+function readSearchString(params, key) {
+    const value = params.get(key);
+    if (!value) {
+        throw new LocalApiError(`${key} is required.`);
+    }
+    return value;
+}
+function readOptionalSearchString(params, key) {
+    const value = params.get(key)?.trim();
+    return value ? value : null;
+}
+function readPreviewMode(params) {
+    const view = params.get("view") ?? "rendered";
+    if (view === "diff" || view === "raw" || view === "rendered") {
+        return view;
+    }
+    throw new LocalApiError("view must be diff, raw, or rendered.");
+}
+async function sendFile(response, filePath, contentType, method = "GET") {
+    const body = await fs.readFile(filePath);
+    response.writeHead(200, {
+        "content-type": contentType,
+        "content-length": body.byteLength,
+        "cache-control": "no-store",
+    });
+    response.end(method === "HEAD" ? undefined : body);
+}
+async function sendFontFile(response, assetsRoot, url, method = "GET") {
+    let fileName;
+    try {
+        fileName = decodeURIComponent(url.pathname.slice("/assets/fonts/".length));
+    }
+    catch {
+        throw new LocalApiError("Invalid font asset path.", 404);
+    }
+    if (!fileName || fileName.includes("/") || fileName.includes("\\")) {
+        throw new LocalApiError("Invalid font asset path.", 404);
+    }
+    await sendFile(response, path.join(assetsRoot, "fonts", fileName), "font/woff2", method);
+}
+async function sendHtml(response, method = "GET") {
+    const body = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Workbench Local</title>
+    <link rel="stylesheet" href="/assets/client.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/assets/client.js"></script>
+  </body>
+</html>`;
+    response.writeHead(200, {
+        "content-type": "text/html; charset=utf-8",
+        "content-length": Buffer.byteLength(body),
+        "cache-control": "no-store",
+    });
+    response.end(method === "HEAD" ? undefined : body);
+}
+function sendJson(response, value, status = 200, method = "GET") {
+    const body = `${JSON.stringify(value, null, 2)}\n`;
+    response.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "content-length": Buffer.byteLength(body),
+        "cache-control": "no-store",
+    });
+    response.end(method === "HEAD" ? undefined : body);
+}
+function sendError(response, error, method = "GET") {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = error instanceof LocalApiError ? error.status : 500;
+    sendJson(response, { message }, status, method);
+}
+function displayHost(host) {
+    if (host === "0.0.0.0" || host === "::") {
+        return "127.0.0.1";
+    }
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+interface CliIo {
+    stdin: NodeJS.ReadableStream;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+}
+interface CliRuntimeOptions {
+}
+export declare function runCli(argv: readonly string[], io?: CliIo, runtimeOptions?: CliRuntimeOptions): Promise<number>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA0GA,UAAU,KAAK;IACb,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AAoCD,UAAU,iBAAiB;CAAG;AA+I9B,wBAAsB,MAAM,CAC1B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,GAAE,KAIH,EACD,cAAc,GAAE,iBAAsB,GACrC,OAAO,CAAC,MAAM,CAAC,CA6GjB"}