wizards 0.1.9

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

@@ -0,0 +1,181 @@
+import { FACT_TYPES, PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
+import { and, count, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { db, schema } from "../db/client.js";
+import { env } from "../env.js";
+import { managed, tenantInfo } from "../manage.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { notFound, ServiceError } from "./errors.js";
+import { forgetWizardLinks } from "./links.js";
+import { removeProjectFiles } from "./project-files.js";
+const MASK = "••••";
+export const mcpServerSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9_]{0,30}$/),
+    name: z.string().min(1).max(60),
+    url: z.string().url(),
+    headers: z.record(z.string(), z.string()).optional(),
+});
+export const brandColorSchema = z.object({
+    name: z.string().max(120),
+    value: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+});
+export const projectFactSchema = z.object({
+    key: z.string().regex(/^[a-z0-9_]{1,40}$/),
+    label: z.string().min(1).max(80),
+    value: z.string().max(4000),
+    type: z.enum(FACT_TYPES).optional(),
+});
+export const projectPatchSchema = z.object({
+    name: z.string().min(1).max(80).optional(),
+    brand: z
+        .object({
+        name: z.string().max(120).optional(),
+        about: z.string().max(8000).optional(),
+        colors: z.array(brandColorSchema).max(PROJECT_LIMITS.colors).optional(),
+    })
+        .optional(),
+    facts: z.array(projectFactSchema).max(PROJECT_LIMITS.facts).optional(),
+    mcpServers: z.array(mcpServerSchema).max(10).optional(),
+});
+/**
+ * How many projects the tenant works with: the number the Manage-App gives for it, else this
+ * runtime's (`LIMIT_PROJECTS`, one unless set). The studio shows a project switcher only above
+ * one. Projects beyond the number stay in the database and are not listed.
+ */
+export async function projectLimit() {
+    if (managed) {
+        const info = await tenantInfo(currentTenant()).catch(() => null);
+        if (info?.limits.projects) {
+            return info.limits.projects;
+        }
+    }
+    return Math.max(1, env.limits.projects);
+}
+export async function ownedProject(_userId, projectId) {
+    const p = await db.query.project.findFirst({
+        where: and(eq(schema.project.id, projectId), eq(schema.project.tenantId, currentTenant())),
+    });
+    if (!p) {
+        throw notFound();
+    }
+    return p;
+}
+/** A tenant always has a project: the first one is made when its studio is first opened. */
+async function ensureProject() {
+    const any = await db.query.project.findFirst({
+        where: eq(schema.project.tenantId, currentTenant()),
+    });
+    if (!any) {
+        await db
+            .insert(schema.project)
+            .values({ id: nanoid(12), tenantId: currentTenant(), name: "Meine Wizards" });
+    }
+}
+/** The project a wizard lands in when the caller names none: the oldest one. */
+export async function defaultProject(_userId) {
+    await ensureProject();
+    const p = await db.query.project.findFirst({
+        where: eq(schema.project.tenantId, currentTenant()),
+        orderBy: [schema.project.createdAt],
+    });
+    if (!p) {
+        throw notFound();
+    }
+    return p;
+}
+export async function listProjects(_userId) {
+    await ensureProject();
+    // The oldest come first: with a limit of one, that is the project everything lands in.
+    const projects = await db.query.project.findMany({
+        where: eq(schema.project.tenantId, currentTenant()),
+        orderBy: [schema.project.createdAt],
+        limit: await projectLimit(),
+    });
+    const counts = await db
+        .select({ projectId: schema.wizard.projectId, n: count() })
+        .from(schema.wizard)
+        .where(eq(schema.wizard.tenantId, currentTenant()))
+        .groupBy(schema.wizard.projectId);
+    return projects.map((p) => ({
+        ...p,
+        wizardCount: counts.find((x) => x.projectId === p.id)?.n ?? 0,
+    }));
+}
+/** MCP server headers carry the admin's credentials: shown masked, kept when sent back masked. */
+export function maskedServers(p) {
+    return p.mcpServers.map((s) => ({
+        ...s,
+        headers: s.headers
+            ? Object.fromEntries(Object.keys(s.headers).map((k) => [k, MASK]))
+            : undefined,
+    }));
+}
+export async function createProject(_userId, name) {
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.project)
+        .where(eq(schema.project.tenantId, currentTenant()));
+    const limit = await projectLimit();
+    if (n >= limit) {
+        throw new ServiceError("refused", limit === 1 ? "Hier gibt es ein Projekt." : `Höchstens ${limit} Projekte.`);
+    }
+    const id = nanoid(12);
+    await db
+        .insert(schema.project)
+        .values({ id, tenantId: currentTenant(), name, brand: {}, mcpServers: [] });
+    return { id };
+}
+export async function updateProject(userId, projectId, patch) {
+    const p = await ownedProject(userId, projectId);
+    const mcpServers = patch.mcpServers?.map((s) => {
+        const before = p.mcpServers.find((x) => x.id === s.id);
+        const headers = s.headers
+            ? Object.fromEntries(Object.entries(s.headers).map(([k, v]) => [
+                k,
+                v === MASK ? (before?.headers?.[k] ?? "") : v,
+            ]))
+            : undefined;
+        return { ...s, headers };
+    });
+    if (patch.facts && new Set(patch.facts.map((f) => f.key)).size !== patch.facts.length) {
+        throw new ServiceError("invalid", "Zwei Einträge haben denselben Schlüssel.");
+    }
+    await db
+        .update(schema.project)
+        .set({
+        ...(patch.name ? { name: patch.name } : {}),
+        ...(patch.brand ? { brand: { ...p.brand, ...patch.brand } } : {}),
+        ...(patch.facts ? { facts: patch.facts } : {}),
+        ...(mcpServers ? { mcpServers } : {}),
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.project.id, p.id));
+}
+export function projectProfile(p) {
+    return {
+        name: p.brand.name ?? "",
+        about: p.brand.about ?? "",
+        colors: p.brand.colors ?? [],
+        facts: p.facts.filter((f) => f.value.trim()),
+    };
+}
+export async function deleteProject(_userId, projectId) {
+    const all = await db.query.project.findMany({
+        where: eq(schema.project.tenantId, currentTenant()),
+    });
+    if (all.length <= 1) {
+        throw new ServiceError("refused", "Das letzte Projekt bleibt.");
+    }
+    const wizards = await db
+        .select({ id: schema.wizard.id })
+        .from(schema.wizard)
+        .where(eq(schema.wizard.projectId, projectId));
+    for (const w of wizards) {
+        await forgetWizardLinks(w.id);
+    }
+    await removeProjectFiles(projectId);
+    await db
+        .delete(schema.project)
+        .where(and(eq(schema.project.id, projectId), eq(schema.project.tenantId, currentTenant())));
+}

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

@@ -0,0 +1,224 @@
+import { formatsFor } from "@engenty-wizards/shared/definition";
+import { and, count, desc, eq, inArray } from "drizzle-orm";
+import { canSpend, MICROS_PER_CREDIT } from "../credits/credits.js";
+import { db, schema } from "../db/client.js";
+import { unattended } from "../engine/asks.js";
+import { emitEvent, recentEvents, subscribe } from "../engine/events.js";
+import { createRun, RunInputError, reviewStep, submitPage } from "../engine/runner.js";
+import { ModelUnavailableError } from "../model-errors.js";
+import { signedUrl } from "../secrets/signing.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { notFound, ServiceError } from "./errors.js";
+import { ownedWizard, requireClean, studioUrl } from "./wizards.js";
+/** Test runs an MCP client started with answers: pages are filled and reviews accepted for it. */
+const autopilots = new Set();
+export async function startTestRun(userId, wizardId, autopilot) {
+    const w = await ownedWizard(userId, wizardId);
+    const { definition, files } = await requireClean(w);
+    if (!(await canSpend())) {
+        throw new ServiceError("no_credits", "Dein Guthaben ist aufgebraucht.");
+    }
+    const runId = await createRun({
+        wizardId: w.id,
+        definition,
+        files,
+        version: null,
+        mode: "test",
+        userId,
+    }).catch((err) => {
+        throw err instanceof ModelUnavailableError ? new ServiceError("refused", err.message) : err;
+    });
+    if (autopilot) {
+        fly(runId, autopilot.answers, autopilot.acceptReviews);
+    }
+    return { runId };
+}
+function fly(runId, answers, acceptReviews) {
+    autopilots.add(runId);
+    unattended.add(runId);
+    let busy = false;
+    let again = false;
+    const land = () => {
+        autopilots.delete(runId);
+        unattended.delete(runId);
+        unsubscribe();
+        clearTimeout(timeout);
+    };
+    const step = async () => {
+        if (busy) {
+            again = true;
+            return;
+        }
+        busy = true;
+        try {
+            do {
+                again = false;
+                const run = await db.query.run.findFirst({ where: eq(schema.run.id, runId) });
+                if (!run ||
+                    run.status === "done" ||
+                    run.status === "failed" ||
+                    run.status === "cancelled") {
+                    land();
+                    return;
+                }
+                if (run.status !== "waiting_input") {
+                    continue;
+                }
+                const current = run.definition.steps.find((s) => s.id === run.cursor);
+                if (current?.type === "page") {
+                    const values = Object.fromEntries(current.fields.filter((f) => f.id in answers).map((f) => [f.id, answers[f.id]]));
+                    await submitPage(runId, current.id, values);
+                }
+                else if (current?.type === "review" && acceptReviews) {
+                    await reviewStep(runId, current.id, { type: "accept" });
+                }
+                else {
+                    land();
+                    return;
+                }
+            } while (again);
+        }
+        catch (err) {
+            const message = err instanceof RunInputError
+                ? `Antworten fehlen oder passen nicht: ${err.errors.map((e) => `${e.field} – ${e.message}`).join("; ")}`
+                : err.message;
+            await emitEvent(runId, null, "error", message).catch(() => undefined);
+            land();
+        }
+        finally {
+            busy = false;
+        }
+    };
+    const unsubscribe = subscribe(runId, () => {
+        void step();
+    });
+    const timeout = setTimeout(land, 30 * 60_000);
+    void step();
+}
+async function ownedTestRun(_userId, runId) {
+    const run = await db.query.run.findFirst({
+        where: and(eq(schema.run.id, runId), eq(schema.run.tenantId, currentTenant()), eq(schema.run.mode, "test")),
+    });
+    if (!run) {
+        throw notFound();
+    }
+    return run;
+}
+/** Still moving: running, or waiting on a page the autopilot is about to fill. */
+function moving(run) {
+    return run.status === "running" || (run.status === "waiting_input" && autopilots.has(run.id));
+}
+async function waitWhileMoving(userId, runId, seconds) {
+    const deadline = Date.now() + seconds * 1000;
+    let run = await ownedTestRun(userId, runId);
+    while (moving(run) && Date.now() < deadline) {
+        await new Promise((resolve) => {
+            const unsubscribe = subscribe(runId, () => {
+                unsubscribe();
+                clearTimeout(timer);
+                resolve();
+            });
+            const timer = setTimeout(() => {
+                unsubscribe();
+                resolve();
+            }, deadline - Date.now());
+        });
+        run = await ownedTestRun(userId, runId);
+    }
+    return run;
+}
+function clip(text, max) {
+    return text.length > max
+        ? `${text.slice(0, max)} … [${text.length - max} more characters]`
+        : text;
+}
+function deliverableFormats(run, step) {
+    const possible = formatsFor(step);
+    const listed = run.definition.steps
+        .flatMap((s) => (s.type === "result" ? s.deliverables : []))
+        .find((d) => d.from === step.id);
+    return listed ? listed.formats.filter((f) => possible.includes(f)) : [];
+}
+/** What a test run did so far, for a client without the studio: outputs, links, cost, errors. */
+export async function testRunReport(userId, runId, waitSeconds = 0) {
+    const run = await waitWhileMoving(userId, runId, waitSeconds);
+    const current = run.definition.steps.find((s) => s.id === run.cursor) ?? null;
+    const base = `/api/runs/${run.id}`;
+    const outputs = run.definition.steps.flatMap((step) => {
+        const output = run.state.outputs[step.id];
+        if (!output) {
+            return [];
+        }
+        return [
+            {
+                stepId: step.id,
+                title: step.title,
+                text: output.text ? clip(output.text, 1500) : undefined,
+                json: output.json === undefined ? undefined : clip(JSON.stringify(output.json), 1500),
+                assets: (output.assets ?? []).map((a) => ({
+                    name: a.name,
+                    mime: a.mime,
+                    url: signedUrl(`${base}/assets/${a.id}`),
+                })),
+                downloads: Object.fromEntries(deliverableFormats(run, step).map((f) => [
+                    f,
+                    signedUrl(`${base}/steps/${step.id}/download?format=${f}`),
+                ])),
+            },
+        ];
+    });
+    const waitingFor = run.status === "waiting_input" && current?.type === "page"
+        ? {
+            page: current.id,
+            fields: current.fields.map((f) => ({
+                id: f.id,
+                label: f.label,
+                kind: f.kind,
+                required: Boolean(f.required),
+                options: f.options,
+            })),
+        }
+        : run.status === "waiting_input" && current?.type === "review"
+            ? { review: current.id, hint: "Accept or regenerate in the studio." }
+            : undefined;
+    return {
+        runId: run.id,
+        status: moving(run) ? "running" : run.status,
+        step: current ? { id: current.id, type: current.type, title: current.title } : null,
+        waitingFor,
+        error: run.error,
+        credits: Math.ceil(run.costMicros / MICROS_PER_CREDIT),
+        events: (await recentEvents(run.id, 0, 15)).map((e) => ({
+            step: e.stepId,
+            type: e.type,
+            message: e.message,
+        })),
+        outputs,
+        studioUrl: studioUrl(run.wizardId),
+    };
+}
+export async function listRuns(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const rows = await db.query.run.findMany({
+        where: eq(schema.run.wizardId, w.id),
+        orderBy: [desc(schema.run.createdAt)],
+        limit: 100,
+    });
+    const assetCounts = rows.length
+        ? await db
+            .select({ runId: schema.asset.runId, n: count() })
+            .from(schema.asset)
+            .where(inArray(schema.asset.runId, rows.map((r) => r.id)))
+            .groupBy(schema.asset.runId)
+        : [];
+    return rows.map((r) => ({
+        id: r.id,
+        mode: r.mode,
+        status: r.status,
+        version: r.version,
+        createdAt: r.createdAt.toISOString(),
+        credits: Math.ceil(r.costMicros / MICROS_PER_CREDIT),
+        assets: assetCounts.find((a) => a.runId === r.id)?.n ?? 0,
+        stepTitle: r.definition.steps.find((s) => s.id === r.cursor)?.title ?? null,
+    }));
+}

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

@@ -0,0 +1,129 @@
+import { and, eq, isNotNull, lt } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { availableFormats } from "../engine/runner.js";
+import { env } from "../env.js";
+import { inlineAssetRefs, loadAsset, loadAssetText, removeAssetFiles, saveAsset, } from "../files/storage.js";
+import { htmlToPng } from "../render/convert.js";
+import { dropLinks, dropRuns, putLink } from "../tenants/control.js";
+import { brandView } from "./brand.js";
+import { ServiceError } from "./errors.js";
+export const shareUrlFor = (token) => `${env.appUrl}/s/${token}`;
+/** Shares a finished run. Idempotent: the same run keeps the same link. */
+export async function shareRun(run) {
+    if (run.status !== "done") {
+        throw new ServiceError("refused", "Nur fertige Ergebnisse lassen sich teilen.");
+    }
+    let token = run.shareToken;
+    if (!token) {
+        token = nanoid(16);
+        await db
+            .update(schema.run)
+            .set({ shareToken: token, sharedAt: new Date() })
+            .where(eq(schema.run.id, run.id));
+        await putLink(token, "result", run.id);
+    }
+    return { url: shareUrlFor(token), expiresAt: run.expiresAt?.toISOString() ?? null };
+}
+export async function unshareRun(run) {
+    if (run.shareToken) {
+        await dropLinks([run.shareToken]);
+    }
+    await db
+        .update(schema.run)
+        .set({ shareToken: null, sharedAt: null })
+        .where(eq(schema.run.id, run.id));
+}
+/** The shared run behind a token, unless the link was withdrawn or the run expired. */
+export async function sharedRun(token) {
+    const run = await db.query.run.findFirst({ where: eq(schema.run.shareToken, token) });
+    if (run?.status !== "done" || (run.expiresAt && run.expiresAt < new Date())) {
+        return null;
+    }
+    return run;
+}
+export async function shareView(run) {
+    const def = run.definition;
+    const result = def.steps.find((s) => s.id === run.cursor && s.type === "result") ??
+        def.steps.findLast((s) => s.type === "result");
+    const deliverables = result?.type === "result" ? result.deliverables : [];
+    const shown = await Promise.all(deliverables.flatMap((d) => {
+        const step = def.steps.find((s) => s.id === d.from);
+        const output = run.state.outputs[d.from];
+        return step && output
+            ? [
+                (async () => ({
+                    step,
+                    output,
+                    formats: await availableFormats(step, run, d.formats),
+                    label: d.label ?? null,
+                }))(),
+            ]
+            : [];
+    }));
+    const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) });
+    return {
+        token: run.shareToken ?? "",
+        title: result?.title ?? def.title,
+        message: result?.type === "result" ? (result.message ?? null) : null,
+        wizard: { title: def.title, description: def.description, avatar: def.avatar },
+        brand: await brandView(w?.projectId ?? ""),
+        shown,
+        createdAt: run.createdAt.toISOString(),
+        expiresAt: run.expiresAt?.toISOString() ?? null,
+        wizardUrl: w?.shareEnabled && w.publishedVersion !== null ? `${env.appUrl}/w/${w.shareToken}` : null,
+    };
+}
+/**
+ * The picture link previews (X, LinkedIn, WhatsApp, Slack) show: the first image of the result,
+ * a widget's poster, or a document's first screen. Rendered once and kept.
+ */
+export async function shareImage(run) {
+    const view = await shareView(run);
+    for (const { output } of view.shown) {
+        const assets = output?.assets ?? [];
+        const image = assets.find((a) => a.mime.startsWith("image/"));
+        if (image) {
+            const found = await loadAsset(image.id);
+            if (found) {
+                return { data: new Uint8Array(found.data), mime: found.row.mime };
+            }
+        }
+        const html = assets.find((a) => a.mime === "text/html");
+        if (html) {
+            const name = `${html.id}.og.png`;
+            const hit = await db.query.asset.findFirst({
+                where: and(eq(schema.asset.kind, "render"), eq(schema.asset.name, name)),
+            });
+            const cached = hit ? await loadAsset(hit.id) : null;
+            if (cached) {
+                return { data: new Uint8Array(cached.data), mime: "image/png" };
+            }
+            const page = await inlineAssetRefs(await loadAssetText(html.id));
+            const png = await htmlToPng(page, 1200, { height: 630, fullPage: false, scale: 1 });
+            await saveAsset({
+                runId: run.id,
+                kind: "render",
+                mime: "image/png",
+                name,
+                data: png,
+            });
+            return { data: png, mime: "image/png" };
+        }
+    }
+    return null;
+}
+/** Deletes runs past their expiry with everything they made. Runs hourly. */
+export async function purgeExpiredRuns() {
+    const expired = await db
+        .select({ id: schema.run.id, shareToken: schema.run.shareToken })
+        .from(schema.run)
+        .where(and(isNotNull(schema.run.expiresAt), lt(schema.run.expiresAt, new Date())));
+    for (const { id } of expired) {
+        await removeAssetFiles(id);
+        await db.delete(schema.run).where(eq(schema.run.id, id));
+    }
+    await dropLinks(expired.map((r) => r.shareToken).filter((t) => Boolean(t)));
+    await dropRuns(expired.map((r) => r.id));
+    return expired.length;
+}

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

@@ -0,0 +1,34 @@
+import { widgetSize } from "@engenty-wizards/shared/definition";
+import { probeWidget } from "../widgets/render.js";
+import { widgetPreviewHtml } from "../widgets/step.js";
+import { notFound, ServiceError } from "./errors.js";
+import { draftFiles } from "./files.js";
+import { ownedProject } from "./projects.js";
+import { ownedWizard } from "./wizards.js";
+async function draftWidget(userId, wizardId, stepId) {
+    const w = await ownedWizard(userId, wizardId);
+    const step = w.draft.steps.find((s) => s.id === stepId);
+    if (!step) {
+        throw notFound();
+    }
+    if (step.type !== "widget") {
+        throw new ServiceError("invalid", `Step "${stepId}" is not a widget.`);
+    }
+    const files = await draftFiles(w.id);
+    if (!files.some((f) => f.path === step.entry)) {
+        throw new ServiceError("invalid", `The widget file ${step.entry} is not in the workspace yet.`);
+    }
+    return { step, files, project: await ownedProject(userId, w.projectId) };
+}
+/** The draft widget with its sample data, as one HTML file — the studio shows it before any run. */
+export async function draftWidgetPreview(userId, wizardId, stepId, data) {
+    const { step, files, project } = await draftWidget(userId, wizardId, stepId);
+    return widgetPreviewHtml(step, files, project, data);
+}
+/** Loads the draft widget in Chromium: what broke, whether it animates, and how it looks. */
+export async function checkDraftWidget(userId, wizardId, stepId, data) {
+    const { step, files, project } = await draftWidget(userId, wizardId, stepId);
+    const html = await widgetPreviewHtml(step, files, project, data);
+    const probe = await probeWidget(html, widgetSize(step));
+    return { ...probe, size: widgetSize(step), bytes: Buffer.byteLength(html) };
+}