wizards 0.2.29 → 0.2.31

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

@@ -91,6 +91,14 @@ export async function accountToken() {
     if (cached && cached.expiresAt - Date.now() > 60_000) {
         return cached.token;
     }
+    // One refresh at a time: a refresh token is used once, a second caller would be refused.
+    refreshing ??= refreshAccount().finally(() => {
+        refreshing = null;
+    });
+    return refreshing;
+}
+let refreshing = null;
+async function refreshAccount() {
     const refresh = await vaultGet(REFRESH);
     if (!refresh) {
         return null;

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

@@ -7,6 +7,7 @@ import { nanoid } from "nanoid";
 import { control, controlDb, withTenant } from "../db/client.js";
 import { basePath, env } from "../env.js";
 import { discovery, managed, tokenRequest, verifyToken, } from "../manage.js";
+import { refreshPro } from "../plugins/pro.js";
 import { seal, unseal } from "../secrets/crypto.js";
 import { LOCAL_TENANT } from "../tenants/tenant.js";
 import { finishLink } from "./account.js";
@@ -278,6 +279,8 @@ export const authRoutes = new Hono()
             await finishLink(code, rawState);
             // What is published here goes to the account's cloud, from now on and once for all there is.
             void firstSync();
+            // The Pro modules the account's plan includes.
+            void refreshPro();
             return c.html(closePage("Angemeldet. Du kannst dieses Fenster schließen."));
         }
         catch (err) {

package/apps/runtime/dist/authoring/guide.js

@@ -256,6 +256,7 @@ ${sandboxGuideLine()}
 - Logins on websites: never ask for passwords in page fields. An agent step with the browser tool asks the person at the moment it meets the login (browser_request_credentials); write that into its instructions, and that it must go on without the site when the person skips.
 - Most people open a wizard on their phone. Keep pages short, and let the phone do the typing: photos with an "image" field (multiple) instead of descriptions, the place with a "location" field instead of an address form, what happened as an "audio" field instead of a long textarea (keep an optional textarea beside it), a sign-off as a "signature" field, a serial or ticket number as a "text" field with scan. Typical: damage report, handover protocol, site inspection, delivery note.
 - Photos in documents: a document step can place the photos of an earlier "image" field and a "signature" (it gets them as asset:// images); say in its prompt where they go.
+- Pictures from the web (a listing's photos, a product shot an agent found): a document's <img src="https://…"> and image URLs in a widget's data (keys like image, photo, thumbnail, or a URL ending in .jpg/.png/.webp) are fetched once when the step runs and kept with the run — up to 40 per step. The page itself loads nothing from the network, so a URL left as is stays blank.
 - Looking at photos: an agent step whose instructions name an image field ({{photos}}) gets up to 8 of its photos attached and sees them itself, in the person's order — do not tell it to call read_document for them. Photos in a "file" field, PDFs and scans are read with read_document / scan_documents.
 - Papers and scans: a "file" field with multiple and camera. Agent steps read uploads with read_document; for invoices and receipts scan_documents returns the fields (vendor, number, date, totals, currency) exactly as printed.
 - Collecting documents (invoices from mail or portals): the step keeps each file with mail_save / browser_download under a dated path ("invoices/2026-09/2026-09-03_Notion_INV-123.pdf"); its deliverable offers "zip". Split a big job into steps (mail, then statements, then portals) — one step manages about 60 tool calls.

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

@@ -5,6 +5,7 @@ import { Agent } from "@mastra/core/agent";
 import { generateText, Output } from "ai";
 import { z } from "zod";
 import { extFor, loadAsset, loadAssetText } from "../files/storage.js";
+import { snapshotHtmlImages } from "../files/web-images.js";
 import { runFilmStep } from "../film/step.js";
 import { generateImageMedia, generateSpeechMedia, generateVideoMedia, } from "../media/generate.js";
 import { markMedia } from "../media/marking.js";
@@ -804,7 +805,8 @@ export async function runGenerateStep(step, ctx) {
         }
         case "document":
         case "dashboard": {
-            const html = await writeHtml(step, ctx, step.asset);
+            // Pictures the model took from the web stay: the page itself may load none.
+            const html = await snapshotHtmlImages(await writeHtml(step, ctx, step.asset), ctx.saveAsset, step.id, ctx.signal);
             const ref = await ctx.saveAsset({
                 stepId: step.id,
                 kind: "html",

package/apps/runtime/dist/env.js

@@ -222,6 +222,11 @@ export const env = {
         watch: !manageUrl && str("PLUGINS_WATCH", "1") === "1",
         /** Plugins' jobs (`server.every`) run. Off (`PLUGIN_JOBS=0`) where another process runs them. */
         jobs: str("PLUGIN_JOBS", "1") === "1",
+        /**
+         * Public keys (Ed25519, SPKI DER in base64) whose signature a Pro module may carry, besides
+         * the one this runtime ships with (plugins/pro-keys.ts). For testing packages signed elsewhere.
+         */
+        proKeys: list("PRO_MODULES_KEYS"),
     },
     limits: {
         visitorRunsPerHour: num("LIMIT_VISITOR_RUNS_PER_HOUR", 6),

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

@@ -11,6 +11,9 @@ const EXT = {
     "image/png": "png",
     "image/jpeg": "jpg",
     "image/webp": "webp",
+    "image/gif": "gif",
+    "image/avif": "avif",
+    "image/svg+xml": "svg",
     "video/mp4": "mp4",
     "video/webm": "webm",
     "video/quicktime": "mov",

package/apps/runtime/dist/files/web-images.js

@@ -0,0 +1,101 @@
+import { safeFetch } from "../tools/net-guard.js";
+/** Pictures one step may take from the web, and how large one may be. */
+const MAX_IMAGES = 40;
+const MAX_BYTES = 8_000_000;
+const TIMEOUT_MS = 10_000;
+const PARALLEL = 4;
+const IMAGE_EXT = /\.(?:jpe?g|png|webp|gif|avif|svg)(?:[?#]|$)/i;
+/** A key whose value is likely a picture: the extension of its URL may be hidden behind a token. */
+const IMAGE_KEY = /image|photo|picture|thumb|cover|logo|avatar|img|poster|banner/i;
+/** Fetches one picture; null when it is no image, too large, unreachable or private. */
+export async function fetchWebImage(url, signal) {
+    const timeout = AbortSignal.timeout(TIMEOUT_MS);
+    try {
+        const res = await safeFetch(url, {
+            signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+            headers: { accept: "image/*" },
+        });
+        const mime = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+        const length = Number(res.headers.get("content-length") ?? 0);
+        if (!res.ok || !mime.startsWith("image/") || length > MAX_BYTES) {
+            await res.body?.cancel();
+            return null;
+        }
+        const data = Buffer.from(await res.arrayBuffer());
+        return data.byteLength && data.byteLength <= MAX_BYTES ? { mime, data } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Takes the pictures behind `urls` into the run, a few at a time. */
+async function snapshot(urls, save, stepId, signal) {
+    const refs = new Map();
+    const list = [...new Set(urls)].slice(0, MAX_IMAGES);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(PARALLEL, list.length) }, async () => {
+        while (next < list.length && !signal?.aborted) {
+            const url = list[next++];
+            const image = await fetchWebImage(url, signal);
+            if (!image) {
+                continue;
+            }
+            const ref = await save({
+                stepId,
+                kind: "web-image",
+                mime: image.mime,
+                name: new URL(url).pathname.split("/").pop()?.slice(0, 120) || "image",
+                data: image.data,
+            });
+            refs.set(url, `asset://${ref.id}`);
+        }
+    }));
+    return { refs };
+}
+const IMG_SRC = /(<img\b[^>]*?\ssrc\s*=\s*)(["'])(https?:\/\/[^"']+)\2/gi;
+/** The pictures a generated page loads from the web, kept as assets; its <img> tags then point at them. */
+export async function snapshotHtmlImages(html, save, stepId, signal) {
+    const urls = [...html.matchAll(IMG_SRC)].map((m) => m[3]);
+    if (!urls.length) {
+        return html;
+    }
+    const { refs } = await snapshot(urls, save, stepId, signal);
+    return html.replace(IMG_SRC, (m, head, q, url) => {
+        const ref = refs.get(url);
+        return ref ? `${head}${q}${ref}${q}` : m;
+    });
+}
+function isImageUrl(value, key) {
+    if (!/^https?:\/\/\S+$/.test(value) || value.length > 2000) {
+        return false;
+    }
+    return IMAGE_EXT.test(new URL(value).pathname + new URL(value).search) || IMAGE_KEY.test(key);
+}
+function walk(value, key, visit) {
+    if (typeof value === "string") {
+        return isImageUrl(value, key) ? visit(value, key) : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => walk(v, key, visit));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v, k, visit)]));
+    }
+    return value;
+}
+/**
+ * The pictures a widget's data points to on the web (a listing's photos, a product's cover),
+ * kept as assets; the data then carries asset://ID where the page expects the URL.
+ */
+export async function snapshotDataImages(data, save, stepId, signal) {
+    const urls = [];
+    walk(data, "", (url) => {
+        urls.push(url);
+        return url;
+    });
+    if (!urls.length) {
+        return data;
+    }
+    const { refs } = await snapshot(urls, save, stepId, signal);
+    return walk(data, "", (url) => refs.get(url) ?? url);
+}

package/apps/runtime/dist/index.js

@@ -8,6 +8,7 @@ import { managed } from "./manage.js";
 import { checkModelsAtStart, loadCatalog, loadLocalModels } from "./models.js";
 import { startJobs } from "./plugins/jobs.js";
 import { loadPlugins } from "./plugins/loader.js";
+import { loadEntitlement, startProChecks } from "./plugins/pro.js";
 import { closeBrowser } from "./render/chromium.js";
 import { clearRunning, writeRunning } from "./running.js";
 import { syncMarketplace } from "./services/marketplace.js";
@@ -16,6 +17,8 @@ import { purgeUnusedStores } from "./store/index.js";
 import { LOCAL_TENANT } from "./tenants/tenant.js";
 import { onRestart } from "./update.js";
 await migrateControlDb();
+// What the linked account's plan confirmed last: the Pro modules it includes load with the rest.
+await loadEntitlement();
 // Before any tenant database opens: each gets the plugins' own tables as it does.
 await loadPlugins();
 startJobs();
@@ -31,6 +34,7 @@ else {
     await loadLocalModels();
     void loadCatalog();
     void checkModelsAtStart().catch(() => undefined);
+    startProChecks();
 }
 // The marketplace's starters and the starred entries, kept for offline use; checked hourly.
 void syncMarketplace();

package/apps/runtime/dist/manage.js

@@ -47,6 +47,11 @@ function toClaims(payload) {
  * `audiences` are the resources this caller accepts; null skips the audience check.
  */
 export async function verifyToken(token, audiences, base = env.manage.url) {
+    const payload = await verifySigned(token, audiences, base);
+    return payload ? toClaims(payload) : null;
+}
+/** Any token the Manage-App at `base` signed (its JWKS, its issuer); null when it is not one. */
+export async function verifySigned(token, audiences, base = env.manage.url) {
     try {
         const d = await discovery(base);
         let keys = keySets.get(d.jwks_uri);
@@ -58,7 +63,7 @@ export async function verifyToken(token, audiences, base = env.manage.url) {
             issuer: d.issuer,
             ...(audiences ? { audience: audiences } : {}),
         });
-        return toClaims(payload);
+        return payload;
     }
     catch {
         return null;

package/apps/runtime/dist/plugins/loader.js

@@ -10,12 +10,14 @@ import { pluginConnections } from "../connectors/plugin-connections.js";
 import { db, onTenantOpen } from "../db/client.js";
 import { parseDocument } from "../documents/parse.js";
 import { env } from "../env.js";
+import { managed } from "../manage.js";
 import { ModelUnavailableError, textModel } from "../models.js";
 import { putIndexEntry, removeIndexEntries } from "../services/project-index.js";
 import { originData } from "../services/space-origin.js";
 import { safeFetch } from "../tools/net-guard.js";
 import { discoverPlugins } from "./discovery.js";
 import { migrateOpenTenants, migratePlugins } from "./migrations.js";
+import { proModulesDir, proSources } from "./pro-state.js";
 import { publicUrlOf } from "./public.js";
 import { announceChange, compileRoute, dropPlugin, emptyRecord, loadedPlugin, loadedPlugins, setPlugin, } from "./registry.js";
 /**
@@ -231,11 +233,16 @@ export function pluginProblems() {
 }
 function discover() {
     const result = discoverPlugins(pluginDirs());
-    problems = result.problems;
+    // Pro modules come last and only while the plan has them (pro-state.ts).
+    const pro = managed ? null : discoverPlugins([proModulesDir()]);
+    const allowed = pro
+        ? proSources(pro.found, new Set(result.found.map((s) => s.id)))
+        : { load: [], problems: [] };
+    problems = [...result.problems, ...(pro?.problems ?? []), ...allowed.problems];
     for (const problem of problems) {
         console.error(`[plugins] ${problem.path}: ${problem.message}`);
     }
-    return result.found;
+    return [...result.found, ...allowed.load];
 }
 /** One load at a time: the watcher and a person may ask for a reload at the same moment. */
 let queue = Promise.resolve();

package/apps/runtime/dist/plugins/pro-keys.js

@@ -0,0 +1,34 @@
+import { createPublicKey, verify } from "node:crypto";
+import { env } from "../env.js";
+/**
+ * The keys a Pro module's package must be signed with (docs/content/dev/plugins/pro-modules).
+ * Only the public halves are here; the private one signs in the build of the closed plugins and
+ * is kept nowhere else. A new key is added beside the old one, which goes a release later.
+ */
+const SHIPPED = ["MCowBQYDK2VwAyEAqVQAptgVhkBtobNObBDHAZzKFdted0nH0I+LWAHGER8="];
+let keys = null;
+function trusted() {
+    keys ??= [...SHIPPED, ...env.plugins.proKeys].map((der) => createPublicKey({ key: Buffer.from(der, "base64"), format: "der", type: "spki" }));
+    return keys;
+}
+/** What the signature covers; the packer of the closed plugins writes the same text. */
+const message = (p) => `engenty-module:v1\n${p.id}\n${p.version}\n${p.runtime}\n${p.sha256}`;
+/** Whether one of the trusted keys signed this package for this release. */
+export function signedByUs(p) {
+    let signature;
+    try {
+        signature = Buffer.from(p.signature, "base64");
+    }
+    catch {
+        return false;
+    }
+    const data = Buffer.from(message(p));
+    return trusted().some((key) => {
+        try {
+            return verify(null, data, key, signature);
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/apps/runtime/dist/plugins/pro-state.js

@@ -0,0 +1,83 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { packageVersion } from "../cli/home.js";
+import { env } from "../env.js";
+import { managed } from "../manage.js";
+/**
+ * Which Pro modules may load (docs/content/dev/plugins/pro-modules). A Pro module is a closed
+ * plugin the linked account's plan includes, installed by pro.ts into a folder of its own. It
+ * loads while the entitlement the account's Manage-App signed lists it and has not ended, and
+ * only in the release it was built for. Kept apart from pro.ts, so the loader needs no network.
+ */
+/** Where Pro modules are installed: apart from the person's own plugins, not watched. */
+export const proModulesDir = () => join(env.dataDir, "pro-modules");
+/** Written beside an installed module: what was installed, for which release. */
+export const INSTALLED_FILE = ".engenty-module.json";
+export const ENTITLEMENT_SETTING = "pro.entitlement";
+let entitlement = null;
+export function currentEntitlement() {
+    return entitlement;
+}
+export function setEntitlement(value) {
+    entitlement = value;
+}
+/** `0.2.26` → `v0.2.26`: the release this runtime is. */
+export const runtimeTag = () => `v${packageVersion()}`;
+export function installedModule(root) {
+    try {
+        return JSON.parse(readFileSync(join(root, INSTALLED_FILE), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function heldBack(source) {
+    if (managed) {
+        return "managed";
+    }
+    const installed = installedModule(source.root);
+    if (!installed || installed.id !== source.id) {
+        return "not_installed";
+    }
+    if (installed.runtime !== runtimeTag()) {
+        return "release";
+    }
+    if (!(entitlement && entitlement.expiresAt > Date.now())) {
+        return "unconfirmed";
+    }
+    if (!entitlement.modules.includes(source.id)) {
+        return "plan";
+    }
+    return null;
+}
+let held = new Map();
+/** The Pro modules that were found and did not load, with the reason, as of the last look. */
+export function heldBackModules() {
+    return held;
+}
+/**
+ * The Pro modules of a look at the folders that may load, marked as such. A Pro module never
+ * takes the id of a plugin found elsewhere.
+ */
+export function proSources(found, taken) {
+    const load = [];
+    const problems = [];
+    held = new Map();
+    for (const source of found) {
+        if (taken.has(source.id)) {
+            problems.push({
+                path: source.root,
+                message: `Plugin "${source.id}" is already loaded from another folder.`,
+            });
+            continue;
+        }
+        const reason = heldBack(source);
+        if (reason) {
+            held.set(source.id, reason);
+        }
+        else {
+            load.push({ ...source, pro: true });
+        }
+    }
+    return { load, problems };
+}