wizards 0.1.9

package/apps/runtime/dist/models.js

@@ -0,0 +1,489 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGateway } from "@ai-sdk/gateway";
+import { createOpenAI } from "@ai-sdk/openai";
+import { MODEL_CLASSES, TEXT_CLASSES, } from "@engenty-wizards/shared/definition";
+import { accountToken } from "./auth/account.js";
+import { env } from "./env.js";
+import { detectHarness, HarnessModel, harness, isHarnessVendor, notInstalled, signedOut, } from "./harness/index.js";
+import { managed } from "./manage.js";
+import { ModelUnavailableError } from "./model-errors.js";
+import { vaultDelete, vaultGet, vaultSet } from "./secrets/vault.js";
+import { readSetting, writeSetting } from "./settings.js";
+import { currentTenantOrNull } from "./tenants/tenant.js";
+export { isHarnessVendor } from "./harness/index.js";
+/**
+ * A step names a model class, never a model. Where the class runs is decided here:
+ *  - a runtime of a Manage-App sends `wizards/<class>` to the model-gateway, which binds it,
+ *    meters the call and books the tenant's credits;
+ *  - a runtime that runs alone uses the linked account's credits through the same gateway, or
+ *    resolves the class itself: an AI client installed on the machine (Claude Code, Codex,
+ *    Gemini CLI, Cursor Agent — on its subscription), own keys (AI Gateway, OpenAI, Anthropic)
+ *    or a local model.
+ * A local binding is `[provider:]vendor/model`, e.g. `anthropic/claude-haiku-4.5`,
+ * `openai:gpt-5.4-mini`, `ollama:qwen3`, `claude/sonnet`, `codex/default`.
+ */
+export { ModelUnavailableError } from "./model-errors.js";
+// --- local configuration -------------------------------------------------------
+export const LOCAL_KEYS = ["gateway", "openai", "anthropic"];
+const local = {
+    settings: { source: "own", bindings: {} },
+    keys: {},
+};
+/** Reads the model settings and keys of a runtime that runs alone; called at start and after a change. */
+export async function loadLocalModels() {
+    if (managed) {
+        return;
+    }
+    local.settings = (await readSetting("models")) ?? {
+        source: "own",
+        bindings: {},
+    };
+    local.keys = {
+        gateway: (await vaultGet("key.gateway")) ?? env.aiGatewayKey,
+        openai: (await vaultGet("key.openai")) ?? env.openaiKey,
+        anthropic: (await vaultGet("key.anthropic")) ?? env.anthropicKey,
+    };
+}
+export function localModelSettings() {
+    return {
+        ...local.settings,
+        bindings: Object.fromEntries(MODEL_CLASSES.map((c) => [c, localRef(c)])),
+        ollamaUrl: local.settings.ollamaUrl ?? env.ollamaUrl,
+        keys: Object.fromEntries(LOCAL_KEYS.map((k) => [k, Boolean(local.keys[k])])),
+    };
+}
+export async function saveLocalModels(input) {
+    const bindings = { ...local.settings.bindings };
+    for (const [cls, ref] of Object.entries(input.bindings ?? {})) {
+        if (ref?.trim()) {
+            bindings[cls] = ref.trim();
+        }
+        else {
+            delete bindings[cls];
+        }
+    }
+    await writeSetting("models", {
+        source: input.source ?? local.settings.source,
+        bindings,
+        ollamaUrl: input.ollamaUrl?.trim() || local.settings.ollamaUrl,
+    });
+    for (const [name, value] of Object.entries(input.keys ?? {})) {
+        if (value?.trim()) {
+            await vaultSet(`key.${name}`, value.trim());
+        }
+        else {
+            await vaultDelete(`key.${name}`);
+        }
+    }
+    await loadLocalModels();
+}
+async function gatewayAccess() {
+    if (managed) {
+        return {
+            baseUrl: env.manage.gatewayUrl,
+            token: env.manage.serviceKey,
+            tenant: currentTenantOrNull(),
+        };
+    }
+    if (local.settings.source !== "account") {
+        return null;
+    }
+    const token = await accountToken();
+    if (!token) {
+        throw new ModelUnavailableError("Das Konto ist nicht mehr angemeldet. Bitte in den Einstellungen neu anmelden.");
+    }
+    return { baseUrl: env.local.gatewayUrl, token, tenant: null };
+}
+function gatewayClient(access, meta) {
+    return createGateway({
+        baseURL: `${access.baseUrl}/v4/ai`,
+        apiKey: access.token,
+        headers: {
+            ...(access.tenant ? { "x-wizards-tenant": access.tenant } : {}),
+            ...(meta.runId ? { "x-wizards-run": meta.runId } : {}),
+            ...(meta.stepId ? { "x-wizards-step": meta.stepId } : {}),
+            ...(meta.effort ? { "x-wizards-effort": meta.effort } : {}),
+        },
+    });
+}
+let gatewayCatalog = null;
+/** What the gateway binds each class to, with prices in credits. Cached for five minutes. */
+export async function classCatalog() {
+    const access = await gatewayAccess().catch(() => null);
+    if (!access) {
+        return null;
+    }
+    if (gatewayCatalog &&
+        gatewayCatalog.base === access.baseUrl &&
+        Date.now() - gatewayCatalog.at < 300_000) {
+        return gatewayCatalog.value;
+    }
+    try {
+        const res = await fetch(`${access.baseUrl}/v1/models`, {
+            headers: {
+                authorization: `Bearer ${access.token}`,
+                ...(access.tenant ? { "x-wizards-tenant": access.tenant } : {}),
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok) {
+            return gatewayCatalog?.value ?? null;
+        }
+        const value = (await res.json());
+        gatewayCatalog = { at: Date.now(), base: access.baseUrl, value };
+        return value;
+    }
+    catch {
+        return gatewayCatalog?.value ?? null;
+    }
+}
+// --- resolving a class -------------------------------------------------------------
+function split(ref) {
+    const [maybeProvider, rest] = ref.includes(":") ? ref.split(/:(.*)/s, 2) : [null, ref];
+    const [vendor, ...model] = (rest ?? ref).split("/");
+    return { provider: maybeProvider, vendor, model: model.join("/") };
+}
+const vendorOf = (ref) => split(ref).vendor;
+function localRef(cls) {
+    const bound = local.settings.bindings[cls];
+    const client = harness(local.settings.source);
+    if (client && TEXT_CLASSES.includes(cls)) {
+        // Text thinks on the installed client; a binding counts only where it names that client.
+        return bound?.startsWith(`${client.id}/`)
+            ? bound
+            : `${client.id}/${client.classes[cls]}`;
+    }
+    if (bound) {
+        return bound;
+    }
+    // A client that makes images on the sign-in makes them too, before any key is paid for.
+    if (cls === "image" && client?.image) {
+        return `${client.id}/${client.image.alias}`;
+    }
+    // The defaults for images, video and sound name gateway models; without a gateway key nothing
+    // reaches them, so the class stays empty instead of showing a model that cannot run.
+    if (!TEXT_CLASSES.includes(cls) && !local.keys.gateway) {
+        return "";
+    }
+    return env.models[cls];
+}
+function ownGateway() {
+    return local.keys.gateway ? createGateway({ apiKey: local.keys.gateway }) : null;
+}
+async function localLanguageModel(ref, meta) {
+    if (!ref) {
+        throw new ModelUnavailableError("Für diese Klasse ist kein Modell eingerichtet.");
+    }
+    const { provider, vendor, model } = split(ref);
+    const client = harness(vendor);
+    if (client) {
+        if (!(await detectHarness(client.id))?.version) {
+            throw new ModelUnavailableError(notInstalled(client));
+        }
+        return { model: client.model(model, meta.effort), gateway: false };
+    }
+    if (provider === "ollama") {
+        const ollama = createOpenAI({
+            baseURL: local.settings.ollamaUrl ?? env.ollamaUrl,
+            apiKey: "ollama",
+        });
+        return { model: ollama.chat(model ? `${vendor}/${model}` : vendor), gateway: false };
+    }
+    const gateway = ownGateway();
+    if ((provider === null || provider === "gateway") && gateway) {
+        return { model: gateway(`${vendor}/${model}`), gateway: true };
+    }
+    if ((provider === "openai" || vendor === "openai") && local.keys.openai) {
+        return {
+            model: createOpenAI({ apiKey: local.keys.openai })(model || vendor),
+            gateway: false,
+        };
+    }
+    if ((provider === "anthropic" || vendor === "anthropic") && local.keys.anthropic) {
+        return {
+            model: createAnthropic({ apiKey: local.keys.anthropic })(model || vendor),
+            gateway: false,
+        };
+    }
+    throw new ModelUnavailableError(`Für das Modell "${ref}" ist kein Zugang eingerichtet. Bitte in den Einstellungen einen Schlüssel hinterlegen oder ein Konto anmelden.`);
+}
+async function viaGateway(cls, meta, pick) {
+    const access = await gatewayAccess();
+    if (!access) {
+        return null;
+    }
+    const bound = (await classCatalog())?.classes[cls]?.model ?? "";
+    return {
+        model: pick(gatewayClient(access, meta), `wizards/${cls}`),
+        ref: bound,
+        vendor: vendorOf(bound.replace(/^[a-z]+:/, "")),
+        gateway: true,
+        metered: true,
+    };
+}
+/** The language model a text class runs on. */
+export async function textModel(cls, meta = {}) {
+    const remote = await viaGateway(cls, meta, (client, id) => client(id));
+    if (remote) {
+        return remote;
+    }
+    const ref = localRef(cls);
+    const { model, gateway } = await localLanguageModel(ref, meta);
+    return { model, ref, vendor: vendorOf(ref), gateway, metered: false };
+}
+/** Hands the tools an agent will call to a model that runs them itself (an installed AI client). */
+export function attachTools(resolved, tools) {
+    if (resolved.model instanceof HarnessModel) {
+        resolved.model.attach(tools);
+    }
+}
+export async function imageModel(meta = {}) {
+    const remote = await viaGateway("image", meta, (client, id) => client.imageModel(id));
+    if (remote) {
+        return remote;
+    }
+    const ref = localRef("image");
+    const { vendor, model } = split(ref);
+    const client = harness(vendor);
+    if (client?.image) {
+        if (!(await detectHarness(client.id))?.version) {
+            throw new ModelUnavailableError(notInstalled(client));
+        }
+        return { model: client.image.model(model), ref, vendor, gateway: false, metered: false };
+    }
+    const gateway = ownGateway();
+    if (gateway) {
+        return {
+            model: gateway.imageModel(`${vendor}/${model}`),
+            ref,
+            vendor,
+            gateway: true,
+            metered: false,
+        };
+    }
+    if (local.keys.openai && vendor === "openai") {
+        return {
+            model: createOpenAI({ apiKey: local.keys.openai }).image(model),
+            ref,
+            vendor,
+            gateway: false,
+            metered: false,
+        };
+    }
+    throw new ModelUnavailableError("Für Bilder ist kein Modell eingerichtet.");
+}
+export async function videoModel(meta = {}) {
+    const remote = await viaGateway("video", meta, (client, id) => client.videoModel(id));
+    if (remote) {
+        return remote;
+    }
+    const ref = localRef("video");
+    const { vendor, model } = split(ref);
+    const gateway = ownGateway();
+    if (gateway) {
+        return {
+            model: gateway.videoModel(`${vendor}/${model}`),
+            ref,
+            vendor,
+            gateway: true,
+            metered: false,
+        };
+    }
+    throw new ModelUnavailableError("Für Videos ist kein Modell eingerichtet.");
+}
+/** The model that reads a text aloud. */
+export async function speechModel(meta = {}) {
+    const access = await gatewayAccess();
+    if (access) {
+        const bound = (await classCatalog())?.classes.speech?.model;
+        if (!bound) {
+            throw new ModelUnavailableError("Für Sprachausgabe ist kein Modell eingerichtet.");
+        }
+        return {
+            model: gatewayClient(access, meta).speechModel("wizards/speech"),
+            ref: bound,
+            vendor: vendorOf(bound.replace(/^[a-z]+:/, "")),
+            gateway: true,
+            metered: true,
+        };
+    }
+    const ref = localRef("speech");
+    const { vendor, model } = split(ref);
+    const gateway = ownGateway();
+    if (gateway) {
+        return {
+            model: gateway.speechModel(`${vendor}/${model}`),
+            ref,
+            vendor,
+            gateway: true,
+            metered: false,
+        };
+    }
+    if (local.keys.openai && vendor === "openai") {
+        return {
+            model: createOpenAI({ apiKey: local.keys.openai }).speech(model),
+            ref,
+            vendor,
+            gateway: false,
+            metered: false,
+        };
+    }
+    throw new ModelUnavailableError("Für Sprachausgabe ist kein Modell eingerichtet.");
+}
+/**
+ * The model that turns passages and questions into vectors for a project's document index.
+ * Null where none is set up — an installed AI client has no such model — and the index then
+ * works on keywords alone.
+ */
+export async function embeddingModel() {
+    const access = await gatewayAccess().catch(() => null);
+    if (access) {
+        const bound = (await classCatalog())?.classes.embedding;
+        return bound
+            ? { model: gatewayClient(access, {}).embeddingModel("wizards/embedding"), ref: bound.model }
+            : null;
+    }
+    const ref = env.models.embedding;
+    const { provider, vendor, model } = split(ref);
+    if (provider === "ollama") {
+        const ollama = createOpenAI({
+            baseURL: local.settings.ollamaUrl ?? env.ollamaUrl,
+            apiKey: "ollama",
+        });
+        return { model: ollama.embedding(model ? `${vendor}/${model}` : vendor), ref };
+    }
+    const gateway = ownGateway();
+    if ((provider === null || provider === "gateway") && gateway) {
+        return { model: gateway.embeddingModel(`${vendor}/${model}`), ref };
+    }
+    if ((provider === "openai" || vendor === "openai") && local.keys.openai) {
+        return { model: createOpenAI({ apiKey: local.keys.openai }).embedding(model || vendor), ref };
+    }
+    return null;
+}
+/** Gemini image models are chat models answering with image files. */
+export function isChatImageModel(ref) {
+    return ref.includes("gemini") && ref.includes("image");
+}
+/** Search tools an AI Gateway runs itself; they travel in the request, so any gateway client names them. */
+export const gatewayTools = createGateway({ apiKey: "unused" }).tools;
+/** Whether any text model can answer at all: the studio says so before the first chat turn. */
+/**
+ * Whether a class can run here, found out without calling it: null, or what the person reads.
+ * A class the gateway serves counts as there unless its catalog leaves it unbound.
+ */
+export async function classProblem(cls) {
+    try {
+        const resolved = cls === "image"
+            ? await imageModel()
+            : cls === "video"
+                ? await videoModel()
+                : cls === "speech"
+                    ? await speechModel()
+                    : await textModel(cls);
+        if (resolved.metered) {
+            const bound = (await classCatalog())?.classes;
+            return bound && !bound[cls] ? "Dafür ist beim Konto kein Modell eingerichtet." : null;
+        }
+        const client = harness(resolved.vendor);
+        if (client && (await detectHarness(client.id))?.auth === "none") {
+            return signedOut(client);
+        }
+        return null;
+    }
+    catch (err) {
+        if (err instanceof ModelUnavailableError) {
+            return err.message;
+        }
+        throw err;
+    }
+}
+export async function hasTextModel() {
+    try {
+        await textModel("standard");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+let catalog = new Map();
+let catalogLoadedAt = 0;
+/** Public prices of the AI Gateway: what a runtime that runs alone shows as the cost of a run. */
+export async function loadCatalog(force = false) {
+    if (!force && Date.now() - catalogLoadedAt < 6 * 3600_000 && catalog.size) {
+        return;
+    }
+    try {
+        const res = await fetch("https://ai-gateway.vercel.sh/v1/models", {
+            signal: AbortSignal.timeout(10_000),
+        });
+        const body = (await res.json());
+        catalog = new Map(body.data.map((m) => [m.id, m]));
+        catalogLoadedAt = Date.now();
+    }
+    catch {
+        // Prices fall back to conservative defaults below.
+    }
+}
+function priceOf(ref) {
+    const { vendor, model } = split(ref);
+    return catalog.get(`${vendor}/${model}`)?.pricing ?? {};
+}
+const n = (v, fallback) => {
+    const x = Number(v);
+    return Number.isFinite(x) ? x : fallback;
+};
+export function usageOf(u) {
+    return {
+        inputTokens: u?.inputTokens ?? 0,
+        outputTokens: u?.outputTokens ?? 0,
+        cachedInputTokens: u?.cachedInputTokens ?? u?.inputTokenDetails?.cacheReadTokens ?? 0,
+    };
+}
+/** Provider cost of a text call a runtime that runs alone made; the gateway books the others itself. */
+export function costOf(resolved, usage) {
+    // An installed client answers on its subscription: nothing to book.
+    return resolved.metered || isHarnessVendor(resolved.vendor)
+        ? 0
+        : tokenCostUsd(resolved.ref, usageOf(usage));
+}
+export function tokenCostUsd(ref, usage) {
+    if (!usage) {
+        return 0;
+    }
+    const p = priceOf(ref);
+    const input = n(p.input, 0.000003);
+    const output = n(p.output, 0.000015);
+    const cached = n(p.input_cache_read, input / 10);
+    const cachedTokens = usage.cachedInputTokens ?? 0;
+    const freshInput = Math.max(0, (usage.inputTokens ?? 0) - cachedTokens);
+    return freshInput * input + cachedTokens * cached + (usage.outputTokens ?? 0) * output;
+}
+export function imageCostUsd(ref) {
+    const p = priceOf(ref);
+    const tiers = p.image_dimension_quality_pricing;
+    const tier = tiers?.find((t) => t.size === "default") ?? tiers?.[0];
+    return n(tier?.cost ?? p.image, 0.08);
+}
+export function videoCostUsd(ref, seconds, resolution = "720p") {
+    const p = priceOf(ref);
+    const tiers = p.video_duration_pricing;
+    // We render at 720p or 480p with sound: price that tier where the catalog has one; else the
+    // dearest below 4K, so the estimate is never short.
+    const exact = tiers?.filter((t) => t.resolution === resolution) ?? [];
+    const usable = exact.length ? exact : (tiers?.filter((t) => t.resolution !== "4k") ?? []);
+    const withAudio = usable.filter((t) => t.audio !== false);
+    const pick = withAudio.length ? withAudio : usable;
+    const perSecond = pick.length ? Math.max(...pick.map((t) => n(t.cost_per_second, 0))) : 0.4;
+    return perSecond * seconds;
+}
+/** Speech is priced per character read, or per audio token (about 25 a second, 15 characters). */
+export function speechCostUsd(ref, characters) {
+    const p = priceOf(ref);
+    if (p.speech_input_character_cost !== undefined) {
+        return n(p.speech_input_character_cost, 0.00003) * characters;
+    }
+    return n(p.audio_output_token_cost, 0.00001) * Math.ceil((characters / 15) * 25);
+}
+export const WEB_SEARCH_COST_USD = 0.01;

package/apps/runtime/dist/plugin.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { zipSync } from "fflate";
+import { env } from "./env.js";
+/**
+ * The Claude Code plugin for this deployment: the `plugin/` folder with this server's URL filled
+ * in, served as a marketplace (`url` source) whose one plugin is a zip (`archive` source). So
+ * every deployment hands out its own plugin and no domain is baked into the repo.
+ */
+const here = dirname(fileURLToPath(import.meta.url));
+/** The folder that holds `plugin/` and the root package.json: three levels above this file. */
+const base = resolve(here, "../../..");
+const root = existsSync(join(base, "plugin")) ? base : undefined;
+export const PLUGIN_NAME = "engenty-wizards";
+export const MARKETPLACE_NAME = "engenty";
+export const pluginBase = `${env.appUrl}/api/claude-plugin`;
+async function filesUnder(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const nested = await Promise.all(entries.map((e) => (e.isDirectory() ? filesUnder(join(dir, e.name)) : [join(dir, e.name)])));
+    return nested.flat();
+}
+let built = null;
+export function pluginArchive() {
+    built ??= (async () => {
+        if (!root) {
+            throw new Error("plugin/ folder missing");
+        }
+        const { version } = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        const dir = join(root, "plugin");
+        const files = {};
+        for (const path of (await filesUnder(dir)).sort()) {
+            const text = (await readFile(path, "utf8"))
+                .replaceAll("{{APP_URL}}", env.appUrl)
+                .replaceAll("{{VERSION}}", version);
+            // Fixed timestamps keep the archive, and so its sha256, stable across restarts.
+            files[relative(dir, path)] = new TextEncoder().encode(text);
+        }
+        const zip = zipSync(files, { level: 9, mtime: new Date("2026-01-01T00:00:00Z") });
+        return { zip, sha256: createHash("sha256").update(zip).digest("hex"), version };
+    })();
+    return built;
+}
+export async function pluginMarketplace() {
+    const { sha256, version } = await pluginArchive();
+    return {
+        name: MARKETPLACE_NAME,
+        owner: { name: "engenty" },
+        description: "engenty wizards for Claude Code",
+        plugins: [
+            {
+                name: PLUGIN_NAME,
+                description: "Build page-by-page AI wizards that people open on a shared link — designed, tested and published from Claude Code.",
+                version,
+                source: { source: "archive", url: `${pluginBase}/${PLUGIN_NAME}.zip`, sha256 },
+            },
+        ],
+    };
+}

package/apps/runtime/dist/render/chromium.js

@@ -0,0 +1,85 @@
+import { chromium } from "playwright-core";
+import { env } from "../env.js";
+import { assertPublicUrl } from "../tools/net-guard.js";
+/**
+ * One Chromium for the whole server: the engenty-browser container over CDP when
+ * `BROWSER_CDP_URL` is set, else a local headless Chrome. Every user of it opens
+ * its own context, so runs never share cookies or storage.
+ */
+let browserPromise = null;
+async function connect() {
+    const browser = env.browserCdpUrl
+        ? await chromium.connectOverCDP(env.browserCdpUrl)
+        : await chromium.launch({
+            executablePath: env.chromePath,
+            headless: true,
+            args: ["--no-sandbox", "--disable-dev-shm-usage", "--font-render-hinting=none"],
+        });
+    browser.on("disconnected", () => {
+        browserPromise = null;
+    });
+    return browser;
+}
+export function getBrowser() {
+    if (!browserPromise) {
+        browserPromise = connect().catch((err) => {
+            browserPromise = null;
+            throw err;
+        });
+    }
+    return browserPromise;
+}
+export async function newContext(options = {}) {
+    const browser = await getBrowser();
+    return browser.newContext({ viewport: { width: 1280, height: 900 }, ...options });
+}
+const hostChecks = new Map();
+function publicHost(url) {
+    let host;
+    try {
+        host = new URL(url).host;
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+    let check = hostChecks.get(host);
+    if (!check) {
+        check = assertPublicUrl(url).then(() => true, () => false);
+        hostChecks.set(host, check);
+        if (hostChecks.size > 2000) {
+            hostChecks.clear();
+        }
+    }
+    return check;
+}
+/**
+ * A context for browsing the web on a person's behalf: every request, whoever started it (the
+ * agent, a redirect, the person clicking), may only reach public hosts.
+ */
+export async function webContext(options = {}) {
+    const context = await newContext({ acceptDownloads: true, ...options });
+    await context.route("**/*", async (route) => {
+        const url = route.request().url();
+        if (!/^https?:/i.test(url) || (await publicHost(url))) {
+            await route.continue();
+        }
+        else {
+            await route.abort("blockedbyclient");
+        }
+    });
+    return context;
+}
+/**
+ * A context for rendering generated HTML: every network request is refused. The HTML is
+ * self-contained by design, and nothing it runs may reach the server's network.
+ */
+export async function offlineContext(options = {}) {
+    const context = await newContext({ javaScriptEnabled: true, ...options });
+    await context.route("**/*", (route) => route.abort("blockedbyclient"));
+    return context;
+}
+export async function closeBrowser() {
+    const b = await browserPromise?.catch(() => null);
+    browserPromise = null;
+    await b?.close().catch(() => undefined);
+}