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

package/src/review-api/workspaces.ts

@@ -103,27 +103,27 @@ export class ReviewWorkspaces {
 
     this.stop = store.subscribeCatalog(() => {
       this.collect();
-      this.releaseDismissed();
+      this.releaseTrashed();
     });
     this.collect();
-    this.releaseDismissed();
+    this.releaseTrashed();
   }
 
-  // Unset until the first scan, so startup also frees reviews dismissed
+  // Unset until the first scan, so startup also frees reviews trashed
   // while no Desktop was running.
-  private dismissed?: Set<string>;
+  private trashed?: Set<string>;
   private readonly releasing = new Map<string, Promise<void>>();
 
   /**
-   * Frees a newly dismissed review's checkouts to save disk. The review itself
+   * Frees a newly trashed review's checkouts to save disk. The review itself
    * stays; reopening it rebuilds them. Checkouts rebuilt by peeking at a
-   * dismissed review are kept until the next startup or dismissal, since
+   * trashed review are kept until the next startup or move to Trash, since
    * the Desktop's canvas tabs and source windows may still show them.
    */
-  private releaseDismissed() {
-    const dismissed = new Set(this.store.dismissedIds());
-    const released = [...dismissed].filter((id) => !this.dismissed?.has(id));
-    this.dismissed = dismissed;
+  private releaseTrashed() {
+    const trashed = new Set(this.store.trashedIds());
+    const released = [...trashed].filter((id) => !this.trashed?.has(id));
+    this.trashed = trashed;
 
     if (!released.length) return;
 
@@ -162,7 +162,7 @@ export class ReviewWorkspaces {
       })
       .catch((error) => {
         console.error(
-          `Could not free the pinned checkouts of dismissed review ${reviewId}:`,
+          `Could not free the pinned checkouts of trashed review ${reviewId}:`,
           error,
         );
       })
@@ -176,8 +176,8 @@ export class ReviewWorkspaces {
   }
 
   private async releaseCheckouts(reviewId: string, repositories: string[]) {
-    // Restored since the dismissal: its checkouts may be in use.
-    if (!this.store.dismissedIds().includes(reviewId)) return;
+    // Restored since the move to Trash: its checkouts may be in use.
+    if (!this.store.trashedIds().includes(reviewId)) return;
 
     const environments = this.all().filter(
       (item) => item.reviewId === reviewId,
@@ -363,7 +363,7 @@ export class ReviewWorkspaces {
     if (!environment || environment.state !== "cleanup-failed")
       throw new ReviewInputError("Cleanup failure not found.", 404);
 
-    // A dismissed review keeps its record, so collection would skip it.
+    // A trashed review keeps its record, so collection would skip it.
     if (this.store.has(environment.reviewId))
       this.release(environment.reviewId);
     else this.collect(id);

package/src/review-api/worktree-events.ts

@@ -37,10 +37,56 @@ export function rootEventMatters(
   return !tracked || tracked.has(parent(file));
 }
 
+/** A directory appearing at the edge of the tracked tree may be newly ignored. */
+export function atTrackedEdge(
+  name: string,
+  tracked: Set<string> | undefined,
+): boolean {
+  const file = normalize(name);
+
+  return !!tracked && tracked.has(parent(file)) && !tracked.has(file);
+}
+
+/** Wholly ignored directories, so watchers can skip them. */
+export async function ignoredDirectories(
+  rootPath: string,
+  gitDirectory?: string,
+): Promise<string[]> {
+  try {
+    const { stdout } = await exec(
+      "git",
+      [
+        "-C",
+        rootPath,
+        ...(gitDirectory
+          ? ["--git-dir", gitDirectory, "--work-tree", rootPath]
+          : []),
+        "ls-files",
+        "-z",
+        "--others",
+        "--ignored",
+        "--exclude-standard",
+        "--directory",
+      ],
+      { maxBuffer: 32 * 1024 * 1024 },
+    );
+
+    return stdout
+      .split("\0")
+      .filter((entry) => entry.endsWith("/") && entry !== ".jj/")
+      .map((entry) => entry.slice(0, -1));
+  } catch {
+    return [];
+  }
+}
+
 // A checkout's own state, per gitrepository-layout(5).
 const CHECKOUT_STATE =
   /^(?:index|[A-Z_]+|(?:rebase-merge|rebase-apply|sequencer|refs\/(?:bisect|worktree|rewritten))(?:\/.*)?)$/;
 
+/** Objects, reflogs, LFS objects and Review's own checkouts; never watched. */
+export const INERT_GIT_PATHS = ["objects", "logs", "lfs", "dev-fast"];
+
 /** Objects, reflogs, locks and other checkouts' state cannot change this one. */
 export function gitEventMatters(name: string, prefix: string): boolean {
   const file = normalize(name);

package/src/review-app.ts

@@ -100,7 +100,7 @@ export async function runReviewAppPick(
     const root = await runtime.resolveReviewRoot(input.cwd);
 
     const reviews = (await client.read<ReviewApiSummary[]>(""))
-      .filter((review) => review.repositoryPath === root && !review.dismissedAt)
+      .filter((review) => review.repositoryPath === root && !review.trashedAt)
       .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 
     if (!reviews.length) throw new ReviewAppStateError("No review to show.");

package/src/review-info.ts

@@ -53,7 +53,7 @@ export async function runReviewInfo(
     event: "info",
     reviews: reviews.filter(
       (review) =>
-        review.repositoryPath === root && (input.all || !review.dismissedAt),
+        review.repositoryPath === root && (input.all || !review.trashedAt),
     ),
   };
 }

package/src/review-stack.ts

@@ -26,7 +26,7 @@ export async function resolveReviewStackLayers(
   subject: Pick<ReviewApiSummary, "origin"> & { reviewId?: string },
   reviews: readonly Pick<
     ReviewApiSummary,
-    "reviewId" | "title" | "origin" | "pins" | "dismissedAt"
+    "reviewId" | "title" | "origin" | "pins" | "trashedAt"
   >[],
   runGitHubApi: RunGitHubApi = defaultRunGitHubApi,
 ): Promise<ReviewStackLayer[]> {
@@ -79,7 +79,7 @@ export async function resolveReviewStackLayers(
 
     const review =
       matches.find((candidate) => candidate.reviewId === subject.reviewId) ??
-      matches.findLast((candidate) => !candidate.dismissedAt) ??
+      matches.findLast((candidate) => !candidate.trashedAt) ??
       matches.at(-1);
 
     return {

package/src/server/review-server-core.ts

@@ -142,6 +142,21 @@ export function createWhiteboardCore(input: WhiteboardCoreInput) {
   const askThreads =
     input.ask && new AskThreads(launchAskAgent, input.ask.tools);
 
+  const closeDeletedThreads = () =>
+    askThreads?.closeDeletedReviews((id) =>
+      id.startsWith("shared-")
+        ? !shared?.has(id) || Boolean(shared.get(id).snapshot.trashedAt)
+        : !store.has(id) || Boolean(store.read(id).trashedAt),
+    );
+
+  const stopLocal =
+    askThreads &&
+    store.subscribe((result) => {
+      if (result.deleted || result.lifecycle) closeDeletedThreads();
+    });
+
+  const stopShared = askThreads && shared?.subscribe(closeDeletedThreads);
+
   const api = createReviewApi(
     store,
     data,
@@ -158,7 +173,16 @@ export function createWhiteboardCore(input: WhiteboardCoreInput) {
   // A shared store mounts the publisher with the rest of sharing.
   if (!shared) mountSharingPublisher(api, store, data);
 
-  return { app, api, close: () => askThreads?.closeAll() };
+  return {
+    app,
+    api,
+    close: () => {
+      stopLocal?.();
+      stopShared?.();
+      closeDeletedThreads();
+      askThreads?.closeAll();
+    },
+  };
 }
 
 /** The Desktop callbacks `createReviewApi` takes, answered over the relay. */

package/src/server/tutorial-service.ts

@@ -4,10 +4,8 @@ import path from "node:path";
 
 import { resolveRevision } from "@dev.fast/local-vcs";
 import { writePrivateJsonAtomic } from "@dev.fast/trace-core";
-import {
-  documentSchema,
-  resourceReferences,
-} from "@review/review-api/document";
+import { lensSchema } from "@review/review-api/diff-lenses";
+import { documentSchema } from "@review/review-api/document";
 import type { LocalReviewData } from "@review/review-api/local-data";
 import type { ReviewStore, Snapshot } from "@review/review-api/store";
 import { devReviewHome } from "@review/review-home-paths";
@@ -18,6 +16,8 @@ const authoredSchema = z.strictObject({
   document: documentSchema,
 });
 
+const lensesSchema = z.array(lensSchema.omit({ id: true }));
+
 const pinsSchema = z.strictObject({
   base: z.string().regex(/^[a-f0-9]{40}$/),
   head: z.string().regex(/^[a-f0-9]{40}$/),
@@ -30,12 +30,7 @@ const stampSchema = z.object({
 });
 
 export async function readTutorialAssets(assetsRoot: string) {
-  const names = [
-    "document.json",
-    "trace.json",
-    "software-map.json",
-    "pins.json",
-  ];
+  const names = ["document.json", "lenses.json", "pins.json"];
 
   const bytes = await Promise.all(
     names.map((name) => readFile(path.join(assetsRoot, name), "utf8")),
@@ -43,9 +38,8 @@ export async function readTutorialAssets(assetsRoot: string) {
 
   return {
     authored: authoredSchema.parse(JSON.parse(bytes[0]!)),
-    trace: JSON.parse(bytes[1]!),
-    model: JSON.parse(bytes[2]!),
-    pins: pinsSchema.parse(JSON.parse(bytes[3]!)),
+    lenses: lensesSchema.parse(JSON.parse(bytes[1]!)),
+    pins: pinsSchema.parse(JSON.parse(bytes[2]!)),
     contentHash: createHash("sha256")
       .update(JSON.stringify(bytes))
       .digest("hex"),
@@ -68,38 +62,6 @@ export async function createNativeTutorial(input: {
     assets.pins.head,
   );
 
-  const aliases = new Map<string, string>();
-  const traceId = randomUUID();
-  await input.data.upload({
-    id: traceId,
-    repositoryId: repository.id,
-    kind: "trace",
-    trace: assets.trace,
-  });
-  aliases.set("tutorial-trace", traceId);
-
-  for (const side of ["base", "head"] as const) {
-    const id = randomUUID();
-    await input.data.upload({
-      id,
-      repositoryId: repository.id,
-      kind: "map",
-      pins,
-      side,
-      model: assets.model,
-    });
-    aliases.set(`tutorial-map-${side}`, id);
-  }
-
-  for (const block of resourceReferences(assets.authored.document)) {
-    if (block.type === "trace_quote")
-      block.traceId = aliases.get(block.traceId) ?? block.traceId;
-
-    if (block.type === "software_map")
-      block.mapVersionId =
-        aliases.get(block.mapVersionId) ?? block.mapVersionId;
-  }
-
   const result = await input.store.execute(
     {
       operation: {
@@ -111,6 +73,15 @@ export async function createNativeTutorial(input: {
     { document: assets.authored.document, origin: { tutorial: true } },
   );
 
+  for (const { title, targets } of assets.lenses)
+    await input.store.execute({
+      operation: {
+        type: "lens_edit",
+        reviewId: result.reviewId,
+        edit: { type: "insert", title, targets },
+      },
+    });
+
   return {
     snapshot: input.store.read(result.reviewId),
     contentHash: assets.contentHash,
@@ -163,10 +134,15 @@ export function createTutorialService(input: {
   }
 
   async function cleanup() {
-    for (const reviewId of input.store.tutorialIds())
+    for (const reviewId of input.store.tutorialIds()) {
+      if (!input.store.read(reviewId).trashedAt)
+        await input.store.execute({
+          operation: { type: "lifecycle", state: "trash", reviewId },
+        });
       await input.store.execute({
         operation: { type: "delete", reviewId },
       });
+    }
 
     // Windows cannot delete a checkout while its Git reader or watchers
     // hold it open, and handles can outlive their close briefly.

package/src/sharing/export.ts

@@ -68,6 +68,7 @@ export async function exportShare(input: {
     staleSources: _staleSources,
     sourceUnavailable: _sourceUnavailable,
     lastEdit: _lastEdit,
+    trashedAt: _trashedAt,
     ...snapshot
   } = structuredClone(input.store.read(input.reviewId, input.version));
 

package/src/sharing/import.ts

@@ -251,10 +251,12 @@ export class SharedReviewStore {
   >();
   private readonly attention = new Map<
     string,
-    { viewedAt: string | null; dismissedAt: string | null }
+    { viewedAt: string | null; trashedAt: string | null }
   >();
   private readonly listeners = new Set<() => void>();
   private catalogLoaded = false;
+  private readonly purgeTimer: ReturnType<typeof setInterval>;
+  private purgePending: Promise<void> | undefined;
   private readonly downloads = new Set<Promise<void>>();
 
   trackImport(job: Promise<void>) {
@@ -263,6 +265,8 @@ export class SharedReviewStore {
   }
 
   async close() {
+    clearInterval(this.purgeTimer);
+    await this.purgePending;
     await Promise.allSettled([...this.downloads, ...this.jobs.values()]);
   }
 
@@ -280,10 +284,38 @@ export class SharedReviewStore {
   constructor(
     readonly root: string,
     private readonly fetchRepository = fetchPinnedRepository,
-  ) {}
+  ) {
+    this.purgeTimer = setInterval(() => {
+      void this.purgeExpired().catch((error) =>
+        console.error("Could not purge expired shared whiteboards:", error),
+      );
+    }, 60_000);
+    this.purgeTimer.unref();
+  }
+
+  private purgeExpired(): Promise<void> {
+    if (this.purgePending) return this.purgePending;
+
+    const expired = [...this.attention].filter(
+      ([, state]) =>
+        state.trashedAt &&
+        Date.parse(state.trashedAt) <= Date.now() - 30 * 86400000,
+    );
+
+    const pending = (async () => {
+      for (const [id] of expired) await this.removeLocal(id);
+    })();
+
+    this.purgePending = pending.finally(() => {
+      this.purgePending = undefined;
+    });
+
+    return this.purgePending;
+  }
 
   connect(store: ReviewStore, data: LocalReviewData) {
     this.local = { store, data };
+    store.askHistory.setExternalWriteGuard((id) => this.assertWritable(id));
     data.workspaces.attachExternalReviews({
       has: (id) =>
         this.has(id) || (!this.catalogLoaded && id.startsWith("shared-")),
@@ -517,33 +549,58 @@ export class SharedReviewStore {
           "Reopen the share link to fetch its repository.",
         );
 
-      try {
-        this.attention.set(
-          id,
-          z
-            .strictObject({
-              viewedAt: z.string().nullable(),
-              dismissedAt: z.string().nullable(),
-            })
-            .parse(
-              JSON.parse(
-                await readFile(
-                  path.join(this.root, id, "attention.json"),
-                  "utf8",
-                ),
-              ),
-            ),
-        );
-      } catch {
-        /* Attention is optional local metadata. */
+      const attentionPath = path.join(this.root, id, "attention.json");
+
+      if (existsSync(attentionPath)) {
+        const raw = JSON.parse(await readFile(attentionPath, "utf8"));
+
+        const migrated =
+          Object.hasOwn(raw, "dismissedAt") || Object.hasOwn(raw, "deletedAt");
+
+        const state = z
+          .strictObject({
+            viewedAt: z.string().nullable(),
+            trashedAt: z.string().nullable(),
+          })
+          .parse(
+            migrated
+              ? {
+                  viewedAt: raw.viewedAt,
+                  trashedAt: Object.hasOwn(raw, "deletedAt")
+                    ? raw.deletedAt
+                    : raw.dismissedAt
+                      ? new Date().toISOString()
+                      : null,
+                }
+              : raw,
+          );
+
+        this.attention.set(id, state);
+
+        if (migrated)
+          await writeFile(attentionPath, JSON.stringify(state), {
+            mode: 0o600,
+          });
       }
     }
 
+    await this.purgeExpired();
+
     this.catalogLoaded = true;
 
     for (const listener of this.listeners) listener();
   }
 
+  assertWritable(id: string) {
+    const trashedAt = this.attention.get(id)?.trashedAt;
+
+    if (trashedAt)
+      throw new ReviewInputError(
+        `This whiteboard was moved to Trash on ${new Date(trashedAt).toLocaleDateString("en-US", { month: "short", day: "numeric" })}. Restore it with session_lifecycle({"sessionId":"${id}","state":"active"}) to continue.`,
+        409,
+      );
+  }
+
   get(id: string) {
     const bundle = this.loaded.get(id);
 
@@ -569,6 +626,7 @@ export class SharedReviewStore {
       snapshot: {
         ...validated.snapshot,
         reviewId: id,
+        trashedAt: this.attention.get(id)?.trashedAt ?? null,
         pins: validated.snapshot.pins
           ? { ...validated.snapshot.pins, repositoryId: repositoryId! }
           : undefined,
@@ -605,7 +663,7 @@ export class SharedReviewStore {
             snapshot.version === 0 ? snapshot.createdAt : undefined,
           repositoryName: "Shared review",
           viewedAt: this.attention.get(id)?.viewedAt ?? null,
-          dismissedAt: this.attention.get(id)?.dismissedAt ?? null,
+          trashedAt: this.attention.get(id)?.trashedAt ?? null,
         };
       })
       .toArray();
@@ -649,6 +707,7 @@ export class SharedReviewStore {
     this.repositories.delete(id);
     this.states.delete(id);
     await rm(path.join(this.root, id), { recursive: true, force: true });
+    this.local?.store.askHistory.removeReview(id);
     this.loaded.delete(id);
     this.validated.delete(id);
     this.attention.delete(id);
@@ -656,18 +715,43 @@ export class SharedReviewStore {
     for (const listener of this.listeners) listener();
   }
 
-  async setAttention(id: string, action: "view" | "dismiss" | "restore") {
+  async setAttention(id: string) {
+    await this.updateAttention(id, "view");
+  }
+
+  async setLifecycle(id: string, state: "active" | "trash") {
+    await this.updateAttention(id, state);
+  }
+
+  private async updateAttention(
+    id: string,
+    action: "view" | "active" | "trash",
+  ) {
     this.get(id);
 
+    const trashedAt = this.attention.get(id)?.trashedAt;
+
+    if (trashedAt && Date.parse(trashedAt) <= Date.now() - 30 * 86400000) {
+      await this.removeLocal(id);
+      throw new ReviewInputError(
+        "The 30-day recovery period has ended. This whiteboard was permanently deleted.",
+        404,
+      );
+    }
+
+    if (action === "view") this.assertWritable(id);
+
     const state = this.attention.get(id) ?? {
       viewedAt: null,
-      dismissedAt: null,
+      trashedAt: null,
     };
 
     if (action === "view") state.viewedAt = new Date().toISOString();
     else
-      state.dismissedAt =
-        action === "dismiss" ? new Date().toISOString() : null;
+      state.trashedAt =
+        action === "trash"
+          ? (state.trashedAt ?? new Date().toISOString())
+          : null;
     await writeFile(
       path.join(this.root, id, "attention.json"),
       JSON.stringify(state),
@@ -681,6 +765,7 @@ export class SharedReviewStore {
   async import(origin: string, shareId: string, bundle: ShareBundle) {
     const validated = validateShareBundle(bundle);
     const id = sharedReviewId(origin, shareId);
+    this.assertWritable(id);
     await mkdir(this.root, { recursive: true, mode: 0o700 });
     const staging = await mkdtemp(path.join(this.root, ".import-"));