wizards 0.1.9

package/apps/runtime/dist/routes/studio.js

@@ -0,0 +1,702 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { MODEL_CLASSES, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
+import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
+import { generateText } from "ai";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { z } from "zod";
+import { runProjectAssistant } from "../agents/project-assistant.js";
+import { chatEngine, setChatEngine, subscriptionClients } from "../agents/subscription.js";
+import { accountOverview, linkedAccount, startLink, unlink } from "../auth/account.js";
+import { createLocalKey, deleteLocalKey, listLocalKeys } from "../auth/keys.js";
+import { connectorImportSchema, importConnector, listConnectors, previewSource, refreshConnector, registryService, removeConnector, searchRegistry, } from "../connectors/external.js";
+import { balanceCredits, canSpend } from "../credits/credits.js";
+import { estimateRun } from "../credits/estimate.js";
+import { missingModels } from "../engine/requirements.js";
+import { env } from "../env.js";
+import { freshAuth, loginEnv } from "../harness/env.js";
+import { detectHarness, detectHarnesses, HARNESS_IDS, harness, installSpec, } from "../harness/index.js";
+import { closeTerminal, openTerminal, resizeTerminal, subscribeTerminal, writeTerminal, } from "../harness/terminal.js";
+import { managed } from "../manage.js";
+import { transcribeAudio } from "../media/transcribe.js";
+import { embeddingModel, hasTextModel, LOCAL_KEYS, localModelSettings, ModelUnavailableError, saveLocalModels, textModel, } from "../models.js";
+import { HTML_RESPONSE_CSP } from "../render/guard.js";
+import { architectTurn } from "../services/architect.js";
+import { cloudCopy, publishToCloud } from "../services/cloud.js";
+import { ServiceError } from "../services/errors.js";
+import { deleteFile, listFiles, readFile, writeFile } from "../services/files.js";
+import { exportWizard, importWizard, PACKAGE_EXTENSION, PACKAGE_MAX_BYTES, PACKAGE_MIME, } from "../services/package.js";
+import { profileSchema, saveProfile, userProfile } from "../services/profile.js";
+import { addProjectFile, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
+import { documentText, searchProject } from "../services/project-index.js";
+import { createProject, deleteProject, listProjects, maskedServers, ownedProject, projectLimit, projectPatchSchema, updateProject, } from "../services/projects.js";
+import { listRuns, startTestRun } from "../services/runs.js";
+import { draftWidgetPreview } from "../services/widgets.js";
+import { createWizard, deleteWizard, duplicateWizard, listWizards, ownedWizard, publishWizard, rotateShareLink, updateWizardSettings, wizardMessages, wizardState, writeDraft, } from "../services/wizards.js";
+import { readSetting, writeSetting } from "../settings.js";
+import { applyUpdate, updateStatus } from "../update.js";
+import { byteRange } from "./delivery.js";
+/** The model sources a test call has worked on: the setup is done for those, not for the others. */
+async function testedSources() {
+    const tested = await readSetting("setup-done");
+    return Array.isArray(tested) ? tested : [];
+}
+/** The chosen source has passed a test call and can still answer: its client is there and signed in. */
+async function setupDone() {
+    const source = localModelSettings().source;
+    if (!(await testedSources()).includes(source)) {
+        return false;
+    }
+    const client = harness(source);
+    if (client) {
+        const status = await detectHarness(client.id);
+        return Boolean(status?.version) && status?.auth !== "none";
+    }
+    return hasTextModel();
+}
+/** The size of an inline terminal, as the page lays it out. */
+const terminalSize = z.object({
+    cols: z.number().int().min(10).max(500).optional(),
+    rows: z.number().int().min(4).max(200).optional(),
+});
+export const studio = new Hono()
+    .get("/me", async (c) => {
+    const user = c.get("user");
+    // A runtime that runs alone may be linked to an account: its credits and the cloud to publish to.
+    const linked = managed ? null : await linkedAccount();
+    const overview = linked ? await accountOverview() : null;
+    const profile = await userProfile(user);
+    return c.json({
+        user: { id: user.id, name: profile.name, email: profile.email, image: user.image ?? null },
+        /** What the person says about themselves; name and e-mail are the account's when managed. */
+        profile,
+        tenant: { id: user.tenantId, role: user.role },
+        mode: managed ? "managed" : "local",
+        /** The tenant's balance; null where the runtime resolves models itself. */
+        credits: managed ? await balanceCredits() : null,
+        /** Where the account, members, API keys and credits are managed. */
+        manageUrl: managed ? env.manage.url : null,
+        account: linked
+            ? {
+                name: linked.name,
+                email: linked.email,
+                credits: overview?.tenant.balanceCredits ?? null,
+                url: env.local.accountUrl,
+                cloudUrl: env.local.cloudUrl,
+                signedIn: Boolean(overview),
+            }
+            : null,
+        models: managed ? null : localModelSettings(),
+        /** The AI clients this runtime can think with — installed or not, and how each is signed in. */
+        harnesses: managed ? [] : await detectHarnesses(),
+        /** Installed AI clients whose subscription can answer the studio chat. */
+        subscriptions: managed ? [] : await subscriptionClients(),
+        /** A runtime that runs alone keeps its setup in front until a test call has worked on the chosen source and the way is still open. */
+        setupDone: managed ? true : await setupDone(),
+        /** What answers the studio chat: a model of class `highest`, or the admin's own subscription. */
+        chatEngine: managed ? "models" : await chatEngine(await hasTextModel()),
+        aiReady: (await hasTextModel()) || (!managed && (await subscriptionClients()).length > 0),
+        mcpUrl: `${env.appUrl}/api/mcp`,
+        /** One project: the studio shows no project switcher. */
+        limits: { projects: await projectLimit() },
+    });
+})
+    // A runtime that runs alone says when a newer release is out and can run the update itself.
+    .get("/update", async (c) => managed ? c.json({ error: "not_local" }, 404) : c.json(await updateStatus()))
+    .post("/update", async (c) => {
+    if (managed) {
+        return c.json({ error: "not_local" }, 404);
+    }
+    applyUpdate();
+    return c.json(await updateStatus());
+})
+    .put("/profile", async (c) => c.json(await saveProfile(c.get("user"), profileSchema.parse(await c.req.json()))))
+    // --- projects --------------------------------------------------------------
+    .get("/projects", async (c) => {
+    const projects = await listProjects(c.get("user").id);
+    return c.json(projects.map((p) => ({
+        id: p.id,
+        name: p.name,
+        brand: p.brand,
+        facts: p.facts,
+        mcpServers: maskedServers(p),
+        wizardCount: p.wizardCount,
+    })));
+})
+    .post("/projects", async (c) => {
+    const body = z.object({ name: z.string().min(1).max(80) }).parse(await c.req.json());
+    return c.json(await createProject(c.get("user").id, body.name));
+})
+    .patch("/projects/:id", async (c) => {
+    const patch = projectPatchSchema.parse(await c.req.json());
+    await updateProject(c.get("user").id, c.req.param("id"), patch);
+    return c.json({ ok: true });
+})
+    // --- what a project holds for all its wizards: logos, assets, documents -------
+    .get("/projects/:id/files", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    return c.json({
+        files: (await projectFiles(project.id)).map(fileView),
+        /** Whether documents get vectors, or the index works on keywords alone. */
+        embeddings: Boolean(await embeddingModel().catch(() => null)),
+    });
+})
+    .post("/projects/:id/files", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const kind = z.enum(PROJECT_FILE_KINDS).parse(c.req.query("kind"));
+    const file = (await c.req.formData()).get("file");
+    if (!(file instanceof File)) {
+        throw new ServiceError("invalid", "Bitte eine Datei wählen.");
+    }
+    const row = await addProjectFile(project.id, {
+        kind,
+        name: file.name,
+        mime: file.type.split(";")[0].trim().toLowerCase(),
+        data: new Uint8Array(await file.arrayBuffer()),
+    });
+    return c.json(fileView(row));
+})
+    .put("/projects/:id/files/order", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const body = z
+        .object({ kind: z.enum(PROJECT_FILE_KINDS), ids: z.array(z.string()).max(200) })
+        .parse(await c.req.json());
+    await orderProjectFiles(project.id, body.kind, body.ids);
+    return c.json({ ok: true });
+})
+    .patch("/projects/:id/files/:fileId", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const patch = z
+        .object({ name: z.string().max(120).optional(), description: z.string().max(600).optional() })
+        .parse(await c.req.json());
+    return c.json(fileView(await updateProjectFile(project.id, c.req.param("fileId"), patch)));
+})
+    .post("/projects/:id/files/:fileId/reindex", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    return c.json(fileView(await reindexProjectFile(project.id, c.req.param("fileId"))));
+})
+    .delete("/projects/:id/files/:fileId", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await removeProjectFile(project.id, c.req.param("fileId"));
+    return c.json({ ok: true });
+})
+    .get("/projects/:id/files/:fileId/content", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const { row, data } = await projectFileContent(project.id, c.req.param("fileId"));
+    const headers = {
+        "content-type": row.mime,
+        "cache-control": "private, max-age=3600",
+        "x-content-type-options": "nosniff",
+        // An uploaded SVG or HTML file is shown, never run. A PDF is left to the browser's own
+        // viewer, which a sandbox would keep from starting.
+        ...(row.mime === "application/pdf" ? {} : { "content-security-policy": "sandbox" }),
+    };
+    if (/^(audio|video)\//.test(row.mime)) {
+        headers["accept-ranges"] = "bytes";
+        const range = byteRange(c.req.header("range"), data.byteLength);
+        if (range === "unsatisfiable") {
+            return c.body(null, 416, { "content-range": `bytes */${data.byteLength}` });
+        }
+        if (range) {
+            headers["content-range"] = `bytes ${range.start}-${range.end}/${data.byteLength}`;
+            return c.body(new Uint8Array(data.subarray(range.start, range.end + 1)), 206, headers);
+        }
+    }
+    return c.body(new Uint8Array(data), 200, headers);
+})
+    // A document as the models read it: its text as Markdown, or the start of it.
+    .get("/projects/:id/files/:fileId/text", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const row = await projectFile(project.id, c.req.param("fileId"));
+    const limit = z.coerce
+        .number()
+        .int()
+        .min(100)
+        .max(400_000)
+        .catch(200_000)
+        .parse(c.req.query("limit"));
+    const text = await documentText(row);
+    return c.json({ text: text.slice(0, limit), chars: text.length });
+})
+    // What the document index finds for a question: the passages an agent step would get.
+    .post("/projects/:id/search", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const { query } = z.object({ query: z.string().min(1).max(400) }).parse(await c.req.json());
+    return c.json({ hits: await searchProject(project.id, query, 6) });
+})
+    // The assistant fills the project in: from a description, a website, the files given.
+    .post("/projects/:id/assist", async (c) => {
+    const user = c.get("user");
+    const project = await ownedProject(user.id, c.req.param("id"));
+    const body = z
+        .object({
+        message: z.string().min(1).max(8000),
+        history: z
+            .array(z.object({ role: z.enum(["user", "assistant"]), content: z.string().max(8000) }))
+            .max(24)
+            .default([]),
+    })
+        .parse(await c.req.json());
+    if (!(await canSpend())) {
+        throw new ServiceError("no_credits", "Dein Guthaben ist aufgebraucht.");
+    }
+    return streamSSE(c, async (stream) => {
+        const abort = new AbortController();
+        stream.onAbort(() => abort.abort());
+        try {
+            const result = await runProjectAssistant({
+                userId: user.id,
+                projectId: project.id,
+                message: body.message,
+                history: body.history,
+                signal: abort.signal,
+                onText: (delta) => {
+                    void stream.writeSSE({ event: "text", data: JSON.stringify(delta) });
+                },
+                onActivity: (label) => {
+                    void stream.writeSSE({ event: "activity", data: JSON.stringify(label) });
+                },
+                onChanged: () => {
+                    void stream.writeSSE({ event: "changed", data: "1" });
+                },
+            });
+            await stream.writeSSE({
+                event: "done",
+                data: JSON.stringify({
+                    reply: result.reply || (result.changed ? "Erledigt." : ""),
+                    changed: result.changed,
+                }),
+            });
+        }
+        catch (err) {
+            console.error("[project-assistant]", err);
+            await stream.writeSSE({
+                event: "error",
+                data: JSON.stringify({
+                    message: err instanceof ServiceError || err instanceof ModelUnavailableError
+                        ? err.message
+                        : "Da ist etwas schiefgelaufen. Bitte noch einmal versuchen.",
+                }),
+            });
+        }
+    });
+})
+    .delete("/projects/:id", async (c) => {
+    await deleteProject(c.get("user").id, c.req.param("id"));
+    return c.json({ ok: true });
+})
+    // --- connectors: services imported from the integrations registry ------------
+    .post("/connectors/search", async (c) => {
+    const { query } = z.object({ query: z.string().min(1).max(200) }).parse(await c.req.json());
+    return c.json(await searchRegistry(query));
+})
+    .get("/connectors/registry/:domain", async (c) => c.json(await registryService(c.req.param("domain"))))
+    .post("/connectors/preview", async (c) => {
+    const body = z
+        .object({
+        domain: z.string().min(1).max(253).optional(),
+        sourceKind: z.enum(["openapi", "mcp"]),
+        sourceUrl: z.string().url(),
+    })
+        .parse(await c.req.json());
+    return c.json(await previewSource(body));
+})
+    .get("/projects/:id/connectors", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    return c.json(await listConnectors(project.id));
+})
+    .post("/projects/:id/connectors", async (c) => {
+    const user = c.get("user");
+    const project = await ownedProject(user.id, c.req.param("id"));
+    return c.json(await importConnector(user.id, project.id, connectorImportSchema.parse(await c.req.json())));
+})
+    .post("/projects/:id/connectors/:connectorId/refresh", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    return c.json(await refreshConnector(project.id, c.req.param("connectorId"), null));
+})
+    .delete("/projects/:id/connectors/:connectorId", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await removeConnector(project.id, c.req.param("connectorId"));
+    return c.json({ ok: true });
+})
+    // --- wizards ---------------------------------------------------------------
+    .get("/projects/:id/wizards", async (c) => {
+    const user = c.get("user");
+    await ownedProject(user.id, c.req.param("id"));
+    return c.json(await listWizards(user.id, c.req.param("id")));
+})
+    .post("/wizards", async (c) => {
+    const body = z
+        .object({
+        projectId: z.string(),
+        starterId: z.string().optional(),
+        lang: z.string().optional(),
+    })
+        .parse(await c.req.json());
+    const { id } = await createWizard(c.get("user").id, body);
+    return c.json({ id });
+})
+    // A wizard as a file, and a new wizard made of such a file.
+    .post("/projects/:id/wizards/import", async (c) => {
+    const file = (await c.req.formData()).get("file");
+    if (!(file instanceof File) || !file.size || file.size > PACKAGE_MAX_BYTES) {
+        throw new ServiceError("invalid", `Bitte ein Wizard-Paket (${PACKAGE_EXTENSION}) bis 30 MB.`);
+    }
+    return c.json(await importWizard(c.get("user").id, c.req.param("id"), new Uint8Array(await file.arrayBuffer()), file.name));
+})
+    .get("/wizards/:id/export", async (c) => {
+    const { name, zip } = await exportWizard(c.get("user").id, c.req.param("id"));
+    return c.body(new Uint8Array(zip), 200, {
+        "content-type": PACKAGE_MIME,
+        "content-disposition": `attachment; filename="${name}"`,
+        "cache-control": "private, no-store",
+    });
+})
+    .get("/wizards/:id", async (c) => {
+    const user = c.get("user");
+    const w = await ownedWizard(user.id, c.req.param("id"));
+    const messages = await wizardMessages(w.id);
+    const project = await ownedProject(user.id, w.projectId);
+    return c.json({
+        ...(await wizardState(w)),
+        blank: messages.length === 0 && !w.starter,
+        messages: messages.map((m) => ({
+            id: m.id,
+            role: m.role,
+            content: m.content,
+            changed: m.changed,
+            source: m.source,
+            client: m.client,
+        })),
+        mcpServers: project.mcpServers.map((s) => ({ id: s.id, name: s.name })),
+    });
+})
+    .put("/wizards/:id/draft", async (c) => {
+    const body = z
+        .object({ definition: z.unknown(), baseRevision: z.number().int().min(0) })
+        .parse(await c.req.json());
+    const { revision, issues } = await writeDraft(c.get("user").id, c.req.param("id"), body);
+    return c.json({ ok: true, revision, issues });
+})
+    .patch("/wizards/:id", async (c) => {
+    const patch = z
+        .object({
+        shareEnabled: z.boolean().optional(),
+        dailyRunLimit: z.number().int().min(1).max(10_000).optional(),
+        projectId: z.string().optional(),
+    })
+        .parse(await c.req.json());
+    await updateWizardSettings(c.get("user").id, c.req.param("id"), patch);
+    return c.json({ ok: true });
+})
+    .post("/wizards/:id/rotate-link", async (c) => c.json(await rotateShareLink(c.get("user").id, c.req.param("id"))))
+    .post("/wizards/:id/duplicate", async (c) => c.json(await duplicateWizard(c.get("user").id, c.req.param("id"))))
+    .delete("/wizards/:id", async (c) => {
+    await deleteWizard(c.get("user").id, c.req.param("id"));
+    return c.json({ ok: true });
+})
+    .post("/wizards/:id/publish", async (c) => c.json(await publishWizard(c.get("user").id, c.req.param("id"))))
+    // What a run of the draft is expected to cost, per step and in total.
+    .get("/wizards/:id/estimate", async (c) => {
+    const w = await ownedWizard(c.get("user").id, c.req.param("id"));
+    return c.json(await estimateRun(w.id, null, w.draft));
+})
+    // The models the draft needs that this runtime cannot serve, by class, with the steps that call them.
+    .get("/wizards/:id/models", async (c) => {
+    const w = await ownedWizard(c.get("user").id, c.req.param("id"));
+    return c.json({ missing: await missingModels(w.draft) });
+})
+    // A runtime that runs alone: the wizard's copy in the cloud of the linked account.
+    .get("/wizards/:id/cloud", async (c) => {
+    const w = await ownedWizard(c.get("user").id, c.req.param("id"));
+    return c.json({ copy: managed ? null : await cloudCopy(w.id) });
+})
+    .post("/wizards/:id/cloud", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    return c.json(await publishToCloud(c.get("user").id, c.req.param("id")));
+})
+    .post("/wizards/:id/chat", async (c) => {
+    const user = c.get("user");
+    const wizardId = c.req.param("id");
+    const { message } = z
+        .object({ message: z.string().min(1).max(8000) })
+        .parse(await c.req.json());
+    await ownedWizard(user.id, wizardId);
+    if (!(await canSpend())) {
+        throw new ServiceError("no_credits", "Dein Guthaben ist aufgebraucht.");
+    }
+    return streamSSE(c, async (stream) => {
+        const abort = new AbortController();
+        stream.onAbort(() => abort.abort());
+        try {
+            const result = await architectTurn(user.id, wizardId, message, {
+                signal: abort.signal,
+                onText: (delta) => {
+                    void stream.writeSSE({ event: "text", data: JSON.stringify(delta) });
+                },
+                onActivity: (label) => {
+                    void stream.writeSSE({ event: "activity", data: JSON.stringify(label) });
+                },
+                onThought: (line) => {
+                    void stream.writeSSE({ event: "thought", data: JSON.stringify(line) });
+                },
+                onBuilding: () => {
+                    void stream.writeSSE({ event: "building", data: "1" });
+                },
+            });
+            await stream.writeSSE({ event: "done", data: JSON.stringify(result) });
+        }
+        catch (err) {
+            console.error("[architect]", err);
+            await stream.writeSSE({
+                event: "error",
+                data: JSON.stringify({
+                    message: err instanceof ServiceError
+                        ? err.message
+                        : "Da ist etwas schiefgelaufen. Bitte noch einmal versuchen.",
+                }),
+            });
+        }
+    });
+})
+    // What the admin says into the composer, written down — where the browser cannot do it itself.
+    .post("/transcribe", async (c) => {
+    const file = (await c.req.formData()).get("file");
+    if (!(file instanceof File) || !file.size || file.size > 10_000_000) {
+        throw new ServiceError("invalid", "Bitte eine Aufnahme bis 10 MB.");
+    }
+    if (!(await canSpend())) {
+        throw new ServiceError("no_credits", "Dein Guthaben ist aufgebraucht.");
+    }
+    try {
+        const { text } = await transcribeAudio({
+            bytes: new Uint8Array(await file.arrayBuffer()),
+            mediaType: file.type || "audio/webm",
+        });
+        return c.json({ text });
+    }
+    catch (err) {
+        if (err instanceof ModelUnavailableError) {
+            throw new ServiceError("refused", err.message);
+        }
+        throw err;
+    }
+})
+    .post("/wizards/:id/test-runs", async (c) => c.json(await startTestRun(c.get("user").id, c.req.param("id"))))
+    .get("/wizards/:id/runs", async (c) => c.json(await listRuns(c.get("user").id, c.req.param("id"))))
+    // --- workspace -------------------------------------------------------------
+    .get("/wizards/:id/files", async (c) => c.json(await listFiles(c.get("user").id, c.req.param("id"))))
+    .get("/wizards/:id/files/:path{.+}", async (c) => {
+    const { file, data } = await readFile(c.get("user").id, c.req.param("id"), c.req.param("path"));
+    return c.body(new Uint8Array(data), 200, {
+        "content-type": file.mime,
+        "content-disposition": `attachment; filename="${file.path.split("/").pop()}"`,
+        "cache-control": "private, no-cache",
+    });
+})
+    .put("/wizards/:id/files/:path{.+}", async (c) => {
+    const data = new Uint8Array(await c.req.arrayBuffer());
+    const file = await writeFile(c.get("user").id, c.req.param("id"), c.req.param("path"), data, c.req.header("content-type")?.split(";")[0]);
+    return c.json(file);
+})
+    .delete("/wizards/:id/files/:path{.+}", async (c) => {
+    await deleteFile(c.get("user").id, c.req.param("id"), c.req.param("path"));
+    return c.json({ ok: true });
+})
+    .get("/wizards/:id/widgets/:stepId/preview", async (c) => {
+    const html = await draftWidgetPreview(c.get("user").id, c.req.param("id"), c.req.param("stepId"));
+    return c.body(new TextEncoder().encode(html), 200, {
+        "content-type": "text/html; charset=utf-8",
+        "content-security-policy": HTML_RESPONSE_CSP,
+        "cache-control": "no-store",
+    });
+})
+    // --- a runtime that runs alone: its keys, models and linked account -----------
+    .get("/api-keys", async (c) => (managed ? c.notFound() : c.json(await listLocalKeys())))
+    .post("/api-keys", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const { name } = z.object({ name: z.string().min(1).max(32) }).parse(await c.req.json());
+    return c.json(await createLocalKey(name));
+})
+    .delete("/api-keys/:id", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    await deleteLocalKey(c.req.param("id"));
+    return c.json({ ok: true });
+})
+    .get("/local/models", (c) => (managed ? c.notFound() : c.json(localModelSettings())))
+    .put("/local/models", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const body = z
+        .object({
+        source: z.enum([...HARNESS_IDS, "account", "own"]).optional(),
+        bindings: z.partialRecord(z.enum(MODEL_CLASSES), z.string().max(120)).optional(),
+        ollamaUrl: z.string().max(200).optional(),
+        keys: z.partialRecord(z.enum(LOCAL_KEYS), z.string().max(400)).optional(),
+    })
+        .parse(await c.req.json());
+    await saveLocalModels(body);
+    return c.json(localModelSettings());
+})
+    // One short call on a class, as a run would make it: shows that the way to the model is open.
+    .post("/local/models/test", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const { cls } = z
+        .object({ cls: z.enum(TEXT_CLASSES).default("classifier") })
+        .parse(await c.req.json().catch(() => ({})));
+    const started = Date.now();
+    // The source this call runs on: the person may pick another one while it is under way.
+    const source = localModelSettings().source;
+    try {
+        const resolved = await textModel(cls);
+        const result = await generateText({
+            model: resolved.model,
+            prompt: "Reply with the single word: OK",
+            maxOutputTokens: 20,
+            abortSignal: AbortSignal.timeout(120_000),
+        });
+        // A working call is what ends the setup — for the source it ran on.
+        const tested = await testedSources();
+        if (!tested.includes(source)) {
+            await writeSetting("setup-done", [...tested, source]);
+        }
+        return c.json({
+            ok: true,
+            ref: resolved.ref,
+            reply: result.text.trim().slice(0, 200),
+            ms: Date.now() - started,
+        });
+    }
+    catch (err) {
+        const message = err?.message ?? String(err);
+        return c.json({ ok: false, error: message.slice(0, 500), ms: Date.now() - started });
+    }
+})
+    // --- the AI clients on this machine: looked at afresh, signed in through the inline terminal ----
+    .post("/local/harness/:id/detect", async (c) => {
+    const id = c.req.param("id");
+    if (managed || !harness(id)) {
+        return c.notFound();
+    }
+    return c.json({ harness: await detectHarness(id, true) });
+})
+    .post("/local/harness/:id/install", async (c) => {
+    const spec = managed ? null : await installSpec(c.req.param("id"));
+    if (!spec) {
+        return c.notFound();
+    }
+    const { cols, rows } = terminalSize.parse(await c.req.json().catch(() => ({})));
+    const cwd = join(env.dataDir, "harness");
+    mkdirSync(cwd, { recursive: true });
+    // The page asks again once the command is over: then the client is there, or its output says why not.
+    const terminal = await openTerminal({ ...spec, cwd, cols, rows });
+    return c.json({ terminal });
+})
+    .post("/local/harness/:id/login", async (c) => {
+    const id = c.req.param("id");
+    const client = harness(id);
+    if (managed || !client) {
+        return c.notFound();
+    }
+    const { cols, rows } = terminalSize.parse(await c.req.json().catch(() => ({})));
+    const cwd = join(env.dataDir, "harness");
+    mkdirSync(cwd, { recursive: true });
+    const terminal = await openTerminal({
+        bin: client.bin,
+        args: client.login.args,
+        cwd,
+        env: { ...(await loginEnv(client)), ...client.login.env },
+        cols,
+        rows,
+        // Signed in: the client says so on its own, and the settings learn it right away.
+        until: async () => (await freshAuth(client)) !== "none",
+        onDone: () => void detectHarness(id, true),
+    });
+    return c.json({ terminal });
+})
+    .get("/local/terminal/:id/stream", (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const id = c.req.param("id");
+    return streamSSE(c, async (stream) => {
+        let ended = false;
+        // One write after the other, and all of them out before the stream ends: the last one is
+        // the exit, and a page that comes after the end gets everything at once.
+        let written = Promise.resolve();
+        const done = new Promise((resolve) => {
+            const unsubscribe = subscribeTerminal(id, (event) => {
+                written = written.then(() => stream.writeSSE({ event: event.type, data: JSON.stringify(event) }));
+                if (event.type === "exit") {
+                    ended = true;
+                    resolve();
+                }
+            });
+            stream.onAbort(() => {
+                unsubscribe();
+                resolve();
+            });
+        });
+        // The page keeps the stream open while the terminal lives; a heartbeat keeps proxies from closing it.
+        const beat = setInterval(() => {
+            if (!ended) {
+                void stream.writeSSE({ event: "ping", data: "" });
+            }
+        }, 15_000);
+        await done;
+        clearInterval(beat);
+        await written;
+    });
+})
+    .post("/local/terminal/:id/input", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const { data } = z.object({ data: z.string().max(10_000) }).parse(await c.req.json());
+    writeTerminal(c.req.param("id"), data);
+    return c.json({ ok: true });
+})
+    .post("/local/terminal/:id/resize", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const { cols, rows } = z
+        .object({ cols: z.number().int().min(10).max(500), rows: z.number().int().min(4).max(200) })
+        .parse(await c.req.json());
+    resizeTerminal(c.req.param("id"), cols, rows);
+    return c.json({ ok: true });
+})
+    .delete("/local/terminal/:id", (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    closeTerminal(c.req.param("id"));
+    return c.json({ ok: true });
+})
+    .put("/local/chat", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    const { engine } = z.object({ engine: z.enum(["models", "claude"]) }).parse(await c.req.json());
+    await setChatEngine(engine);
+    return c.json({ ok: true });
+})
+    .post("/account/link", async (c) => (managed ? c.notFound() : c.json({ url: await startLink() })))
+    .delete("/account", async (c) => {
+    if (managed) {
+        return c.notFound();
+    }
+    await unlink();
+    await saveLocalModels({ source: "own" });
+    return c.json({ ok: true });
+});