wizards 0.1.9

package/apps/runtime/dist/services/draft-events.js

@@ -0,0 +1,27 @@
+import { EventEmitter } from "node:events";
+const bus = new EventEmitter();
+bus.setMaxListeners(0);
+export function emitDraftChanged(change) {
+    bus.emit(change.wizardId, change);
+}
+export function subscribeDraft(wizardId, listener) {
+    bus.on(wizardId, listener);
+    return () => bus.off(wizardId, listener);
+}
+/** Steps that are new or differ in `after`. */
+export function changedSteps(before, after) {
+    const old = new Map(before.steps.map((s) => [s.id, JSON.stringify(s)]));
+    return after.steps.filter((s) => old.get(s.id) !== JSON.stringify(s)).map((s) => s.id);
+}
+/** A workspace file was written or removed. Files carry no revision; the draft's is passed along. */
+export function filesChanged(w, path) {
+    return {
+        wizardId: w.id,
+        kind: "files",
+        revision: w.revision,
+        source: "studio",
+        client: null,
+        note: null,
+        touched: [path],
+    };
+}

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

@@ -0,0 +1,24 @@
+const STATUS = {
+    not_found: 404,
+    invalid: 400,
+    has_issues: 400,
+    revision_conflict: 409,
+    no_credits: 402,
+    refused: 400,
+};
+export class ServiceError extends Error {
+    code;
+    data;
+    constructor(code, message, data = {}) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    get status() {
+        return STATUS[this.code];
+    }
+    toJSON() {
+        return { error: this.message, code: this.code, ...this.data };
+    }
+}
+export const notFound = () => new ServiceError("not_found", "not found");

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

@@ -0,0 +1,129 @@
+import { cleanPath, isTextMime, mimeForPath, WORKSPACE_LIMITS, } from "@engenty-wizards/shared/workspace";
+import { and, asc, eq } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+import { getBlob, putBlob } from "../files/blobs.js";
+import { emitDraftChanged, filesChanged } from "./draft-events.js";
+import { notFound, ServiceError } from "./errors.js";
+import { ownedWizard } from "./wizards.js";
+/** The draft's workspace, sorted by path — the same shape publishing and runs snapshot. */
+export async function draftFiles(wizardId) {
+    const rows = await db.query.wizardFile.findMany({
+        where: eq(schema.wizardFile.wizardId, wizardId),
+        orderBy: [asc(schema.wizardFile.path)],
+    });
+    return rows.map(({ path, hash, mime, size }) => ({ path, hash, mime, size }));
+}
+export async function listFiles(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    return draftFiles(w.id);
+}
+function requirePath(raw) {
+    const path = cleanPath(raw);
+    if (!path) {
+        throw new ServiceError("invalid", `"${raw}" is not a valid file path (letters, digits, - _ . and /, no "..").`);
+    }
+    return path;
+}
+export async function readFile(userId, wizardId, rawPath) {
+    const w = await ownedWizard(userId, wizardId);
+    const path = requirePath(rawPath);
+    const row = await db.query.wizardFile.findFirst({
+        where: and(eq(schema.wizardFile.wizardId, w.id), eq(schema.wizardFile.path, path)),
+    });
+    if (!row) {
+        throw notFound();
+    }
+    return { file: row, data: await getBlob(row.hash) };
+}
+/** Reads a file as text for a model; binary files are described, not dumped. */
+export async function readFileText(userId, wizardId, rawPath) {
+    const { file, data } = await readFile(userId, wizardId, rawPath);
+    if (!isTextMime(file.mime)) {
+        return { path: file.path, mime: file.mime, size: file.size, text: null };
+    }
+    return { path: file.path, mime: file.mime, size: file.size, text: data.toString("utf8") };
+}
+export async function writeFile(userId, wizardId, rawPath, content, mime) {
+    const w = await ownedWizard(userId, wizardId);
+    const path = requirePath(rawPath);
+    const data = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
+    if (data.byteLength > WORKSPACE_LIMITS.fileBytes) {
+        throw new ServiceError("invalid", `${path} is larger than 5 MB.`);
+    }
+    const files = await draftFiles(w.id);
+    const others = files.filter((f) => f.path !== path);
+    if (others.length >= WORKSPACE_LIMITS.files) {
+        throw new ServiceError("invalid", "The workspace already holds 200 files.");
+    }
+    if (others.reduce((n, f) => n + f.size, 0) + data.byteLength > WORKSPACE_LIMITS.totalBytes) {
+        throw new ServiceError("invalid", "The workspace would be larger than 25 MB.");
+    }
+    const hash = await putBlob(data);
+    const file = {
+        path,
+        hash,
+        mime: mime && mime !== "application/octet-stream" ? mime : mimeForPath(path),
+        size: data.byteLength,
+    };
+    await db
+        .insert(schema.wizardFile)
+        .values({ wizardId: w.id, ...file })
+        .onConflictDoUpdate({
+        target: [schema.wizardFile.wizardId, schema.wizardFile.path],
+        set: { hash: file.hash, mime: file.mime, size: file.size, updatedAt: new Date() },
+    });
+    await touch(w.id);
+    emitDraftChanged(filesChanged(w, path));
+    return file;
+}
+export async function deleteFile(userId, wizardId, rawPath) {
+    const w = await ownedWizard(userId, wizardId);
+    const path = requirePath(rawPath);
+    const gone = await db
+        .delete(schema.wizardFile)
+        .where(and(eq(schema.wizardFile.wizardId, w.id), eq(schema.wizardFile.path, path)))
+        .returning({ path: schema.wizardFile.path });
+    if (!gone.length) {
+        throw notFound();
+    }
+    await touch(w.id);
+    emitDraftChanged(filesChanged(w, path));
+}
+/** Copies a workspace onto another wizard (duplicate). Blobs are shared, only rows are new. */
+export async function copyFiles(fromWizardId, toWizardId) {
+    const files = await draftFiles(fromWizardId);
+    if (files.length) {
+        await db.insert(schema.wizardFile).values(files.map((f) => ({ wizardId: toWizardId, ...f })));
+    }
+}
+/** The files a new wizard starts with (a starter's widget, price list, reference text). */
+export async function seedFiles(wizardId, files) {
+    const rows = [];
+    for (const [path, content] of Object.entries(files)) {
+        const data = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
+        rows.push({
+            wizardId,
+            path: requirePath(path),
+            hash: await putBlob(data),
+            mime: mimeForPath(path),
+            size: data.byteLength,
+        });
+    }
+    if (rows.length) {
+        await db.insert(schema.wizardFile).values(rows);
+    }
+}
+async function touch(wizardId) {
+    await db
+        .update(schema.wizard)
+        .set({ updatedAt: new Date() })
+        .where(eq(schema.wizard.id, wizardId));
+}
+/** The content of one file of a snapshot (a run's or a version's), by path. */
+export async function snapshotFile(files, path) {
+    const file = files.find((f) => f.path === path);
+    return file ? { file, data: await getBlob(file.hash) } : null;
+}
+export function sameFiles(a, b) {
+    return a.length === b.length && a.every((f, i) => f.path === b[i].path && f.hash === b[i].hash);
+}

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,292 @@
+import { DEFINITION_VERSION, readable, wizardSchema, } from "@engenty-wizards/shared/definition";
+import { MARKETPLACE_LANGS, } from "@engenty-wizards/shared/marketplace";
+import { wizardOutline } from "@engenty-wizards/shared/marketplace-entry";
+import { searchEntries } from "@engenty-wizards/shared/marketplace-search";
+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 } 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 { readSetting, writeSetting } from "../settings.js";
+import { 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.
+ */
+export const asLang = (raw) => MARKETPLACE_LANGS.includes(raw ?? "") ? raw : "de";
+/** 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;
+}
+// --- 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) {
+    return {
+        ...summary,
+        credits: null,
+        usable: summary.version <= DEFINITION_VERSION,
+        starred: starred.has(summary.id),
+        missing: summary.capabilities.filter((c) => unavailable.has(c)),
+    };
+}
+/** Searches the marketplace; without an answer, what is kept here, scored the same way. */
+export async function searchMarketplace(search) {
+    const { q = "", lang, starred: onlyStarred, limit = 60, offset = 0, ...filters } = search;
+    const stars = await starredIds();
+    const starred = new Set(stars);
+    const unavailable = await missingCapabilities();
+    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) {
+        return {
+            ...remote,
+            entries: remote.entries.map((e) => asEntry(e, starred, unavailable)),
+            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 });
+    return {
+        ...page,
+        entries: page.entries.map((e) => asEntry(e, starred, unavailable)),
+        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());
+    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 found = await fetchItem(id, lang);
+    if (!found) {
+        return null;
+    }
+    const { definition, files, ...summary } = found;
+    const entry = asEntry(summary, new Set(await starredIds()), await missingCapabilities());
+    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 found = await fetchItem(id, lang);
+    if (!found) {
+        return null;
+    }
+    if (!readable(found.definition)) {
+        throw new ServiceError("refused", "Diese Vorlage braucht eine neuere Version der App. Bitte aktualisiere die App.");
+    }
+    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;
+}