wizards 0.3.7 → 0.4.0

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

@@ -1,6 +1,6 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { ASSISTANT_LAYOUTS, ASSISTANT_PAGE_BYTES, assistantTurnSchema, } from "@engenty-wizards/shared/assistant";
+import { ASSISTANT_LAYOUTS, ASSISTANT_PAGE_BYTES, assistantSignalSchema, assistantTurnSchema, } from "@engenty-wizards/shared/assistant";
 import { MODEL_CLASSES, TEXT_CLASSES, } from "@engenty-wizards/shared/definition";
 import { CATEGORY_TYPES, whereSchema } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
@@ -11,10 +11,11 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-import { runStudioAssistant } from "../agents/studio-assistant.js";
+import { runStudioAssistant, signalText } from "../agents/studio-assistant.js";
 import { chatEngine, setChatEngine, subscriptionClients } from "../agents/subscription.js";
 import { scanColors, scanFonts, scanImages, scanLogos } from "../agents/website.js";
 import { answerBrowser, awaitBrowser } from "../assistant/browser.js";
+import { endRun, signalRun, startRun, takeSignals } from "../assistant/runs.js";
 import { accountOverview, linkedAccount, startLink, unlink } from "../auth/account.js";
 import { createLocalKey, deleteLocalKey, listLocalKeys } from "../auth/keys.js";
 import { appStates, connectApps } from "../cli/connect.js";
@@ -29,14 +30,14 @@ import { appleStatus } from "../harness/apple.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, tenantInfo, tenantMembers, userFeatures } from "../manage.js";
+import { installMail, managed, renameTenant, tenantInfo, tenantMembers, userInfo, } from "../manage.js";
 import { seenApps } from "../mcp/seen.js";
 import { generateImageMedia, generateSpeechMedia, generateVideoMedia } from "../media/generate.js";
 import { transcribeAudio } from "../media/transcribe.js";
 import { checkKey, classProblem, classWays, embeddingModel, hasTextModel, LOCAL_KEYS, localModelSettings, ModelUnavailableError, modelSettings, saveLocalModels, saveModels, storedKey, textModel, } from "../models.js";
 import { refreshPro } from "../plugins/pro.js";
 import { HTML_RESPONSE_CSP } from "../render/guard.js";
-import { isAdminRole, mayBuild, mayCreate, projectWritable, requireWritable, } from "../services/access.js";
+import { isAdminRole, mayBuild, mayCreate, projectWritable, requireAdmin, requireWritable, } from "../services/access.js";
 import { architectTurn } from "../services/architect.js";
 import { addMessage, assistantLayout, currentChat, earlierChats, foldChat, newChat, openChat, readChat, turnHistory, } from "../services/assistant-chats.js";
 import { checkForCloud, cloudLinked, cloudSpaces, cloudState, forgetCloud, publishAndSync, pushSharing, removeFromCloud, replaceCloudSpaces, rotateInCloud, syncToCloud, } from "../services/cloud.js";
@@ -44,6 +45,7 @@ import { notFound, ServiceError } from "../services/errors.js";
 import { deleteFile, listFiles, readFile, writeFile } from "../services/files.js";
 import { categoryContents, listKnowledge, resolvePath, valueContents, } from "../services/knowledge.js";
 import { writeSummary } from "../services/knowledge-model.js";
+import { applyWebsite, finishOnboarding, needsOnboarding } from "../services/onboarding.js";
 import { exportWizard, importWizard } from "../services/package.js";
 import { profileSchema, saveProfile, userProfile } from "../services/profile.js";
 import { addProjectFile, addProjectFileFromUrl, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
@@ -190,6 +192,10 @@ async function testClass(cls, lang) {
     }
 }
 /** The size of an inline terminal, as the page lays it out. */
+/** Whether the studio assistant's developer mode is offered to this person. */
+async function assistantDevFor(user) {
+    return managed ? (await userInfo(user.id)).admin : env.assistantDev;
+}
 const terminalSize = z.object({
     cols: z.number().int().min(10).max(500).optional(),
     rows: z.number().int().min(4).max(200).optional(),
@@ -203,7 +209,7 @@ export const studio = new Hono()
     const profile = await userProfile(user);
     // What the Manage-App says of the tenant: its plan and feature switches; and of the person.
     const info = managed ? await tenantInfo(user.tenantId).catch(() => null) : null;
-    const own = managed ? await userFeatures(user.id) : null;
+    const person = managed ? await userInfo(user.id) : null;
     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. */
@@ -215,7 +221,9 @@ export const studio = new Hono()
             plan: info?.plan ?? null,
         },
         /** The feature switches: the code's defaults, what the Manage-App says of the team and the person, this install's file. */
-        features: features(managed ? { ...info?.features, ...own } : overview?.tenant.features),
+        features: features(managed ? { ...info?.features, ...person?.features } : overview?.tenant.features),
+        /** The studio assistant's developer mode may be switched on: ASSISTANT_DEV here, the platform's admins when managed. */
+        assistantDev: await assistantDevFor(user),
         mode: managed ? "managed" : "local",
         /** The tenant's balance; null where the runtime resolves models itself. */
         credits: managed ? await balanceCredits() : null,
@@ -225,6 +233,8 @@ export const studio = new Hono()
             ? {
                 name: linked.name,
                 email: linked.email,
+                /** The team the account's space belongs to, as the Manage-App names it. */
+                team: overview?.tenant.name ?? null,
                 credits: overview?.tenant.balanceCredits ?? null,
                 /** What of the credits ends on a date, the nearest first. */
                 expiring: overview?.tenant.expiring ?? [],
@@ -242,6 +252,8 @@ export const studio = new Hono()
         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(),
+        /** The cloud studio's first visit: the short wizard that names the team and fills the space (services/onboarding.ts). */
+        onboarding: await needsOnboarding(user),
         /** 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),
@@ -317,6 +329,12 @@ export const studio = new Hono()
     }
     const voice = await generateSpeechMedia({ text, abortSignal: c.req.raw.signal });
     return c.body(new Uint8Array(voice.bytes), 200, { "content-type": voice.mime });
+})
+    // A message written while a turn runs: the turn takes it before its next step or after its answer.
+    .post("/assistant/run/:runId/signal", async (c) => {
+    const body = assistantSignalSchema.parse(await c.req.json());
+    const taken = signalRun(c.get("user").id, c.req.param("runId"), body);
+    return c.json({ ok: taken }, taken ? 200 : 404);
 })
     // A browser tool's result: the turn that waits for it goes on.
     .post("/assistant/tool/:callId", async (c) => {
@@ -339,53 +357,100 @@ export const studio = new Hono()
         ? { route: body.page.route, title: body.page.title, view: body.page.view }
         : (body.page ?? null);
     const chat = await openChat(user);
-    const history = await turnHistory(user, chat);
+    const debug = Boolean(body.debug) && (await assistantDevFor(user));
+    let history = await turnHistory(user, chat);
     const runId = nanoid(10);
     const userMessageId = await addMessage(chat.id, {
         role: "user",
         content: body.message,
         page: page ? { route: page.route, title: page.title } : null,
     });
+    startRun(runId, user.id);
     return streamSSE(c, async (stream) => {
         const abort = new AbortController();
         stream.onAbort(() => abort.abort());
         const send = (event, data) => stream.writeSSE({ event, data: JSON.stringify(data) });
-        const messageId = nanoid(14);
+        let messageId = nanoid(14);
         await send("run_started", { threadId: chat.id, runId, messageId: userMessageId });
+        // The answer's text since the last message written meanwhile.
         let reply = "";
+        let changed = false;
+        let steps = 0;
+        /** What the answer said and did up to messages written meanwhile; null when nothing. */
+        const storePart = async (before) => {
+            changed ||= before.changed;
+            return before.reply || before.toolCalls.length || before.cards.length
+                ? await addMessage(chat.id, { role: "assistant", content: before.reply, ...before })
+                : null;
+        };
+        /** The messages written meanwhile, after the part of the answer before them. */
+        const storeSignals = async (taken, answerId) => {
+            for (const [i, s] of taken.entries()) {
+                const stored = await addMessage(chat.id, { role: "user", content: s.message });
+                await send("signal", {
+                    ref: s.ref,
+                    messageId: stored,
+                    content: s.message,
+                    answerId: i === 0 ? answerId : null,
+                });
+            }
+            reply = "";
+            messageId = nanoid(14);
+        };
         try {
-            const result = await runStudioAssistant({
-                user,
-                chat,
-                history,
-                project,
-                writable,
-                message: body.message,
-                page,
-                browserTools: body.tools,
-                lang: body.lang,
-                signal: abort.signal,
-                onText: (delta) => {
-                    reply += delta;
-                    void send("text", { messageId, delta });
-                },
-                onActivity: (label) => void send("activity", { label }),
-                onChanged: () => void send("changed", {}),
-                onCard: (card) => void send("card", card),
-                onToolCall: (call) => void send("tool_call", call),
-                onToolResult: (result) => void send("tool_result", result),
-                callBrowser: (call) => awaitBrowser(user.id, call.toolCallId, abort.signal),
-            });
-            reply =
-                result.reply || (result.changed ? (body.lang === "de" ? "Erledigt." : "Done.") : "");
-            const stored = await addMessage(chat.id, {
-                role: "assistant",
-                content: reply,
-                cards: result.cards,
-                toolCalls: result.toolCalls,
-                changed: result.changed,
-            });
-            await send("done", { messageId: stored, reply, changed: result.changed });
+            let message = body.message;
+            for (;;) {
+                const result = await runStudioAssistant({
+                    user,
+                    chat,
+                    history,
+                    project,
+                    writable,
+                    message,
+                    page,
+                    browserTools: body.tools,
+                    lang: body.lang,
+                    signal: abort.signal,
+                    onText: (delta) => {
+                        reply += delta;
+                        void send("text", { messageId, delta });
+                    },
+                    onActivity: (label) => void send("activity", { label }),
+                    onChanged: () => void send("changed", {}),
+                    onCard: (card) => void send("card", card),
+                    onToolCall: (call) => void send("tool_call", call),
+                    onToolResult: (result) => void send("tool_result", result),
+                    callBrowser: (call) => awaitBrowser(user.id, call.toolCallId, abort.signal),
+                    takeSignals: () => takeSignals(runId),
+                    onSignal: async (taken, before) => storeSignals(taken, await storePart(before)),
+                    ...(debug
+                        ? {
+                            onPrompt: (prompt) => void send("prompt", prompt),
+                            onStep: (step) => void send("step", { ...step, step: ++steps }),
+                        }
+                        : {}),
+                });
+                // Written after the answer's last step: the turn goes on with it.
+                const left = takeSignals(runId);
+                if (!left.length || abort.signal.aborted) {
+                    changed ||= result.changed;
+                    reply = result.reply || (changed ? (body.lang === "de" ? "Erledigt." : "Done.") : "");
+                    const stored = await addMessage(chat.id, {
+                        role: "assistant",
+                        content: reply,
+                        cards: result.cards,
+                        toolCalls: result.toolCalls,
+                        changed: result.changed,
+                    });
+                    await send("done", { messageId: stored, reply, changed });
+                    break;
+                }
+                // The next answer knows this one: it is stored before the history is read again.
+                const answerId = await storePart(result);
+                history = await turnHistory(user, chat);
+                await storeSignals(left, answerId);
+                message = signalText(left);
+            }
         }
         catch (err) {
             console.error("[studio-assistant]", err);
@@ -400,6 +465,7 @@ export const studio = new Hono()
                         : "Something went wrong. Please try again.",
             });
         }
+        endRun(runId);
         // Older messages fold into the chat's running summary once enough have piled up.
         void foldChat(chat.id).catch((err) => console.error("[studio-assistant] fold:", err));
     });
@@ -1331,6 +1397,40 @@ export const studio = new Hono()
 })
     // The address the system browser opens: the account's sign-in, or — for someone without an
     // account — its sign-up page with the invitation code, which then goes on to the sign-in.
+    // --- the first visit of a cloud studio: who the team is, its website, first documents -----
+    .put("/team", async (c) => {
+    if (!managed) {
+        return c.json({ error: "not_managed" }, 404);
+    }
+    await requireAdmin();
+    const { name } = z.object({ name: z.string().trim().min(1).max(80) }).parse(await c.req.json());
+    const info = await renameTenant(c.get("user").tenantId, name);
+    return c.json({ name: info.name });
+})
+    .post("/onboarding/done", async (c) => {
+    if (!managed) {
+        return c.json({ error: "not_managed" }, 404);
+    }
+    await finishOnboarding(c.get("user").tenantId);
+    return c.json({ ok: true });
+})
+    .post("/projects/:id/website", async (c) => {
+    const user = c.get("user");
+    const project = await ownedProject(user.id, c.req.param("id"));
+    const { url } = z.object({ url: z.string().trim().min(3).max(400) }).parse(await c.req.json());
+    return c.json(await applyWebsite(user.id, project.id, url));
+})
+    // The install command and the first steps, mailed to the signed-in person by the Manage-App.
+    .post("/install-mail", async (c) => {
+    if (!managed) {
+        return c.json({ error: "not_managed" }, 404);
+    }
+    const { lang } = z
+        .object({ lang: z.enum(["de", "en"]).default("en") })
+        .parse(await c.req.json().catch(() => ({})));
+    await installMail(c.get("user").email, lang);
+    return c.json({ ok: true });
+})
     .post("/account/link", async (c) => {
     if (managed) {
         return c.notFound();

package/apps/runtime/dist/services/assistant-chats.js

@@ -9,8 +9,8 @@ import { ServiceError } from "./errors.js";
 import { trigramQuery } from "./project-index.js";
 /**
  * The studio assistant's chats: one open chat per person and tenant, the same on every page and
- * space. "New chat" closes it with a dense summary; every turn of the next one carries the
- * summaries of the last chats, and older ones are found with `searchChats`.
+ * space. "New chat" closes it at once and writes its dense summary meanwhile; every turn of the
+ * next one carries the summaries of the last chats, and older ones are found with `searchChats`.
  */
 /** Messages of the open chat a turn sends as they are; older ones live in its running summary. */
 export const TURN_MESSAGES = 12;
@@ -74,6 +74,7 @@ export async function addMessage(chatId, message) {
 }
 /** What a turn of the open chat carries besides the new message. */
 export async function turnHistory(user, chat) {
+    await closedSummaries(user);
     const all = await messagesOf(chat.id);
     const earlier = await db.query.assistantChat.findMany({
         where: and(mine(user), isNotNull(schema.assistantChat.closedAt)),
@@ -81,8 +82,11 @@ export async function turnHistory(user, chat) {
         limit: EARLIER_IN_TURN,
     });
     return {
+        // A part of an answer that only called tools (before a message written meanwhile) has no
+        // text: models refuse empty messages.
         messages: all
             .slice(chat.folded)
+            .filter((m) => m.content.trim())
             .slice(-TURN_MESSAGES)
             .map(({ role, content }) => ({ role, content })),
         running: chat.summary,
@@ -170,9 +174,45 @@ export async function foldChat(chatId) {
         .set({ summary, folded: upTo })
         .where(and(eq(schema.assistantChat.id, chat.id), eq(schema.assistantChat.folded, chat.folded)));
 }
+/** Summaries of chats "New chat" closed, still being written: by chat id, with whose chat it is. */
+const summarising = new Map();
+const whose = (user) => `${user.tenantId}:${user.id}`;
+/** Writes the summary and the title of a closed chat. */
+function summariseClosed(user, chat) {
+    const running = summarising.get(chat.id);
+    if (running) {
+        return running.done;
+    }
+    const done = (async () => {
+        const all = await messagesOf(chat.id);
+        const { title, summary } = await summarise(all.slice(chat.folded), chat.summary);
+        await db
+            .update(schema.assistantChat)
+            .set({ ...(title ? { title } : {}), summary })
+            .where(eq(schema.assistantChat.id, chat.id));
+    })()
+        .catch((err) => console.error("[assistant] summary of a closed chat:", err.message))
+        .finally(() => summarising.delete(chat.id));
+    summarising.set(chat.id, { user: whose(user), done });
+    return done;
+}
+/**
+ * Waits for the summaries of the person's closed chats: those being written, and any a stopped
+ * runtime left unwritten.
+ */
+export async function closedSummaries(user) {
+    const unwritten = await db.query.assistantChat.findMany({
+        where: and(mine(user), isNotNull(schema.assistantChat.closedAt), isNull(schema.assistantChat.summary)),
+    });
+    await Promise.all([
+        ...unwritten.map((chat) => summariseClosed(user, chat)),
+        ...[...summarising.values()].filter((s) => s.user === whose(user)).map((s) => s.done),
+    ]);
+}
 /**
- * "New chat": the open chat is summarised and closed (kept to read under "Earlier chats"), and
- * an empty one opens. An open chat without messages stays as it is.
+ * "New chat": the open chat is closed at once (kept to read under "Earlier chats", titled by its
+ * first question until its summary is written) and an empty one opens. An open chat without
+ * messages stays as it is.
  */
 export async function newChat(user) {
     const chat = await openChat(user);
@@ -180,11 +220,12 @@ export async function newChat(user) {
     if (!all.length) {
         return { id: chat.id, messages: [] };
     }
-    const { title, summary } = await summarise(all.slice(chat.folded), chat.summary);
+    const firstAsk = all.find((m) => m.role === "user")?.content ?? "";
     await db
         .update(schema.assistantChat)
-        .set({ title, summary, closedAt: new Date() })
+        .set({ title: firstAsk.replace(/\s+/g, " ").trim().slice(0, 60), closedAt: new Date() })
         .where(eq(schema.assistantChat.id, chat.id));
+    void summariseClosed(user, chat);
     const next = await openChat(user);
     return { id: next.id, messages: [] };
 }
@@ -199,6 +240,8 @@ export async function earlierChats(user, limit = 50) {
         id: c.id,
         title: c.title ?? "",
         summary: c.summary ?? "",
+        /** Its summary is still being written. */
+        summarising: summarising.has(c.id),
         startedAt: c.createdAt.toISOString(),
         closedAt: c.closedAt.toISOString(),
     }));

package/apps/runtime/dist/services/cloud.js

@@ -25,7 +25,7 @@ export async function cloudState(wizardId) {
 async function call(method, path, body, timeoutMs = 30_000) {
     const token = await accountToken();
     if (!token) {
-        throw new ServiceError("refused", "Das Konto ist nicht mehr angemeldet. Bitte neu anmelden.", {
+        throw new ServiceError("refused", "The account is signed out. Please sign in again.", {
             reason: "signed_out",
         });
     }
@@ -39,7 +39,7 @@ async function call(method, path, body, timeoutMs = 30_000) {
         signal: AbortSignal.timeout(timeoutMs),
     }).catch(() => null);
     if (!res) {
-        throw new ServiceError("refused", "Die Cloud ist gerade nicht erreichbar.", {
+        throw new ServiceError("refused", "The cloud is not reachable right now.", {
             reason: "unreachable",
         });
     }
@@ -49,7 +49,7 @@ async function call(method, path, body, timeoutMs = 30_000) {
 function refusal(answer, fallback) {
     const { error, reason, ...rest } = answer.body;
     const message = answer.status === 401
-        ? "Das Konto ist nicht mehr angemeldet. Bitte neu anmelden."
+        ? "The account is signed out. Please sign in again."
         : typeof error === "string" && error
             ? error
             : fallback;
@@ -213,7 +213,7 @@ export async function syncToCloud(userId, wizardId) {
     const w = await ownedWizard(userId, wizardId);
     const version = await publishedVersion(w);
     if (!version) {
-        throw new ServiceError("refused", "Bitte den Wizard zuerst veröffentlichen.");
+        throw new ServiceError("refused", "Publish the wizard first.");
     }
     const before = await cloudState(w.id);
     try {
@@ -231,7 +231,7 @@ export async function syncToCloud(userId, wizardId) {
             dailyRunLimit: w.dailyRunLimit,
         }, 120_000);
         if (!answer.ok || !answer.body.shareUrl) {
-            throw refusal(answer, "Die Cloud hat den Wizard nicht angenommen.");
+            throw refusal(answer, "The cloud did not take the wizard.");
         }
         const state = {
             copy: {
@@ -255,7 +255,7 @@ export async function syncToCloud(userId, wizardId) {
         const failed = {
             copy: before.copy,
             error: {
-                message: err instanceof ServiceError ? err.message : "Das Senden hat nicht geklappt.",
+                message: err instanceof ServiceError ? err.message : "Sending did not work.",
                 reason: err instanceof ServiceError ? err.data.reason : undefined,
                 at: now.toISOString(),
                 tries,
@@ -309,7 +309,7 @@ export async function rotateInCloud(userId, wizardId) {
     const w = await ownedWizard(userId, wizardId);
     const answer = await call("POST", `/spaces/${w.projectId}/wizards/${w.id}/rotate-link`);
     if (!answer.ok || !answer.body.shareUrl) {
-        throw refusal(answer, "Der Link in der Cloud ließ sich nicht erneuern.");
+        throw refusal(answer, "The link in the cloud could not be renewed.");
     }
     const next = {
         ...state,
@@ -416,7 +416,7 @@ export async function checkForCloud(userId, wizardId) {
         files: files.map((f) => f.path),
     });
     if (!answer.ok) {
-        throw refusal(answer, "Die Cloud hat nicht geantwortet.");
+        throw refusal(answer, "The cloud did not answer.");
     }
     const documents = await projectFiles(w.projectId, "document");
     return {
@@ -428,7 +428,7 @@ export async function checkForCloud(userId, wizardId) {
 export async function cloudSpaces() {
     const answer = await call("GET", "/spaces");
     if (!answer.ok) {
-        throw refusal(answer, "Die Cloud hat nicht geantwortet.");
+        throw refusal(answer, "The cloud did not answer.");
     }
     return answer.body.spaces ?? [];
 }
@@ -446,7 +446,7 @@ export async function replaceCloudSpaces(userId) {
         if (!mine.has(space.id)) {
             const answer = await call("DELETE", `/spaces/${space.id}`);
             if (!answer.ok) {
-                throw refusal(answer, "Das Projekt in der Cloud ließ sich nicht entfernen.");
+                throw refusal(answer, "The space in the cloud could not be removed.");
             }
         }
     }

package/apps/runtime/dist/services/onboarding.js

@@ -0,0 +1,152 @@
+import { readWebsite } from "../agents/website.js";
+import { managed } from "../manage.js";
+import { readSetting, writeSetting } from "../settings.js";
+import { isAdminRole } from "./access.js";
+import { addProjectFile, projectFiles } from "./project-files.js";
+import { listProjects, updateProject } from "./projects.js";
+/**
+ * The first visit of a team's studio in the cloud: a short wizard asks who the team is, reads
+ * its website into the space, takes first documents and explains the space. It shows once, to
+ * the people who may change the team, and never to a team that already has wizards; the mark
+ * that it is done sits in the control database under the tenant.
+ */
+const key = (tenantId) => `onboarding:${tenantId}`;
+export async function needsOnboarding(user) {
+    if (!managed || !isAdminRole(user.role)) {
+        return false;
+    }
+    if (await readSetting(key(user.tenantId))) {
+        return false;
+    }
+    const projects = await listProjects(user.id);
+    return projects.every((p) => p.wizardCount === 0);
+}
+export async function finishOnboarding(tenantId) {
+    await writeSetting(key(tenantId), { doneAt: new Date().toISOString() });
+}
+/** A hex colour as `#rrggbb`, or null when the value is no plain colour. */
+function hex(value) {
+    const v = value.trim().toLowerCase();
+    const six = v.match(/^#([0-9a-f]{6})\b/);
+    if (six) {
+        return `#${six[1]}`;
+    }
+    const three = v.match(/^#([0-9a-f]{3})\b/);
+    if (three) {
+        return `#${[...three[1]].map((c) => c + c).join("")}`;
+    }
+    const rgb = v.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (rgb) {
+        const part = (n) => Math.min(255, Number(n)).toString(16).padStart(2, "0");
+        return `#${part(rgb[1])}${part(rgb[2])}${part(rgb[3])}`;
+    }
+    return null;
+}
+/** Greys and near-whites say nothing about a brand. */
+function telling(color) {
+    const r = Number.parseInt(color.slice(1, 3), 16);
+    const g = Number.parseInt(color.slice(3, 5), 16);
+    const b = Number.parseInt(color.slice(5, 7), 16);
+    const spread = Math.max(r, g, b) - Math.min(r, g, b);
+    const light = (r + g + b) / 3;
+    return spread > 24 && light > 24 && light < 235;
+}
+/** A page title is often "Company – Slogan" or "Home | Company": the company's part of it. */
+export function companyOf(title) {
+    const parts = title
+        .split(/\s+[–—|·-]\s+|:\s+/)
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length < 2) {
+        return title.trim().slice(0, 120);
+    }
+    const generic = /^(home|start|startseite|willkommen|welcome)$/i;
+    const named = parts.filter((p) => !generic.test(p));
+    // The shortest telling part is the name; a slogan is longer.
+    return (named.sort((a, b) => a.length - b.length)[0] ?? parts[0]).slice(0, 120);
+}
+/** The first paragraph of the page's text that reads like prose, as the about text. */
+export function aboutOf(description, text) {
+    if (description.trim().length >= 40) {
+        return description.trim().slice(0, 600);
+    }
+    const paragraph = text
+        .split(/\n{2,}/)
+        .map((p) => p.replace(/^[#>*\-\s]+/, "").trim())
+        .find((p) => p.length >= 80 && !p.startsWith("[") && !/^!\[/.test(p));
+    return (paragraph ?? description.trim()).slice(0, 600);
+}
+/**
+ * Up to three brand colours out of what the site declares and uses: the theme colour first, then
+ * the stylesheet's named colours, then the most used ones; greys and near-whites left out.
+ */
+export function brandColors(brand) {
+    const candidates = [
+        ...(brand.themeColor ? [{ name: "Brand", value: brand.themeColor }] : []),
+        ...brand.variables,
+        ...brand.frequent.map((value, i) => ({ name: `Colour ${i + 1}`, value })),
+    ];
+    const colors = [];
+    for (const c of candidates) {
+        const value = hex(c.value);
+        if (value && telling(value) && !colors.some((x) => x.value === value)) {
+            colors.push({ name: c.name.replace(/^--/, "").slice(0, 120) || "Colour", value });
+        }
+        if (colors.length === 3) {
+            break;
+        }
+    }
+    return colors;
+}
+/**
+ * Reads a website into the space's Info & brand: the company's name, what it does, up to three
+ * of its colours and, where the space has none yet, its logo. What the assistant does on
+ * request, done once at the start without a model.
+ */
+export async function applyWebsite(userId, projectId, url) {
+    const reading = await readWebsite(url, AbortSignal.timeout(30_000));
+    const name = companyOf(reading.title || new URL(reading.url).hostname);
+    const about = aboutOf(reading.description, reading.text);
+    const colors = brandColors(reading.brand);
+    await updateProject(userId, projectId, {
+        brand: {
+            name,
+            ...(about ? { about } : {}),
+            ...(colors.length ? { colors } : {}),
+        },
+    });
+    let logo = false;
+    const first = reading.brand.logos[0];
+    if (first && (await projectFiles(projectId, "logo")).length === 0) {
+        logo = await fetchLogo(projectId, first.url, first.hint);
+    }
+    return { name, about: Boolean(about), colors: colors.length, logo };
+}
+const LOGO_BYTES = 5 * 1024 * 1024;
+async function fetchLogo(projectId, url, hint) {
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+        const mime = res.headers.get("content-type")?.split(";")[0].trim().toLowerCase() ?? "";
+        if (!res.ok || !mime.startsWith("image/")) {
+            return false;
+        }
+        const data = new Uint8Array(await res.arrayBuffer());
+        if (data.byteLength === 0 || data.byteLength > LOGO_BYTES) {
+            return false;
+        }
+        const name = decodeURIComponent(new URL(url).pathname.split("/").pop() || "logo");
+        await addProjectFile(projectId, {
+            kind: "logo",
+            name,
+            mime,
+            data,
+            description: hint || undefined,
+            source: url,
+        });
+        return true;
+    }
+    catch {
+        // A logo that cannot be fetched is no loss: the person adds one under Space → Logos.
+        return false;
+    }
+}