wizards 0.1.9

package/apps/runtime/dist/harness/terminal.js

@@ -0,0 +1,193 @@
+import { accessSync, chmodSync, constants } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { nanoid } from "nanoid";
+import { ServiceError } from "../services/errors.js";
+const BUFFER = 200_000;
+/** A session nobody looks at is ended after this long. */
+const IDLE_MS = 20 * 60_000;
+/** An ended session is kept this long for a page to read its last lines. */
+const LINGER_MS = 5 * 60_000;
+const sessions = new Map();
+/** The prebuilt helper node-pty forks must be executable; an install that skips scripts leaves it without the bit. */
+function ensureHelper() {
+    try {
+        const entry = createRequire(import.meta.url).resolve("node-pty");
+        const helper = join(dirname(entry), "..", "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+        try {
+            accessSync(helper, constants.X_OK);
+        }
+        catch {
+            chmodSync(helper, 0o755);
+        }
+    }
+    catch {
+        // Not on this platform, or not ours to change: spawning tells.
+    }
+}
+async function ptyModule() {
+    try {
+        ensureHelper();
+        const mod = (await import("node-pty"));
+        const spawn = mod.spawn ?? mod.default?.spawn;
+        if (!spawn) {
+            throw new Error("node-pty has no spawn");
+        }
+        return { spawn };
+    }
+    catch {
+        throw new ServiceError("refused", "Das eingebaute Terminal ist auf diesem Gerät nicht verfügbar. Führe den Befehl in deinem eigenen Terminal aus.");
+    }
+}
+function emit(session, event) {
+    for (const listener of session.listeners) {
+        listener(event);
+    }
+}
+function forget(session) {
+    if (session.poll) {
+        clearInterval(session.poll);
+    }
+    if (session.reaper) {
+        clearTimeout(session.reaper);
+    }
+    sessions.delete(session.id);
+}
+function rearm(session) {
+    if (session.reaper) {
+        clearTimeout(session.reaper);
+    }
+    session.reaper = setTimeout(() => {
+        if (session.listeners.size) {
+            rearm(session);
+            return;
+        }
+        if (!session.exit) {
+            session.pty.kill();
+        }
+        forget(session);
+    }, session.exit ? LINGER_MS : IDLE_MS);
+    session.reaper.unref();
+}
+/** Starts a command in a new terminal; the id names it to the page. */
+export async function openTerminal(opts) {
+    const { spawn } = await ptyModule();
+    const id = nanoid(16);
+    let pty;
+    try {
+        pty = spawn(opts.bin, opts.args, {
+            name: "xterm-256color",
+            cols: opts.cols ?? 100,
+            rows: opts.rows ?? 28,
+            cwd: opts.cwd,
+            env: opts.env,
+        });
+    }
+    catch (err) {
+        throw new ServiceError("refused", `Der Befehl konnte nicht starten: ${err.message}`);
+    }
+    const session = {
+        id,
+        pty,
+        buffer: "",
+        listeners: new Set(),
+        exit: null,
+        done: false,
+        poll: null,
+        reaper: null,
+    };
+    sessions.set(id, session);
+    pty.onData((data) => {
+        session.buffer = (session.buffer + data).slice(-BUFFER);
+        emit(session, { type: "data", data });
+    });
+    pty.onExit(({ exitCode }) => {
+        session.exit = { code: exitCode };
+        if (session.poll) {
+            clearInterval(session.poll);
+            session.poll = null;
+        }
+        emit(session, { type: "exit", code: exitCode });
+        rearm(session);
+    });
+    if (opts.until) {
+        const until = opts.until;
+        let asking = false;
+        session.poll = setInterval(() => {
+            if (asking || session.done) {
+                return;
+            }
+            asking = true;
+            void until()
+                .then((ok) => {
+                if (ok && !session.done) {
+                    session.done = true;
+                    emit(session, { type: "done" });
+                    opts.onDone?.();
+                    if (!session.exit) {
+                        // The command did its job; an app that stays open is ended for the person.
+                        setTimeout(() => {
+                            if (!session.exit) {
+                                session.pty.kill();
+                            }
+                        }, 1500).unref();
+                    }
+                }
+            })
+                .catch(() => undefined)
+                .finally(() => {
+                asking = false;
+            });
+        }, 3000);
+    }
+    rearm(session);
+    return id;
+}
+function sessionOf(id) {
+    const session = sessions.get(id);
+    if (!session) {
+        throw new ServiceError("not_found", "Dieses Terminal gibt es nicht mehr.");
+    }
+    return session;
+}
+/** Follows a terminal: what it printed so far, then everything new, then its end. */
+export function subscribeTerminal(id, listener) {
+    const session = sessionOf(id);
+    if (session.buffer) {
+        listener({ type: "data", data: session.buffer });
+    }
+    if (session.done) {
+        listener({ type: "done" });
+    }
+    if (session.exit) {
+        listener({ type: "exit", code: session.exit.code });
+    }
+    session.listeners.add(listener);
+    rearm(session);
+    return () => {
+        session.listeners.delete(listener);
+        rearm(session);
+    };
+}
+export function writeTerminal(id, data) {
+    const session = sessionOf(id);
+    if (!session.exit) {
+        session.pty.write(data);
+    }
+}
+export function resizeTerminal(id, cols, rows) {
+    const session = sessionOf(id);
+    if (!session.exit && cols > 0 && rows > 0) {
+        session.pty.resize(Math.min(cols, 500), Math.min(rows, 200));
+    }
+}
+export function closeTerminal(id) {
+    const session = sessions.get(id);
+    if (!session) {
+        return;
+    }
+    if (!session.exit) {
+        session.pty.kill();
+    }
+    forget(session);
+}

package/apps/runtime/dist/harness/types.js

@@ -0,0 +1,7 @@
+/**
+ * A harness is an AI client installed on this machine — Claude Code, Codex, Gemini CLI, Cursor
+ * Agent — that answers on the person's own subscription or sign-in. The runtime runs it headless
+ * as a model (./model.ts) and signs it in through the inline terminal (./terminal.ts). Nothing of
+ * this process reaches it: no key of ours, no session of a parent client.
+ */
+export const HARNESS_IDS = ["claude", "codex", "gemini", "cursor"];

package/apps/runtime/dist/index.js

@@ -0,0 +1,76 @@
+import { serve } from "@hono/node-server";
+import { localEntryUrl, purgeSessions } from "./auth/index.js";
+import { adoptLegacyData } from "./db/adopt.js";
+import { knownTenants, migrateAllTenants, migrateControlDb, openTenantDb, withTenant, } from "./db/client.js";
+import { resumeInterruptedRuns } from "./engine/runner.js";
+import { basePath, env } from "./env.js";
+import { managed } from "./manage.js";
+import { loadCatalog, loadLocalModels } from "./models.js";
+import { closeBrowser } from "./render/chromium.js";
+import { clearRunning, writeRunning } from "./running.js";
+import { syncMarketplace } from "./services/marketplace.js";
+import { purgeExpiredRuns } from "./services/shares.js";
+import { purgeUnusedStores } from "./store/index.js";
+import { LOCAL_TENANT } from "./tenants/tenant.js";
+import { onRestart } from "./update.js";
+await migrateControlDb();
+if (managed) {
+    // Every tenant database is brought to this release's schema; a new one migrates when first opened.
+    void migrateAllTenants().then(({ migrated, failed }) => {
+        console.log(`tenant databases: ${migrated} current${failed.length ? `, failed: ${failed}` : ""}`);
+    });
+}
+else {
+    await adoptLegacyData();
+    await openTenantDb(LOCAL_TENANT);
+    await loadLocalModels();
+    void loadCatalog();
+}
+// The marketplace's starters and the starred entries, kept for offline use; checked hourly.
+void syncMarketplace();
+setInterval(() => void syncMarketplace(), 3600_000).unref();
+const { default: app } = await import("./app.js");
+/** Behind a path (APP_URL ends in /w) the proxy may leave the prefix on; the routes know none. */
+function withoutBasePath(request) {
+    const url = new URL(request.url);
+    if (basePath && (url.pathname === basePath || url.pathname.startsWith(`${basePath}/`))) {
+        url.pathname = url.pathname.slice(basePath.length) || "/";
+        return app.fetch(new Request(url, request));
+    }
+    return app.fetch(request);
+}
+const server = serve({ fetch: withoutBasePath, port: env.port, hostname: env.host }, (info) => {
+    console.log(`engenty wizards on :${info.port} — ${env.appUrl}`);
+    const entry = localEntryUrl();
+    if (entry && !env.local.accessKey) {
+        console.log(`Open the studio: ${entry}`);
+    }
+    if (!managed) {
+        writeRunning(env.dataDir, {
+            pid: process.pid,
+            port: info.port,
+            url: env.appUrl,
+            startedAt: new Date().toISOString(),
+        });
+    }
+});
+await resumeInterruptedRuns();
+// End-user results are kept RESULT_TTL_DAYS; expired runs and their files go once an hour.
+// What a wizard keeps for a person goes once nobody used it for STORE_TTL_DAYS.
+async function purge() {
+    await purgeSessions();
+    for (const id of await knownTenants()) {
+        await withTenant(id, () => Promise.all([purgeExpiredRuns(), purgeUnusedStores()])).catch((err) => console.error(`[retention ${id}]`, err));
+    }
+}
+void purge().catch((err) => console.error("[retention]", err));
+setInterval(() => void purge().catch((err) => console.error("[retention]", err)), 3600_000).unref();
+async function shutdown(code = 0) {
+    clearRunning(env.dataDir);
+    server.close();
+    await closeBrowser();
+    process.exit(code);
+}
+process.on("SIGINT", () => shutdown());
+process.on("SIGTERM", () => shutdown());
+onRestart((code) => void shutdown(code));

package/apps/runtime/dist/limits.js

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+import { and, count, eq, gte } from "drizzle-orm";
+import { canSpend } from "./credits/credits.js";
+import { db, schema } from "./db/client.js";
+import { env } from "./env.js";
+export function hashIp(ip) {
+    if (!ip) {
+        return null;
+    }
+    return createHash("sha256").update(`${env.authSecret}:${ip}`).digest("hex").slice(0, 32);
+}
+function startOfDay() {
+    const d = new Date();
+    d.setUTCHours(0, 0, 0, 0);
+    return d;
+}
+/** Why a shared wizard cannot start a run right now, or null when it can. */
+export async function wizardUnavailable(w) {
+    if (!w.shareEnabled || w.publishedVersion === null) {
+        return "Dieser Wizard ist gerade nicht verfügbar.";
+    }
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.run)
+        .where(and(eq(schema.run.wizardId, w.id), eq(schema.run.mode, "live"), gte(schema.run.createdAt, startOfDay())));
+    if (n >= w.dailyRunLimit) {
+        return "Für heute ist das Limit dieses Wizards erreicht. Bitte morgen wieder versuchen.";
+    }
+    if (!(await canSpend())) {
+        return "Dieser Wizard ist gerade nicht verfügbar.";
+    }
+    return null;
+}
+export async function verifyTurnstile(token, ip) {
+    if (!env.turnstile.secret) {
+        return true;
+    }
+    if (!token) {
+        return false;
+    }
+    const body = new URLSearchParams({ secret: env.turnstile.secret, response: token });
+    if (ip) {
+        body.set("remoteip", ip);
+    }
+    try {
+        const res = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
+            method: "POST",
+            body,
+            signal: AbortSignal.timeout(8000),
+        });
+        const data = (await res.json());
+        return Boolean(data.success);
+    }
+    catch {
+        return false;
+    }
+}

package/apps/runtime/dist/link-preview.js

@@ -0,0 +1,59 @@
+import { and, eq } from "drizzle-orm";
+import { db, schema } from "./db/client.js";
+import { env } from "./env.js";
+import { escapeHtml } from "./render/convert.js";
+import { sharedRun, shareView } from "./services/shares.js";
+function tags(p) {
+    const t = [
+        `<meta property="og:title" content="${escapeHtml(p.title)}">`,
+        `<meta property="og:description" content="${escapeHtml(p.description)}">`,
+        `<meta property="og:url" content="${escapeHtml(p.url)}">`,
+        `<meta property="og:type" content="website">`,
+        `<meta name="twitter:card" content="${p.image ? "summary_large_image" : "summary"}">`,
+        `<meta name="twitter:title" content="${escapeHtml(p.title)}">`,
+        `<meta name="twitter:description" content="${escapeHtml(p.description)}">`,
+    ];
+    if (p.image) {
+        t.push(`<meta property="og:image" content="${escapeHtml(p.image)}">`);
+        t.push(`<meta name="twitter:image" content="${escapeHtml(p.image)}">`);
+    }
+    return `<title>${escapeHtml(p.title)}</title>\n${t.join("\n")}`;
+}
+/**
+ * Open Graph tags for shared links, so X, LinkedIn, WhatsApp and Slack show a card: a shared
+ * result (`/s/<token>`) with its picture, a public wizard (`/w/<token>`) with its title.
+ */
+export async function linkPreview(path) {
+    const share = path.match(/^\/s\/([A-Za-z0-9_-]+)\/?$/);
+    if (share) {
+        const run = await sharedRun(share[1]);
+        if (!run) {
+            return null;
+        }
+        const view = await shareView(run);
+        return tags({
+            title: view.title === view.wizard.title ? view.title : `${view.title} · ${view.wizard.title}`,
+            description: view.message ?? view.wizard.description,
+            url: `${env.appUrl}/s/${share[1]}`,
+            image: `${env.appUrl}/api/shares/${share[1]}/image`,
+        });
+    }
+    const wizard = path.match(/^\/w\/([A-Za-z0-9_-]+)\/?$/);
+    if (wizard) {
+        const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.shareToken, wizard[1]) });
+        if (!w || w.publishedVersion === null || !w.shareEnabled) {
+            return null;
+        }
+        const v = await db.query.wizardVersion.findFirst({
+            where: and(eq(schema.wizardVersion.wizardId, w.id), eq(schema.wizardVersion.version, w.publishedVersion)),
+        });
+        return v
+            ? tags({
+                title: v.definition.title,
+                description: v.definition.description,
+                url: `${env.appUrl}/w/${wizard[1]}`,
+            })
+            : null;
+    }
+    return null;
+}

package/apps/runtime/dist/manage.js

@@ -0,0 +1,151 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+import { env } from "./env.js";
+/**
+ * The Manage-App as this runtime sees it (docs/manage-contract.md): it issues the tokens,
+ * knows the tenants and their credits. Nothing here runs when `MANAGE_URL` is empty.
+ */
+export const managed = Boolean(env.manage.url);
+const discoveries = new Map();
+/** OIDC discovery of a Manage-App, cached for an hour. */
+export async function discovery(base = env.manage.url) {
+    const hit = discoveries.get(base);
+    if (hit && Date.now() - hit.at < 3600_000) {
+        return hit.value;
+    }
+    const res = await fetch(`${base}/.well-known/openid-configuration`, {
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok) {
+        throw new Error(`Manage-App discovery failed: ${res.status}`);
+    }
+    const value = (await res.json());
+    discoveries.set(base, { at: Date.now(), value });
+    return value;
+}
+const keySets = new Map();
+function toClaims(payload) {
+    const p = payload;
+    if (typeof p.sub !== "string" || typeof p.tenant !== "string") {
+        return null;
+    }
+    const role = p.role === "owner" || p.role === "admin" ? p.role : "member";
+    return {
+        userId: p.sub,
+        tenantId: p.tenant,
+        role,
+        name: typeof p.name === "string" ? p.name : "",
+        email: typeof p.email === "string" ? p.email : "",
+        clientId: typeof p.azp === "string" ? p.azp : String(p.client_id ?? ""),
+        scopes: String(p.scope ?? "")
+            .split(" ")
+            .filter(Boolean),
+        expiresAt: (p.exp ?? 0) * 1000,
+    };
+}
+/**
+ * Verifies an access token of the Manage-App against its JWKS — no round trip per request.
+ * `audiences` are the resources this caller accepts; null skips the audience check.
+ */
+export async function verifyToken(token, audiences, base = env.manage.url) {
+    try {
+        const d = await discovery(base);
+        let keys = keySets.get(d.jwks_uri);
+        if (!keys) {
+            keys = createRemoteJWKSet(new URL(d.jwks_uri));
+            keySets.set(d.jwks_uri, keys);
+        }
+        const { payload } = await jwtVerify(token, keys, {
+            issuer: d.issuer,
+            ...(audiences ? { audience: audiences } : {}),
+        });
+        return toClaims(payload);
+    }
+    catch {
+        return null;
+    }
+}
+/** Reads a token's claims without verifying it — only for tokens the token endpoint just handed us. */
+export function unverifiedClaims(token) {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+        return toClaims(payload);
+    }
+    catch {
+        return null;
+    }
+}
+// --- service calls -----------------------------------------------------------
+export class ManageError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+async function call(method, path, body) {
+    const res = await fetch(`${env.manage.url}${path}`, {
+        method,
+        headers: {
+            authorization: `Bearer ${env.manage.serviceKey}`,
+            ...(body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(15_000),
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        throw new ManageError(res.status, data.code ?? "error", data.error ?? `Manage-App ${res.status}`);
+    }
+    return data;
+}
+const tenants = new Map();
+/** Plan, limits and balance of a tenant, cached for a minute. */
+export async function tenantInfo(id, fresh = false) {
+    const hit = tenants.get(id);
+    if (!fresh && hit && Date.now() - hit.at < 60_000) {
+        return hit.value;
+    }
+    const value = await call("GET", `/v1/tenants/${encodeURIComponent(id)}`);
+    tenants.set(id, { at: Date.now(), value });
+    return value;
+}
+export function forgetTenant(id) {
+    tenants.delete(id);
+}
+export function verifyKey(key) {
+    return call("POST", "/v1/keys/verify", { key });
+}
+export function reserve(tenantId, runId, credits) {
+    return call("POST", "/v1/reservations", { tenantId, runId, credits });
+}
+export function release(runId) {
+    return call("POST", "/v1/reservations/release", { runId });
+}
+export function runUsage(tenantId, runId) {
+    return call("GET", `/v1/runs/${encodeURIComponent(runId)}/usage?tenantId=${encodeURIComponent(tenantId)}`);
+}
+export function bookUsage(input) {
+    return call("POST", "/v1/usage", input);
+}
+/** Code or refresh token → tokens. A confidential client sends its secret, a public one only its id. */
+export async function tokenRequest(params, client, base = env.manage.url) {
+    const d = await discovery(base);
+    const body = new URLSearchParams({ ...params, client_id: client.id });
+    const headers = { "content-type": "application/x-www-form-urlencoded" };
+    if (client.secret) {
+        headers.authorization = `Basic ${Buffer.from(`${encodeURIComponent(client.id)}:${encodeURIComponent(client.secret)}`).toString("base64")}`;
+    }
+    const res = await fetch(d.token_endpoint, {
+        method: "POST",
+        headers,
+        body,
+        signal: AbortSignal.timeout(15_000),
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.access_token) {
+        throw new ManageError(res.status, data.error ?? "token_error", "Token request failed");
+    }
+    return data;
+}

package/apps/runtime/dist/mcp/auth.js

@@ -0,0 +1,102 @@
+import { API_KEY_PREFIX, verifyLocalKey } from "../auth/keys.js";
+import { env } from "../env.js";
+import { managed, verifyKey, verifyToken } from "../manage.js";
+import { LOCAL_TENANT } from "../tenants/tenant.js";
+import { MCP_RESOURCE, SCOPES } from "./scopes.js";
+export function principalOf(info) {
+    return info.extra;
+}
+function authInfoFor(who, token, clientId) {
+    return { token, clientId, scopes: who.scopes, extra: { ...who } };
+}
+function bearer(request) {
+    return (request.headers
+        .get("authorization")
+        ?.match(/^Bearer\s+(.+)$/i)?.[1]
+        ?.trim() || null);
+}
+const resourceMetadataUrl = (() => {
+    const url = new URL(MCP_RESOURCE);
+    return `${url.origin}/.well-known/oauth-protected-resource${url.pathname}`;
+})();
+/** RFC 6750 / RFC 9728 challenge: tells an MCP client where to start OAuth. */
+function challenge(status, error, description) {
+    return new Response(JSON.stringify({ error, error_description: description }), {
+        status,
+        headers: {
+            "content-type": "application/json",
+            ...(status === 401
+                ? {
+                    "www-authenticate": managed
+                        ? `Bearer error="${error}", error_description="${description}", resource_metadata="${resourceMetadataUrl}", scope="${SCOPES.join(" ")}"`
+                        : `Bearer error="${error}", error_description="${description}"`,
+                }
+                : {}),
+        },
+    });
+}
+const keyCache = new Map();
+/** An API key acts as its owner, in the key's tenant, with every scope. */
+async function apiKeyAuth(key) {
+    if (!managed) {
+        const found = await verifyLocalKey(key);
+        if (!found) {
+            return challenge(401, "invalid_token", "This API key is unknown or revoked.");
+        }
+        const who = {
+            userId: "local",
+            tenantId: LOCAL_TENANT,
+            client: found.name || "MCP",
+            scopes: [...SCOPES],
+        };
+        return authInfoFor(who, key, found.id);
+    }
+    const hit = keyCache.get(key);
+    if (hit && Date.now() - hit.at < 60_000) {
+        return authInfoFor(hit.who, key, hit.keyId);
+    }
+    const result = await verifyKey(key).catch(() => null);
+    if (!result?.valid || !result.userId || !result.tenantId) {
+        keyCache.delete(key);
+        return challenge(401, "invalid_token", "This API key is unknown or revoked.");
+    }
+    const who = {
+        userId: result.userId,
+        tenantId: result.tenantId,
+        client: result.name || "MCP",
+        scopes: [...SCOPES],
+    };
+    keyCache.set(key, { at: Date.now(), who, keyId: result.keyId ?? "" });
+    return authInfoFor(who, key, result.keyId ?? "");
+}
+/** An access token of the Manage-App, issued for this MCP endpoint, acts within its scopes. */
+async function tokenAuth(token) {
+    if (!managed) {
+        return challenge(401, "invalid_token", "Sign in with an API key from the settings.");
+    }
+    const claims = await verifyToken(token, [MCP_RESOURCE, env.appUrl]);
+    if (!claims) {
+        return challenge(401, "invalid_token", "The access token is invalid or expired.");
+    }
+    const granted = new Set(claims.scopes);
+    const who = {
+        userId: claims.userId,
+        tenantId: claims.tenantId,
+        client: claims.clientId || "MCP",
+        scopes: SCOPES.filter((s) => granted.has(s)),
+    };
+    return authInfoFor(who, token, claims.clientId);
+}
+/** Who an MCP or API request acts for: an API key (`x-api-key` or a `wz_…` bearer) or an OAuth access token. */
+export async function authenticate(request) {
+    const header = request.headers.get("x-api-key")?.trim();
+    const token = bearer(request);
+    const key = header || (token?.startsWith(API_KEY_PREFIX) ? token : null);
+    if (key) {
+        return apiKeyAuth(key);
+    }
+    if (!token) {
+        return challenge(401, "invalid_token", "Sign in to use this endpoint.");
+    }
+    return tokenAuth(token);
+}