@dev.fast/whiteboard 0.2.4 → 0.2.5-preview.20261013.109

package/src/review-api/document.ts

@@ -353,18 +353,32 @@ function documentReferences(
       });
 
     if (element.type === "database_lens")
-      return element.useCases.flatMap((useCase) =>
-        useCase.operations.flatMap((operation) =>
-          select(operation.source, operation.pins ?? element.pins).map(
-            (source) => ({
-              id: operation.id!,
-              source,
-              label: operation.label,
-              peek: true,
-            }),
+      return [
+        ...Object.entries(element.stores).flatMap(([storeKey, store]) =>
+          Object.entries(store.collections).flatMap(([key, collection]) =>
+            collection.source
+              ? select(collection.source, element.pins).map((source) => ({
+                  id: `${element.id}:schema:${storeKey}:${key}`,
+                  source,
+                  label: collection.label,
+                  peek: true,
+                }))
+              : [],
           ),
         ),
-      );
+        ...element.useCases.flatMap((useCase) =>
+          useCase.operations.flatMap((operation) =>
+            select(operation.source, operation.pins ?? element.pins).map(
+              (source) => ({
+                id: operation.id!,
+                source,
+                label: operation.label,
+                peek: true,
+              }),
+            ),
+          ),
+        ),
+      ];
 
     return [];
   });

package/src/review-api/http.ts

@@ -226,6 +226,23 @@ export function createReviewApi(
   const sharedData = shared ? new SharedReviewData(shared) : undefined;
   const isShared = (id: string) => id.startsWith("shared-");
 
+  const assertWritable = (id: string) => {
+    if (isShared(id)) shared?.assertWritable(id);
+    else store.assertWritable(id);
+  };
+
+  const reviewAccess =
+    (access: "read" | "active" | "edit"): MiddlewareHandler =>
+    async (context, next) => {
+      const id = context.req.param("id")!;
+
+      if (access !== "read") assertWritable(id);
+
+      if (access === "edit" && isShared(id))
+        throw new ReviewInputError("Shared reviews are read-only.", 409);
+      await next();
+    };
+
   const sharedCommandSchema = z.object({
     operation: z.object({ reviewId: z.string().optional() }),
   });
@@ -257,13 +274,6 @@ export function createReviewApi(
 
     readReview(id, query.version);
 
-    if (
-      context.req.method !== "GET" &&
-      !/\/(open|source|copy-context|environment)$/.test(context.req.path) &&
-      !/\/workspaces\/[^/]+\/retry$/.test(context.req.path)
-    )
-      throw new ReviewInputError("Shared reviews are read-only.", 409);
-
     return next();
   };
 
@@ -378,7 +388,7 @@ export function createReviewApi(
       ),
     );
   });
-  app.post("/:id/progress", async (context) => {
+  app.post("/:id/progress", reviewAccess("edit"), async (context) => {
     if (!data) throw new ReviewInputError("Source data is unavailable.", 409);
 
     const input = progressUpdateSchema.parse(
@@ -483,18 +493,22 @@ export function createReviewApi(
 
   // One route per agent tool; the path names the action.
   for (const action of ["begin", "update", "end"] as const)
-    app.post(`/:id/activity/${action}`, async (context) => {
-      const input = await readBoundedRequestJson(context.req.raw);
-      const id = context.req.param("id");
-      store.assertExists(id);
+    app.post(
+      `/:id/activity/${action}`,
+      reviewAccess("edit"),
+      async (context) => {
+        const input = await readBoundedRequestJson(context.req.raw);
+        const id = context.req.param("id");
+        store.assertExists(id);
 
-      return context.json(
-        store.activity.update(
-          id,
-          isJsonObject(input) ? { ...input, action } : input,
-        ),
-      );
-    });
+        return context.json(
+          store.activity.update(
+            id,
+            isJsonObject(input) ? { ...input, action } : input,
+          ),
+        );
+      },
+    );
   app.get("/watch", async (context) => {
     const query = context.req.query("subscriptions");
 
@@ -663,7 +677,7 @@ export function createReviewApi(
     }
   };
 
-  app.post("/:id/open", async (context) => {
+  app.post("/:id/open", reviewAccess("active"), async (context) => {
     const id = context.req.param("id");
 
     if (isShared(id)) await shared?.assertReady(id);
@@ -753,7 +767,7 @@ export function createReviewApi(
 
       return context.json(result);
     });
-    app.post("/:id/navigator", async (context) => {
+    app.post("/:id/navigator", reviewAccess("edit"), async (context) => {
       if (remoteCaller(context))
         throw new ReviewInputError(
           "Source windows are not available for a review on another machine.",
@@ -886,7 +900,7 @@ export function createReviewApi(
           : environment,
       );
     });
-    app.post("/:id/environment", async (context) => {
+    app.post("/:id/environment", reviewAccess("active"), async (context) => {
       const input = z
         .strictObject({ retry: z.boolean().optional() })
         .parse(await readBoundedRequestJson(context.req.raw));
@@ -913,14 +927,18 @@ export function createReviewApi(
 
       return context.json(data.workspaces.list(context.req.param("id")));
     });
-    app.post("/:id/workspaces/:workspaceId/retry", async (context) => {
-      return context.json(
-        await data.workspaces.retry(
-          context.req.param("id"),
-          context.req.param("workspaceId"),
-        ),
-      );
-    });
+    app.post(
+      "/:id/workspaces/:workspaceId/retry",
+      reviewAccess("active"),
+      async (context) => {
+        return context.json(
+          await data.workspaces.retry(
+            context.req.param("id"),
+            context.req.param("workspaceId"),
+          ),
+        );
+      },
+    );
     app.get("/:id/file", async (context) => {
       // Browsing can describe binaries; authoring reads still require text.
       const input = readQuerySchemas.file
@@ -1039,7 +1057,7 @@ export function createReviewApi(
     });
   }
 
-  app.post("/:id/copy-context", async (context) => {
+  app.post("/:id/copy-context", reviewAccess("read"), async (context) => {
     const query = readQuerySchemas.get
       .pick({ version: true })
       .extend({ mode: coverageModeSchema })
@@ -1256,7 +1274,7 @@ export function createReviewApi(
       return context.json({ paths: files.slice(0, MENTION_LIMIT) });
     });
 
-    app.post("/:id/ask", async (context) => {
+    app.post("/:id/ask", reviewAccess("edit"), async (context) => {
       const reviewId = context.req.param("id");
 
       const { version } = readQuerySchemas.get
@@ -1273,6 +1291,16 @@ export function createReviewApi(
       const id = crypto.randomUUID();
       const createdAt = new Date().toISOString();
 
+      const initialContext = await askContext(
+        input.agent,
+        snapshot,
+        checkout,
+        input.selection,
+        version,
+      );
+
+      assertWritable(reviewId);
+
       const thread = ask.threads.open({
         id,
         reviewId,
@@ -1309,13 +1337,7 @@ export function createReviewApi(
           title: input.selection.title,
           quote: target.kind === "text" ? target.quote : undefined,
         },
-        context: await askContext(
-          input.agent,
-          snapshot,
-          checkout,
-          input.selection,
-          version,
-        ),
+        context: initialContext,
         question: input.question,
       });
 
@@ -1332,7 +1354,7 @@ export function createReviewApi(
 
     // The threads of every open Ask in a review, over one connection. Before
     // the route for one thread, which would read `watch` as its id.
-    app.post("/:id/ask/watch", async (context) => {
+    app.post("/:id/ask/watch", reviewAccess("read"), async (context) => {
       const reviewId = context.req.param("id");
 
       readReview(reviewId);
@@ -1383,182 +1405,209 @@ export function createReviewApi(
 
     // A saved conversation: attach to it if it is still running, else start
     // the agent and load it, at the commit it was asked about.
-    app.post("/:id/ask/:threadId/open", async (context) => {
-      const reviewId = context.req.param("id");
-      const threadId = context.req.param("threadId");
-      const live = ask.threads.get(threadId);
-
-      if (live?.reviewId === reviewId) return context.json({ threadId });
-      const record = store.askHistory.get(threadId);
-
-      const { picks } = askOpenSchema.parse(
-        await readBoundedRequestJson(context.req.raw, undefined, {}),
-      );
+    app.post(
+      "/:id/ask/:threadId/open",
+      reviewAccess("edit"),
+      async (context) => {
+        const reviewId = context.req.param("id");
+        const threadId = context.req.param("threadId");
+        const live = ask.threads.get(threadId);
+
+        if (live?.reviewId === reviewId) return context.json({ threadId });
+        const record = store.askHistory.get(threadId);
+
+        const { picks } = askOpenSchema.parse(
+          await readBoundedRequestJson(context.req.raw, undefined, {}),
+        );
 
-      if (record?.reviewId !== reviewId)
-        throw new ReviewInputError("This conversation was not found.", 404);
+        if (record?.reviewId !== reviewId)
+          throw new ReviewInputError("This conversation was not found.", 404);
 
-      const snapshot = readReview(reviewId, record.version);
-      const checkout = await data.agentCheckout(snapshot);
-      const target = record.selection.target;
+        const snapshot = readReview(reviewId, record.version);
+        const checkout = await data.agentCheckout(snapshot);
+        const target = record.selection.target;
 
-      ask.threads.open({
-        id: record.id,
-        reviewId,
-        agent: record.agent,
-        cwd: checkout.rootPath,
-        head: checkout.head,
-        selection: {
-          title: record.selection.title,
-          quote: target.kind === "text" ? target.quote : undefined,
-        },
-        resume: { sessionId: record.sessionId, entries: record.entries },
-        // For a new session, should the agent no longer have this one.
-        context: await askContext(
+        const initialContext = await askContext(
           record.agent,
           snapshot,
           checkout,
           record.selection,
           record.version,
-        ),
-        onSession: (sessionId) =>
-          store.askHistory.updateSession(record.id, sessionId),
-        onTurn: () => store.askHistory.touch(record.id),
-        onSave: (entries) => store.askHistory.saveEntries(record.id, entries),
-        picks,
-        bypass: record.bypass,
-        onBypass: (bypass) => store.askHistory.setBypass(record.id, bypass),
-        onOffer: (offer) => store.askHistory.saveOffer(record.agent, offer),
-        onTitle: (title) => store.askHistory.rename(record.id, title),
-      });
+        );
 
-      return context.json({ threadId: record.id });
-    });
+        assertWritable(reviewId);
+        ask.threads.open({
+          id: record.id,
+          reviewId,
+          agent: record.agent,
+          cwd: checkout.rootPath,
+          head: checkout.head,
+          selection: {
+            title: record.selection.title,
+            quote: target.kind === "text" ? target.quote : undefined,
+          },
+          resume: { sessionId: record.sessionId, entries: record.entries },
+          // For a new session, should the agent no longer have this one.
+          context: initialContext,
+          onSession: (sessionId) =>
+            store.askHistory.updateSession(record.id, sessionId),
+          onTurn: () => store.askHistory.touch(record.id),
+          onSave: (entries) => store.askHistory.saveEntries(record.id, entries),
+          picks,
+          bypass: record.bypass,
+          onBypass: (bypass) => store.askHistory.setBypass(record.id, bypass),
+          onOffer: (offer) => store.askHistory.saveOffer(record.agent, offer),
+          onTitle: (title) => store.askHistory.rename(record.id, title),
+        });
 
-    app.post("/:id/ask/:threadId/prompt", async (context) => {
-      const thread = readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      );
+        return context.json({ threadId: record.id });
+      },
+    );
 
-      const { question } = askFollowUpSchema.parse(
-        await readBoundedRequestJson(context.req.raw, ASK_REQUEST_MAX_BYTES),
-      );
+    app.post(
+      "/:id/ask/:threadId/prompt",
+      reviewAccess("edit"),
+      async (context) => {
+        const thread = readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        );
 
-      const refusal = thread.askRefusal();
+        const { question } = askFollowUpSchema.parse(
+          await readBoundedRequestJson(context.req.raw, ASK_REQUEST_MAX_BYTES),
+        );
 
-      if (refusal) throw new ReviewInputError(refusal, 409);
+        const refusal = thread.askRefusal();
 
-      void thread.ask(question);
+        if (refusal) throw new ReviewInputError(refusal, 409);
 
-      return context.json({ ok: true });
-    });
+        void thread.ask(question);
 
-    app.post("/:id/ask/:threadId/permission", async (context) => {
-      const thread = readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      );
+        return context.json({ ok: true });
+      },
+    );
 
-      const decision = askDecisionSchema.parse(
-        await readBoundedRequestJson(context.req.raw),
-      );
+    app.post(
+      "/:id/ask/:threadId/permission",
+      reviewAccess("edit"),
+      async (context) => {
+        const thread = readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        );
 
-      if (!thread.decide(decision.permissionId, decision.optionId))
-        throw new ReviewInputError("This request was already answered.", 409);
+        const decision = askDecisionSchema.parse(
+          await readBoundedRequestJson(context.req.raw),
+        );
 
-      return context.json({ ok: true });
-    });
+        if (!thread.decide(decision.permissionId, decision.optionId))
+          throw new ReviewInputError("This request was already answered.", 409);
+
+        return context.json({ ok: true });
+      },
+    );
 
     // The files an answer names, as the checkout's own paths, so the panel
     // can open them.
-    app.post("/:id/ask/:threadId/files", async (context) => {
-      const thread = readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      );
+    app.post(
+      "/:id/ask/:threadId/files",
+      reviewAccess("edit"),
+      async (context) => {
+        const thread = readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        );
 
-      const { paths } = askFilesSchema.parse(
-        await readBoundedRequestJson(context.req.raw),
-      );
+        const { paths } = askFilesSchema.parse(
+          await readBoundedRequestJson(context.req.raw),
+        );
 
-      const { cwd, entries } = thread.read();
+        const { cwd, entries } = thread.read();
 
-      const touched = entries.flatMap((entry) =>
-        entry.kind === "tool"
-          ? `${entry.title} ${entry.input ?? ""}`
-              .split(/\s+/)
-              .flatMap((token) => parseFileRef(token)?.path ?? [])
-          : [],
-      );
+        const touched = entries.flatMap((entry) =>
+          entry.kind === "tool"
+            ? `${entry.title} ${entry.input ?? ""}`
+                .split(/\s+/)
+                .flatMap((token) => parseFileRef(token)?.path ?? [])
+            : [],
+        );
 
-      const files = resolveFileRefs(
-        cwd,
-        await checkoutFiles(cwd),
-        paths,
-        touched,
-      );
+        const files = resolveFileRefs(
+          cwd,
+          await checkoutFiles(cwd),
+          paths,
+          touched,
+        );
 
-      return context.json({
-        files: [...files].map(([path, file]) => ({ path, file })),
-      });
-    });
+        return context.json({
+          files: [...files].map(([path, file]) => ({ path, file })),
+        });
+      },
+    );
 
     // Another model or effort for the next answer.
-    app.post("/:id/ask/:threadId/choice", async (context) => {
-      const thread = readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      );
-
-      const { kind, value } = askChoiceSchema.parse(
-        await readBoundedRequestJson(context.req.raw),
-      );
+    app.post(
+      "/:id/ask/:threadId/choice",
+      reviewAccess("edit"),
+      async (context) => {
+        const thread = readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        );
 
-      if (thread.read().status !== "idle")
-        throw new ReviewInputError(
-          "Settings can change once the agent finishes answering.",
-          409,
+        const { kind, value } = askChoiceSchema.parse(
+          await readBoundedRequestJson(context.req.raw),
         );
 
-      try {
-        await thread.choose(kind, value);
-      } catch (error) {
-        throw new ReviewInputError(errorMessage(error), 409);
-      }
+        if (thread.read().status !== "idle")
+          throw new ReviewInputError(
+            "Settings can change once the agent finishes answering.",
+            409,
+          );
 
-      return context.json({ ok: true });
-    });
+        try {
+          await thread.choose(kind, value);
+        } catch (error) {
+          throw new ReviewInputError(errorMessage(error), 409);
+        }
 
-    // Bypasses permissions from the next answer, or stops.
-    app.post("/:id/ask/:threadId/permissions", async (context) => {
-      const thread = readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      );
+        return context.json({ ok: true });
+      },
+    );
 
-      const { bypass } = askPermitSchema.parse(
-        await readBoundedRequestJson(context.req.raw),
-      );
+    // Bypasses permissions from the next answer, or stops.
+    app.post(
+      "/:id/ask/:threadId/permissions",
+      reviewAccess("edit"),
+      async (context) => {
+        const thread = readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        );
 
-      if (thread.read().status !== "idle")
-        throw new ReviewInputError(
-          "Settings can change once the agent finishes answering.",
-          409,
+        const { bypass } = askPermitSchema.parse(
+          await readBoundedRequestJson(context.req.raw),
         );
 
-      try {
-        await thread.permit(bypass);
-      } catch (error) {
-        throw new ReviewInputError(errorMessage(error), 409);
-      }
+        if (thread.read().status !== "idle")
+          throw new ReviewInputError(
+            "Settings can change once the agent finishes answering.",
+            409,
+          );
 
-      return context.json({ ok: true });
-    });
+        try {
+          await thread.permit(bypass);
+        } catch (error) {
+          throw new ReviewInputError(errorMessage(error), 409);
+        }
+
+        return context.json({ ok: true });
+      },
+    );
 
     // Starts a failed agent again, as after signing it back in, and asks
     // again what it did not answer. The state reports how that goes.
-    app.post("/:id/ask/:threadId/retry", (context) => {
+    app.post("/:id/ask/:threadId/retry", reviewAccess("edit"), (context) => {
       const thread = readThread(
         context.req.param("id"),
         context.req.param("threadId"),
@@ -1574,26 +1623,33 @@ export function createReviewApi(
       return context.json({ ok: true });
     });
 
-    app.post("/:id/ask/:threadId/cancel", async (context) => {
-      await readThread(
-        context.req.param("id"),
-        context.req.param("threadId"),
-      ).cancel();
+    app.post(
+      "/:id/ask/:threadId/cancel",
+      reviewAccess("read"),
+      async (context) => {
+        await readThread(
+          context.req.param("id"),
+          context.req.param("threadId"),
+        ).cancel();
 
-      return context.json({ ok: true });
-    });
+        return context.json({ ok: true });
+      },
+    );
 
     // Closing an Ask ends its agent; the conversation stays saved. A tab
     // switched away from or a reload leaves it running, to come back to.
-    app.post("/:id/ask/:threadId/close", (context) => {
+    app.post("/:id/ask/:threadId/close", reviewAccess("read"), (context) => {
       readThread(context.req.param("id"), context.req.param("threadId"));
-      ask.threads.close(context.req.param("threadId"));
+      ask.threads.close(
+        context.req.param("threadId"),
+        !readReview(context.req.param("id")).trashedAt,
+      );
 
       return context.json({ ok: true });
     });
 
     // Forgets a saved conversation. The agent keeps its own transcript.
-    app.delete("/:id/ask/:threadId", (context) => {
+    app.delete("/:id/ask/:threadId", reviewAccess("edit"), (context) => {
       const reviewId = context.req.param("id");
       const threadId = context.req.param("threadId");
 
@@ -1733,6 +1789,11 @@ export function createReviewApi(
       const parsed = commandSchema.parse(input);
 
       if (shared && parsed.operation.type === "delete") {
+        if (!shared.get(parsed.operation.reviewId).snapshot.trashedAt)
+          throw new ReviewInputError(
+            "Move this whiteboard to Trash before deleting it.",
+            409,
+          );
         await shared.removeLocal(parsed.operation.reviewId);
 
         return context.json({
@@ -1742,11 +1803,22 @@ export function createReviewApi(
         });
       }
 
-      if (shared && parsed.operation.type === "attention") {
-        await shared.setAttention(
-          parsed.operation.reviewId,
-          parsed.operation.action,
-        );
+      if (
+        shared &&
+        (parsed.operation.type === "attention" ||
+          parsed.operation.type === "lifecycle")
+      ) {
+        if (parsed.operation.type === "lifecycle")
+          await shared.setLifecycle(
+            parsed.operation.reviewId,
+            parsed.operation.state,
+          );
+        else await shared.setAttention(parsed.operation.reviewId);
+
+        const reviewId = parsed.operation.reviewId;
+
+        if (shared.get(reviewId).snapshot.trashedAt)
+          ask?.threads.closeDeletedReviews((id) => id === reviewId);
 
         return context.json({
           reviewId: parsed.operation.reviewId,
@@ -1760,6 +1832,12 @@ export function createReviewApi(
 
     const result = await store.execute(input);
 
+    if (
+      result.deleted ||
+      (result.lifecycle && store.read(result.reviewId).trashedAt)
+    )
+      ask?.threads.closeDeletedReviews((id) => id === result.reviewId);
+
     if (input.operation.type === "edit" && data && !result.deleted) {
       const { quotes, unquoted } = await anchorQuotes(
         result.version > 0