wizards 0.2.2 → 0.2.4

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

@@ -1,10 +1,10 @@
 import { cleanPath, isTextMime, mimeForPath, WORKSPACE_LIMITS, } from "@engenty-wizards/shared/workspace";
-import { and, asc, eq } from "drizzle-orm";
+import { and, asc, eq, inArray } from "drizzle-orm";
 import { db, schema } from "../db/client.js";
 import { getBlob, putBlob } from "../files/blobs.js";
 import { emitDraftChanged, filesChanged } from "./draft-events.js";
 import { notFound, ServiceError } from "./errors.js";
-import { ownedWizard } from "./wizards.js";
+import { ownedWizard, writableWizard } from "./wizards.js";
 /** The draft's workspace, sorted by path — the same shape publishing and runs snapshot. */
 export async function draftFiles(wizardId) {
     const rows = await db.query.wizardFile.findMany({
@@ -44,7 +44,7 @@ export async function readFileText(userId, wizardId, rawPath) {
     return { path: file.path, mime: file.mime, size: file.size, text: data.toString("utf8") };
 }
 export async function writeFile(userId, wizardId, rawPath, content, mime) {
-    const w = await ownedWizard(userId, wizardId);
+    const w = await writableWizard(userId, wizardId);
     const path = requirePath(rawPath);
     const data = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
     if (data.byteLength > WORKSPACE_LIMITS.fileBytes) {
@@ -76,8 +76,57 @@ export async function writeFile(userId, wizardId, rawPath, content, mime) {
     emitDraftChanged(filesChanged(w, path));
     return file;
 }
+/**
+ * Keeps the bytes of files that are about to become a wizard's workspace, checked against the
+ * workspace limits, and says how their rows look — without touching the wizard yet. Bytes that
+ * nothing comes to refer to take no harm.
+ */
+export async function keepFiles(files) {
+    if (files.length > WORKSPACE_LIMITS.files) {
+        throw new ServiceError("invalid", `A workspace holds up to ${WORKSPACE_LIMITS.files} files.`);
+    }
+    let total = 0;
+    const kept = [];
+    for (const file of files) {
+        const path = requirePath(file.path);
+        if (file.data.byteLength > WORKSPACE_LIMITS.fileBytes) {
+            throw new ServiceError("invalid", `${path} is larger than 5 MB.`);
+        }
+        total += file.data.byteLength;
+        if (total > WORKSPACE_LIMITS.totalBytes) {
+            throw new ServiceError("invalid", "The workspace would be larger than 25 MB.");
+        }
+        kept.push({
+            path,
+            hash: await putBlob(file.data),
+            mime: file.mime && file.mime !== "application/octet-stream" ? file.mime : mimeForPath(path),
+            size: file.data.byteLength,
+        });
+    }
+    return kept;
+}
+/** Makes a wizard's workspace exactly `files` (kept with keepFiles): rows only, no bytes. */
+export async function replaceFiles(wizardId, files) {
+    const paths = files.map((f) => f.path);
+    const before = await draftFiles(wizardId);
+    const gone = before.filter((f) => !paths.includes(f.path)).map((f) => f.path);
+    if (gone.length) {
+        await db
+            .delete(schema.wizardFile)
+            .where(and(eq(schema.wizardFile.wizardId, wizardId), inArray(schema.wizardFile.path, gone)));
+    }
+    for (const file of files) {
+        await db
+            .insert(schema.wizardFile)
+            .values({ wizardId, ...file })
+            .onConflictDoUpdate({
+            target: [schema.wizardFile.wizardId, schema.wizardFile.path],
+            set: { hash: file.hash, mime: file.mime, size: file.size, updatedAt: new Date() },
+        });
+    }
+}
 export async function deleteFile(userId, wizardId, rawPath) {
-    const w = await ownedWizard(userId, wizardId);
+    const w = await writableWizard(userId, wizardId);
     const path = requirePath(rawPath);
     const gone = await db
         .delete(schema.wizardFile)

package/apps/runtime/dist/services/project-files.js

@@ -6,6 +6,7 @@ import { documentMime, UnreadableDocument } from "../documents/parse.js";
 import { loadAsset, removeAsset, saveAsset } from "../files/storage.js";
 import { textModel } from "../models.js";
 import { dropLinks, putLink } from "../tenants/control.js";
+import { requireWritableProject } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
 import { dropIndex, indexDocument } from "./project-index.js";
 /** Reading a file takes seconds to a few minutes; a row still `pending` after this was cut off. */
@@ -64,6 +65,7 @@ function accepts(kind, mime) {
     return true;
 }
 export async function addProjectFile(projectId, input) {
+    await requireWritableProject(projectId);
     const mime = documentMime(input.name, input.mime) || "application/octet-stream";
     if (!accepts(input.kind, mime)) {
         throw new ServiceError("invalid", input.kind === "logo"
@@ -208,6 +210,7 @@ async function prepare(row) {
     });
 }
 export async function reindexProjectFile(projectId, fileId) {
+    await requireWritableProject(projectId);
     const row = await projectFile(projectId, fileId);
     if (row.kind !== "document") {
         throw new ServiceError("invalid", "Nur Dokumente stehen im Index.");
@@ -221,6 +224,7 @@ export async function reindexProjectFile(projectId, fileId) {
     return pending;
 }
 export async function updateProjectFile(projectId, fileId, patch) {
+    await requireWritableProject(projectId);
     const row = await projectFile(projectId, fileId);
     const [updated] = await db
         .update(schema.projectFile)
@@ -236,6 +240,7 @@ export async function updateProjectFile(projectId, fileId, patch) {
 }
 /** Puts the files of one kind into the order of `ids`; the first logo is the one end users see. */
 export async function orderProjectFiles(projectId, kind, ids) {
+    await requireWritableProject(projectId);
     const rows = await projectFiles(projectId, kind);
     const order = [...ids.filter((id) => rows.some((r) => r.id === id))];
     for (const r of rows) {
@@ -256,6 +261,7 @@ async function removeRow(row) {
     }
 }
 export async function removeProjectFile(projectId, fileId) {
+    await requireWritableProject(projectId);
     await removeRow(await projectFile(projectId, fileId));
 }
 /** Before a project goes: its files leave the object store and the public links. */

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

@@ -1,11 +1,12 @@
 import { FACT_TYPES, PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
-import { and, count, eq } from "drizzle-orm";
+import { and, count, eq, isNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { db, schema } from "../db/client.js";
 import { env } from "../env.js";
 import { managed, tenantInfo } from "../manage.js";
 import { currentTenant } from "../tenants/tenant.js";
+import { mayBuild, requireBuild, requireWritable } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
 import { forgetWizardLinks } from "./links.js";
 import { removeProjectFiles } from "./project-files.js";
@@ -61,22 +62,33 @@ export async function ownedProject(_userId, projectId) {
     }
     return p;
 }
-/** A tenant always has a project: the first one is made when its studio is first opened. */
+/** The tenant's projects that were made here, not synced from a local install. */
+const madeHere = () => and(eq(schema.project.tenantId, currentTenant()), isNull(schema.project.origin));
+/** The tenant's projects a local install synced. */
+const synced = () => and(eq(schema.project.tenantId, currentTenant()), eq(schema.project.origin, "local"));
+/**
+ * A tenant that builds here always has a project of its own: the first one is made when its
+ * studio is first opened.
+ */
 async function ensureProject() {
-    const any = await db.query.project.findFirst({
-        where: eq(schema.project.tenantId, currentTenant()),
-    });
+    const any = await db.query.project.findFirst({ where: madeHere() });
     if (!any) {
         await db
             .insert(schema.project)
             .values({ id: nanoid(12), tenantId: currentTenant(), name: "Meine Wizards" });
     }
 }
-/** The project a wizard lands in when the caller names none: the oldest one. */
+/**
+ * The project a caller means when it names none: the oldest one made here, where a wizard
+ * lands; for a tenant that builds nothing here, the one its local install synced.
+ */
 export async function defaultProject(_userId) {
-    await ensureProject();
+    const build = await mayBuild();
+    if (build) {
+        await ensureProject();
+    }
     const p = await db.query.project.findFirst({
-        where: eq(schema.project.tenantId, currentTenant()),
+        where: build ? madeHere() : synced(),
         orderBy: [schema.project.createdAt],
     });
     if (!p) {
@@ -84,11 +96,18 @@ export async function defaultProject(_userId) {
     }
     return p;
 }
+/**
+ * The projects the studio shows. A tenant that builds here: its own and the synced ones, up to
+ * its number. One that does not: only what its local install synced — possibly nothing yet.
+ */
 export async function listProjects(_userId) {
-    await ensureProject();
+    const build = await mayBuild();
+    if (build) {
+        await ensureProject();
+    }
     // The oldest come first: with a limit of one, that is the project everything lands in.
     const projects = await db.query.project.findMany({
-        where: eq(schema.project.tenantId, currentTenant()),
+        where: build ? eq(schema.project.tenantId, currentTenant()) : synced(),
         orderBy: [schema.project.createdAt],
         limit: await projectLimit(),
     });
@@ -112,6 +131,7 @@ export function maskedServers(p) {
     }));
 }
 export async function createProject(_userId, name) {
+    await requireBuild();
     const [{ n }] = await db
         .select({ n: count() })
         .from(schema.project)
@@ -128,6 +148,7 @@ export async function createProject(_userId, name) {
 }
 export async function updateProject(userId, projectId, patch) {
     const p = await ownedProject(userId, projectId);
+    await requireWritable(p);
     const mcpServers = patch.mcpServers?.map((s) => {
         const before = p.mcpServers.find((x) => x.id === s.id);
         const headers = s.headers
@@ -160,13 +181,16 @@ export function projectProfile(p) {
         facts: p.facts.filter((f) => f.value.trim()),
     };
 }
-export async function deleteProject(_userId, projectId) {
-    const all = await db.query.project.findMany({
-        where: eq(schema.project.tenantId, currentTenant()),
-    });
+export async function deleteProject(userId, projectId) {
+    await requireWritable(await ownedProject(userId, projectId));
+    const all = await db.query.project.findMany({ where: madeHere() });
     if (all.length <= 1) {
         throw new ServiceError("refused", "Das letzte Projekt bleibt.");
     }
+    await removeProject(projectId);
+}
+/** Takes a project away with its wizards' links and its files. */
+export async function removeProject(projectId) {
     const wizards = await db
         .select({ id: schema.wizard.id })
         .from(schema.wizard)

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

@@ -0,0 +1,400 @@
+import { createHash } from "node:crypto";
+import { PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
+import { WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
+import { and, count, eq, inArray, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { db, inTransaction, schema } from "../db/client.js";
+import { missingModels, unavoidableSteps } from "../engine/requirements.js";
+import { env } from "../env.js";
+import { codeOf, putLink } from "../tenants/control.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { asSync, mayBuild } from "./access.js";
+import { emitDraftChanged } from "./draft-events.js";
+import { notFound, ServiceError } from "./errors.js";
+import { keepFiles, replaceFiles } from "./files.js";
+import { addProjectFile, projectFiles, removeProjectFile } from "./project-files.js";
+import { brandColorSchema, projectFactSchema, projectLimit, removeProject, } from "./projects.js";
+import { deleteWizard, draftIssues, parseDraft, shareUrl } from "./wizards.js";
+/**
+ * A local install's project on this runtime (docs/manage-contract.md, "Spaces of a local
+ * install"). The install sends a wizard when it publishes it: the published version and its
+ * workspace, under the ids they have there. Here the project is shown and its wizards run; it
+ * is changed only by the next sync. The share link is this runtime's own.
+ */
+/** Ids as the local install makes them (nanoid); nothing else is taken as a key. */
+const syncedId = z.string().regex(/^[A-Za-z0-9_-]{8,40}$/);
+const spaceSchema = z.object({
+    name: z.string().min(1).max(80),
+    brand: z
+        .object({
+        name: z.string().max(120).optional(),
+        about: z.string().max(8000).optional(),
+        colors: z.array(brandColorSchema).max(PROJECT_LIMITS.colors).optional(),
+    })
+        .default({}),
+    facts: z.array(projectFactSchema).max(PROJECT_LIMITS.facts).default([]),
+    /** The logo end users see; null for none. */
+    logo: z
+        .object({
+        name: z.string().min(1).max(120),
+        mime: z.string().max(100),
+        description: z.string().max(600).default(""),
+        data: z.string(),
+    })
+        .nullable()
+        .default(null),
+});
+export const syncWizardSchema = z.object({
+    space: spaceSchema,
+    /** The version the install published, as it counts them. */
+    version: z.number().int().min(1).max(1_000_000),
+    definition: z.unknown(),
+    files: z
+        .array(z.object({
+        path: z.string().max(300),
+        mime: z.string().max(100).optional(),
+        data: z.string(),
+    }))
+        .max(WORKSPACE_LIMITS.files)
+        .default([]),
+    shareEnabled: z.boolean().default(true),
+    dailyRunLimit: z.number().int().min(1).max(10_000).optional(),
+});
+export const syncSettingsSchema = z.object({
+    shareEnabled: z.boolean().optional(),
+    dailyRunLimit: z.number().int().min(1).max(10_000).optional(),
+});
+export const checkSchema = z.object({
+    definition: z.unknown(),
+    /** Paths of the wizard's workspace files. */
+    files: z.array(z.string().max(300)).max(WORKSPACE_LIMITS.files).default([]),
+});
+const stepsWith = (def, has) => def.steps.filter(has).map((s) => ({ id: s.id, title: s.title }));
+/**
+ * What of a wizard does not work on this runtime: what its validator says here (a connector
+ * the project lacks, a plugin's tool), model classes nothing is bound to, the sandbox where
+ * there is none, MCP servers the project does not know.
+ */
+export async function serverProblems(def, issues, mcpServers) {
+    const problems = issues.map((issue) => ({
+        code: /connector/i.test(issue.message) ? "connector" : "invalid",
+        blocking: true,
+        steps: stepsWith(def, (s) => s.id === issue.stepId),
+        detail: issue.message,
+    }));
+    for (const missing of await missingModels(def)) {
+        problems.push({
+            code: "model",
+            blocking: missing.blocking,
+            steps: missing.steps,
+            detail: `${missing.cls}: ${missing.problem}`,
+        });
+    }
+    if (env.sandbox === "off") {
+        const steps = stepsWith(def, (s) => s.type === "agent" && s.tools.includes("sandbox"));
+        if (steps.length) {
+            problems.push({ code: "sandbox", blocking: false, steps, detail: "" });
+        }
+    }
+    const unknown = new Set();
+    const steps = stepsWith(def, (s) => {
+        const lacking = s.type === "agent" ? (s.mcp ?? []).filter((id) => !mcpServers.includes(id)) : [];
+        for (const id of lacking) {
+            unknown.add(id);
+        }
+        return lacking.length > 0;
+    });
+    if (steps.length) {
+        const unavoidable = unavoidableSteps(def);
+        problems.push({
+            code: "mcp",
+            blocking: steps.some((s) => unavoidable.has(s.id)),
+            steps,
+            detail: [...unknown].join(", "),
+        });
+    }
+    return problems;
+}
+/** What a wizard would lack here, asked before it is sent: no project is touched. */
+export async function checkOnServer(input) {
+    const { draft, issues } = parseDraft(input.definition, input.files);
+    // Connectors are a project's; a project that is not here yet has none.
+    const connectors = (draft.connections ?? [])
+        .filter((c) => c.connector)
+        .map((c) => ({
+        message: `Connection "${c.id}" uses connector "${c.connector}", which this project has not imported.`,
+    }));
+    return serverProblems(draft, [...issues, ...connectors], []);
+}
+async function syncedProject(spaceId) {
+    const p = await db.query.project.findFirst({
+        where: and(eq(schema.project.id, spaceId), eq(schema.project.tenantId, currentTenant())),
+    });
+    return p ?? null;
+}
+/** Refuses a project beyond the tenant's number; a synced one counts like one made here. */
+async function requireRoom(spaceId) {
+    const mine = eq(schema.project.tenantId, currentTenant());
+    // What a tenant that builds nothing here once made here is not shown, so it takes no place.
+    const counted = (await mayBuild()) ? mine : and(mine, eq(schema.project.origin, "local"));
+    const others = await db
+        .select({ id: schema.project.id, name: schema.project.name, origin: schema.project.origin })
+        .from(schema.project)
+        .where(and(counted, sql `${schema.project.id} <> ${spaceId}`));
+    const limit = await projectLimit();
+    if (others.length >= limit) {
+        throw new ServiceError("refused", limit === 1
+            ? "Dieses Konto hat hier schon ein Projekt."
+            : `Dieses Konto hat hier schon ${limit} Projekte.`, {
+            reason: "space_limit",
+            limit,
+            spaces: others.filter((p) => p.origin === "local").map((p) => ({ id: p.id, name: p.name })),
+        });
+    }
+}
+/** A synced project holds so many wizards: each brings up to 25 MB of files to keep. */
+async function requireWizardRoom(spaceId) {
+    const [row] = await db
+        .select({ n: count() })
+        .from(schema.wizard)
+        .where(eq(schema.wizard.projectId, spaceId));
+    if ((row?.n ?? 0) >= env.limits.syncedWizards) {
+        throw new ServiceError("refused", `Hier haben höchstens ${env.limits.syncedWizards} veröffentlichte Wizards Platz.`, { reason: "wizard_limit", limit: env.limits.syncedWizards });
+    }
+}
+const hashOf = (data) => createHash("sha256").update(data).digest("hex");
+/**
+ * The project's logo follows the install's: kept when it is the same picture, else replaced —
+ * the new one is stored before the old one goes, so a store that fails leaves the old one.
+ */
+async function syncLogo(projectId, logo) {
+    const here = await projectFiles(projectId, "logo");
+    const data = logo ? Buffer.from(logo.data, "base64") : null;
+    const mark = data ? `sync:${hashOf(data)}` : null;
+    if (mark && here.length === 1 && here[0].source === mark) {
+        return;
+    }
+    if (logo && data && mark) {
+        await addProjectFile(projectId, {
+            kind: "logo",
+            name: logo.name,
+            mime: logo.mime,
+            data,
+            // With words of its own no model is asked to describe it.
+            description: logo.description || logo.name,
+            source: mark,
+        });
+    }
+    for (const old of here) {
+        await removeProjectFile(projectId, old.id);
+    }
+}
+/** Makes or updates the synced project: its name and what it says about itself (the logo: syncLogo). */
+async function syncSpace(spaceId, space) {
+    const existing = await syncedProject(spaceId);
+    if (existing && existing.origin !== "local") {
+        throw new ServiceError("refused", "Ein Projekt mit dieser Kennung wurde hier angelegt.", {
+            reason: "id_taken",
+        });
+    }
+    if (!existing) {
+        await requireRoom(spaceId);
+    }
+    const now = new Date();
+    const values = { name: space.name, brand: space.brand, facts: space.facts, syncedAt: now };
+    if (existing) {
+        await db
+            .update(schema.project)
+            .set({ ...values, updatedAt: now })
+            .where(eq(schema.project.id, spaceId));
+    }
+    else {
+        await db.insert(schema.project).values({
+            id: spaceId,
+            tenantId: currentTenant(),
+            origin: "local",
+            mcpServers: [],
+            ...values,
+        });
+    }
+    const project = await syncedProject(spaceId);
+    if (!project) {
+        throw notFound();
+    }
+    return project;
+}
+/**
+ * Takes a wizard a local install published: the project it is in, the wizard under its id, its
+ * workspace, and the version — published here when a run of it can finish. Sending the same
+ * wizard again updates the copy; its link stays. The files' bytes are kept first; then the
+ * project, the wizard, its workspace and the version are written in one transaction, so an
+ * install whose sending broke off finds nothing half done and sends again.
+ */
+export async function syncWizard(rawSpaceId, rawWizardId, input) {
+    const spaceId = syncedId.parse(rawSpaceId);
+    const wizardId = syncedId.parse(rawWizardId);
+    // The shape is checked before anything is written; a wrong one leaves nothing behind.
+    const { draft } = parseDraft(input.definition, input.files.map((f) => f.path));
+    return asSync(async () => {
+        const files = await keepFiles(input.files.map((f) => ({ path: f.path, mime: f.mime, data: Buffer.from(f.data, "base64") })));
+        const taken = await inTransaction(async () => {
+            const project = await syncSpace(spaceId, input.space);
+            const existing = await db.query.wizard.findFirst({
+                where: and(eq(schema.wizard.id, wizardId), eq(schema.wizard.tenantId, currentTenant())),
+            });
+            if (existing && existing.projectId !== spaceId) {
+                throw new ServiceError("refused", "Ein Wizard mit dieser Kennung gehört hier woanders hin.", {
+                    reason: "id_taken",
+                });
+            }
+            const settings = {
+                title: draft.title,
+                draft,
+                shareEnabled: input.shareEnabled,
+                ...(input.dailyRunLimit ? { dailyRunLimit: input.dailyRunLimit } : {}),
+            };
+            if (!existing) {
+                await requireWizardRoom(spaceId);
+            }
+            if (existing) {
+                await db
+                    .update(schema.wizard)
+                    .set({ ...settings, revision: sql `${schema.wizard.revision} + 1`, updatedAt: new Date() })
+                    .where(eq(schema.wizard.id, wizardId));
+            }
+            else {
+                await db.insert(schema.wizard).values({
+                    id: wizardId,
+                    projectId: spaceId,
+                    tenantId: currentTenant(),
+                    // The link is made here: a token an install brought could be one another tenant holds.
+                    shareToken: nanoid(14),
+                    dailyRunLimit: env.limits.defaultDailyRuns,
+                    ...settings,
+                });
+            }
+            // The workspace becomes what was sent: files that are gone there go here.
+            await replaceFiles(wizardId, files);
+            const row = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, wizardId) });
+            if (!row) {
+                throw notFound();
+            }
+            const problems = await serverProblems(draft, await draftIssues(row), project.mcpServers.map((s) => s.id));
+            const runnable = !problems.some((p) => p.blocking);
+            let publishedVersion = row.publishedVersion;
+            if (runnable) {
+                await db
+                    .insert(schema.wizardVersion)
+                    .values({ id: nanoid(12), wizardId, version: input.version, definition: draft, files })
+                    .onConflictDoUpdate({
+                    target: [schema.wizardVersion.wizardId, schema.wizardVersion.version],
+                    set: { definition: draft, files },
+                });
+                await db
+                    .update(schema.wizard)
+                    .set({ publishedVersion: input.version })
+                    .where(eq(schema.wizard.id, wizardId));
+                publishedVersion = input.version;
+            }
+            // Last, since it reaches the object store: a store that fails takes everything back.
+            await syncLogo(spaceId, input.space.logo);
+            return { row, problems, runnable, publishedVersion };
+        });
+        const { row, problems, runnable, publishedVersion } = taken;
+        // The public link lives in the control database, outside the transaction: set on every
+        // sync, so one that failed to get there once is there after the next.
+        await putLink(row.shareToken, "wizard", wizardId);
+        emitDraftChanged({
+            wizardId,
+            kind: "draft",
+            revision: row.revision,
+            source: "mcp",
+            client: "sync",
+            note: null,
+            touched: [],
+        });
+        return {
+            wizardId,
+            shareUrl: shareUrl(row.shareToken),
+            code: await codeOf(row.shareToken),
+            shareEnabled: row.shareEnabled,
+            publishedVersion,
+            runnable,
+            problems,
+        };
+    });
+}
+async function syncedWizard(rawSpaceId, rawWizardId) {
+    const spaceId = syncedId.parse(rawSpaceId);
+    const wizardId = syncedId.parse(rawWizardId);
+    const project = await syncedProject(spaceId);
+    const w = project?.origin === "local"
+        ? await db.query.wizard.findFirst({
+            where: and(eq(schema.wizard.id, wizardId), eq(schema.wizard.projectId, spaceId)),
+        })
+        : null;
+    if (!w) {
+        throw notFound();
+    }
+    return w;
+}
+/** The install changed how a synced wizard is shared: its link on or off, its runs a day. */
+export async function patchSyncedWizard(spaceId, wizardId, patch) {
+    const w = await syncedWizard(spaceId, wizardId);
+    await db
+        .update(schema.wizard)
+        .set({ ...patch, updatedAt: new Date() })
+        .where(eq(schema.wizard.id, w.id));
+    return { ok: true };
+}
+/** The install deleted a wizard: its copy here goes, with its link and its runs. */
+export async function removeSyncedWizard(userId, spaceId, wizardId) {
+    const w = await syncedWizard(spaceId, wizardId);
+    await asSync(() => deleteWizard(userId, w.id));
+    return { ok: true };
+}
+/** The projects local installs synced, with their wizards: what an install compares itself to. */
+export async function listSyncedSpaces() {
+    const projects = await db.query.project.findMany({
+        where: and(eq(schema.project.tenantId, currentTenant()), eq(schema.project.origin, "local")),
+        orderBy: [schema.project.createdAt],
+    });
+    const wizards = projects.length
+        ? await db
+            .select({
+            id: schema.wizard.id,
+            projectId: schema.wizard.projectId,
+            title: schema.wizard.title,
+            publishedVersion: schema.wizard.publishedVersion,
+            shareToken: schema.wizard.shareToken,
+            shareEnabled: schema.wizard.shareEnabled,
+        })
+            .from(schema.wizard)
+            .where(inArray(schema.wizard.projectId, projects.map((p) => p.id)))
+        : [];
+    return projects.map((p) => ({
+        id: p.id,
+        name: p.name,
+        syncedAt: p.syncedAt?.toISOString() ?? null,
+        wizards: wizards
+            .filter((w) => w.projectId === p.id)
+            .map((w) => ({
+            id: w.id,
+            title: w.title,
+            publishedVersion: w.publishedVersion,
+            shareUrl: shareUrl(w.shareToken),
+            shareEnabled: w.shareEnabled,
+        })),
+    }));
+}
+/** Takes a synced project away from this runtime: its wizards, their links and runs, its files. */
+export async function removeSyncedSpace(rawSpaceId) {
+    const spaceId = syncedId.parse(rawSpaceId);
+    const project = await syncedProject(spaceId);
+    if (project?.origin !== "local") {
+        throw notFound();
+    }
+    await asSync(() => removeProject(spaceId));
+    return { ok: true };
+}