@netnodeag/kraftwerk 0.61.0 → 0.63.0

package/dist/inspector/api/router.js

@@ -0,0 +1,186 @@
+import { touch } from "../live.js";
+/** A result with a status other than 200 (201 created, 409 with a body, …). */
+export class Reply {
+    status;
+    body;
+    constructor(status, body) {
+        this.status = status;
+        this.body = body;
+    }
+}
+export const reply = (status, body) => new Reply(status, body);
+/** A refusal with a status; the body is `{error}` unless given. */
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, message, body = { error: message }) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+export function fail(status, message) {
+    throw new ApiError(status, message);
+}
+export function route(def, handle) {
+    return { ...def, handle };
+}
+/** Maps an error message to a status by the usual wording: "no <thing>" is 404, "… are off" 409, else 400. */
+export const statusByMessage = (missing) => (message) => missing.test(message) ? 404 : /are off/.test(message) ? 409 : 400;
+/** What a thrown error becomes: an ApiError's status and body, else the route's mapping. */
+function failure(route, err) {
+    if (err instanceof ApiError)
+        return { status: err.status, data: err.body };
+    const message = err.message;
+    return { status: typeof route.errors === "function" ? route.errors(message) : (route.errors ?? 500), data: { error: message } };
+}
+export function json(res, body, status = 200) {
+    // A late error on an SSE response must not try to write headers again.
+    if (res.headersSent)
+        return void res.end();
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(JSON.stringify(body));
+}
+export function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (c) => {
+            data += c;
+            if (data.length > 1_000_000)
+                reject(new ApiError(413, "body too large"));
+        });
+        req.on("end", () => resolve(data));
+        req.on("error", reject);
+    });
+}
+/** A raw upload body (attachments), capped at `max` bytes. */
+export function readRawBody(req, max) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (c) => {
+            size += c.length;
+            if (size > max) {
+                reject(new Error(`file too large (max ${Math.round(max / 1_000_000)} MB)`));
+                req.destroy();
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+function decode(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        throw new ApiError(400, "malformed path");
+    }
+}
+export function createRouter(routes) {
+    const names = new Set();
+    const compiled = routes.map((route) => {
+        if (names.has(route.name))
+            throw new Error(`duplicate route name ${route.name}`);
+        names.add(route.name);
+        const parts = route.path.split("/").filter(Boolean);
+        return { route, parts, rank: parts.reduce((n, p, i) => n + (p.startsWith(":") ? 0 : 2 ** (parts.length - i)), 0) };
+    });
+    compiled.sort((a, b) => b.rank - a.rank);
+    const byName = new Map(routes.map((r) => [r.name, r]));
+    const match = (method, seg) => {
+        for (const c of compiled) {
+            if (c.route.method !== method || c.parts.length !== seg.length)
+                continue;
+            const params = {};
+            let ok = true;
+            for (let i = 0; i < seg.length && ok; i++) {
+                if (c.parts[i].startsWith(":"))
+                    params[c.parts[i].slice(1)] = seg[i];
+                else
+                    ok = c.parts[i] === seg[i];
+            }
+            if (ok)
+                return { route: c.route, params };
+        }
+        return undefined;
+    };
+    return {
+        routes,
+        async handle(req, res, url) {
+            const seg = url.pathname.split("/").filter(Boolean);
+            const found = match(req.method ?? "GET", seg);
+            if (!found)
+                return json(res, { error: "not found" }, 404);
+            const { route } = found;
+            let bodyRead;
+            try {
+                const params = Object.fromEntries(Object.entries(found.params).map(([k, v]) => [k, decode(v)]));
+                const c = {
+                    req,
+                    res,
+                    url,
+                    params,
+                    query: url.searchParams,
+                    body: () => (bodyRead ??= readBody(req).then((raw) => {
+                        if (!raw.trim())
+                            return {};
+                        try {
+                            return JSON.parse(raw);
+                        }
+                        catch {
+                            throw new ApiError(400, "invalid JSON body");
+                        }
+                    })),
+                };
+                const result = await route.handle(c);
+                if (route.method !== "GET")
+                    touch();
+                if (route.raw)
+                    return;
+                if (result instanceof Reply)
+                    return json(res, result.body, result.status);
+                return json(res, result);
+            }
+            catch (err) {
+                const f = failure(route, err);
+                return json(res, f.data, f.status);
+            }
+        },
+        async invoke(name, input) {
+            const route = byName.get(name);
+            if (!route)
+                return { status: 404, data: { error: `no route ${name}` } };
+            if (route.raw || route.upload)
+                return { status: 400, data: { error: `${name} is HTTP only` } };
+            try {
+                const params = {};
+                for (const p of route.path.split("/"))
+                    if (p.startsWith(":"))
+                        params[p.slice(1)] = String(input[p.slice(1)] ?? "");
+                const query = new URLSearchParams();
+                for (const [k, v] of Object.entries(input.query ?? {}))
+                    if (v !== undefined && v !== null && v !== false)
+                        query.set(k, v === true ? "1" : String(v));
+                const c = {
+                    // No HTTP request behind an invoke; only raw and upload routes read these.
+                    req: undefined,
+                    res: undefined,
+                    url: new URL(`http://invoke${route.path}`),
+                    params,
+                    query,
+                    body: async () => (input.body ?? {}),
+                };
+                const result = await route.handle(c);
+                if (route.method !== "GET")
+                    touch();
+                return result instanceof Reply ? { status: result.status, data: result.body } : { status: 200, data: result };
+            }
+            catch (err) {
+                return failure(route, err);
+            }
+        },
+    };
+}

package/dist/inspector/api/runs.d.ts

@@ -0,0 +1,33 @@
+/** Workflows, their runs, and the routines that start them. */
+export declare const runRoutes: (import("./router.js").Route<"routines.list", {
+    routines: (import("../routines.js").RoutineStatus & {
+        agent: {
+            slug: string;
+            name: string;
+            emoji: string;
+        };
+        workflows: string[];
+    })[];
+}, "/api/routines"> | import("./router.js").Route<"runs.decide", import("../decisions.js").DecisionAnswer, "/api/runs/:id/decision"> | import("./router.js").Route<"runs.delete", {
+    deleted: boolean;
+}, "/api/runs/:id"> | import("./router.js").Route<"runs.file", undefined, "/api/runs/:id/file"> | import("./router.js").Route<"runs.fileText", {
+    name: string;
+    size: number;
+    truncated: boolean;
+    content: string;
+}, "/api/runs/:id/text"> | import("./router.js").Route<"runs.get", import("../runs.js").RunDetail, "/api/runs/:id"> | import("./router.js").Route<"runs.list", {
+    outputDir: string;
+    runs: import("../runs.js").RunListItem[];
+}, "/api/runs"> | import("./router.js").Route<"runs.stop", {
+    stopped: boolean;
+}, "/api/runs/:id/stop"> | import("./router.js").Route<"workflows.delete", {
+    ok: boolean;
+}, "/api/workflows/:slug"> | import("./router.js").Route<"workflows.get", import("../workflows.js").WorkflowDetail, "/api/workflows/:slug"> | import("./router.js").Route<"workflows.list", {
+    root?: string;
+    workflows: import("../workflows.js").WorkflowSummary[];
+}, "/api/workflows"> | import("./router.js").Route<"workflows.run", {
+    runId: string;
+}, "/api/workflows/:slug/run"> | import("./router.js").Route<"workflows.runner", {
+    available: boolean;
+    image: boolean;
+}, "/api/workflows/:slug/run">)[];

package/dist/inspector/api/runs.js

@@ -0,0 +1,105 @@
+import { promises as fs } from "node:fs";
+import { getOutputDir } from "../context.js";
+import { decide } from "../decisions.js";
+import { allRoutines } from "../routines.js";
+import { dockerStatus, stopRun, triggerRun } from "../runner.js";
+import { deleteRun, getRun, listRuns, readRunFile, safeRunDir } from "../runs.js";
+import { deleteWorkflow, getWorkflow, listWorkflows } from "../workflows.js";
+import { MIME } from "./mime.js";
+import { ApiError, fail, route } from "./router.js";
+/** CSP for raw run files: same shape as the vibeable preview — scripts allowed, origin opaque. */
+const RUN_FILE_CSP = "sandbox allow-scripts allow-forms allow-popups allow-modals allow-downloads";
+/** Text preview payloads are capped; the tail matters most for logs. */
+const MAX_TEXT = 400_000;
+/** A run file's text, tail-capped: what the run page shows for logs and reports. */
+async function fileText(name, absPath, size) {
+    let content = await fs.readFile(absPath, "utf8");
+    const truncated = content.length > MAX_TEXT;
+    if (truncated)
+        content = content.slice(-MAX_TEXT);
+    return { name, size, truncated, content };
+}
+/** A run id that does not name a run folder is refused as a 400. */
+const validRun = (p, message = "invalid run id") => p.catch((err) => {
+    throw err instanceof ApiError ? err : new ApiError(400, message);
+});
+/** Workflows, their runs, and the routines that start them. */
+export const runRoutes = [
+    route({ name: "workflows.list", method: "GET", path: "/api/workflows", summary: "every workflow, with validation errors" }, async () => listWorkflows()),
+    route({ name: "workflows.get", method: "GET", path: "/api/workflows/:slug", summary: "one workflow: agents, steps, gates" }, async (c) => (await getWorkflow(c.params.slug)) ?? fail(404, "not found")),
+    route({ name: "workflows.delete", method: "DELETE", path: "/api/workflows/:slug", summary: "move it to the trash; refused while a run is running" }, async (c) => {
+        const outcome = await deleteWorkflow(c.params.slug);
+        if (outcome === "missing")
+            fail(404, "not found");
+        if (outcome === "running")
+            fail(409, "a run of this workflow is still running — stop it first");
+        return { ok: true };
+    }),
+    route({ name: "workflows.runner", method: "GET", path: "/api/workflows/:slug/run", summary: "whether runs can start here (docker state)" }, async () => dockerStatus()),
+    route({ name: "workflows.run", method: "POST", path: "/api/workflows/:slug/run", summary: "start a run {request?, sandbox?, ssh?}" }, async (c) => {
+        const wf = await getWorkflow(c.params.slug);
+        if (!wf || wf.error || !wf.name)
+            fail(404, "workflow not found or broken");
+        const body = await c.body();
+        const request = (body.request ?? "").trim();
+        if (!request && wf.usesRequest)
+            fail(400, "this workflow needs a request");
+        try {
+            return { runId: triggerRun({ workflowName: wf.name, request, sandbox: body.sandbox ?? true, ssh: !!body.ssh }).runId };
+        }
+        catch (err) {
+            throw new ApiError(503, err.message);
+        }
+    }),
+    route({ name: "routines.list", method: "GET", path: "/api/routines", summary: "every agent's routines with run state and the workflows each one names" }, async () => ({
+        routines: await allRoutines((await listWorkflows()).workflows),
+    })),
+    route({ name: "runs.list", method: "GET", path: "/api/runs", summary: "every run in the output dir" }, async () => ({ outputDir: getOutputDir(), runs: await listRuns() })),
+    route({ name: "runs.get", method: "GET", path: "/api/runs/:id", summary: "one run: phases, gates, files" }, async (c) => (await validRun(getRun(c.params.id))) ?? fail(404, "not found")),
+    route({ name: "runs.fileText", method: "GET", path: "/api/runs/:id/text", summary: "one run file's text ?name=, tail-capped" }, async (c) => {
+        const name = c.query.get("name") ?? "";
+        const file = await validRun(readRunFile(c.params.id, name), "invalid request");
+        if (!file)
+            fail(404, "not found");
+        return fileText(name, file.absPath, file.size);
+    }),
+    // ?raw=1 serves the file itself (sandboxed); without it, the same JSON as runs.fileText (older clients).
+    route({ name: "runs.file", method: "GET", path: "/api/runs/:id/file", summary: "one run file ?name=[&raw=1]", raw: true }, async ({ res, params, query }) => {
+        const name = query.get("name") ?? "";
+        const file = await validRun(readRunFile(params.id, name), "invalid request");
+        if (!file)
+            fail(404, "not found");
+        if (query.get("raw") === "1") {
+            const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+            // Agent-written files must not run as the inspector's origin: the
+            // sandbox keeps scripts working (interactive reports) but makes the
+            // origin opaque, so no fetch() into /api and no cookies. PDFs are
+            // exempt — Chrome's viewer refuses sandboxed documents, and PDF
+            // scripting has no DOM or origin access.
+            res.writeHead(200, {
+                "content-type": MIME[ext] ?? "text/plain; charset=utf-8",
+                "cache-control": "no-store",
+                "x-content-type-options": "nosniff",
+                ...(ext === ".pdf" ? {} : { "content-security-policy": RUN_FILE_CSP }),
+            });
+            return void res.end(await fs.readFile(file.absPath));
+        }
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+        res.end(JSON.stringify(await fileText(name, file.absPath, file.size)));
+    }),
+    // A person answers the step that wrote decision-request.json; the answer is written once.
+    route({ name: "runs.decide", method: "POST", path: "/api/runs/:id/decision", summary: "answer a decision request {decision, note?}" }, async (c) => {
+        const runDir = await validRun(Promise.resolve().then(() => safeRunDir(c.params.id)), "invalid request");
+        const r = await decide(runDir, (await c.body()) ?? {});
+        return r.ok ? r.answer : fail(r.status, r.error);
+    }),
+    route({ name: "runs.stop", method: "POST", path: "/api/runs/:id/stop", summary: "stop a running run" }, async (c) => stopRun(c.params.id) ? { stopped: true } : fail(404, "nothing to stop: no launcher of this inspector and no sandbox container for this run")),
+    route({ name: "runs.delete", method: "DELETE", path: "/api/runs/:id", summary: "delete a run; refused while it is live" }, async (c) => {
+        const outcome = await validRun(deleteRun(c.params.id));
+        if (outcome === "missing")
+            fail(404, "not found");
+        if (outcome === "running")
+            fail(409, "run is still running — stop it first");
+        return { deleted: true };
+    }),
+];

package/dist/inspector/api/socket.d.ts

@@ -0,0 +1,3 @@
+import type { Workspace } from "../workspace.js";
+import type { Socket } from "../ws.js";
+export declare function serveSocket(conn: Socket, workspace: Workspace, version: string): void;

package/dist/inspector/api/socket.js

@@ -0,0 +1,115 @@
+import { subscribeChat } from "../chat/sessions.js";
+import { watch } from "../live.js";
+import { resolveVibeable, subscribeVibeable } from "../vibeables.js";
+import { apiRouter, PROTOCOL_VERSION, routes } from "./index.js";
+/**
+ * The control plane over one WebSocket (`/api/ws`): every JSON route by
+ * name, live route results, and event streams — what a native app needs
+ * from one connection, and what the web UI uses instead of polling.
+ *
+ * Server → client, first: `{hello: {protocol, version}}`.
+ *
+ * Client → server, each a JSON text message:
+ * - `{id, call, input?}` runs route `call` (input = path params by name, `query`, `body`)
+ *   → `{id, status, data}`. Raw and upload routes stay HTTP.
+ * - `{watch: key, name, input?, interval?}` keeps a GET route's result live
+ *   → `{watch: key, data}` now and whenever it changes. `{unwatch: key}` stops.
+ * - `{sub: key, topic, after?}` follows an event stream: `chat.<id>` (events
+ *   after seq `after`, then new ones) or `vibeable.<slug>` (file changes, dev
+ *   server state) → `{event: key, data}` per event. `{unsub: key}` stops.
+ *
+ * `key`s are the client's own names, unique per connection. A refusal of a
+ * message is `{id?, watch?, sub?, error}`.
+ */
+const DEFAULT_INTERVAL = 5000;
+const GET_ROUTES = new Set(routes.filter((r) => r.method === "GET" && !r.raw).map((r) => r.name));
+export function serveSocket(conn, workspace, version) {
+    const stops = new Map();
+    const send = (msg) => conn.send(JSON.stringify(msg));
+    const stop = (key) => {
+        stops.get(key)?.();
+        stops.delete(key);
+    };
+    const objectOf = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+    /** `placeholder` holds the key's place while the subscription is set up; a newer sub or unsub on the key replaces it. */
+    async function follow(key, topic, after, placeholder) {
+        const [kind, ...rest] = topic.split(".");
+        const name = rest.join(".");
+        let unsubscribe = null;
+        // Only the key's current subscription speaks: a superseded one may still be replaying.
+        const push = (data) => {
+            const current = stops.get(key);
+            if (current === placeholder || (current && current === unsubscribe))
+                send({ event: key, data });
+        };
+        if (kind === "chat" && name)
+            unsubscribe = await subscribeChat(name, after, push).catch(() => null);
+        else if (kind === "vibeable" && name) {
+            const dir = await resolveVibeable(name).then((v) => v.dir, () => null);
+            if (dir)
+                unsubscribe = subscribeVibeable(name, dir, push);
+        }
+        else {
+            if (stops.get(key) === placeholder)
+                stops.delete(key);
+            return send({ sub: key, error: `unknown topic ${topic}` });
+        }
+        if (!unsubscribe) {
+            if (stops.get(key) === placeholder)
+                stops.delete(key);
+            return send({ sub: key, error: `no such ${kind}: ${name}` });
+        }
+        // Unsubscribed (or closed) while subscribing: let go at once.
+        if (!conn.open || stops.get(key) !== placeholder)
+            return unsubscribe();
+        stops.set(key, unsubscribe);
+    }
+    async function handle(msg) {
+        if (typeof msg.call === "string") {
+            const r = await apiRouter.invoke(msg.call, objectOf(msg.input));
+            return send({ id: msg.id, status: r.status, data: r.data });
+        }
+        if (typeof msg.watch === "string") {
+            const key = msg.watch;
+            const name = String(msg.name ?? "");
+            if (!GET_ROUTES.has(name))
+                return send({ watch: key, error: `${name} cannot be watched` });
+            const input = objectOf(msg.input);
+            const interval = typeof msg.interval === "number" && msg.interval > 0 ? msg.interval : DEFAULT_INTERVAL;
+            stop(key);
+            stops.set(key, watch(`${name} ${JSON.stringify(input)}`, async () => {
+                const r = await apiRouter.invoke(name, input);
+                return { ok: r.status < 300, data: r.data };
+            }, interval, (data) => send({ watch: key, data })));
+            return;
+        }
+        if (typeof msg.unwatch === "string")
+            return stop(msg.unwatch);
+        if (typeof msg.sub === "string" && typeof msg.topic === "string") {
+            stop(msg.sub);
+            const placeholder = () => { };
+            stops.set(msg.sub, placeholder);
+            return follow(msg.sub, msg.topic, Number(msg.after) || 0, placeholder);
+        }
+        if (typeof msg.unsub === "string")
+            return stop(msg.unsub);
+        send({ id: msg.id, error: "unknown message" });
+    }
+    conn.onMessage((text) => {
+        let msg;
+        try {
+            msg = objectOf(JSON.parse(text));
+        }
+        catch {
+            return send({ error: "invalid JSON" });
+        }
+        // Every message runs in the connection's workspace, whatever started the read.
+        void workspace.run(() => handle(msg)).catch((err) => send({ id: msg.id, error: err.message }));
+    });
+    conn.onClose(() => {
+        for (const fn of stops.values())
+            fn();
+        stops.clear();
+    });
+    send({ hello: { protocol: PROTOCOL_VERSION, version } });
+}

package/dist/inspector/api/vibeables.d.ts

@@ -0,0 +1,4 @@
+/** Apps (vibeables): folders under the vibeables root, previewed in the chat. */
+export declare const vibeableRoutes: (import("./router.js").Route<"vibeables.create", import("./router.js").Reply<import("../vibeables.js").VibeableInfo>, "/api/vibeables"> | import("./router.js").Route<"vibeables.delete", {
+    ok: boolean;
+}, "/api/vibeables/:slug"> | import("./router.js").Route<"vibeables.devStart", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug/dev/start"> | import("./router.js").Route<"vibeables.devStop", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug/dev/stop"> | import("./router.js").Route<"vibeables.events", void, "/api/vibeables/:slug/events"> | import("./router.js").Route<"vibeables.get", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug"> | import("./router.js").Route<"vibeables.list", import("../vibeables.js").VibeablesView, "/api/vibeables">)[];

package/dist/inspector/api/vibeables.js

@@ -0,0 +1,31 @@
+import { createVibeable, deleteVibeable, listVibeables, openVibeables, resolveVibeable, startDev, stopDev, subscribeVibeable, vibeableStatus } from "../vibeables.js";
+import { fail, reply, route, statusByMessage } from "./router.js";
+const errors = statusByMessage(/^no vibeable/);
+/** Apps (vibeables): folders under the vibeables root, previewed in the chat. */
+export const vibeableRoutes = [
+    route({ name: "vibeables.list", method: "GET", path: "/api/vibeables", summary: "every app folder under the vibeables root" }, async () => listVibeables()),
+    route({ name: "vibeables.create", method: "POST", path: "/api/vibeables", summary: "create one {name} from the starter", errors: 400 }, async (c) => {
+        if ((await openVibeables()).off)
+            fail(409, "vibeables are off");
+        const body = await c.body();
+        return reply(201, await createVibeable(typeof body.name === "string" ? body.name : ""));
+    }),
+    route({ name: "vibeables.get", method: "GET", path: "/api/vibeables/:slug", summary: "how the app previews: mode, static url, dev server state", errors }, async (c) => vibeableStatus(c.params.slug)),
+    route({ name: "vibeables.delete", method: "DELETE", path: "/api/vibeables/:slug", summary: "remove the folder", errors }, async (c) => {
+        await deleteVibeable(c.params.slug);
+        return { ok: true };
+    }),
+    route({ name: "vibeables.devStart", method: "POST", path: "/api/vibeables/:slug/dev/start", summary: "start the app's dev command", errors }, async (c) => startDev(c.params.slug)),
+    route({ name: "vibeables.devStop", method: "POST", path: "/api/vibeables/:slug/dev/stop", summary: "stop the app's dev command", errors }, async (c) => stopDev(c.params.slug)),
+    route({ name: "vibeables.events", method: "GET", path: "/api/vibeables/:slug/events", summary: "SSE: file changes (debounced) and dev-server state", errors, raw: true }, async ({ req, res, params }) => {
+        const { dir } = await resolveVibeable(params.slug);
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+        res.write(":ok\n\n");
+        const unsubscribe = subscribeVibeable(params.slug, dir, (ev) => res.write(`data: ${JSON.stringify(ev)}\n\n`));
+        const heartbeat = setInterval(() => res.write(":hb\n\n"), 25_000);
+        req.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+    }),
+];

package/dist/inspector/api/workspace.d.ts

@@ -0,0 +1,55 @@
+/** The workspace itself: identity and features, settings, the other workspaces, updates. */
+export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
+    version: string;
+    diskVersion: string;
+    restartable: boolean;
+    projectName: string;
+    projectIcon: string;
+    projectColor: string;
+    projectNamed: boolean;
+    projectRoot: string;
+    projectRootLabel: string;
+    git: boolean;
+    repos: boolean;
+    vibeables: boolean;
+    projects: boolean;
+    publicUrl: string;
+    cloud: import("../cloud.js").CloudStatus;
+    switcher: import("../../config.js").SwitcherEntry[];
+}, "/api/meta"> | import("./router.js").Route<"search.agents", import("../search.js").AgentSearch, "/api/search/agents"> | import("./router.js").Route<"server.restart", {
+    ok: boolean;
+}, "/api/restart"> | import("./router.js").Route<"settings.get", import("../settings.js").SettingsView, "/api/settings"> | import("./router.js").Route<"settings.save", import("../settings.js").SettingsView, "/api/settings"> | import("./router.js").Route<"update.check", import("./router.js").Reply<{
+    name: string;
+    current: string;
+    latest: string;
+    error: string;
+}> | {
+    name: string;
+    current: string;
+    latest: string;
+    error?: string;
+}, "/api/update-check"> | import("./router.js").Route<"update.start", import("./router.js").Reply<{
+    state: "idle" | "running" | "done" | "failed";
+    version?: string;
+    log: string[];
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number | null;
+    name: string;
+}>, "/api/update"> | import("./router.js").Route<"update.status", {
+    state: "idle" | "running" | "done" | "failed";
+    version?: string;
+    log: string[];
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number | null;
+    name: string;
+    available: boolean;
+    reason: string | undefined;
+    restartable: boolean;
+}, "/api/update"> | import("./router.js").Route<"workspaces.forget", {
+    ok: boolean;
+}, "/api/workspaces/forget"> | import("./router.js").Route<"workspaces.list", import("../instances.js").WorkspaceDetail[], "/api/workspaces"> | import("./router.js").Route<"workspaces.start", import("./router.js").Reply<import("../instances.js").StartResult>, "/api/workspaces/start"> | import("./router.js").Route<"workspaces.stop", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+}>, "/api/workspaces/stop">)[];