wizards 0.2.11 → 0.2.13

package/apps/runtime/dist/db/migrations/tenant/meta/_journal.json

@@ -50,6 +50,13 @@
       "when": 1791283092075,
       "tag": "0006_hard_war_machine",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "6",
+      "when": 1791287441521,
+      "tag": "0007_space_data",
+      "breakpoints": true
     }
   ]
 }

package/apps/runtime/dist/db/schema.js

@@ -225,6 +225,61 @@ export const projectChunk = sqliteTable("project_chunk", {
     index("project_chunk_file").on(t.fileId),
     index("project_chunk_ref").on(t.projectId, t.plugin, t.ref),
 ]);
+// --- The space's data -------------------------------------------------------
+// Tables and pages a space keeps, its own or one of its wizards'. Shared by everyone who works
+// in the space, unlike the wizard's store below, which belongs to one person.
+/** A table: its columns are engenty data-table columns, its rows in `space_table_row`. */
+export const spaceTable = sqliteTable("space_table", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    /** The wizard it belongs to; null: the space's own. */
+    wizardId: text("wizard_id").references(() => wizard.id, { onDelete: "cascade" }),
+    /**
+     * The wizard's shared list it keeps: its title, columns and key come from the wizard's
+     * definition, its rows from every run. Null: a table made in the studio.
+     */
+    list: text("list"),
+    /** The column a row is matched on, as the list says. */
+    keyColumn: text("key_column"),
+    title: text("title").notNull(),
+    columns: text("columns", { mode: "json" }).$type().notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [
+    index("space_table_project").on(t.projectId, t.wizardId),
+    uniqueIndex("space_table_list").on(t.wizardId, t.list),
+]);
+/** A row of a table: cells by column id. Rows stand in the order they were added. */
+export const spaceTableRow = sqliteTable("space_table_row", {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+        .notNull()
+        .references(() => spaceTable.id, { onDelete: "cascade" }),
+    /** The key column's value, normalised: saving a row with a known key updates that row. */
+    key: text("key"),
+    cells: text("cells", { mode: "json" }).$type().notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [
+    index("space_table_row_table").on(t.tableId, t.createdAt),
+    index("space_table_row_key").on(t.tableId, t.key),
+]);
+/** A page: a title and markdown, what the editor shows and an agent reads and writes. */
+export const spacePage = sqliteTable("space_page", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    wizardId: text("wizard_id").references(() => wizard.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    markdown: text("markdown").notNull().default(""),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [index("space_page_project").on(t.projectId, t.wizardId)]);
 // --- The wizard's store ------------------------------------------------------
 // What a wizard keeps between runs for one person. `holder` is that person: "u:<userId>" for a
 // signed-in admin, "v:<visitorId>" for an end user on a shared link.

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

@@ -226,7 +226,7 @@ async function storedLists(run) {
     const scope = scopeOf(run);
     const out = {};
     for (const def of run.definition.lists ?? []) {
-        out[def.id] = { def, rows: await listRows(scope, def.id) };
+        out[def.id] = { def, rows: await listRows(scope, def) };
     }
     return out;
 }

package/apps/runtime/dist/routes/api.js

@@ -6,7 +6,7 @@ import { allowed } from "../limits.js";
 import { authenticate, principalOf } from "../mcp/auth.js";
 import { ServiceError } from "../services/errors.js";
 import { deleteFile, draftFiles, writeFile } from "../services/files.js";
-import { checkOnServer, checkSchema, listSyncedSpaces, patchSyncedWizard, removeSyncedSpace, removeSyncedWizard, rotateSyncedLink, syncSettingsSchema, syncWizard, syncWizardSchema, } from "../services/spaces.js";
+import { checkOnServer, checkSchema, listSyncedSpaces, patchSyncedWizard, removeSyncedSpace, removeSyncedWizard, rotateSyncedLink, syncDataSchema, syncSettingsSchema, syncSpaceData, syncWizard, syncWizardSchema, } from "../services/spaces.js";
 import { createWizard, ownedWizard, publishWizard, writeDraft } from "../services/wizards.js";
 import { codeOf, tenantStatus } from "../tenants/control.js";
 const importSchema = z.object({
@@ -83,6 +83,19 @@ export const apiRoutes = new Hono()
     }
     const body = syncWizardSchema.parse(await c.req.json());
     return withTenant(who.tenantId, async () => c.json(await syncWizard(c.req.param("spaceId"), c.req.param("wizardId"), body)));
+})
+    // The space's own tables and pages, sent with a wizard when they changed.
+    .put("/spaces/:spaceId/data", tooLarge, async (c) => {
+    const who = await caller(c, ["wizards:write"]);
+    if (who instanceof Response) {
+        return who;
+    }
+    const limited = withinSyncLimit(c, who);
+    if (limited) {
+        return limited;
+    }
+    const body = syncDataSchema.parse(await c.req.json());
+    return withTenant(who.tenantId, async () => c.json(await syncSpaceData(c.req.param("spaceId"), body)));
 })
     .patch("/spaces/:spaceId/wizards/:wizardId", async (c) => {
     const who = await caller(c, ["wizards:publish"]);

package/apps/runtime/dist/routes/runs.js

@@ -594,7 +594,8 @@ export const runRoutes = new Hono()
     // --- the wizard's lists and files for this person -------------------------------
     .post("/:id/lists/:list/rows", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
-    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list"));
+    // A shared list is every run's: the person never sees it.
+    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list") && !l.shared);
     if (!run || !def) {
         return c.json({ error: "not found" }, 404);
     }
@@ -612,7 +613,8 @@ export const runRoutes = new Hono()
 })
     .patch("/:id/lists/:list/rows/:rowId", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
-    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list"));
+    // A shared list is every run's: the person never sees it.
+    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list") && !l.shared);
     if (!run || !def) {
         return c.json({ error: "not found" }, 404);
     }
@@ -632,7 +634,8 @@ export const runRoutes = new Hono()
 })
     .delete("/:id/lists/:list/rows/:rowId", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
-    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list"));
+    // A shared list is every run's: the person never sees it.
+    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list") && !l.shared);
     if (!run || !def) {
         return c.json({ error: "not found" }, 404);
     }
@@ -642,13 +645,14 @@ export const runRoutes = new Hono()
 })
     .get("/:id/lists/:list/download", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
-    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list"));
+    // A shared list is every run's: the person never sees it.
+    const def = run?.definition.lists?.find((l) => l.id === c.req.param("list") && !l.shared);
     const format = z.enum(FORMATS).safeParse(c.req.query("format"));
     if (!run || !def || !format.success || !LIST_FORMATS.includes(format.data)) {
         return c.notFound();
     }
     const scope = scopeOf(run);
-    const download = await listDownload(def, await listRows(scope, def.id), format.data, `${run.definition.title} ${def.title}`, async (path) => {
+    const download = await listDownload(def, await listRows(scope, def), format.data, `${run.definition.title} ${def.title}`, async (path) => {
         const found = await readStoreFile(scope, path).catch(() => null);
         return found ? new Uint8Array(found.data) : null;
     });
@@ -660,10 +664,12 @@ export const runRoutes = new Hono()
         return c.json({ error: "not found" }, 404);
     }
     const scope = scopeOf(run);
-    const lists = await Promise.all((run.definition.lists ?? []).map(async (def) => ({
+    const lists = await Promise.all((run.definition.lists ?? [])
+        .filter((def) => !def.shared)
+        .map(async (def) => ({
         id: def.id,
         title: def.title,
-        rows: (await listRows(scope, def.id)).length,
+        rows: (await listRows(scope, def)).length,
     })));
     const secrets = await listSecrets(scope);
     return c.json({

package/apps/runtime/dist/routes/studio.js

@@ -37,7 +37,8 @@ import { profileSchema, saveProfile, userProfile } from "../services/profile.js"
 import { addProjectFile, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
 import { documentText, searchProject } from "../services/project-index.js";
 import { createProject, deleteProject, listProjects, maskedServers, ownedProject, projectLimit, projectPatchSchema, updateProject, } from "../services/projects.js";
-import { listRuns, startTestRun } from "../services/runs.js";
+import { listResults, listRuns, startTestRun } from "../services/runs.js";
+import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
 import { draftWidgetPreview } from "../services/widgets.js";
 import { createWizard, deleteWizard, duplicateWizard, listWizards, ownedWizard, rotateShareLink, updateWizardSettings, wizardMessages, wizardState, writableWizard, writeDraft, } from "../services/wizards.js";
 import { readSetting, writeSetting } from "../settings.js";
@@ -447,6 +448,93 @@ export const studio = new Hono()
     const project = await ownedProject(c.get("user").id, c.req.param("id"));
     await removeConnector(project.id, c.req.param("connectorId"));
     return c.json({ ok: true });
+})
+    // The runs of the space's wizards that reached their result: of one wizard, or of all.
+    .get("/projects/:id/results", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const query = z
+        .object({
+        wizard: z.string().optional(),
+        q: z.string().max(200).optional(),
+        mode: z.enum(["live", "test"]).optional(),
+        days: z.coerce.number().int().min(1).max(3650).optional(),
+    })
+        .parse(c.req.query());
+    return c.json(await listResults(project.id, {
+        wizardId: query.wizard || undefined,
+        q: query.q,
+        mode: query.mode,
+        days: query.days,
+    }));
+})
+    // --- the space's tables and pages --------------------------------------------
+    .get("/projects/:id/data", async (c) => c.json(await listSpaceData(c.get("user").id, c.req.param("id"))))
+    .post("/projects/:id/tables", async (c) => {
+    const body = z
+        .object({
+        title: z.string().max(120),
+        wizardId: z.string().nullish(),
+        columns: z.unknown().optional(),
+    })
+        .parse(await c.req.json());
+    return c.json(await createTable(c.get("user").id, c.req.param("id"), body));
+})
+    .get("/tables/:id", async (c) => c.json(await getTable(c.get("user").id, c.req.param("id"))))
+    .patch("/tables/:id", async (c) => {
+    const body = z
+        .object({
+        title: z.string().max(120).optional(),
+        wizardId: z.string().nullish(),
+        columns: z.unknown().optional(),
+    })
+        .parse(await c.req.json());
+    await updateTable(c.get("user").id, c.req.param("id"), body);
+    return c.json({ ok: true });
+})
+    .delete("/tables/:id", async (c) => {
+    await deleteTable(c.get("user").id, c.req.param("id"));
+    return c.json({ ok: true });
+})
+    .post("/tables/:id/rows", async (c) => {
+    const body = z
+        .object({ cells: z.record(z.string(), z.unknown()).optional() })
+        .parse(await c.req.json());
+    return c.json(await addTableRow(c.get("user").id, c.req.param("id"), body.cells));
+})
+    .patch("/tables/:id/rows/:rowId", async (c) => {
+    const body = z.object({ cells: z.record(z.string(), z.unknown()) }).parse(await c.req.json());
+    return c.json(await updateTableRow(c.get("user").id, c.req.param("id"), c.req.param("rowId"), body.cells));
+})
+    .post("/tables/:id/rows/delete", async (c) => {
+    const body = z.object({ ids: z.array(z.string()).max(5000) }).parse(await c.req.json());
+    await deleteTableRows(c.get("user").id, c.req.param("id"), body.ids);
+    return c.json({ ok: true });
+})
+    .post("/projects/:id/pages", async (c) => {
+    const body = z
+        .object({
+        title: z.string().max(200),
+        wizardId: z.string().nullish(),
+        markdown: z.string().optional(),
+    })
+        .parse(await c.req.json());
+    return c.json(await createPage(c.get("user").id, c.req.param("id"), body));
+})
+    .get("/pages/:id", async (c) => c.json(await getPage(c.get("user").id, c.req.param("id"))))
+    .patch("/pages/:id", async (c) => {
+    const body = z
+        .object({
+        title: z.string().max(200).optional(),
+        wizardId: z.string().nullish(),
+        markdown: z.string().optional(),
+    })
+        .parse(await c.req.json());
+    await updatePage(c.get("user").id, c.req.param("id"), body);
+    return c.json({ ok: true });
+})
+    .delete("/pages/:id", async (c) => {
+    await deletePage(c.get("user").id, c.req.param("id"));
+    return c.json({ ok: true });
 })
     // --- wizards ---------------------------------------------------------------
     .get("/projects/:id/wizards", async (c) => {

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

@@ -1,4 +1,5 @@
-import { and, eq, isNotNull, like } from "drizzle-orm";
+import { createHash } from "node:crypto";
+import { and, asc, eq, inArray, isNotNull, isNull, like } from "drizzle-orm";
 import { accountToken, linkedAccount } from "../auth/account.js";
 import { control, controlDb, db, schema } from "../db/client.js";
 import { env } from "../env.js";
@@ -94,10 +95,61 @@ async function spaceOf(userId, projectId) {
             : null,
     };
 }
+/** The space's own tables and pages, as they are sent: not what a wizard's runs keep. */
+async function spaceDataOf(projectId) {
+    const own = (table) => and(eq(table.projectId, projectId), isNull(table.wizardId));
+    const tables = await db.query.spaceTable.findMany({
+        where: own(schema.spaceTable),
+        orderBy: [asc(schema.spaceTable.id)],
+    });
+    const rows = tables.length
+        ? await db.query.spaceTableRow.findMany({
+            where: inArray(schema.spaceTableRow.tableId, tables.map((t) => t.id)),
+            orderBy: [asc(schema.spaceTableRow.createdAt), asc(schema.spaceTableRow.id)],
+        })
+        : [];
+    const pages = await db.query.spacePage.findMany({
+        where: own(schema.spacePage),
+        orderBy: [asc(schema.spacePage.id)],
+    });
+    return {
+        tables: tables.map((t) => ({
+            id: t.id,
+            title: t.title,
+            columns: t.columns,
+            rows: rows.filter((r) => r.tableId === t.id).map((r) => ({ id: r.id, cells: r.cells })),
+        })),
+        pages: pages.map((p) => ({ id: p.id, title: p.title, markdown: p.markdown })),
+    };
+}
+/**
+ * Sends the space's own tables and pages along with a wizard, when they changed since they last
+ * arrived. A sending that fails is tried with the next wizard; the wizard is there either way.
+ */
+async function syncSpaceDataToCloud(projectId) {
+    const data = await spaceDataOf(projectId);
+    const hash = createHash("sha256").update(JSON.stringify(data)).digest("hex");
+    const sent = `cloud-data:${projectId}`;
+    if ((await readSetting(sent)) === hash) {
+        return;
+    }
+    try {
+        const answer = await call("PUT", `/spaces/${projectId}/data`, data, 120_000);
+        if (answer.ok) {
+            await writeSetting(sent, hash);
+        }
+        else {
+            console.error("[cloud] the space's data was not taken:", answer.status, answer.body);
+        }
+    }
+    catch (err) {
+        console.error("[cloud] sending the space's data failed:", err);
+    }
+}
 /**
  * Sends a wizard's published version to the cloud: the same wizard again updates its copy
  * there, whose link stays. What came back is kept; a try that failed is kept as such beside
- * the copy from before.
+ * the copy from before. The space's own tables and pages follow it.
  */
 export async function syncToCloud(userId, wizardId) {
     const w = await ownedWizard(userId, wizardId);
@@ -136,6 +188,7 @@ export async function syncToCloud(userId, wizardId) {
             error: null,
         };
         await writeSetting(key(w.id), state);
+        await syncSpaceDataToCloud(w.projectId);
         return state;
     }
     catch (err) {
@@ -253,9 +306,16 @@ export async function retryFailedSends(userId) {
 /** The account was unlinked: what this runtime kept of its cloud belongs to no account now. */
 export async function forgetCloud() {
     await controlDb.delete(control.setting).where(like(control.setting.key, "cloud:%"));
+    await forgetSentData();
+}
+/** The space's data counts as not sent: the next wizard takes it along again. */
+async function forgetSentData() {
+    await controlDb.delete(control.setting).where(like(control.setting.key, "cloud-data:%"));
 }
 /** Sends every published wizard: once after an account was linked. */
 export async function syncAllToCloud(userId) {
+    // A cloud that was linked anew, or whose spaces were replaced, has none of it.
+    await forgetSentData();
     const wizards = await db
         .select({ id: schema.wizard.id })
         .from(schema.wizard)

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

@@ -1,5 +1,5 @@
 import { formatsFor } from "@engenty-wizards/shared/definition";
-import { and, count, desc, eq, inArray, or } from "drizzle-orm";
+import { and, count, desc, eq, gte, inArray, max, or, sql } from "drizzle-orm";
 import { canSpend, MICROS_PER_CREDIT } from "../credits/credits.js";
 import { db, schema } from "../db/client.js";
 import { answerAsk, unattended } from "../engine/asks.js";
@@ -384,3 +384,71 @@ export async function listRuns(userId, wizardId) {
         stepTitle: r.definition.steps.find((s) => s.id === r.cursor)?.title ?? null,
     }));
 }
+/**
+ * The results of a space: its wizards' runs that reached their result, newest first, narrowed by
+ * `filter`; and each wizard with how many it has and when its last one came, the latest first.
+ */
+export async function listResults(projectId, filter = {}) {
+    const wizards = await db
+        .select({
+        id: schema.wizard.id,
+        title: schema.wizard.title,
+        results: count(schema.run.id),
+        lastAt: max(schema.run.updatedAt),
+    })
+        .from(schema.wizard)
+        .leftJoin(schema.run, and(eq(schema.run.wizardId, schema.wizard.id), eq(schema.run.status, "done")))
+        .where(and(eq(schema.wizard.projectId, projectId), eq(schema.wizard.tenantId, currentTenant())))
+        .groupBy(schema.wizard.id)
+        // Wizards without a result last: SQLite sorts null below every time.
+        .orderBy(desc(max(schema.run.updatedAt)), desc(schema.wizard.updatedAt));
+    const q = filter.q?.trim().toLowerCase();
+    const like = q ? `%${q.replace(/[\\%_]/g, (c) => `\\${c}`)}%` : null;
+    const titled = like
+        ? new Set(wizards.filter((w) => w.title.toLowerCase().includes(q)).map((w) => w.id))
+        : null;
+    const ids = wizards.map((w) => w.id).filter((id) => !filter.wizardId || id === filter.wizardId);
+    const rows = ids.length
+        ? await db
+            .select({
+            id: schema.run.id,
+            wizardId: schema.run.wizardId,
+            mode: schema.run.mode,
+            version: schema.run.version,
+            costMicros: schema.run.costMicros,
+            updatedAt: schema.run.updatedAt,
+        })
+            .from(schema.run)
+            .where(and(inArray(schema.run.wizardId, ids), eq(schema.run.status, "done"), filter.mode ? eq(schema.run.mode, filter.mode) : undefined, filter.days
+            ? gte(schema.run.updatedAt, new Date(Date.now() - filter.days * 86_400_000))
+            : undefined, like
+            ? or(titled?.size ? inArray(schema.run.wizardId, [...titled]) : undefined, sql `lower(${schema.run.state}) like ${like} escape '\\'`)
+            : undefined))
+            .orderBy(desc(schema.run.updatedAt))
+            .limit(100)
+        : [];
+    const assetCounts = rows.length
+        ? await db
+            .select({ runId: schema.asset.runId, n: count() })
+            .from(schema.asset)
+            .where(inArray(schema.asset.runId, rows.map((r) => r.id)))
+            .groupBy(schema.asset.runId)
+        : [];
+    return {
+        wizards: wizards.map((w) => ({
+            id: w.id,
+            title: w.title,
+            results: w.results,
+            lastAt: w.lastAt ? new Date(w.lastAt).toISOString() : null,
+        })),
+        runs: rows.map((r) => ({
+            id: r.id,
+            wizardId: r.wizardId,
+            mode: r.mode,
+            version: r.version,
+            doneAt: r.updatedAt.toISOString(),
+            credits: Math.ceil(r.costMicros / MICROS_PER_CREDIT),
+            assets: assetCounts.find((a) => a.runId === r.id)?.n ?? 0,
+        })),
+    };
+}