wizards 0.1.9

package/apps/runtime/dist/engine/runner.js

@@ -0,0 +1,560 @@
+import { branchValues, dataRef, formatsFor, LIST_FORMATS, listRef, nextStepId, } from "@engenty-wizards/shared/definition";
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { connectionViews } from "../connectors/index.js";
+import { addLocalCost, canSpend, releaseRun, reserveForRun, syncRunCost, } from "../credits/credits.js";
+import { estimateRun } from "../credits/estimate.js";
+import { db, schema, withTenant } from "../db/client.js";
+import { env } from "../env.js";
+import { saveAsset } from "../files/storage.js";
+import { managed, tenantInfo } from "../manage.js";
+import { hasFfmpeg } from "../media/ffmpeg.js";
+import { ModelUnavailableError } from "../models.js";
+import { projectFiles } from "../services/project-files.js";
+import { projectProfile } from "../services/projects.js";
+import { listRows, scopeOf } from "../store/index.js";
+import { activeRuns, indexRun, markRunActive } from "../tenants/control.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { askPerson, clearStaleAsk, unattended } from "./asks.js";
+import { emitEvent, recentEvents, signalChanged } from "./events.js";
+import { readPageInput } from "./input.js";
+import { blockingMessage, missingModels } from "./requirements.js";
+import { releaseResources, resourcesFor } from "./resources.js";
+import { runAutomaticStep } from "./steps.js";
+import { resolveRef } from "./template.js";
+import { StepError } from "./types.js";
+/** A command the run cannot take in its current state. */
+export class RunConflict extends Error {
+}
+export class RunInputError extends Error {
+    errors;
+    constructor(errors) {
+        super("Bitte die markierten Felder prüfen.");
+        this.errors = errors;
+    }
+}
+export class NoCreditsError extends Error {
+    constructor() {
+        super("Dieser Wizard hat gerade kein Guthaben mehr. Bitte später erneut versuchen.");
+    }
+}
+const active = new Map();
+// --- a tenant's runs that work at the same time ---------------------------------
+// Runs beyond the limit wait in line; nothing is refused.
+const slots = new Map();
+async function concurrencyLimit(tenant) {
+    if (!managed) {
+        return env.limits.concurrentRuns;
+    }
+    const info = await tenantInfo(tenant).catch(() => null);
+    return info?.limits.concurrentRuns || env.limits.concurrentRuns;
+}
+async function acquireSlot(tenant, signal) {
+    const limit = await concurrencyLimit(tenant);
+    let slot = slots.get(tenant);
+    if (!slot) {
+        slot = { busy: 0, waiting: [] };
+        slots.set(tenant, slot);
+    }
+    if (slot.busy < limit) {
+        slot.busy++;
+        return true;
+    }
+    const queue = slot.waiting;
+    return new Promise((resolve) => {
+        const go = () => {
+            signal.removeEventListener("abort", stop);
+            resolve(true);
+        };
+        const stop = () => {
+            queue.splice(queue.indexOf(go), 1);
+            resolve(false);
+        };
+        queue.push(go);
+        signal.addEventListener("abort", stop, { once: true });
+    });
+}
+function releaseSlot(tenant) {
+    const slot = slots.get(tenant);
+    if (!slot) {
+        return;
+    }
+    const next = slot.waiting.shift();
+    if (next) {
+        // The slot passes straight to the next run in line.
+        next();
+    }
+    else {
+        slot.busy--;
+    }
+}
+async function loadRun(runId) {
+    return db.query.run.findFirst({ where: eq(schema.run.id, runId) });
+}
+/** The project a run's wizard belongs to — where its imported connectors live. */
+export async function projectIdOf(run) {
+    const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) });
+    return w?.projectId ?? "";
+}
+async function loadProject(run) {
+    const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) });
+    const p = w && (await db.query.project.findFirst({ where: eq(schema.project.id, w.projectId) }));
+    if (!p) {
+        throw new Error("project missing");
+    }
+    return p;
+}
+async function updateRun(runId, patch) {
+    await db
+        .update(schema.run)
+        .set({ ...patch, updatedAt: new Date() })
+        .where(eq(schema.run.id, runId));
+    // A run that ended needs no credits held for it any more.
+    if (patch.status === "done" || patch.status === "failed" || patch.status === "cancelled") {
+        await releaseRun(runId);
+    }
+    signalChanged(runId);
+}
+function stepOf(def, id) {
+    return id ? def.steps.find((s) => s.id === id) : undefined;
+}
+function friendly(err) {
+    if (err instanceof StepError || err instanceof ModelUnavailableError) {
+        return err.message;
+    }
+    const msg = err?.message ?? String(err);
+    // The model-gateway answers 402 once the tenant's credits are used up.
+    if (/insufficient_credits|\b402\b/i.test(msg)) {
+        return new NoCreditsError().message;
+    }
+    // A runtime that runs alone pays its provider itself: its admin can top the account up.
+    if (!managed && /minimum balance|insufficient_funds|top up your credits/i.test(msg)) {
+        return "Das Guthaben beim Modell-Anbieter reicht dafür nicht aus (Videos brauchen dort ein Mindestguthaben). Bitte dort aufladen und noch einmal versuchen.";
+    }
+    if (/rate.?limit|429/i.test(msg)) {
+        return "Der KI-Dienst ist gerade ausgelastet. Bitte gleich noch einmal versuchen.";
+    }
+    if (/timeout|timed out/i.test(msg)) {
+        return "Der Schritt hat zu lange gedauert. Bitte noch einmal versuchen.";
+    }
+    // The platform's own provider account (budget, quota, key): nothing the person can fix.
+    if (/budget|quota|insufficient|billing|credit balance|api key|unauthori[sz]ed|401|403/i.test(msg)) {
+        return "Der KI-Dienst ist gerade nicht erreichbar. Bitte später noch einmal versuchen.";
+    }
+    return `Dieser Schritt ist fehlgeschlagen: ${msg.slice(0, 300)}`;
+}
+// --- creating & driving ------------------------------------------------------
+export async function createRun(input) {
+    const id = nanoid(18);
+    const first = input.definition.steps[0];
+    const state = { values: {}, outputs: {}, history: [], notes: {} };
+    // A step every run passes through needs a model this runtime cannot serve: refuse before anything is held.
+    const blocked = blockingMessage(await missingModels(input.definition));
+    if (blocked) {
+        throw new ModelUnavailableError(blocked);
+    }
+    // The run's expected cost is held before it starts; what it really costs is booked per call.
+    const estimate = await estimateRun(input.wizardId, input.version, input.definition);
+    if (!(await reserveForRun(id, estimate.reserve))) {
+        throw new NoCreditsError();
+    }
+    await db.insert(schema.run).values({
+        id,
+        wizardId: input.wizardId,
+        tenantId: currentTenant(),
+        definition: input.definition,
+        files: input.files,
+        version: input.version,
+        mode: input.mode,
+        visitorId: input.visitorId ?? null,
+        userId: input.userId ?? null,
+        ipHash: input.ipHash ?? null,
+        status: first.type === "page" ? "waiting_input" : "running",
+        cursor: first.id,
+        state,
+        // Without an account nobody can come back for a result later: it is kept a week.
+        expiresAt: input.mode === "live"
+            ? new Date(Date.now() + env.limits.resultTtlDays * 24 * 60 * 60 * 1000)
+            : null,
+    });
+    await indexRun({ runId: id, visitorId: input.visitorId, ipHash: input.ipHash });
+    if (first.type !== "page") {
+        kick(id);
+    }
+    return id;
+}
+export function kick(runId) {
+    if (active.has(runId)) {
+        return;
+    }
+    const abort = new AbortController();
+    active.set(runId, abort);
+    const tenant = currentTenant();
+    const work = async () => {
+        await markRunActive(runId, true);
+        if (!(await acquireSlot(tenant, abort.signal))) {
+            return;
+        }
+        try {
+            await drive(runId, abort.signal);
+        }
+        finally {
+            releaseSlot(tenant);
+        }
+    };
+    work()
+        .catch(async (err) => {
+        console.error(`[run ${runId}]`, err);
+        await updateRun(runId, { status: "failed", error: friendly(err) }).catch(() => undefined);
+    })
+        .finally(async () => {
+        active.delete(runId);
+        await markRunActive(runId, false).catch(() => undefined);
+        await releaseResources(runId);
+        signalChanged(runId);
+    });
+}
+/** The wizard's lists with the person's rows, by list id. */
+async function storedLists(run) {
+    const scope = scopeOf(run);
+    const out = {};
+    for (const def of run.definition.lists ?? []) {
+        out[def.id] = { def, rows: await listRows(scope, def.id) };
+    }
+    return out;
+}
+async function makeContext(run, project, state, signal) {
+    const store = scopeOf(run);
+    const resources = resourcesFor(run.id);
+    resources.bind(store);
+    const stepId = run.cursor ?? "";
+    return {
+        runId: run.id,
+        tenantId: run.tenantId,
+        stepId,
+        store,
+        def: run.definition,
+        files: run.files,
+        state,
+        scope: {
+            def: run.definition,
+            state,
+            brand: projectProfile(project),
+            lists: await storedLists(run),
+        },
+        project,
+        projectFiles: (await projectFiles(project.id)).filter((f) => f.status === "ready"),
+        signal,
+        resources,
+        ask: (ask) => unattended.has(run.id)
+            ? Promise.resolve(null)
+            : askPerson(run.id, { ...ask, stepId }, signal),
+        emit: (type, message, asset) => emitEvent(run.id, run.cursor, type, message, asset),
+        call: { runId: run.id, stepId },
+        chargeUsd: (usd) => addLocalCost(run.id, stepId, usd),
+        saveAsset: (input) => saveAsset({
+            ...input,
+            runId: run.id,
+            stepId: input.stepId ?? run.cursor,
+        }),
+    };
+}
+async function drive(runId, signal) {
+    await clearStaleAsk(runId);
+    while (!signal.aborted) {
+        const run = await loadRun(runId);
+        if (run?.status !== "running") {
+            return;
+        }
+        const def = run.definition;
+        const step = stepOf(def, run.cursor);
+        if (!step) {
+            await updateRun(runId, { status: "done" });
+            return;
+        }
+        if (step.type === "result") {
+            await updateRun(runId, { status: "done" });
+            return;
+        }
+        if (step.type === "page" || step.type === "review") {
+            await updateRun(runId, { status: "waiting_input" });
+            return;
+        }
+        if (!(await canSpend())) {
+            const message = new NoCreditsError().message;
+            await emitEvent(runId, step.id, "error", message);
+            await updateRun(runId, { status: "failed", error: message });
+            return;
+        }
+        await emitEvent(runId, step.id, "step_started", step.working ?? step.title);
+        const project = await loadProject(run);
+        const state = structuredClone(run.state);
+        try {
+            const output = await runAutomaticStep(step, await makeContext(run, project, state, signal));
+            if (signal.aborted) {
+                return;
+            }
+            await syncRunCost(runId);
+            state.outputs[step.id] = output;
+            delete state.notes[step.id];
+            delete state.redo?.[step.id];
+            const cursor = nextStepId(def, step.id, branchValues(state.values, state.outputs));
+            await updateRun(runId, { state, cursor, status: cursor ? "running" : "done", error: null });
+            await emitEvent(runId, step.id, "step_done", step.title);
+        }
+        catch (err) {
+            if (signal.aborted) {
+                return;
+            }
+            console.error(`[run ${runId} step ${step.id}]`, err);
+            const message = friendly(err);
+            await emitEvent(runId, step.id, "error", message);
+            await updateRun(runId, { status: "failed", error: message });
+            return;
+        }
+    }
+}
+/** Runs a restart left mid-step go on where they were. */
+export async function resumeInterruptedRuns() {
+    for (const r of await activeRuns()) {
+        await withTenant(r.tenantId, async () => {
+            const run = await loadRun(r.runId);
+            if (run?.status === "running") {
+                kick(r.runId);
+            }
+            else {
+                await markRunActive(r.runId, false);
+            }
+        }).catch((err) => console.error(`[resume ${r.runId}]`, err));
+    }
+}
+// --- commands ----------------------------------------------------------------
+async function requireWaiting(runId, stepId) {
+    const run = await loadRun(runId);
+    if (!run) {
+        throw new RunConflict("Run not found");
+    }
+    if (run.status !== "waiting_input" && run.status !== "done") {
+        throw new RunConflict("Der Wizard arbeitet gerade.");
+    }
+    if (run.cursor !== stepId) {
+        throw new RunConflict("Diese Seite ist nicht mehr aktuell.");
+    }
+    return run;
+}
+export async function submitPage(runId, stepId, input) {
+    const run = await requireWaiting(runId, stepId);
+    const step = stepOf(run.definition, stepId);
+    if (step?.type !== "page") {
+        throw new RunConflict("Not a page");
+    }
+    const { values, errors } = readPageInput(step, input);
+    if (errors.length) {
+        throw new RunInputError(errors);
+    }
+    const connections = step.fields.some((f) => f.kind === "connection")
+        ? await connectionViews(run.definition.connections ?? [], scopeOf(run), await projectIdOf(run))
+        : [];
+    for (const field of step.fields) {
+        if (field.kind === "image" || field.kind === "file") {
+            const value = values[field.id];
+            for (const id of Array.isArray(value) ? value : value ? [value] : []) {
+                const asset = await db.query.asset.findFirst({ where: eq(schema.asset.id, String(id)) });
+                if (asset?.runId !== runId) {
+                    throw new RunInputError([{ field: field.id, message: "Datei nicht gefunden" }]);
+                }
+            }
+        }
+        if (field.kind === "connection") {
+            // What the step later reads as {{field}} is the connected account, as the server knows it.
+            const account = connections.find((c) => c.id === field.connection)?.account;
+            if (account) {
+                values[field.id] = account.label;
+            }
+            else if (field.required) {
+                throw new RunInputError([{ field: field.id, message: "Bitte zuerst verbinden" }]);
+            }
+        }
+    }
+    const state = structuredClone(run.state);
+    state.values = { ...state.values, ...values };
+    // Fields left empty on a revisited page are cleared, not kept from before.
+    for (const field of step.fields) {
+        if (!(field.id in values)) {
+            delete state.values[field.id];
+        }
+    }
+    state.history.push(stepId);
+    const cursor = nextStepId(run.definition, stepId, branchValues(state.values, state.outputs));
+    await updateRun(runId, { state, cursor, status: "running", error: null });
+    kick(runId);
+}
+export async function reviewStep(runId, stepId, action) {
+    const run = await requireWaiting(runId, stepId);
+    const step = stepOf(run.definition, stepId);
+    if (step?.type !== "review") {
+        throw new RunConflict("Not a review");
+    }
+    const state = structuredClone(run.state);
+    if (action.type === "accept") {
+        for (const [target, text] of Object.entries(action.edits ?? {})) {
+            if (step.edit && step.show.includes(target) && state.outputs[target]) {
+                state.outputs[target] = { ...state.outputs[target], text: String(text).slice(0, 50_000) };
+            }
+        }
+        state.history.push(stepId);
+        const cursor = nextStepId(run.definition, stepId, branchValues(state.values, state.outputs));
+        await updateRun(runId, { state, cursor, status: "running", error: null });
+        kick(runId);
+        return;
+    }
+    if (!step.show.includes(action.target)) {
+        throw new RunConflict("Unknown target");
+    }
+    state.notes[action.target] = action.note.slice(0, 2000) || "Bitte eine neue Variante.";
+    // A step with several results makes only the named ones again.
+    if (action.items?.length) {
+        state.redo = { ...state.redo, [action.target]: action.items };
+    }
+    else {
+        delete state.redo?.[action.target];
+    }
+    await updateRun(runId, { state, cursor: action.target, status: "running", error: null });
+    await emitEvent(runId, action.target, "info", "Wird neu erstellt …");
+    kick(runId);
+}
+export async function goBack(runId) {
+    const run = await loadRun(runId);
+    if (!run ||
+        (run.status !== "waiting_input" && run.status !== "done" && run.status !== "failed")) {
+        throw new RunConflict("Der Wizard arbeitet gerade.");
+    }
+    const state = structuredClone(run.state);
+    const previous = state.history.pop();
+    if (!previous) {
+        throw new RunConflict("Kein vorheriger Schritt.");
+    }
+    await updateRun(runId, { state, cursor: previous, status: "waiting_input", error: null });
+}
+export async function retry(runId) {
+    const run = await loadRun(runId);
+    if (run?.status !== "failed") {
+        throw new RunConflict("Nothing to retry");
+    }
+    await updateRun(runId, { status: "running", error: null });
+    kick(runId);
+}
+export async function cancel(runId) {
+    active.get(runId)?.abort();
+    await updateRun(runId, { status: "cancelled" });
+}
+// --- view --------------------------------------------------------------------
+/** The formats a deliverable can really be downloaded in: a still widget has no video. */
+export async function availableFormats(step, run, wanted) {
+    const possible = formatsFor(step);
+    let formats = wanted ? wanted.filter((f) => possible.includes(f)) : possible;
+    const output = run.state.outputs[step.id];
+    if (step.type === "widget" && formats.includes("mp4")) {
+        // A film is rendered when its step runs; any other widget on demand.
+        const has = step.video
+            ? output?.assets?.some((a) => a.kind === "video")
+            : output?.widget?.duration && (await hasFfmpeg());
+        if (!has) {
+            formats = formats.filter((f) => f !== "mp4");
+        }
+    }
+    // A zip holds the files a step collected, or its several results; with one there is nothing to zip.
+    if (formats.includes("zip")) {
+        const has = step.type === "generate"
+            ? (output?.assets?.length ?? 0) > 1
+            : output?.assets?.some((a) => a.kind === "file");
+        if (!has) {
+            formats = formats.filter((f) => f !== "zip");
+        }
+    }
+    return formats;
+}
+/** What the page's fields start with, where they name an earlier step's result. */
+function prefillOf(step, run) {
+    const scope = { def: run.definition, state: run.state, brand: {} };
+    const out = {};
+    for (const field of step.fields) {
+        if (!field.prefill) {
+            continue;
+        }
+        const value = resolveRef(dataRef(field.prefill), scope);
+        if (value !== undefined && value !== null && value !== "") {
+            out[field.id] = value;
+        }
+    }
+    return out;
+}
+export async function runView(run, brand) {
+    const def = run.definition;
+    const step = stepOf(def, run.cursor) ?? null;
+    const index = step ? def.steps.indexOf(step) : def.steps.length;
+    const refs = step?.type === "review"
+        ? step.show
+        : step?.type === "result"
+            ? [...new Set(step.deliverables.map((d) => d.from))]
+            : [];
+    const shownIds = refs.filter((ref) => !listRef(ref));
+    const listIds = [
+        ...refs.map(listRef),
+        ...(step?.type === "page" ? step.fields.map((f) => (f.kind === "list" ? f.list : null)) : []),
+    ].filter((id) => Boolean(id));
+    const stored = listIds.length ? await storedLists(run) : {};
+    const lists = [...new Set(listIds)]
+        .filter((id) => stored[id])
+        .map((id) => {
+        const deliverable = step?.type === "result" ? step.deliverables.find((d) => listRef(d.from) === id) : undefined;
+        return {
+            ...stored[id],
+            formats: deliverable
+                ? deliverable.formats.filter((f) => LIST_FORMATS.includes(f) && (f !== "zip" || stored[id].def.check?.file))
+                : [],
+            label: deliverable?.label ?? null,
+        };
+    });
+    const shown = await Promise.all(shownIds
+        .map((id) => stepOf(def, id))
+        .filter((s) => Boolean(s))
+        .map(async (s) => {
+        const deliverable = step?.type === "result" ? step.deliverables.find((d) => d.from === s.id) : undefined;
+        return {
+            step: s,
+            output: run.state.outputs[s.id] ?? null,
+            formats: await availableFormats(s, run, deliverable?.formats),
+            label: deliverable?.label ?? null,
+        };
+    }));
+    return {
+        id: run.id,
+        status: run.status,
+        mode: run.mode,
+        wizard: {
+            title: def.title,
+            description: def.description,
+            avatar: def.avatar,
+            intro: def.intro,
+        },
+        step,
+        values: run.state.values,
+        prefill: step?.type === "page" ? prefillOf(step, run) : {},
+        outputs: Object.fromEntries(shownIds.map((id) => [id, run.state.outputs[id]]).filter(([, o]) => o)),
+        shown,
+        progress: { done: run.status === "done" ? def.steps.length : index, total: def.steps.length },
+        canBack: run.state.history.length > 0 && run.status !== "running",
+        error: run.error,
+        events: await recentEvents(run.id, 0, 30),
+        brand,
+        ask: run.status === "running" ? run.ask : null,
+        lists,
+        connections: step?.type === "page" && step.fields.some((f) => f.kind === "connection")
+            ? await connectionViews(def.connections ?? [], scopeOf(run), await projectIdOf(run))
+            : [],
+        keeps: Boolean(def.lists?.length || def.connections?.length),
+        shareUrl: run.shareToken ? `${env.appUrl}/s/${run.shareToken}` : null,
+        expiresAt: run.expiresAt?.toISOString() ?? null,
+    };
+}