@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/apps/runtime/dist/services/package-file.js

@@ -0,0 +1,82 @@
+import { note } from "@engenty-wizards/shared/run";
+import { manifestSchema, PACKAGE_FILES, PACKAGE_FORMAT, PACKAGE_MANIFEST, PACKAGE_MAX_BYTES, } from "@engenty-wizards/shared/wizard-package";
+import { cleanPath, WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
+import { strFromU8, unzipSync } from "fflate";
+import { ServiceError } from "./errors.js";
+/**
+ * Reading a `.wizard` package, with nothing of a project or a database: the studio's import and
+ * `wizards validate` both start here.
+ */
+const invalid = (said) => new ServiceError("invalid", said);
+export function json(data) {
+    try {
+        return JSON.parse(strFromU8(data));
+    }
+    catch {
+        throw invalid(note("wizardJsonUnreadable"));
+    }
+}
+/** A manifest, or a bare definition: a wizard without workspace is fully told by its JSON. */
+export function readManifest(raw) {
+    if (raw?.format !== PACKAGE_FORMAT) {
+        return { format: PACKAGE_FORMAT, version: 1, definition: raw, connectors: [], mcpServers: [] };
+    }
+    const parsed = manifestSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw invalid(note("wizardFileComesNewer"));
+    }
+    return parsed.data;
+}
+/** The package's content, checked against the workspace limits before anything is unpacked. */
+export function readPackage(data) {
+    const zipped = data[0] === 0x50 && data[1] === 0x4b;
+    if (!zipped) {
+        return { manifest: readManifest(json(data)), files: [] };
+    }
+    let total = 0;
+    let count = 0;
+    let entries;
+    try {
+        entries = unzipSync(data, {
+            filter: (file) => {
+                // Folders, and what the Finder adds when a package is zipped by hand.
+                if (file.name.endsWith("/") || /(^|\/)(__MACOSX\/|\.DS_Store$)/.test(file.name)) {
+                    return false;
+                }
+                total += file.originalSize;
+                count += 1;
+                if (file.originalSize > WORKSPACE_LIMITS.fileBytes) {
+                    throw invalid(note("fileOver5Mb", { name: file.name }));
+                }
+                if (count > WORKSPACE_LIMITS.files + 1 || total > PACKAGE_MAX_BYTES) {
+                    throw invalid(note("wizardFileTooLarge"));
+                }
+                return true;
+            },
+        });
+    }
+    catch (err) {
+        throw err instanceof ServiceError ? err : invalid(note("wizardFileNotOpened"));
+    }
+    // A package unpacked and zipped again often sits in a folder of its own.
+    const manifestPath = Object.keys(entries)
+        .filter((name) => name === PACKAGE_MANIFEST || name.endsWith(`/${PACKAGE_MANIFEST}`))
+        .sort((a, b) => a.length - b.length)[0];
+    if (manifestPath === undefined) {
+        throw invalid(note("wizardJsonMissing"));
+    }
+    const root = manifestPath.slice(0, -PACKAGE_MANIFEST.length);
+    const files = Object.entries(entries)
+        .filter(([name]) => name.startsWith(root + PACKAGE_FILES))
+        .map(([name, content]) => {
+        const path = cleanPath(name.slice(root.length + PACKAGE_FILES.length));
+        if (!path) {
+            throw invalid(note("notValidFilePath", { name }));
+        }
+        return { path, data: content };
+    });
+    if (files.reduce((n, f) => n + f.data.byteLength, 0) > WORKSPACE_LIMITS.totalBytes) {
+        throw invalid(note("workspaceWizardFileLarger"));
+    }
+    return { manifest: readManifest(json(entries[manifestPath])), files };
+}

package/apps/runtime/dist/services/package.js

@@ -0,0 +1,170 @@
+import { PACKAGE_EXTENSION, PACKAGE_FILES, PACKAGE_FORMAT, PACKAGE_MANIFEST, PACKAGE_SCHEMA_URL, } from "@engenty-wizards/shared/wizard-package";
+import { and, eq, isNull } from "drizzle-orm";
+import { strToU8, zipSync } from "fflate";
+import { listConnectors } from "../connectors/external.js";
+import { db, schema } from "../db/client.js";
+import { getBlob } from "../files/blobs.js";
+import { serverText } from "../texts.js";
+import { requireAdmin } from "./access.js";
+import { draftFiles, writeFile } from "./files.js";
+import { pageTree } from "./knowledge.js";
+import { readPackage } from "./package-file.js";
+import { ownedProject } from "./projects.js";
+import { createWizard, deleteWizard, draftIssues, ownedWizard, parseDraft } from "./wizards.js";
+/** A wizard as a file — the format is `@engenty-wizards/shared/wizard-package`'s. */
+/** Where the project's pages go in a package, as Markdown the standalone runner reads inline. */
+export const KNOWLEDGE_DIR = "knowledge/";
+/** How much of the project's knowledge a package takes along: enough pages, never the whole space. */
+export const KNOWLEDGE_MAX_CHARS = 2_000_000;
+/** What one page may hold in the package (the plugin hands a file to the model up to there). */
+export const KNOWLEDGE_PAGE_CHARS = 60_000;
+function fileName(title) {
+    const slug = title
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60);
+    return `${slug || "wizard"}${PACKAGE_EXTENSION}`;
+}
+/**
+ * The wizard as a file: its draft, or with `published` the version that is live (what a website
+ * runs on its own). Null with `published` while the wizard is a draft only.
+ */
+export async function exportWizard(userId, wizardId, options = {}) {
+    const w = await ownedWizard(userId, wizardId);
+    const live = options.published && w.publishedVersion !== null
+        ? await db.query.wizardVersion.findFirst({
+            where: and(eq(schema.wizardVersion.wizardId, w.id), eq(schema.wizardVersion.version, w.publishedVersion)),
+        })
+        : null;
+    if (options.published && !live) {
+        return null;
+    }
+    const definition = live ? live.definition : w.draft;
+    const project = await ownedProject(userId, w.projectId);
+    const named = new Set((definition.connections ?? []).map((c) => c.connector));
+    const servers = new Set(definition.steps.flatMap((s) => (s.type === "agent" ? (s.mcp ?? []) : [])));
+    const manifest = {
+        $schema: PACKAGE_SCHEMA_URL,
+        format: PACKAGE_FORMAT,
+        version: 1,
+        exportedAt: new Date().toISOString(),
+        definition,
+        connectors: (await listConnectors(project.id))
+            .filter((c) => c.sourceKind !== "builtin" && named.has(c.id))
+            .map((c) => ({
+            id: c.id,
+            name: c.name,
+            domain: c.domain,
+            sourceKind: c.sourceKind,
+        })),
+        mcpServers: project.mcpServers
+            .filter((s) => servers.has(s.id))
+            .map((s) => ({ id: s.id, name: s.name })),
+    };
+    const entries = {};
+    for (const f of live ? live.files : await draftFiles(w.id)) {
+        entries[PACKAGE_FILES + f.path] = new Uint8Array(await getBlob(f.hash));
+    }
+    if (options.knowledge) {
+        const snapshot = await knowledgeSnapshot(project.id);
+        manifest.knowledge = { pages: snapshot.pages.length, truncated: snapshot.truncated };
+        for (const page of snapshot.pages) {
+            entries[PACKAGE_FILES + KNOWLEDGE_DIR + page.path] = strToU8(page.text);
+        }
+    }
+    entries[PACKAGE_MANIFEST] = strToU8(JSON.stringify(manifest, null, 2));
+    return { name: fileName(definition.title), zip: zipSync(entries, { level: 6 }) };
+}
+/**
+ * The project's pages as Markdown files, one per page at its path (`pages/<a>/<b>` becomes
+ * `a/b.md`), each with its title in front: what a wizard that ran with `pages` reads inline on
+ * a site without the space. Opt-in, and capped: a page is cut at its own limit, and the pages
+ * stop where the whole would pass the snapshot's; `truncated` says so.
+ */
+export async function knowledgeSnapshot(projectId) {
+    const tree = await pageTree(projectId);
+    const rows = await db.query.spacePage.findMany({
+        where: and(eq(schema.spacePage.projectId, projectId), isNull(schema.spacePage.wizardId)),
+        columns: { id: true, markdown: true },
+    });
+    const markdown = new Map(rows.map((r) => [r.id, r.markdown]));
+    const nodes = [...tree.values()].sort((a, b) => a.path.localeCompare(b.path));
+    const pages = [];
+    let left = KNOWLEDGE_MAX_CHARS;
+    let truncated = false;
+    for (const node of nodes) {
+        const body = (markdown.get(node.id) ?? "").trim();
+        if (!body) {
+            continue;
+        }
+        const cut = body.length > KNOWLEDGE_PAGE_CHARS;
+        const text = `---\ntitle: ${yamlValue(node.title)}\npath: ${node.path}\n---\n\n${cut ? body.slice(0, KNOWLEDGE_PAGE_CHARS) : body}\n`;
+        if (text.length > left) {
+            truncated = true;
+            break;
+        }
+        truncated ||= cut;
+        left -= text.length;
+        pages.push({ path: `${node.path.replace(/^pages\//, "")}.md`, text });
+    }
+    return { pages, truncated };
+}
+/** A string as a YAML value: quoted, so a colon or a quote in a title does no harm. */
+function yamlValue(s) {
+    return JSON.stringify(s);
+}
+/** What the wizard names that the project does not have, in words for the chat. */
+async function missing(userId, projectId, draft, manifest) {
+    const project = await ownedProject(userId, projectId);
+    const connectors = await listConnectors(project.id);
+    const wanted = [...new Set((draft.connections ?? []).flatMap((c) => c.connector ?? []))];
+    const servers = [
+        ...new Set(draft.steps.flatMap((s) => (s.type === "agent" ? (s.mcp ?? []) : []))),
+    ];
+    return [
+        ...wanted
+            .filter((id) => !connectors.some((c) => c.id === id))
+            .map((id) => {
+            const told = manifest.connectors.find((c) => c.id === id);
+            return `Connector „${told?.name ?? id}“${told?.domain ? ` (${told.domain})` : ""}`;
+        }),
+        ...servers
+            .filter((id) => !project.mcpServers.some((s) => s.id === id))
+            .map((id) => `MCP-Server „${manifest.mcpServers.find((s) => s.id === id)?.name ?? id}“`),
+    ];
+}
+/** Makes a new wizard of a package in the project: the draft and its workspace, not published. */
+export async function importWizard(userId, projectId, data, name, 
+/** The language the admin reads the import's note in. */
+lang = "en") {
+    await requireAdmin();
+    const { manifest, files } = readPackage(data);
+    // The shape is checked before anything is written; a wrong one leaves no wizard behind.
+    const { draft } = parseDraft(manifest.definition, files.map((f) => f.path));
+    const lacks = await missing(userId, projectId, draft, manifest);
+    const counts = {
+        name,
+        steps: serverText(lang, "stepCount", { count: draft.steps.length }),
+        files: serverText(lang, "fileCount", { count: files.length }),
+    };
+    const note = [
+        serverText(lang, name ? "importedFrom" : "imported", counts),
+        lacks.length ? serverText(lang, "spaceStillNeeds", { needs: lacks }) : "",
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    const { id } = await createWizard(userId, { projectId, definition: draft, note });
+    try {
+        for (const file of files) {
+            await writeFile(userId, id, file.path, file.data);
+        }
+    }
+    catch (err) {
+        await deleteWizard(userId, id);
+        throw err;
+    }
+    return { id, issues: await draftIssues(await ownedWizard(userId, id)) };
+}

package/apps/runtime/dist/services/profile.js

@@ -0,0 +1,51 @@
+import { isLang } from "@engenty-wizards/shared/definition";
+import { z } from "zod";
+import { linkedAccount } from "../auth/account.js";
+import { managed } from "../manage.js";
+import { readSetting, writeSetting } from "../settings.js";
+export const profileSchema = z.object({
+    name: z.string().trim().max(80),
+    about: z.string().trim().max(2000),
+    email: z.string().trim().max(200),
+    phone: z.string().trim().max(40),
+});
+const key = (user) => `profile:${user.tenantId}:${user.id}`;
+/** The account whose name and e-mail the profile shows; null where the person sets them here. */
+async function accountOf(user) {
+    if (managed) {
+        return { name: user.name, email: user.email };
+    }
+    const linked = await linkedAccount();
+    return linked ? { name: linked.name, email: linked.email } : null;
+}
+export async function userProfile(user) {
+    const stored = (await readSetting(key(user))) ?? {};
+    const account = await accountOf(user);
+    return {
+        name: account?.name || stored.name || user.name,
+        about: stored.about ?? "",
+        email: account ? account.email : stored.email || user.email,
+        phone: stored.phone ?? "",
+    };
+}
+const langKey = (user) => `lang:${user.tenantId}:${user.id}`;
+/**
+ * The language the person picked in the studio, kept with them rather than one browser: a new
+ * browser or device opens in it. Null until they pick one; the browser's language stands then.
+ */
+export async function userLang(user) {
+    const lang = await readSetting(langKey(user));
+    return isLang(lang) ? lang : null;
+}
+export async function saveUserLang(user, lang) {
+    await writeSetting(langKey(user), lang);
+}
+export async function saveProfile(user, profile) {
+    // Name and e-mail an account gives stay the person's own underneath: they come back unlinked.
+    const stored = (await readSetting(key(user))) ?? {};
+    const own = (await accountOf(user))
+        ? { ...profile, name: stored.name ?? "", email: stored.email ?? "" }
+        : profile;
+    await writeSetting(key(user), own);
+    return userProfile(user);
+}