@alisio/server 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import { type ServerResponse } from "node:http";
+import { type ServerAppOptions } from "./host/workspace-host.ts";
+import { type Logger } from "./log.ts";
+export { isLoopbackHost } from "./auth/guard.ts";
+export { ApprovalBridge } from "./bridges/approval-bridge.ts";
+export { InteractionBridge } from "./bridges/interaction-bridge.ts";
+export { type Application, type OpenWorkspace, type ServerAppOptions, WorkspaceHost, workspaceId, } from "./host/workspace-host.ts";
+export { HttpError } from "./http/errors.ts";
+export { contentSecurityPolicy, PLACEHOLDER_HTML } from "./http/static.ts";
+export { createLogger, type Logger, type LogLevel, logLevel } from "./log.ts";
+export { PROTOCOL_VERSION } from "./routes/health.ts";
+export interface ServerOptions {
+    /** Bind address (default `127.0.0.1`). Anything but loopback requires `allowRemote`. */
+    host?: string;
+    /** Port; `0` picks a free one (default 4317). */
+    port?: number;
+    /** Required to bind a non-loopback address (no TLS; prefer an SSH tunnel). */
+    allowRemote?: boolean;
+    /** Launch token (a fresh 256-bit secret by default). */
+    token?: string;
+    /** Version reported by `/api/health` (the CLI passes its own). */
+    version?: string;
+    /** Directory with the web UI build (default: `dist/web` next to the server). */
+    webRoot?: string;
+    logger?: Logger;
+    /**
+     * Base options for every workspace `Application` (launch flags, builtins, prompts, db). The
+     * policy flags are the capability ceiling of every web session.
+     */
+    app?: ServerAppOptions;
+    /** Listed as a workspace even before it has sessions (the CLI passes its cwd). */
+    defaultWorkspace?: string;
+    /** Maximum workspace applications open at once (default 4). */
+    maxOpenWorkspaces?: number;
+    /** Maximum runs executing at once across all sessions (default 4). */
+    maxConcurrentRuns?: number;
+    /** Close a workspace app after this long without activity (default 10 min). */
+    idleEvictMs?: number;
+    /** SSE heartbeat interval (default 15 s). */
+    heartbeatMs?: number;
+    /** Delta coalescing window, clamped to 16–50 ms (default 33 ms). */
+    coalesceMs?: number;
+    /** Maximum concurrent event streams (default 16). */
+    maxStreams?: number;
+    /** Deny an approval when nobody watches its session for this long (default 30 s). */
+    approvalGraceMs?: number;
+    /** Deny an approval after this long even when watched (default 10 min; 0 = no limit). */
+    approvalTimeoutMs?: number;
+}
+export interface RunningServer {
+    host: string;
+    port: number;
+    /** Base URL of the server, e.g. `http://127.0.0.1:4317`. */
+    url: string;
+    /** The launch token (exchanged once for the session cookie). */
+    token: string;
+    /** `url` plus `/?token=…`: what the CLI prints and opens. */
+    launchUrl: string;
+    /** Whether the web UI build is installed (otherwise a placeholder page is served). */
+    webInstalled: boolean;
+    close(): Promise<void>;
+}
+/** Starts the server and resolves once it listens. */
+export declare function startServer(options?: ServerOptions): Promise<RunningServer>;
+/** Writes a JSON response. */
+export declare function sendJson(res: ServerResponse, status: number, body: unknown): void;

package/dist/index.js

@@ -0,0 +1,350 @@
+/**
+ * @alisio/server: the local HTTP + SSE server behind `alisio serve`. Loaded only through a
+ * dynamic `import("@alisio/server")`, so `alisio`, `alisio run` and the TUI never pay for it.
+ */
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { dirname, join } from "node:path";
+import { BlobStore, SQLiteStore, stateHome } from "@alisio/core";
+import { AuthGuard, isLoopbackHost } from "./auth/guard.js";
+import { ApprovalBridge } from "./bridges/approval-bridge.js";
+import { InteractionBridge } from "./bridges/interaction-bridge.js";
+import { RunScheduler } from "./host/run-scheduler.js";
+import { SessionService } from "./host/sessions.js";
+import { WorkspaceHost, workspaceId } from "./host/workspace-host.js";
+import { HttpError, toApiError } from "./http/errors.js";
+import { Router } from "./http/router.js";
+import { StaticAssets } from "./http/static.js";
+import { createLogger } from "./log.js";
+import { registerApprovalRoutes } from "./routes/approvals.js";
+import { registerBlobRoutes } from "./routes/blobs.js";
+import { registerCommandRoutes } from "./routes/commands.js";
+import { registerEventRoutes } from "./routes/events.js";
+import { registerFileRoutes } from "./routes/files.js";
+import { registerHealthRoutes } from "./routes/health.js";
+import { registerManagementRoutes, WorkspaceRecycler } from "./routes/management.js";
+import { registerPromptRoutes } from "./routes/prompts.js";
+import { registerProviderRoutes } from "./routes/providers.js";
+import { registerSessionViewRoutes } from "./routes/session-views.js";
+import { registerSessionRoutes } from "./routes/sessions.js";
+import { registerWorkspaceRoutes } from "./routes/workspaces.js";
+import { SseHub } from "./sse/hub.js";
+import { InflightTracker } from "./sse/inflight.js";
+export { isLoopbackHost } from "./auth/guard.js";
+export { ApprovalBridge } from "./bridges/approval-bridge.js";
+export { InteractionBridge } from "./bridges/interaction-bridge.js";
+export { WorkspaceHost, workspaceId, } from "./host/workspace-host.js";
+export { HttpError } from "./http/errors.js";
+export { contentSecurityPolicy, PLACEHOLDER_HTML } from "./http/static.js";
+export { createLogger, logLevel } from "./log.js";
+export { PROTOCOL_VERSION } from "./routes/health.js";
+const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** Security headers of §11.2 (the CSP comes from the served web build). */
+function securityHeaders(res, csp, api) {
+    res.setHeader("Content-Security-Policy", csp);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+    res.setHeader("Cross-Origin-Resource-Policy", "same-origin");
+    if (api)
+        res.setHeader("Cache-Control", "no-store");
+}
+/** Starts the server and resolves once it listens. */
+export async function startServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    if (!isLoopbackHost(host) && !options.allowRemote)
+        throw new Error(`Refusing to listen on ${host}: it is not a loopback address. Pass --allow-remote to expose the server on the network (no TLS; prefer an SSH tunnel).`);
+    const logger = options.logger ?? createLogger();
+    const assets = new StaticAssets(options.webRoot);
+    const router = new Router();
+    let guard;
+    let closing = false;
+    const base = options.app ?? {};
+    // Server-level connection to the shared session database (lists, metadata, snapshots).
+    const dbPath = base.db ?? join(stateHome(), "sessions.sqlite");
+    const catalog = new SQLiteStore(dbPath);
+    // The same content-addressed store every workspace app resolves attachments from.
+    const blobs = new BlobStore({
+        root: dbPath !== ":memory:" ? join(dirname(dbPath), "blobs") : join(stateHome(), "blobs"),
+        db: catalog.db,
+    });
+    // Startup reconciliation (RNF-09): runs and child sessions left queued/running by a dead
+    // process become interrupted before any client lists them.
+    catalog.interruptRuns();
+    catalog.interruptStale();
+    let shutdown;
+    let sessions;
+    const inflight = new InflightTracker();
+    let recycler;
+    const scheduler = new RunScheduler({
+        ...(options.maxConcurrentRuns ? { maxConcurrent: options.maxConcurrentRuns } : {}),
+        onChange: (job, status) => {
+            if (status === "finished") {
+                inflight.clear(job.sessionId, job.runId);
+                // A deferred plugin change applies once the workspace has no runs left.
+                setImmediate(() => recycler?.idle(job.workspaceId));
+            }
+            else
+                inflight.mark(job.sessionId, job.runId, status);
+            sessions?.notify(job.sessionId);
+        },
+    });
+    const workspaceOf = (sessionId) => {
+        try {
+            return workspaceId(catalog.get(sessionId).workspace);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    let approvals;
+    let interactions;
+    const hub = new SseHub({
+        onSubscribersChanged: () => {
+            approvals?.subscribersChanged();
+            interactions?.subscribersChanged();
+        },
+        snapshot: (sessionId) => {
+            const service = sessions;
+            const session = service.get(sessionId);
+            const current = inflight.get(sessionId);
+            return {
+                t: "snapshot",
+                sessionId,
+                cursor: catalog.lastEventId(sessionId),
+                session: service.wire(session),
+                messages: catalog.messagesPage(sessionId, { limit: 50 }),
+                ...(current ? { inflight: current } : {}),
+                pending: {
+                    approvals: approvals?.pending(sessionId) ?? [],
+                    interactions: interactions?.pending(sessionId) ?? [],
+                },
+            };
+        },
+        messagesAfter: (sessionId, after) => catalog.messagesPage(sessionId, { after, limit: 200 }),
+        toolResult: (sessionId, callId) => catalog.callResult(sessionId, callId),
+        workspaceOf,
+        ...(options.heartbeatMs ? { heartbeatMs: options.heartbeatMs } : {}),
+        ...(options.coalesceMs ? { coalesceMs: options.coalesceMs } : {}),
+    });
+    const workspaces = new WorkspaceHost({
+        base,
+        catalog,
+        wire: () => ({
+            onEvent: (event) => {
+                inflight.apply(event);
+                hub.publish(event);
+            },
+            ...(approvals
+                ? { approve: approvals.handler, approveExternalDirectory: approvals.directoryHandler }
+                : {}),
+        }),
+        onOpen: (entry) => {
+            if (interactions)
+                entry.app.plugins.setInteractiveUI(interactions.uiFor(entry.id));
+        },
+        busy: (id) => scheduler.busyWorkspace(id) || hub.watchesWorkspace(id),
+        ...(options.maxOpenWorkspaces ? { maxOpen: options.maxOpenWorkspaces } : {}),
+        ...(options.idleEvictMs ? { idleEvictMs: options.idleEvictMs } : {}),
+        ...(options.defaultWorkspace ? { defaultWorkspace: options.defaultWorkspace } : {}),
+    });
+    const sweeper = setInterval(() => void workspaces.sweep().catch(() => { }), Math.min(60_000, options.idleEvictMs ?? 60_000));
+    sweeper.unref();
+    sessions = new SessionService({
+        catalog,
+        workspaces,
+        scheduler,
+        base,
+        broadcast: (frame) => hub.broadcast(frame),
+        awaitingInput: (root) => !!approvals?.awaiting(root) || !!interactions?.awaiting(root),
+    });
+    const service = sessions;
+    approvals = new ApprovalBridge({
+        hub,
+        rootOf: (id) => service.rootOf(id),
+        runOf: (id) => scheduler.job(id)?.runId,
+        ...(options.approvalGraceMs !== undefined ? { graceMs: options.approvalGraceMs } : {}),
+        ...(options.approvalTimeoutMs !== undefined ? { timeoutMs: options.approvalTimeoutMs } : {}),
+        onChange: (root) => service.notify(root),
+    });
+    interactions = new InteractionBridge({
+        hub,
+        rootOf: (id) => service.rootOf(id),
+        workspaceOf,
+        ...(options.approvalGraceMs !== undefined ? { graceMs: options.approvalGraceMs } : {}),
+        ...(options.approvalTimeoutMs !== undefined ? { timeoutMs: options.approvalTimeoutMs } : {}),
+        onOpen: (id) => service.notify(id),
+        onChange: (root) => root && service.notify(root),
+    });
+    const stats = () => ({
+        shuttingDown: closing,
+        activeRuns: scheduler.counts().active,
+        queuedRuns: scheduler.counts().queued,
+        openWorkspaces: workspaces.openCount,
+        subscribers: hub.size,
+        pendingApprovals: approvals?.size ?? 0,
+        sseDropped: hub.dropped,
+    });
+    registerHealthRoutes(router, {
+        version: options.version ?? "dev",
+        remote: !isLoopbackHost(host),
+        stats,
+    });
+    registerWorkspaceRoutes(router, { workspaces, catalog });
+    registerSessionRoutes(router, { catalog, workspaces, sessions, scheduler });
+    registerSessionViewRoutes(router, { catalog, sessions });
+    registerFileRoutes(router, { workspaces, catalog, sessions });
+    registerBlobRoutes(router, { blobs });
+    registerPromptRoutes(router, { sessions, scheduler });
+    registerCommandRoutes(router, { sessions, scheduler, workspaces });
+    registerApprovalRoutes(router, { approvals, interactions });
+    const management = {
+        workspaces,
+        scheduler,
+        base,
+        broadcast: (frame) => hub.broadcast(frame),
+    };
+    recycler = new WorkspaceRecycler(management);
+    registerManagementRoutes(router, management, recycler);
+    registerProviderRoutes(router, management, recycler);
+    registerEventRoutes(router, {
+        hub,
+        sessions,
+        ...(options.maxStreams ? { maxStreams: options.maxStreams } : {}),
+    });
+    const server = createServer((req, res) => void handle(req, res));
+    async function handle(req, res) {
+        const started = Date.now();
+        const header = req.headers["x-request-id"];
+        const correlationId = typeof header === "string" && REQUEST_ID.test(header) ? header : randomUUID();
+        res.setHeader("X-Request-Id", correlationId);
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const api = url.pathname === "/api" || url.pathname.startsWith("/api/");
+        securityHeaders(res, assets.csp, api);
+        const method = req.method ?? "GET";
+        try {
+            if (!guard)
+                throw new HttpError("shutting_down", "Server is not ready");
+            guard.checkHost(req);
+            guard.checkOrigin(req);
+            if (!api) {
+                if (method !== "GET" && method !== "HEAD")
+                    throw new HttpError("not_found", "Not found");
+                const token = url.searchParams.get("token");
+                if (url.pathname === "/" && token !== null) {
+                    if (!guard.validToken(token))
+                        throw new HttpError("unauthorized", "Invalid token");
+                    res.writeHead(303, { Location: "/", "Set-Cookie": guard.sessionCookie() });
+                    res.end();
+                    return;
+                }
+                await assets.serve(res, url.pathname, method === "HEAD");
+                return;
+            }
+            const matched = router.match(method, url.pathname);
+            if (!matched)
+                throw new HttpError("not_found", "Not found");
+            const isHealth = url.pathname === "/api/health" && method === "GET";
+            if (!isHealth && !guard.authenticated(req))
+                throw new HttpError("unauthorized", "Open the launch URL printed by `alisio serve`");
+            if (matched === "method")
+                throw new HttpError("not_found", "Method not supported");
+            // Every write is JSON (it forces a CORS preflight) except the raw image upload, which
+            // checks its own image content types (also non-safelisted, so also preflighted).
+            const upload = method === "POST" && url.pathname === "/api/blobs";
+            if (!["GET", "HEAD", "OPTIONS"].includes(method) && !upload) {
+                const type = String(req.headers["content-type"] ?? "")
+                    .split(";")[0]
+                    ?.trim();
+                if (type !== "application/json")
+                    throw new HttpError("unsupported_media_type", "Content-Type must be application/json");
+            }
+            if (closing && !isHealth && url.pathname !== "/api/ready")
+                throw new HttpError("shutting_down", "Server is shutting down");
+            const ctx = { req, res, url, params: matched.params, correlationId };
+            const result = await matched.handler(ctx);
+            if (result)
+                sendJson(res, result.status ?? 200, result.body);
+        }
+        catch (error) {
+            const { status, body } = toApiError(error, correlationId);
+            if (status === 500)
+                logger.error("request failed", {
+                    correlationId,
+                    route: url.pathname,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            if (!res.headersSent)
+                sendJson(res, status, body);
+            else
+                res.end();
+        }
+        finally {
+            logger.debug("request", {
+                correlationId,
+                route: `${method} ${url.pathname}`,
+                status: res.statusCode,
+                ms: Date.now() - started,
+            });
+        }
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(options.port ?? 4317, host, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+    }
+    catch (error) {
+        clearInterval(sweeper);
+        catalog.close();
+        throw error;
+    }
+    const port = server.address().port;
+    guard = new AuthGuard({ host, port, ...(options.token ? { token: options.token } : {}) });
+    const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    const url = `http://${displayHost.includes(":") ? `[${displayHost}]` : displayHost}:${port}`;
+    return {
+        host,
+        port,
+        url,
+        token: guard.token,
+        launchUrl: `${url}/?token=${guard.token}`,
+        webInstalled: assets.installed,
+        close() {
+            shutdown ??= (async () => {
+                // RNF-08: refuse new work (503), abort runs (queued ones are journaled cancelled),
+                // withdraw approvals (deny), end the streams, close every app within the core's
+                // per-stage teardown caps, then stop listening. Locks are released by the runner.
+                const began = Date.now();
+                closing = true;
+                clearInterval(sweeper);
+                const settling = scheduler.shutdown(2_000);
+                approvals?.denyAll();
+                interactions?.cancelAll();
+                await settling;
+                hub.closeAll();
+                await workspaces.closeAll();
+                await new Promise((resolve) => {
+                    server.closeAllConnections();
+                    server.close(() => resolve());
+                });
+                catalog.close();
+                logger.info("server stopped", { ms: Date.now() - began });
+            })();
+            return shutdown;
+        },
+    };
+}
+/** Writes a JSON response. */
+export function sendJson(res, status, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(text),
+    });
+    res.end(text);
+}

package/dist/log.d.ts

@@ -0,0 +1,21 @@
+/** Structured JSON-per-line logs to stderr (RNF-13). No OpenTelemetry. */
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+export interface LogFields {
+    correlationId?: string;
+    sessionId?: string;
+    runId?: string;
+    route?: string;
+    status?: number;
+    ms?: number;
+    [key: string]: unknown;
+}
+export interface Logger {
+    debug(msg: string, fields?: LogFields): void;
+    info(msg: string, fields?: LogFields): void;
+    warn(msg: string, fields?: LogFields): void;
+    error(msg: string, fields?: LogFields): void;
+}
+/** Parses `ALISIO_LOG_LEVEL`; anything unknown falls back to `info`. */
+export declare function logLevel(value?: string | undefined): LogLevel;
+/** A logger that writes one JSON object per line through `write` (stderr by default). */
+export declare function createLogger(level?: LogLevel, write?: (line: string) => void): Logger;

package/dist/log.js

@@ -0,0 +1,19 @@
+const ORDER = { debug: 10, info: 20, warn: 30, error: 40, silent: 99 };
+/** Parses `ALISIO_LOG_LEVEL`; anything unknown falls back to `info`. */
+export function logLevel(value = process.env.ALISIO_LOG_LEVEL) {
+    return value && value in ORDER ? value : "info";
+}
+/** A logger that writes one JSON object per line through `write` (stderr by default). */
+export function createLogger(level = logLevel(), write = (line) => process.stderr.write(line)) {
+    const emit = (at) => (msg, fields = {}) => {
+        if (ORDER[at] < ORDER[level])
+            return;
+        try {
+            write(`${JSON.stringify({ ts: new Date().toISOString(), level: at, msg, ...fields })}\n`);
+        }
+        catch {
+            /* Logging never breaks a request. */
+        }
+    };
+    return { debug: emit("debug"), info: emit("info"), warn: emit("warn"), error: emit("error") };
+}

package/dist/routes/approvals.d.ts

@@ -0,0 +1,8 @@
+import type { ApprovalBridge } from "../bridges/approval-bridge.ts";
+import type { InteractionBridge } from "../bridges/interaction-bridge.ts";
+import type { Router } from "../http/router.ts";
+/** Approvals and plugin interactions answered from the web (first answer wins). */
+export declare function registerApprovalRoutes(router: Router, ctx: {
+    approvals: ApprovalBridge;
+    interactions: InteractionBridge;
+}): void;

package/dist/routes/approvals.js

@@ -0,0 +1,33 @@
+import { readJson } from "../http/body.js";
+import { HttpError } from "../http/errors.js";
+import { is, validate } from "../schemas.js";
+/** Approvals and plugin interactions answered from the web (first answer wins). */
+export function registerApprovalRoutes(router, ctx) {
+    router.get("/api/approvals", ({ url }) => ({
+        body: ctx.approvals.pending(url.searchParams.get("session") ?? undefined),
+    }));
+    router.post("/api/approvals/:aid", async ({ req, params }) => {
+        const { decision } = validate(await readJson(req), {
+            decision: { check: is.oneOf(["once", "session", "deny"]), required: true },
+        });
+        const outcome = ctx.approvals.resolve(params.aid ?? "", decision);
+        if (outcome === "not_found")
+            throw new HttpError("not_found", "Approval not found");
+        if (outcome === "already_resolved")
+            throw new HttpError("approval_resolved", "This approval was already answered");
+        return { body: { resolved: true } };
+    });
+    router.post("/api/interactions/:iid", async ({ req, params }) => {
+        const { answer } = validate(await readJson(req), {
+            answer: { check: is.any(), required: true },
+        });
+        const outcome = ctx.interactions.resolve(params.iid ?? "", answer);
+        if (outcome === "not_found")
+            throw new HttpError("not_found", "Interaction not found");
+        if (outcome === "already_resolved")
+            throw new HttpError("approval_resolved", "This interaction was already answered");
+        if (outcome === "invalid")
+            throw new HttpError("validation_failed", "Invalid answer", { fields: ["answer"] });
+        return { body: { resolved: true } };
+    });
+}

package/dist/routes/blobs.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Attachment uploads (RF-06, spec §8.2/§11.1): `POST /api/blobs` takes the raw image bytes
+ * (≤ 10 MB), trusts only their magic bytes (PNG, JPEG, GIF, WebP), stores them once in the
+ * content-addressed `BlobStore` and answers the `BlobRef` a prompt then carries. `GET` serves
+ * them back with the stored type, inline and immutable.
+ */
+import type { BlobStore } from "@alisio/core";
+import type { Router } from "../http/router.ts";
+/** Per-image upload limit (spec RF-06). */
+export declare const MAX_BLOB_BYTES: number;
+export declare function registerBlobRoutes(router: Router, ctx: {
+    blobs: BlobStore;
+}): void;

package/dist/routes/blobs.js

@@ -0,0 +1,46 @@
+import { readBody } from "../http/body.js";
+import { HttpError } from "../http/errors.js";
+import { sniffImage } from "./images.js";
+/** Per-image upload limit (spec RF-06). */
+export const MAX_BLOB_BYTES = 10 * 1024 * 1024;
+/** Declared types an upload may carry; the stored type always comes from the bytes. */
+const DECLARED = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "application/octet-stream",
+]);
+export function registerBlobRoutes(router, ctx) {
+    router.post("/api/blobs", async ({ req }) => {
+        const declared = String(req.headers["content-type"] ?? "")
+            .split(";")[0]
+            ?.trim()
+            .toLowerCase();
+        if (!declared || !DECLARED.has(declared)) {
+            req.resume();
+            throw new HttpError("unsupported_media_type", "Upload PNG, JPEG, GIF or WebP images as the raw request body");
+        }
+        const bytes = await readBody(req, MAX_BLOB_BYTES);
+        if (!bytes.length)
+            throw new HttpError("validation_failed", "The upload is empty");
+        const image = sniffImage(bytes);
+        if (!image)
+            throw new HttpError("unsupported_media_type", "The file is not a PNG, JPEG, GIF or WebP image");
+        const { mimeType, ...dims } = image;
+        return { status: 201, body: ctx.blobs.put(bytes, mimeType, dims) };
+    });
+    router.get("/api/blobs/:hash", ({ params, res }) => {
+        const found = ctx.blobs.get(params.hash ?? "");
+        if (!found || !found.mimeType.startsWith("image/"))
+            throw new HttpError("not_found", "Blob not found");
+        res.writeHead(200, {
+            "Content-Type": found.mimeType,
+            "Content-Length": found.bytes.length,
+            "Content-Disposition": "inline",
+            "Cache-Control": "private, max-age=31536000, immutable",
+        });
+        res.end(found.bytes);
+        return undefined;
+    });
+}

package/dist/routes/commands.d.ts

@@ -0,0 +1,21 @@
+import type { RunScheduler } from "../host/run-scheduler.ts";
+import type { SessionService } from "../host/sessions.ts";
+import type { WorkspaceHost } from "../host/workspace-host.ts";
+import type { Router } from "../http/router.ts";
+import { RecentRequests } from "./prompts.ts";
+/**
+ * The `/ask` prompt: the TUI sends the same instruction (packages/cli/src/tui/app.ts); both turn
+ * the user's question into a multiple-choice `ask_user_question` call.
+ */
+export declare const askPrompt: (question: string) => string;
+/**
+ * The shared slash-command catalog for the web (RF-07): `GET /api/commands` lists the commands
+ * whose surfaces include `web`; `POST /api/sessions/:sid/commands` runs core commands and expands
+ * prompt templates, skills and `/ask` into a prompt the client sends itself.
+ */
+export declare function registerCommandRoutes(router: Router, ctx: {
+    sessions: SessionService;
+    scheduler: RunScheduler;
+    workspaces: WorkspaceHost;
+    recent?: RecentRequests;
+}): void;