@engenty/wizards-runtime 0.0.0-stage → 0.7.5

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

@@ -0,0 +1,16 @@
+import { eq } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+import { dropLinks, dropRuns } from "../tenants/control.js";
+/** Takes a wizard's public tokens and its runs out of the control database. */
+export async function forgetWizardLinks(wizardId) {
+    const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, wizardId) });
+    const runs = await db
+        .select({ id: schema.run.id, shareToken: schema.run.shareToken })
+        .from(schema.run)
+        .where(eq(schema.run.wizardId, wizardId));
+    await dropLinks([
+        ...(w ? [w.shareToken] : []),
+        ...runs.map((r) => r.shareToken).filter((t) => Boolean(t)),
+    ]);
+    await dropRuns(runs.map((r) => r.id));
+}

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

@@ -0,0 +1,492 @@
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
+import { DEFINITION_VERSION, readable, wizardSchema, } from "@engenty-wizards/shared/definition";
+import { capabilitiesOf, costTierOf, effortOf, formatsOf, MARKETPLACE_LANGS, pluginsOf, } from "@engenty-wizards/shared/marketplace";
+import { wizardOutline } from "@engenty-wizards/shared/marketplace-entry";
+import { searchEntries } from "@engenty-wizards/shared/marketplace-search";
+import { note } from "@engenty-wizards/shared/run";
+import { and, eq, inArray, notInArray } from "drizzle-orm";
+import { formulaEstimate } from "../credits/estimate.js";
+import { control, controlDb, db, schema, withTenant } from "../db/client.js";
+import { missingCapabilities, optionalCapabilities, stepsWithoutModel, } from "../engine/requirements.js";
+import { env } from "../env.js";
+import { managed } from "../manage.js";
+import { classCatalog, imageCostUsd, tokenCostUsd, videoCostUsd, WEB_SEARCH_COST_USD, } from "../models.js";
+import { pluginIdsOf, pluginStartersOf } from "../plugins/registry.js";
+import { readSetting, writeSetting } from "../settings.js";
+import { currentTenant, LOCAL_TENANT } from "../tenants/tenant.js";
+import { ServiceError } from "./errors.js";
+/**
+ * The marketplace is an app of its own; this runtime is one of its clients
+ * (docs/marketplace-contract.md). It searches the marketplace live and starts wizards from its
+ * entries. Its starters and what people starred are kept in the control database, so the list
+ * and starting a wizard work without a connection too.
+ *
+ * Beside them stand the starters the tenant's plugins bring (docs/content/dev/plugins/starters.md),
+ * listed first and never fetched. They are known as `<plugin id>.<starter id>`; a marketplace
+ * entry's id has no dot, so the two never meet.
+ */
+export const asLang = (raw) => MARKETPLACE_LANGS.includes(raw ?? "") ? raw : "en";
+/** A search waits this long for the marketplace; then it searches what is kept here. */
+const TIMEOUT_MS = 5000;
+/** One call to the marketplace's API; null without an answer, or with an error. */
+async function call(path, init) {
+    if (!env.marketplace.url) {
+        return null;
+    }
+    try {
+        const res = await fetch(`${env.marketplace.url}/api/v1${path}`, {
+            ...init,
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            return null;
+        }
+        return res.status === 204 ? {} : (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+// --- stars: a person's own, in the tenant's database ------------------------------------
+async function starredIds() {
+    const rows = await db
+        .select({ id: schema.marketplaceStar.entryId })
+        .from(schema.marketplaceStar)
+        .orderBy(schema.marketplaceStar.createdAt);
+    return rows.map((r) => r.id);
+}
+/** Stars an entry or takes the star away; a starred entry is kept for offline use. */
+export async function starEntry(tenantId, entryId, on) {
+    if (on) {
+        await db.insert(schema.marketplaceStar).values({ tenantId, entryId }).onConflictDoNothing();
+    }
+    else {
+        await db
+            .delete(schema.marketplaceStar)
+            .where(and(eq(schema.marketplaceStar.tenantId, tenantId), eq(schema.marketplaceStar.entryId, entryId)));
+    }
+    // What is kept follows at once, beside the request.
+    void syncMarketplace(true).catch(() => undefined);
+}
+// --- what is kept for offline use --------------------------------------------------------
+async function kept(ids) {
+    const rows = await controlDb
+        .select({ entry: control.marketplaceCache.entry })
+        .from(control.marketplaceCache)
+        .where(ids ? inArray(control.marketplaceCache.id, ids) : undefined);
+    return rows.map((r) => r.entry);
+}
+/** The words of a kept entry in a language: a translation where it has one, else its own. */
+function textIn(e, lang) {
+    return e.texts.find((t) => t.language === lang) ?? e.texts.find((t) => t.language === e.language);
+}
+function keptSummary(e, lang) {
+    const { texts: _texts, files: _files, ...summary } = e;
+    const text = textIn(e, lang);
+    return text
+        ? { ...summary, language: text.language, title: text.title, pitch: text.pitch }
+        : summary;
+}
+function keptItem(e, lang) {
+    const text = textIn(e, lang);
+    return text ? { ...keptSummary(e, lang), definition: text.definition, files: e.files } : null;
+}
+// --- the plugins' starters ------------------------------------------------------------------
+/** One of the starters the tenant's plugins bring, by its id; undefined for any other id. */
+async function pluginStarter(id) {
+    if (!id.includes(".")) {
+        return undefined;
+    }
+    return (await pluginStartersOf(currentTenant())).find((s) => s.id === id);
+}
+/** A plugin's starter as the marketplace lists an entry, read from its definition. */
+function pluginSummary({ id, plugin, starter }) {
+    const definition = starter.definition;
+    const { name, version } = plugin.source.manifest;
+    const capabilities = capabilitiesOf(definition);
+    const changed = statSync(plugin.source.entry ?? plugin.source.root, { throwIfNoEntry: false });
+    return {
+        id,
+        revision: 0,
+        hash: createHash("sha256")
+            .update(`${version}\n${JSON.stringify(definition)}`)
+            .digest("hex")
+            .slice(0, 16),
+        updatedAt: (changed?.mtime ?? new Date()).toISOString(),
+        starter: true,
+        language: starter.language ?? "en",
+        title: starter.title,
+        pitch: starter.description,
+        // Found by the plugin's name as well: "Termine" finds the appointment plugin's starters.
+        terms: [name],
+        avatar: definition.avatar,
+        formats: formatsOf(definition),
+        industries: ["any"],
+        useCases: [],
+        capabilities,
+        effort: effortOf(definition),
+        costTier: costTierOf(capabilities),
+        steps: definition.steps.length,
+        version: definition.version,
+        plugins: [plugin.source.id],
+        plan: "pro",
+    };
+}
+/** A plugin's starter as this app shows it: never starred, and marked with its plugin. */
+function pluginEntry(found, unavailable) {
+    const { id, name } = found.plugin.source.manifest;
+    return {
+        ...asEntry(pluginSummary(found), new Set(), unavailable, optionalOf(found.starter.definition)),
+        plugin: { id, name },
+    };
+}
+/** Two searches' counts per option, added up. */
+function addFacets(a, b) {
+    const add = (x = {}, y = {}) => {
+        const out = { ...x };
+        for (const [key, n] of Object.entries(y)) {
+            out[key] = (out[key] ?? 0) + n;
+        }
+        return out;
+    };
+    return {
+        useCase: add(a.useCase, b.useCase),
+        industry: add(a.industry, b.industry),
+        format: add(a.format, b.format),
+        capability: add(a.capability, b.capability),
+        plan: add(a.plan, b.plan),
+    };
+}
+/**
+ * The marketplace's entries as this tenant sees them: an entry that stands for a starter of a
+ * plugin it has is left out (the plugin's own is listed), and the others say which plugins they
+ * need that it does not have.
+ */
+async function withPlugins(entries) {
+    if (!entries.some((e) => e.plugins?.length || e.pluginStarter)) {
+        return entries;
+    }
+    const tenant = currentTenant();
+    const [have, starters] = await Promise.all([
+        pluginIdsOf(tenant),
+        pluginStartersOf(tenant).then((list) => new Set(list.map((s) => s.id))),
+    ]);
+    return entries.flatMap((e) => {
+        if (e.pluginStarter && starters.has(e.pluginStarter)) {
+            return [];
+        }
+        const needs = (e.plugins ?? []).filter((id) => !have.has(id));
+        return [needs.length ? { ...e, needs } : e];
+    });
+}
+// --- searching -----------------------------------------------------------------------------
+/** A summary as this app shows it: whether it can read and run it, and whether it is starred. */
+function asEntry(summary, starred, unavailable, optional = new Set()) {
+    const lacking = summary.capabilities.filter((c) => unavailable.has(c));
+    return {
+        ...summary,
+        credits: null,
+        usable: summary.version <= DEFINITION_VERSION,
+        starred: starred.has(summary.id),
+        missing: lacking.filter((c) => !optional.has(c)),
+        optional: lacking.filter((c) => optional.has(c)),
+    };
+}
+/** What only some paths of a wizard need; nothing where it cannot be read. */
+function optionalOf(definition) {
+    return readable(definition)
+        ? optionalCapabilities(wizardSchema.parse(definition))
+        : new Set();
+}
+/**
+ * Per entry, what only some of its paths need, read from the wizards kept here (the starters
+ * and what is starred); an entry not kept counts everything it needs as needed.
+ */
+async function keptOptional(ids, lang, unavailable) {
+    const out = new Map();
+    if (!(unavailable.size && ids.length)) {
+        return out;
+    }
+    for (const e of await kept(ids)) {
+        const text = textIn(e, lang);
+        if (text) {
+            out.set(e.id, optionalOf(text.definition));
+        }
+    }
+    return out;
+}
+/**
+ * Searches the tenant's plugins' starters and the marketplace, in that order: a page holds the
+ * plugins' starters the words and filters find, then the marketplace's entries.
+ */
+export async function searchMarketplace(search) {
+    const { q = "", starred, limit = 60, offset = 0, lang: _lang, ...filters } = search;
+    const own = starred ? [] : await pluginStartersOf(currentTenant());
+    if (!own.length) {
+        return searchListed(search);
+    }
+    const byId = new Map(own.map((s) => [s.id, s]));
+    const found = searchEntries(own.map(pluginSummary), q, filters, { limit: own.length });
+    const shown = found.entries.slice(offset, offset + limit);
+    // The marketplace fills what is left of the page, and counts from where its entries begin.
+    const room = limit - shown.length;
+    const listed = await searchListed({
+        ...search,
+        limit: Math.max(1, room),
+        offset: Math.max(0, offset - found.total),
+    });
+    const unavailable = new Set(listed.unavailable);
+    return {
+        ...listed,
+        entries: [
+            ...shown.flatMap((e) => {
+                const entry = byId.get(e.id);
+                return entry ? [pluginEntry(entry, unavailable)] : [];
+            }),
+            ...listed.entries.slice(0, room),
+        ],
+        total: found.total + listed.total,
+        all: own.length + listed.all,
+        facets: addFacets(listed.facets, found.facets),
+    };
+}
+/**
+ * The gallery for someone not signed in (the studio's start page for guests): what the
+ * marketplace lists, without a tenant's stars and plugins. An entry that needs a plugin says so.
+ */
+export function searchMarketplaceAsGuest(search) {
+    return searchListed(search, true);
+}
+/** Searches the marketplace; without an answer, what is kept here, scored the same way. */
+async function searchListed(search, guest = false) {
+    const { q = "", lang, starred: onlyStarred, limit = 60, offset = 0, ...filters } = search;
+    const stars = guest ? [] : await starredIds();
+    const starred = new Set(stars);
+    const unavailable = guest ? new Set() : await missingCapabilities();
+    const plugged = (entries) => guest
+        ? entries.map((e) => (e.plugins?.length ? { ...e, needs: e.plugins } : e))
+        : withPlugins(entries);
+    const params = new URLSearchParams({ lang, limit: String(limit), offset: String(offset) });
+    if (onlyStarred) {
+        params.set("ids", stars.join(","));
+    }
+    else {
+        if (q.trim()) {
+            params.set("q", q.trim());
+        }
+        for (const [key, value] of Object.entries(filters)) {
+            if (value) {
+                params.set(key, value);
+            }
+        }
+    }
+    const remote = onlyStarred && !stars.length
+        ? { entries: [], total: 0, all: 0, facets: { useCase: {}, industry: {}, format: {} } }
+        : await call(`/entries?${params}`);
+    if (remote) {
+        const optional = await keptOptional(remote.entries.map((e) => e.id), lang, unavailable);
+        return {
+            ...remote,
+            entries: await plugged(remote.entries.map((e) => asEntry(e, starred, unavailable, optional.get(e.id)))),
+            offline: false,
+            unavailable: [...unavailable],
+        };
+    }
+    const local = (await kept(onlyStarred ? stars : undefined)).map((e) => keptSummary(e, lang));
+    const page = onlyStarred
+        ? searchEntries(local, "", {}, { limit, offset })
+        : searchEntries(local, q, filters, { limit, offset });
+    const optional = await keptOptional(page.entries.map((e) => e.id), lang, unavailable);
+    return {
+        ...page,
+        entries: await plugged(page.entries.map((e) => asEntry(e, starred, unavailable, optional.get(e.id)))),
+        offline: true,
+        unavailable: [...unavailable],
+    };
+}
+// --- one entry -----------------------------------------------------------------------------
+/** An entry with its wizard: from the marketplace, else from what is kept here. */
+async function fetchItem(id, lang) {
+    const remote = await call(`/entries/${encodeURIComponent(id)}?lang=${encodeURIComponent(lang)}`);
+    if (remote) {
+        return remote;
+    }
+    const [local] = await kept([id]);
+    return local ? keptItem(local, lang) : null;
+}
+const CREDITS_PER_USD = 100;
+/**
+ * Prices for a runtime that has no gateway to ask: what the models each class is bound to by
+ * default cost at their list price, in credits. An estimate needs a number even where a run is
+ * paid for another way.
+ */
+function listPrices() {
+    const text = (ref) => ({
+        model: ref,
+        kind: "text",
+        inputCreditsPerMTok: tokenCostUsd(ref, { inputTokens: 1e6 }) * CREDITS_PER_USD,
+        outputCreditsPerMTok: tokenCostUsd(ref, { outputTokens: 1e6 }) * CREDITS_PER_USD,
+    });
+    const m = env.models;
+    return {
+        markup: 1,
+        webSearchCredits: WEB_SEARCH_COST_USD * CREDITS_PER_USD,
+        classes: {
+            classifier: text(m.classifier),
+            standard: text(m.standard),
+            high: text(m.high),
+            highest: text(m.highest),
+            image: {
+                model: m.image,
+                kind: "image",
+                creditsPerImage: imageCostUsd(m.image) * CREDITS_PER_USD,
+            },
+            video: {
+                model: m.video,
+                kind: "video",
+                creditsPerSecond: videoCostUsd(m.video, 1) * CREDITS_PER_USD,
+            },
+        },
+    };
+}
+/** What a run costs: at the gateway's prices where there is one, else at list prices. */
+async function priced(definition) {
+    const catalog = await classCatalog().catch(() => null);
+    const price = formulaEstimate(definition, catalog ?? listPrices(), await stepsWithoutModel(definition));
+    return { credits: Math.round(price.credits), high: price.high };
+}
+/** An entry in a language with its wizard read against this app; null where there is none. */
+export async function marketplaceDetail(id, lang) {
+    const own = await pluginStarter(id);
+    if (own) {
+        const definition = own.starter.definition;
+        return {
+            ...pluginEntry(own, await missingCapabilities()),
+            credits: await priced(definition),
+            ...wizardOutline(definition, Object.keys(own.starter.files ?? {}), lang),
+        };
+    }
+    const found = await fetchItem(id, lang);
+    if (!found) {
+        return null;
+    }
+    const { definition, files, ...summary } = found;
+    const entry = asEntry(summary, new Set(await starredIds()), await missingCapabilities(), optionalOf(definition));
+    const parsed = readable(definition) ? wizardSchema.parse(definition) : null;
+    if (!parsed) {
+        return {
+            ...entry,
+            usable: false,
+            description: "",
+            outline: [],
+            results: [],
+            files: Object.keys(files),
+        };
+    }
+    return {
+        ...entry,
+        credits: await priced(parsed),
+        ...wizardOutline(parsed, Object.keys(files), lang),
+    };
+}
+/** An entry's wizard and workspace in a language: what a wizard is made from. */
+export async function marketplaceWizard(id, lang) {
+    const own = await pluginStarter(id);
+    if (own) {
+        // A plugin's starter is in its one language, whatever is asked for.
+        const { starter, plugin } = own;
+        return {
+            id,
+            revision: null,
+            plugin: plugin.source.id,
+            title: starter.title,
+            language: starter.language ?? "en",
+            definition: structuredClone(starter.definition),
+            files: Object.fromEntries(Object.entries(starter.files ?? {}).map(([path, data]) => [
+                path,
+                typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data),
+            ])),
+        };
+    }
+    const found = await fetchItem(id, lang);
+    if (!found) {
+        return null;
+    }
+    if (!readable(found.definition)) {
+        throw new ServiceError("refused", note("templateNeedsNewerVersion"));
+    }
+    // A wizard whose plugins are not here would stop at its first step that uses them.
+    const have = await pluginIdsOf(currentTenant());
+    const needs = pluginsOf(wizardSchema.parse(found.definition)).filter((p) => !have.has(p));
+    if (needs.length) {
+        throw new ServiceError("refused", note("templateNeedsPlugins", { count: needs.length, plugins: needs }));
+    }
+    return {
+        id: found.id,
+        revision: found.revision,
+        title: found.title,
+        language: found.language,
+        definition: wizardSchema.parse(found.definition),
+        files: Object.fromEntries(Object.entries(found.files).map(([path, data]) => [path, Buffer.from(data, "base64")])),
+    };
+}
+/** Tells the marketplace a wizard was made from an entry. */
+export async function countInstall(id) {
+    await call(`/entries/${encodeURIComponent(id)}/installs`, { method: "POST" });
+}
+// --- keeping the starters and the starred ones ----------------------------------------------
+// Not the key the copying into the database used before: the first look after an update is
+// not held back.
+const SYNCED = "marketplace:kept";
+const SYNC_EVERY_MS = 3600_000;
+let syncing = null;
+/** The stars that count for what is kept: a runtime that runs alone has one person's. */
+async function keptStars() {
+    return managed ? [] : withTenant(LOCAL_TENANT, starredIds);
+}
+async function takeOver() {
+    const list = await call(`/sync?ids=${encodeURIComponent((await keptStars()).join(","))}`);
+    if (!list?.items) {
+        return;
+    }
+    const have = await controlDb
+        .select({ id: control.marketplaceCache.id, hash: control.marketplaceCache.hash })
+        .from(control.marketplaceCache);
+    for (const item of list.items) {
+        if (have.some((h) => h.id === item.id && h.hash === item.hash)) {
+            continue;
+        }
+        const entry = await call(`/entries/${encodeURIComponent(item.id)}/export`);
+        if (!entry) {
+            continue;
+        }
+        const values = { id: entry.id, hash: entry.hash, entry, fetchedAt: new Date() };
+        await controlDb
+            .insert(control.marketplaceCache)
+            .values(values)
+            .onConflictDoUpdate({ target: control.marketplaceCache.id, set: values });
+    }
+    // What the marketplace no longer lists here is not kept either.
+    await controlDb.delete(control.marketplaceCache).where(notInArray(control.marketplaceCache.id, list.items.map((i) => i.id)));
+    await writeSetting(SYNCED, Date.now());
+}
+/**
+ * Keeps the marketplace's starters and the starred entries, by hash: an entry is fetched again
+ * only when it changed. At most once an hour unless forced.
+ */
+export async function syncMarketplace(force = false) {
+    if (!env.marketplace.url) {
+        return;
+    }
+    const last = await readSetting(SYNCED);
+    if (!force && last && Date.now() - last < SYNC_EVERY_MS) {
+        return;
+    }
+    syncing ??= takeOver()
+        .catch((err) => console.error("[marketplace]", err.message))
+        .finally(() => {
+        syncing = null;
+    });
+    await syncing;
+}

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;
+    }
+}