wizards 0.2.26 → 0.2.28

package/apps/runtime/dist/agents/project-assistant.js

@@ -12,7 +12,7 @@ import { brandColorSchema, ownedProject, updateProject } from "../services/proje
 import { categoryRows } from "../services/space-categories.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { safeFetch } from "../tools/net-guard.js";
-import { assistantToolsOf } from "../tools/plugin.js";
+import { assistantPageOf, assistantToolsOf } from "../tools/plugin.js";
 import { readWebsite } from "./website.js";
 const MAX_STEPS = 24;
 const SYSTEM = `You help the admin of "engenty wizards" set up a SPACE: what every wizard of the space draws on — who they are (title, about), the brand (logos, colours), assets (images, graphics, videos), documents, and facts (label → value: address, VAT id, phone, opening hours — anything).
@@ -337,7 +337,16 @@ export async function runProjectAssistant(input) {
         model: resolved.model,
         tools,
     });
+    const page = input.plugin
+        ? await assistantPageOf(currentTenant(), input.plugin, { id: project.id, name: project.name })
+        : null;
     const context = [
+        page
+            ? [
+                `The admin talks to you from the page of "${page.name}" in the studio${page.description ? `: ${page.description}` : "."} They most likely want to change what that page holds: use its tools (their names begin with "${input.plugin?.replace(/-/g, "_")}_"). Space settings stay possible when they ask for them.`,
+                ...page.blocks,
+            ].join("\n\n")
+            : "",
         `The project now:\n\`\`\`json\n${JSON.stringify(await projectState(input.userId, input.projectId))}\n\`\`\``,
         input.part === "knowledge"
             ? "The admin talks to you from Wissen: they want the wizards to know something."

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

@@ -78,7 +78,7 @@ type PageStep = { type: "page", fields: Field[] (1–5 per page), groups?: { id,
 //   rule can say it; "when" stays the first choice.
 type Field = {
   id (camelCase, unique across the WHOLE wizard), label, kind, required?, placeholder?, help?,
-  options?: string[]            // select / multiselect
+  options?: string[]            // select / multiselect / slot
   default?: string|number|boolean|string[]
   columns?: { id, label, kind: "text"|"number"|"money" }[]   // items only; row amount = product of number/money columns
   vat?: { rate?: number, field?: fieldId }                    // items only; VAT % fixed or read from a field
@@ -99,11 +99,11 @@ type Field = {
                                 //   the person types) or anything known before the page (an earlier answer, steps.<id>.<field>).
                                 //   A hidden field is not required and not kept; its {{template}} is empty.
   optionsFrom?: "steps.<id>.<key>" | "steps.<id>.<key>.<column>" | "lists.<id>.<column>"
-                                // select / multiselect: the choices come from earlier data — a "list" output, one column of a
+                                // select / multiselect / slot: the choices come from earlier data — a "list" output, one column of a
                                 //   "table" output, or a column of a stored list. "options" stand in while that data is empty.
 }
 // kinds: text textarea number select multiselect date email url toggle color image file items connection list
-//        location audio signature
+//        location audio signature slot
 //   location:  where the person is — the phone's position on a tap (with its accuracy), or an address they type.
 //              {{field}} → "Herrengasse 16, 8010 Graz (47.07071, 15.43950, ±12 m)" · {{field.lat}} {{field.lng}}
 //              {{field.accuracy}} (metres) · {{field.label}} (the address line) · {{field.map}} (a map link).
@@ -112,6 +112,10 @@ type Field = {
 //              {{field}} is what the person said, as text. {{field.seconds}} is its length.
 //   signature: drawn with the finger — a picture (dark ink, clear ground). A document step can place it:
 //              {{field}} → asset://ID, used as <img src="asset://ID">.
+//   slot:      the person picks one appointment time, shown by day. Options are ISO 8601 date-times with their offset
+//              ("2026-10-12T09:00:00+02:00"), nearly always from optionsFrom; {{field}} is the chosen one, as offered.
+//              Booking: agent step "free" with tools ["appointments.availability"] outputs a table "slots" with a "start" column;
+//              then a page { kind: "slot", optionsFrom: "steps.free.slots.start" }; then an agent step with appointments.book.
 
 type AgentStep = {
   type: "agent"

package/apps/runtime/dist/connectors/plugin-connections.js

@@ -0,0 +1,248 @@
+import { and, desc, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { buildAuthorizationUrl, createOAuth2Pkce, exchangeAuthorizationCode, refreshAccessToken, } from "../engenty/connections-sdk/oauth2.js";
+import { seal, unseal } from "../secrets/crypto.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { builtinConnector, connectorFetch, resolveEnv, usable, viaAccount } from "./builtin.js";
+import { connectRedirectUri as redirectUri } from "./index.js";
+import { AccountConnectError, redeemTicket, refreshThroughAccount, startThroughAccount, } from "./via-account.js";
+function oauthConnector(id) {
+    const connector = builtinConnector(id);
+    if (connector?.auth.kind !== "oauth2") {
+        throw new Error(`"${id}" is not a built-in connector that signs in.`);
+    }
+    return connector;
+}
+/** The provider rights the named actions need, and the connector's own base rights. */
+function scopesOf(connector, actions) {
+    const scopes = new Set(connector.auth.kind === "oauth2" ? connector.auth.oauth2.baseScopes : []);
+    for (const id of actions) {
+        const action = connector.actions.find((a) => a.id === id);
+        if (!action) {
+            throw new Error(`${connector.name} has no action "${id}".`);
+        }
+        for (const scope of action.providerScopes ?? []) {
+            scopes.add(scope);
+        }
+    }
+    return [...scopes];
+}
+const view = (row) => ({
+    id: row.id,
+    space: row.projectId,
+    connector: row.connector,
+    label: row.label,
+    actions: row.actions,
+    createdAt: row.createdAt.toISOString(),
+});
+/** A state the callback can tell is a plugin's: the tenant to finish it in, or null. */
+export function pluginStateTenant(rawState) {
+    const state = unseal(rawState);
+    return state && typeof state.plugin === "string" ? state.tenantId : null;
+}
+/**
+ * The provider came back for a plugin's sign-in: keeps the account. A second sign-in to the
+ * same account for the same space replaces the first one's tokens.
+ */
+export async function finishPluginOAuth(answer, rawState) {
+    const state = unseal(rawState);
+    if (!state?.plugin || state.exp < Date.now()) {
+        throw new Error("Die Anmeldung ist abgelaufen. Bitte noch einmal verbinden.");
+    }
+    const connector = oauthConnector(state.connectorId);
+    if (connector.auth.kind !== "oauth2") {
+        throw new Error("not an oauth connector");
+    }
+    const tokens = "ticket" in answer
+        ? await redeemTicket(answer.ticket)
+        : await exchangeAuthorizationCode({
+            code: answer.code,
+            codeVerifier: state.verifier,
+            config: connector.auth.oauth2,
+            redirectUri: redirectUri(),
+            resolveEnv,
+        });
+    const account = (await connector.auth.oauth2
+        .resolveAccount?.(tokens.accessToken, fetch)
+        .catch(() => null)) ?? { label: connector.name };
+    const stored = {
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt?.toISOString() ?? null,
+        scopes: tokens.grantedScopes,
+        ...("ticket" in answer ? { via: "account" } : {}),
+    };
+    const same = await db.query.pluginConnection.findFirst({
+        where: and(eq(schema.pluginConnection.plugin, state.plugin), eq(schema.pluginConnection.projectId, state.projectId), eq(schema.pluginConnection.connector, connector.id), eq(schema.pluginConnection.label, account.label)),
+    });
+    if (same) {
+        await db
+            .update(schema.pluginConnection)
+            .set({ actions: state.actions, data: seal(stored), updatedAt: new Date() })
+            .where(eq(schema.pluginConnection.id, same.id));
+    }
+    else {
+        await db.insert(schema.pluginConnection).values({
+            id: nanoid(14),
+            plugin: state.plugin,
+            projectId: state.projectId,
+            connector: connector.id,
+            label: account.label,
+            actions: state.actions,
+            data: seal(stored),
+        });
+    }
+    return { plugin: state.plugin, projectId: state.projectId };
+}
+/** The tokens of a connection, refreshed when they run out within five minutes. */
+async function freshTokens(row, connector) {
+    let data = unseal(row.data);
+    if (!data) {
+        throw new Error("The connection's keys cannot be read here. Connect the account again.");
+    }
+    const expires = data.expiresAt ? Date.parse(data.expiresAt) : null;
+    if (connector.auth.kind === "oauth2" &&
+        data.refreshToken &&
+        expires !== null &&
+        expires - Date.now() < 5 * 60_000) {
+        const tokens = data.via === "account"
+            ? await refreshThroughAccount(data.refreshToken)
+            : await refreshAccessToken({
+                config: connector.auth.oauth2,
+                refreshToken: data.refreshToken,
+                resolveEnv,
+            });
+        data = {
+            ...(data.via ? { via: data.via } : {}),
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken ?? data.refreshToken,
+            expiresAt: tokens.expiresAt?.toISOString() ?? null,
+            scopes: tokens.grantedScopes.length ? tokens.grantedScopes : data.scopes,
+        };
+        await db
+            .update(schema.pluginConnection)
+            .set({ data: seal(data), updatedAt: new Date() })
+            .where(eq(schema.pluginConnection.id, row.id));
+    }
+    return data;
+}
+function contextOf(row, connector, data) {
+    const ctx = {
+        accessToken: data.accessToken,
+        fetchImpl: connectorFetch,
+        log: () => undefined,
+        connection: {
+            id: row.id,
+            connector_id: connector.id,
+            auth_kind: connector.auth.kind,
+            autonomous_mode: "read_only",
+            connected_by: row.createdBy,
+            created_at: row.createdAt.toISOString(),
+            display_name: row.label,
+            error_message: null,
+            external_account: row.label,
+            granted_scopes: data.scopes,
+            owner_user_id: null,
+            space_id: row.projectId,
+            status: "active",
+            tenant_id: currentTenant(),
+        },
+    };
+    return ctx;
+}
+/** `server.connections` of one plugin; every call runs inside the current tenant. */
+export function pluginConnections(plugin) {
+    const own = (id) => db.query.pluginConnection.findFirst({
+        where: and(eq(schema.pluginConnection.id, id), eq(schema.pluginConnection.plugin, plugin)),
+    });
+    return {
+        async available(ids) {
+            const out = [];
+            for (const id of ids) {
+                const connector = builtinConnector(id);
+                if (connector?.auth.kind === "oauth2" && (await usable(connector))) {
+                    out.push({ id, name: connector.name });
+                }
+            }
+            return out;
+        },
+        async start({ space, connector: connectorId, actions }) {
+            const connector = oauthConnector(connectorId);
+            if (connector.auth.kind !== "oauth2") {
+                throw new Error("not an oauth connector");
+            }
+            const project = await db.query.project.findFirst({
+                where: eq(schema.project.id, space),
+                columns: { id: true },
+            });
+            if (!project) {
+                throw new Error(`There is no space "${space}".`);
+            }
+            const scopes = scopesOf(connector, actions);
+            const base = {
+                plugin,
+                tenantId: currentTenant(),
+                projectId: space,
+                connectorId,
+                actions: [...new Set(actions)],
+                exp: Date.now() + 15 * 60_000,
+            };
+            if (await viaAccount(connector)) {
+                // The Manage-App keeps the PKCE verifier; ours stays empty.
+                try {
+                    const url = await startThroughAccount(scopes, seal({ ...base, verifier: "" }), redirectUri());
+                    return { url };
+                }
+                catch (err) {
+                    throw err instanceof AccountConnectError
+                        ? Object.assign(new Error(err.message), { status: 409, code: "account" })
+                        : err;
+                }
+            }
+            await connector.auth.oauth2.registerClient?.();
+            const pkce = createOAuth2Pkce();
+            const url = await buildAuthorizationUrl({
+                connector,
+                pkce,
+                redirectUri: redirectUri(),
+                scopes,
+                state: seal({ ...base, verifier: pkce.codeVerifier }),
+                resolveEnv,
+            });
+            return { url };
+        },
+        async list(space) {
+            const rows = await db.query.pluginConnection.findMany({
+                where: and(eq(schema.pluginConnection.plugin, plugin), eq(schema.pluginConnection.projectId, space)),
+                orderBy: [desc(schema.pluginConnection.createdAt)],
+            });
+            return rows.map(view);
+        },
+        async get(id) {
+            const row = await own(id);
+            return row ? view(row) : null;
+        },
+        async call(id, actionId, input) {
+            const row = await own(id);
+            if (!row) {
+                throw new Error(`There is no connection "${id}".`);
+            }
+            if (!row.actions.includes(actionId)) {
+                throw new Error(`The connection was not made for "${actionId}". Connect it again.`);
+            }
+            const connector = oauthConnector(row.connector);
+            const action = connector.actions.find((a) => a.id === actionId);
+            if (!action) {
+                throw new Error(`${connector.name} has no action "${actionId}".`);
+            }
+            const data = await freshTokens(row, connector);
+            return (await action.handler(action.inputSchema.parse(input), contextOf(row, connector, data)));
+        },
+        async remove(id) {
+            await db
+                .delete(schema.pluginConnection)
+                .where(and(eq(schema.pluginConnection.id, id), eq(schema.pluginConnection.plugin, plugin)));
+        },
+    };
+}

package/apps/runtime/dist/db/migrations/tenant/0010_plugin_connection.sql

@@ -0,0 +1,15 @@
+CREATE TABLE `plugin_connection` (
+	`id` text PRIMARY KEY NOT NULL,
+	`plugin` text NOT NULL,
+	`project_id` text NOT NULL,
+	`connector` text NOT NULL,
+	`label` text NOT NULL,
+	`actions` text NOT NULL,
+	`data` text NOT NULL,
+	`created_by` text,
+	`created_at` integer DEFAULT (unixepoch() * 1000) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch() * 1000) NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `project`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `plugin_connection_space` ON `plugin_connection` (`plugin`,`project_id`);