@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/cli/ui.d.ts

@@ -1,31 +0,0 @@
-import type { Server } from "node:http";
-import { type SpawnOptions, type ChildProcess } from "node:child_process";
-import { type UiHandlerDeps } from "../ui/index.js";
-import type { EnvSource } from "../gateway/config.js";
-import type { CliIo } from "./runner.js";
-export interface UiCliArgs {
-    readonly port: number;
-    readonly evidenceDir: string | undefined;
-    readonly config: string | undefined;
-    readonly uiDbPath: string | undefined;
-}
-export interface UiCliDeps {
-    readonly createServer?: (deps: {
-        staticRoot: string;
-        csp: string;
-        port: number;
-        handlerDeps: UiHandlerDeps;
-    }) => Server | Promise<Server>;
-    readonly staticRoot?: string;
-    readonly hashesFile?: string;
-    readonly sqliteProbe?: () => boolean;
-    readonly spawnFn?: SpawnFn;
-    readonly currentExecArgv?: () => readonly string[];
-    readonly cwd?: string | undefined;
-}
-export type SpawnFn = (command: string, args: readonly string[], opts: SpawnOptions) => ChildProcess;
-export declare function parseUiArgs(args: readonly string[]): UiCliArgs | null;
-export declare function applyServerTimeouts(server: Server): void;
-export declare function waitForShutdown(server: Server): Promise<void>;
-export declare function reExecWithSqliteFlag(_env: EnvSource, spawnFn: SpawnFn): Promise<number>;
-export declare function runUiCli(args: readonly string[], io: CliIo, env: EnvSource, deps?: UiCliDeps): Promise<number>;

package/dist/cli/ui.js

@@ -1,240 +0,0 @@
-// `keiko ui` — launches the local Wave 1 UI BFF (ADR-0011). It resolves the packaged static export
-// (dist/ui/static) and the precomputed CSP hashes (dist/ui/csp-hashes.json) relative to this
-// compiled module, builds the CSP, starts createUiServer bound to 127.0.0.1 only, prints the local
-// URL, and keeps running until the process is signalled. Exit 2 on a usage error (bad --host/--port
-// or a flag missing its value), 1 when the static export is not present (the package was built with
-// `npm run build` but not `npm run build:ui`).
-//
-// ADR-0013 D2 site 1 — Detect-and-re-exec guard. Node 22.0–22.11 builds require
-// --experimental-sqlite to import node:sqlite; 22.22+ loads it without the flag. The guard tries
-// the import; on failure it re-spawns the current process with --experimental-sqlite prepended,
-// inheriting stdio and forwarding SIGINT/SIGTERM to the child, then propagates the child's exit
-// code. Injected-test invocations skip the guard entirely.
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
-import { createUiServer, loadCspHeader, buildUiHandlerDeps, DEFAULT_UI_PORT, UI_HOST, } from "../ui/index.js";
-const ALLOWED_HOSTS = new Set(["127.0.0.1", "localhost"]);
-const SQLITE_FLAG = "--experimental-sqlite";
-const KEIKO_ENV_NAME_RE = /^KEIKO_[A-Z0-9_]+$/;
-const USAGE = `Usage:
-  keiko ui [--port PORT] [--host 127.0.0.1|localhost] [--evidence-dir PATH] [--config PATH] [--ui-db PATH]
-
-Launches the local Keiko UI on the loopback interface and prints its URL. The server
-binds 127.0.0.1 only and serves the packaged UI assets (built with \`npm run build:ui\`).
-`;
-function flagValue(args, name) {
-    const i = args.indexOf(name);
-    if (i === -1) {
-        return undefined;
-    }
-    const value = args[i + 1];
-    return value === undefined || value.startsWith("--") ? null : value;
-}
-function parsePort(raw) {
-    if (!/^\d{1,5}$/.test(raw)) {
-        return null;
-    }
-    const port = Number(raw);
-    return port >= 1 && port <= 65535 ? port : null;
-}
-// Parses flags. Returns the parsed args, or null on any usage error (missing flag value, invalid
-// port, or a host other than the two loopback names).
-export function parseUiArgs(args) {
-    const portRaw = flagValue(args, "--port");
-    const hostRaw = flagValue(args, "--host");
-    const evidenceRaw = flagValue(args, "--evidence-dir");
-    const configRaw = flagValue(args, "--config");
-    const uiDbRaw = flagValue(args, "--ui-db");
-    if (portRaw === null ||
-        hostRaw === null ||
-        evidenceRaw === null ||
-        configRaw === null ||
-        uiDbRaw === null) {
-        return null;
-    }
-    if (hostRaw !== undefined && !ALLOWED_HOSTS.has(hostRaw)) {
-        return null;
-    }
-    const port = portRaw === undefined ? DEFAULT_UI_PORT : parsePort(portRaw);
-    if (port === null) {
-        return null;
-    }
-    return { port, evidenceDir: evidenceRaw, config: configRaw, uiDbPath: uiDbRaw };
-}
-function defaultStaticRoot() {
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "ui", "static");
-}
-function parseEnvValue(raw) {
-    const value = raw.trim();
-    if (value.length >= 2) {
-        const first = value[0];
-        const last = value[value.length - 1];
-        if ((first === `"` && last === `"`) || (first === "'" && last === "'")) {
-            return value.slice(1, -1);
-        }
-    }
-    return value;
-}
-function loadLocalKeikoEnv(cwd, env) {
-    const file = join(cwd, ".env");
-    if (!existsSync(file)) {
-        return env;
-    }
-    const merged = { ...env };
-    const text = readFileSync(file, "utf8");
-    for (const rawLine of text.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (line.length === 0 || line.startsWith("#"))
-            continue;
-        const equals = line.indexOf("=");
-        if (equals <= 0)
-            continue;
-        const key = line.slice(0, equals).trim();
-        if (!KEIKO_ENV_NAME_RE.test(key))
-            continue;
-        if (merged[key] !== undefined)
-            continue;
-        merged[key] = parseEnvValue(line.slice(equals + 1));
-    }
-    return merged;
-}
-function resolveUiConfigPath(parsed, env) {
-    return parsed.config ?? env.KEIKO_CONFIG_FILE;
-}
-// Conservative request/header timeouts on the loopback BFF (defense in depth, L2/L3): even on
-// 127.0.0.1 a slow or stuck client must not hold a connection indefinitely. headersTimeout must be
-// at or below requestTimeout so an incomplete request line/header set is cut first.
-const REQUEST_TIMEOUT_MS = 30_000;
-const HEADERS_TIMEOUT_MS = 10_000;
-export function applyServerTimeouts(server) {
-    server.requestTimeout = REQUEST_TIMEOUT_MS;
-    server.headersTimeout = HEADERS_TIMEOUT_MS;
-}
-async function listen(server, port) {
-    await new Promise((res, rej) => {
-        server.once("error", rej);
-        server.listen(port, UI_HOST, res);
-    });
-}
-// Keeps the real-CLI process alive until a shutdown signal or server close. Resolves cleanly so
-// the caller can return 0. Registered listeners are removed on resolve to prevent leaks.
-export function waitForShutdown(server) {
-    return new Promise((resolve) => {
-        const onClose = () => {
-            process.removeListener("SIGINT", onSignal);
-            process.removeListener("SIGTERM", onSignal);
-            resolve();
-        };
-        const onSignal = () => {
-            server.removeListener("close", onClose);
-            server.close(() => {
-                resolve();
-            });
-        };
-        server.once("close", onClose);
-        process.once("SIGINT", onSignal);
-        process.once("SIGTERM", onSignal);
-    });
-}
-// Default probe: try to require node:sqlite. Any failure (ERR_UNKNOWN_BUILTIN_MODULE on early
-// 22.x, or a thrown ExperimentalWarning that escaped) means we need the flag. The require is
-// guarded inside a try; we never throw past here.
-function defaultSqliteProbe() {
-    try {
-        const req = createRequire(import.meta.url);
-        req("node:sqlite");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Returns true if `--experimental-sqlite` is already on execArgv, meaning we are inside the child
-// already and must not loop. Inspects both the supplied execArgv source (Node-level flags the
-// parent inherited) AND NODE_OPTIONS (where the flag may live in env).
-function alreadyFlagged(env, execArgv) {
-    if (execArgv.includes(SQLITE_FLAG))
-        return true;
-    const nodeOptions = env.NODE_OPTIONS;
-    return typeof nodeOptions === "string" && nodeOptions.includes(SQLITE_FLAG);
-}
-// Re-spawns the current process with --experimental-sqlite prepended, inheriting stdio. Returns
-// the exit code the child terminated with so the parent can propagate it.
-export async function reExecWithSqliteFlag(_env, spawnFn) {
-    const entry = process.argv[1];
-    if (entry === undefined)
-        return 1;
-    const childArgs = [SQLITE_FLAG, ...process.execArgv, entry, ...process.argv.slice(2)];
-    const child = spawnFn(process.execPath, childArgs, { stdio: "inherit" });
-    const forwardSigint = () => {
-        child.kill("SIGINT");
-    };
-    const forwardSigterm = () => {
-        child.kill("SIGTERM");
-    };
-    process.on("SIGINT", forwardSigint);
-    process.on("SIGTERM", forwardSigterm);
-    return new Promise((res) => {
-        child.on("exit", (code, signal) => {
-            process.removeListener("SIGINT", forwardSigint);
-            process.removeListener("SIGTERM", forwardSigterm);
-            if (typeof code === "number") {
-                res(code);
-                return;
-            }
-            res(signal === null ? 1 : 128);
-        });
-    });
-}
-// Returns undefined when no re-exec is needed; returns the child's exit code when a re-exec
-// happened. The guard never runs when an injected test factory bypasses the production loop, and
-// it never re-loops once --experimental-sqlite is already in execArgv.
-async function maybeReExecForSqlite(env, deps) {
-    if (deps.createServer !== undefined)
-        return undefined;
-    const execArgv = (deps.currentExecArgv ?? (() => process.execArgv))();
-    if (alreadyFlagged(env, execArgv))
-        return undefined;
-    const probe = deps.sqliteProbe ?? defaultSqliteProbe;
-    if (probe())
-        return undefined;
-    const spawnFn = deps.spawnFn ?? spawn;
-    return reExecWithSqliteFlag(env, spawnFn);
-}
-export async function runUiCli(args, io, env, deps = {}) {
-    const effectiveEnv = loadLocalKeikoEnv(deps.cwd ?? process.cwd(), env);
-    const reExec = await maybeReExecForSqlite(effectiveEnv, deps);
-    if (reExec !== undefined)
-        return reExec;
-    const parsed = parseUiArgs(args);
-    if (parsed === null) {
-        io.err(USAGE);
-        return 2;
-    }
-    const staticRoot = deps.staticRoot ?? defaultStaticRoot();
-    if (!existsSync(staticRoot)) {
-        io.err(`keiko ui: UI assets not found at ${staticRoot}. Run \`npm run build:ui\` first.\n`);
-        return 1;
-    }
-    const csp = await loadCspHeader(deps.hashesFile ?? join(staticRoot, "..", "csp-hashes.json"));
-    const handlerDeps = buildUiHandlerDeps({
-        configPath: resolveUiConfigPath(parsed, effectiveEnv),
-        evidenceDir: parsed.evidenceDir,
-        uiDbPath: parsed.uiDbPath,
-        env: effectiveEnv,
-    });
-    const factory = deps.createServer ?? createUiServer;
-    const server = await factory({ staticRoot, csp, port: parsed.port, handlerDeps });
-    applyServerTimeouts(server);
-    await listen(server, parsed.port);
-    io.out(`Keiko UI listening on http://${UI_HOST}:${String(parsed.port)}\n`);
-    // Block only in the real CLI path (no injected factory). Injected-server tests skip blocking so
-    // they don't hang; the real process must stay alive until signalled.
-    if (deps.createServer === undefined) {
-        await waitForShutdown(server);
-    }
-    return 0;
-}

package/dist/cli/verify.d.ts

@@ -1,2 +0,0 @@
-import type { CliIo } from "./runner.js";
-export declare function runVerifyCli(args: readonly string[], io: CliIo): Promise<number>;

package/dist/cli/verify.js

@@ -1,103 +0,0 @@
-// `keiko verify` — the real verification gate (NOT a dry-run). It detects the workspace, builds a
-// plan from the detected npm scripts, runs the allowlisted commands through the #6 safe tool layer
-// under per-command resource limits, and prints a redacted human table (or --json of the report).
-// Exit 0 when overall status is `passed`; 1 when any step did not pass or a workspace/runtime error
-// occurred; 2 on a usage error. Mirrors runContextCli's structure (flag parsing, --json, typed
-// error catch at the boundary).
-import { detectWorkspace } from "../workspace/index.js";
-import { WorkspaceError } from "../workspace/index.js";
-import { buildVerificationPlan, buildVerificationSummary, detectScripts, EmptyPlanError, runVerification, VerificationError, } from "../verification/index.js";
-const VALID_KINDS = new Set([
-    "test",
-    "targeted-test",
-    "typecheck",
-    "lint",
-    "build",
-]);
-const USAGE = `Usage:
-  keiko verify [--dir PATH] [--only KIND[,KIND]] [--changed FILE[,FILE]] [--json]
-
-Runs the project's own gates (typecheck, lint, test, build) through the safe tool
-layer under per-command resource limits and prints a redacted evidence summary.
-KIND is one of: test, targeted-test, typecheck, lint, build.
-`;
-// Returns the value of a `--flag value` pair, undefined if absent, or null if present without a
-// value (a usage error) — identical contract to runContextCli's flagValue.
-function flagValue(args, name) {
-    const i = args.indexOf(name);
-    if (i === -1) {
-        return undefined;
-    }
-    const value = args[i + 1];
-    return value === undefined || value.startsWith("--") ? null : value;
-}
-function parseKinds(raw) {
-    const parts = raw.split(",").map((p) => p.trim());
-    if (parts.some((p) => !VALID_KINDS.has(p))) {
-        return null;
-    }
-    return parts;
-}
-function parseArgs(args) {
-    const dirRaw = flagValue(args, "--dir");
-    const onlyRaw = flagValue(args, "--only");
-    const changedRaw = flagValue(args, "--changed");
-    if (dirRaw === null || onlyRaw === null || changedRaw === null) {
-        return null;
-    }
-    const only = onlyRaw === undefined ? undefined : parseKinds(onlyRaw);
-    if (only === null) {
-        return null;
-    }
-    const changed = changedRaw === undefined ? undefined : changedRaw.split(",").map((p) => p.trim());
-    return { dir: dirRaw ?? ".", only, changed, json: args.includes("--json") };
-}
-async function runPlan(parsed) {
-    const workspace = detectWorkspace(parsed.dir);
-    const catalog = detectScripts(workspace);
-    const plan = buildVerificationPlan(workspace, catalog, {
-        only: parsed.only,
-        changedFiles: parsed.changed,
-    });
-    if (plan.steps.length === 0) {
-        throw new EmptyPlanError("verification plan contains no runnable or skipped steps");
-    }
-    return runVerification(plan, { workspace });
-}
-function renderText(report, io) {
-    const summary = buildVerificationSummary(report);
-    io.out(`Verification: ${summary.overallStatus} (${String(summary.durationMs)}ms)\n`);
-    io.out("KIND\tSTATUS\tEXIT\tMS\tCOMMAND\tDETAIL\n");
-    for (const r of summary.results) {
-        const exit = r.exitCode === null ? "-" : String(r.exitCode);
-        io.out(`${r.kind}\t${r.status}\t${exit}\t${String(r.durationMs)}\t${r.command}\t${r.detail ?? ""}\n`);
-    }
-}
-export async function runVerifyCli(args, io) {
-    const parsed = parseArgs(args);
-    if (parsed === null) {
-        io.err(USAGE);
-        return 2;
-    }
-    try {
-        const report = await runPlan(parsed);
-        if (parsed.json) {
-            io.out(`${JSON.stringify(buildVerificationSummary(report), null, 2)}\n`);
-        }
-        else {
-            renderText(report, io);
-        }
-        return report.overallStatus === "passed" ? 0 : 1;
-    }
-    catch (error) {
-        if (error instanceof WorkspaceError) {
-            io.err(`Error [${error.code}]: ${error.message}\n`);
-            return 1;
-        }
-        if (error instanceof VerificationError) {
-            io.err(`Error [${error.code}]: ${error.message}\n`);
-            return 1;
-        }
-        throw error;
-    }
-}

package/dist/ui/browser.d.ts

@@ -1,10 +0,0 @@
-import type { UiHandlerDeps } from "./deps.js";
-import { type HandlerOutcome, type RouteContext, type RouteResult } from "./routes.js";
-export declare function handleBrowserStatus(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleCreateBrowserSession(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleDeleteBrowserSession(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleBrowserNavigate(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleBrowserScreenshot(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleBrowserApplyScreenshot(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleBrowserContent(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleBrowserEvents(ctx: RouteContext, deps: UiHandlerDeps): HandlerOutcome;

package/dist/ui/browser.js

@@ -1,231 +0,0 @@
-// ADR-0017 D8 — eight /api/browser/* BFF route handlers. CSRF guarding is enforced by the
-// server.ts state-changing-request gate (POST/DELETE all flow through it). GET status + GET
-// events are exempt by the same gate. SSE framing reuses the existing sse.ts helpers.
-import { BrowserToolError, } from "../tools/browser/index.js";
-import { SSE_HEADERS, readyMessage } from "./sse.js";
-import { errorBody, STREAMING, } from "./routes.js";
-const MAX_BROWSER_BODY_BYTES = 64_000;
-class BodyTooLargeError extends Error {
-    constructor() {
-        super("browser request body too large");
-        this.name = "BodyTooLargeError";
-    }
-}
-function noBrowserDeps() {
-    return {
-        status: 503,
-        body: errorBody("BROWSER_UNAVAILABLE", "Browser tool is not configured for this BFF."),
-    };
-}
-function requireBrowser(deps) {
-    return deps.browser ?? noBrowserDeps();
-}
-function isRouteResult(value) {
-    return typeof value.status === "number";
-}
-function toRouteResult(error) {
-    return { status: error.status, body: errorBody(error.code, error.message) };
-}
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let total = 0;
-        let capped = false;
-        req.on("data", (chunk) => {
-            total += chunk.length;
-            if (total > MAX_BROWSER_BODY_BYTES) {
-                if (!capped) {
-                    capped = true;
-                    chunks.length = 0;
-                    reject(new BodyTooLargeError());
-                    req.resume();
-                }
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on("end", () => {
-            if (!capped)
-                resolve(Buffer.concat(chunks).toString("utf8"));
-        });
-        req.on("error", reject);
-    });
-}
-async function readJsonObject(req) {
-    const raw = await readBody(req);
-    if (raw.length === 0)
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new BrowserToolError("BAD_REQUEST", "Request body is not valid JSON.");
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new BrowserToolError("BAD_REQUEST", "Request body must be a JSON object.");
-    }
-    return parsed;
-}
-function requireString(body, key) {
-    const value = body[key];
-    if (typeof value !== "string" || value.length === 0) {
-        throw new BrowserToolError("BAD_REQUEST", `Field "${key}" must be a non-empty string.`);
-    }
-    return value;
-}
-function requireNumber(body, key) {
-    const value = body[key];
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw new BrowserToolError("BAD_REQUEST", `Field "${key}" must be a finite number.`);
-    }
-    return value;
-}
-async function runHandler(work) {
-    try {
-        return await work();
-    }
-    catch (error) {
-        if (error instanceof BodyTooLargeError) {
-            return {
-                status: 413,
-                body: errorBody("PAYLOAD_TOO_LARGE", "Request body exceeds the size limit."),
-            };
-        }
-        if (error instanceof BrowserToolError)
-            return toRouteResult(error);
-        throw error;
-    }
-}
-export async function handleBrowserStatus(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        const portParam = ctx.url.searchParams.get("port");
-        if (portParam === null) {
-            throw new BrowserToolError("BAD_REQUEST", "Query parameter 'port' is required.");
-        }
-        const port = Number.parseInt(portParam, 10);
-        if (!Number.isFinite(port)) {
-            throw new BrowserToolError("BAD_REQUEST", "Query parameter 'port' must be an integer.");
-        }
-        const status = await guard.checkStatus(port);
-        return { status: 200, body: status };
-    });
-}
-export async function handleCreateBrowserSession(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        const body = await readJsonObject(ctx.req);
-        const port = requireNumber(body, "port");
-        const meta = await guard.openSession(port);
-        return { status: 201, body: meta };
-    });
-}
-export async function handleDeleteBrowserSession(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        const sessionId = ctx.params.sessionId ?? "";
-        await guard.closeSession(sessionId);
-        return { status: 200, body: { ok: true } };
-    });
-}
-export async function handleBrowserNavigate(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        const body = await readJsonObject(ctx.req);
-        const url = requireString(body, "url");
-        const sessionId = ctx.params.sessionId ?? "";
-        const result = await guard.navigate(sessionId, url);
-        return { status: 200, body: result };
-    });
-}
-export async function handleBrowserScreenshot(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        // Drain the body through readJsonObject so the 64 KB cap (MAX_BROWSER_BODY_BYTES) is
-        // enforced even though this handler expects no fields. Raw node:http has no global cap.
-        await readJsonObject(ctx.req);
-        const sessionId = ctx.params.sessionId ?? "";
-        const result = await guard.screenshot(sessionId);
-        return { status: 200, body: result };
-    });
-}
-export async function handleBrowserApplyScreenshot(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        const body = await readJsonObject(ctx.req);
-        const captureSeq = requireNumber(body, "captureSeq");
-        const sessionId = ctx.params.sessionId ?? "";
-        const result = await guard.applyScreenshot(sessionId, captureSeq);
-        return { status: 200, body: result };
-    });
-}
-export async function handleBrowserContent(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    return runHandler(async () => {
-        // Drain the body through readJsonObject so the 64 KB cap (MAX_BROWSER_BODY_BYTES) is
-        // enforced even though this handler expects no fields. Raw node:http has no global cap.
-        await readJsonObject(ctx.req);
-        const sessionId = ctx.params.sessionId ?? "";
-        const result = await guard.content(sessionId);
-        return { status: 200, body: result };
-    });
-}
-// SSE — re-uses the existing framer shape. Each browser event becomes one SSE message with
-// event: <kind> and data: <JSON>. A 'ready' synthetic is sent first so clients can transition
-// from connecting to live.
-export function handleBrowserEvents(ctx, deps) {
-    const guard = requireBrowser(deps);
-    if (isRouteResult(guard))
-        return guard;
-    const sessionId = ctx.params.sessionId ?? "";
-    if (sessionId.length === 0) {
-        return { status: 400, body: errorBody("BAD_REQUEST", "sessionId is required.") };
-    }
-    if (!guard.hasSession(sessionId)) {
-        return { status: 404, body: errorBody("SESSION_NOT_FOUND", "Browser session not found.") };
-    }
-    openBrowserSseStream(ctx.res, guard, sessionId, deps.redactor);
-    ctx.req.on("close", () => {
-        ctx.res.end();
-    });
-    return STREAMING;
-}
-function openBrowserSseStream(res, manager, sessionId, redactor) {
-    res.writeHead(200, SSE_HEADERS);
-    let seq = 0;
-    const unsubscribe = manager.subscribe(sessionId, (event) => {
-        seq += 1;
-        writeBrowserEvent(res, event, seq, redactor);
-        if (event.kind === "session-closed") {
-            unsubscribe();
-            res.end();
-        }
-    });
-    res.write(readyMessage());
-    res.on("close", () => {
-        unsubscribe();
-    });
-}
-function writeBrowserEvent(res, event, seq, redactor) {
-    const redacted = redactor(event);
-    const data = JSON.stringify(redacted);
-    const frame = `id: ${String(seq)}\nevent: browser:${event.kind}\ndata: ${data}\n\n`;
-    if (!res.write(frame)) {
-        res.destroy();
-    }
-}

package/dist/ui/chat-handlers.d.ts

@@ -1,4 +0,0 @@
-import type { UiHandlerDeps } from "./deps.js";
-import type { RouteContext, RouteResult } from "./routes.js";
-export declare function handleCreateDesktopChat(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
-export declare function handleSendDesktopChat(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;