@dev.fast/whiteboard 0.2.5-preview.20261013.113 → 0.2.5-preview.20261015.115

package/src/review-api/recent-folders.ts

@@ -0,0 +1,173 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { z } from "zod";
+
+export interface RecentFoldersEnvironment {
+  homeDir?: string;
+  env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+}
+
+/** VS Code forks whose recently opened folders count as projects. */
+const EDITORS = ["Cursor", "Code"];
+
+async function readText(file: string): Promise<string | undefined> {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+/** A file's JSON as `schema` reads it, or undefined when it is missing,
+ * malformed, or shaped otherwise: another app's file, read on its terms. */
+async function readJson<Schema extends z.ZodType>(
+  file: string,
+  schema: Schema,
+): Promise<z.infer<Schema> | undefined> {
+  const text = await readText(file);
+
+  try {
+    return text === undefined
+      ? undefined
+      : schema.safeParse(JSON.parse(text)).data;
+  } catch {
+    return undefined;
+  }
+}
+
+const claudeConfigSchema = z.object({
+  projects: z.record(z.string(), z.object({}).loose()),
+});
+
+/** Claude Code keeps per-folder settings for every folder it ran in. */
+async function claudeFolders(homeDir: string, env: NodeJS.ProcessEnv) {
+  const config = await readJson(
+    path.join(env.CLAUDE_CONFIG_DIR ?? homeDir, ".claude.json"),
+    claudeConfigSchema,
+  );
+
+  return Object.keys(config?.projects ?? {});
+}
+
+/** Codex records each folder it was trusted in as a `[projects."…"]` table. */
+export function codexConfigFolders(toml: string): string[] {
+  const folders: string[] = [];
+
+  for (const match of toml.matchAll(
+    /^\[projects\.(?:"((?:[^"\\]|\\.)*)"|'([^']*)')\]/gmu,
+  )) {
+    if (match[2] !== undefined) folders.push(match[2]);
+    else if (match[1] !== undefined)
+      try {
+        // A TOML basic string escapes as JSON does for paths.
+        folders.push(JSON.parse(`"${match[1]}"`));
+      } catch {
+        // An escape JSON lacks: not a path worth guessing at.
+      }
+  }
+
+  return folders;
+}
+
+async function codexFolders(homeDir: string, env: NodeJS.ProcessEnv) {
+  const toml = await readText(
+    path.join(env.CODEX_HOME ?? path.join(homeDir, ".codex"), "config.toml"),
+  );
+
+  return toml === undefined ? [] : codexConfigFolders(toml);
+}
+
+function editorDataDir(
+  app: string,
+  homeDir: string,
+  env: NodeJS.ProcessEnv,
+  platform: NodeJS.Platform,
+) {
+  if (platform === "darwin")
+    return path.join(homeDir, "Library", "Application Support", app);
+
+  if (platform === "win32")
+    return path.join(
+      env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"),
+      app,
+    );
+
+  return path.join(env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config"), app);
+}
+
+/** The parts of an editor's storage.json that name folders; either can be
+ * missing or reshaped by another version without losing the other. */
+const editorStorageSchema = z.object({
+  profileAssociations: z
+    .object({ workspaces: z.record(z.string(), z.unknown()) })
+    .optional()
+    .catch(undefined),
+  backupWorkspaces: z
+    .object({ folders: z.array(z.object({ folderUri: z.string() })) })
+    .optional()
+    .catch(undefined),
+});
+
+/** The folders an editor opened: those with a profile, and those with
+ * unsaved work. Both live in its storage.json, unlike its sqlite history. */
+function editorStorageFolders(
+  storage: z.infer<typeof editorStorageSchema>,
+): string[] {
+  const uris = [
+    ...Object.keys(storage.profileAssociations?.workspaces ?? {}),
+    ...(storage.backupWorkspaces?.folders ?? []).map(
+      (folder) => folder.folderUri,
+    ),
+  ];
+
+  return uris.flatMap((uri) => {
+    if (!uri.startsWith("file://")) return [];
+
+    try {
+      return [fileURLToPath(uri)];
+    } catch {
+      return [];
+    }
+  });
+}
+
+async function editorFolders(
+  app: string,
+  homeDir: string,
+  env: NodeJS.ProcessEnv,
+  platform: NodeJS.Platform,
+) {
+  const storage = await readJson(
+    path.join(
+      editorDataDir(app, homeDir, env, platform),
+      "User",
+      "globalStorage",
+      "storage.json",
+    ),
+    editorStorageSchema,
+  );
+
+  return storage ? editorStorageFolders(storage) : [];
+}
+
+/** Folders the user's agents and editors have worked in, unverified: some
+ * are gone, and many are not repositories or are inside one. */
+export async function recentFolders(
+  input: RecentFoldersEnvironment = {},
+): Promise<string[]> {
+  const homeDir = input.homeDir ?? os.homedir();
+  const env = input.env ?? process.env;
+  const platform = input.platform ?? process.platform;
+
+  const lists = await Promise.all([
+    claudeFolders(homeDir, env),
+    codexFolders(homeDir, env),
+    ...EDITORS.map((app) => editorFolders(app, homeDir, env, platform)),
+  ]);
+
+  return [...new Set(lists.flat().filter((folder) => path.isAbsolute(folder)))];
+}

package/src/review-api/store.ts

@@ -150,12 +150,14 @@ export const commandSchema = z.strictObject({
 
 /** Source identity displayed in the review header and Home, alongside immutable pins. */
 export interface SnapshotOrigin {
-  /** Managed tutorial; readable by ID but excluded from the user catalog. */
-  tutorial?: boolean;
   branch?: string;
   baseRef?: string;
+  /** The base the review's target names, such as the branch below it. */
+  baseBranch?: string;
   pullRequestNumber?: number;
   pullRequestUrl?: string;
+  /** As the forge reported it when the PR was attached. */
+  pullRequestTitle?: string;
   /** The legacy review revision this version was imported from. */
   revision?: string;
 }
@@ -216,6 +218,7 @@ export interface Result {
 export interface ResolvedPullRequest {
   target: ReviewTarget;
   pins: Pins;
+  /** Empty when the PR has none. */
   title: string;
 }
 
@@ -228,6 +231,8 @@ export interface ReviewProviders {
     url: string,
     repository: { id?: string; preferred?: string },
   ): Promise<ResolvedPullRequest>;
+  /** Undefined when the forge can't be read. */
+  pullRequestTitle?(url: string): Promise<string | undefined>;
   resolveTarget?(
     target: ReviewTarget,
     pinned?: Pins,
@@ -844,8 +849,8 @@ export class ReviewStore {
     }
   }
 
-  /** Managed records are discoverable even if their preparation stamp was lost. */
-  tutorialIds(): string[] {
+  /** Reviews of the tutorial earlier versions shipped, for their removal. */
+  legacyTutorialIds(): string[] {
     return this.db
       .prepare(
         `SELECT reviews.id FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version WHERE json_extract(versions.snapshot,'$.origin.tutorial') = 1`,
@@ -877,8 +882,7 @@ export class ReviewStore {
         JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
         LEFT JOIN review_attention ON review_attention.review_id=reviews.id
         LEFT JOIN repositories ON repositories.id=json_extract(versions.snapshot,'$.pins.repositoryId')
-        WHERE COALESCE(json_extract(versions.snapshot,'$.origin.tutorial'), 0) = 0
-        ${id === undefined ? "" : "AND reviews.id=?"}
+        ${id === undefined ? "" : "WHERE reviews.id=?"}
         ORDER BY reviews.rowid`,
       )
       .all(...(id === undefined ? [] : [id]))
@@ -1004,7 +1008,7 @@ export class ReviewStore {
 
     return inspectSnapshot(snapshot, targetId);
   }
-  /** The host can seed a managed document; transport callers only supply a command. */
+  /** The host can seed a document; transport callers only supply a command. */
   execute(
     // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Command boundary: commandSchema.parse below rejects malformed input before mutation.
     input: unknown,
@@ -1016,11 +1020,19 @@ export class ReviewStore {
 
     if (initial && command.operation.type !== "create")
       throw new ReviewInputError("Initial content requires a create command.");
+
     // Network and fetch time stay out of the write queue.
     const pullRequest = this.startPullRequest(command);
 
     pullRequest?.catch(() => {});
 
+    const pullRequestTitle = pullRequest
+      ? pullRequest.then(
+          ({ title }) => title || undefined,
+          () => undefined,
+        )
+      : this.startPullRequestTitle(command);
+
     const run = this.pending.then(async () => {
       const op = command.operation;
       this.purgeExpired();
@@ -1172,7 +1184,14 @@ export class ReviewStore {
 
       let snapshot: Snapshot =
         op.type === "create"
-          ? createdSnapshot(id, op, resolvedTarget, fromPullRequest?.title)
+          ? createdSnapshot(
+              id,
+              op,
+              resolvedTarget,
+              fromPullRequest &&
+                (fromPullRequest.title ||
+                  `PR #${op.pullRequestUrl!.split("/").at(-1)}`),
+            )
           : structuredClone(previous!);
 
       delete snapshot.trashedAt;
@@ -1210,6 +1229,17 @@ export class ReviewStore {
         }
       }
 
+      // A base named rather than given as a commit; a stacked review names
+      // the branch below it.
+      if (requestedTarget)
+        snapshot.origin = {
+          ...snapshot.origin,
+          baseBranch:
+            requestedTarget.base === resolvedTarget?.pins.base
+              ? undefined
+              : requestedTarget.base,
+        };
+
       switch (op.type) {
         case "create":
           if (initial) {
@@ -1223,7 +1253,7 @@ export class ReviewStore {
               assignFreshIds(block, (prefix) => `${prefix}-${++nextId}`);
           }
 
-          setPullRequest(snapshot, op.pullRequestUrl);
+          setPullRequest(snapshot, op.pullRequestUrl, await pullRequestTitle);
           break;
         case "rename":
           snapshot.title = op.title;
@@ -1236,6 +1266,7 @@ export class ReviewStore {
               snapshot.pins?.repositoryId !== resolvedTarget!.pins.repositoryId
                 ? null
                 : undefined),
+            await pullRequestTitle,
           );
           snapshot.staleSources = [];
           snapshot.target = resolvedTarget!.target;
@@ -1425,6 +1456,22 @@ export class ReviewStore {
       preferred: existing && this.read(existing).pins?.repositoryId,
     });
   }
+  private startPullRequestTitle(
+    command: z.infer<typeof commandSchema>,
+  ): Promise<string | undefined> {
+    const op = command.operation;
+
+    if (
+      (op.type !== "create" && op.type !== "set_target") ||
+      !op.pullRequestUrl
+    )
+      return Promise.resolve(undefined);
+
+    return (
+      this.providers.pullRequestTitle?.(op.pullRequestUrl) ??
+      Promise.resolve(undefined)
+    );
+  }
   /** Reviews whose PR is this one, newest version first. Summaries only. */
   private reviewsForPullRequest(url: string): string[] {
     return this.db
@@ -1432,7 +1479,6 @@ export class ReviewStore {
         `SELECT reviews.id FROM reviews
         JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
         WHERE lower(json_extract(versions.snapshot,'$.origin.pullRequestUrl'))=?
-          AND COALESCE(json_extract(versions.snapshot,'$.origin.tutorial'), 0) = 0
         ORDER BY json_extract(versions.snapshot,'$.createdAt') DESC, reviews.rowid DESC`,
       )
       .all(pullRequestKey(url))

package/src/review-api/workspaces.ts

@@ -48,9 +48,8 @@ interface Environment extends WorkspaceStatus {
   role: "base" | "head";
 }
 
-// A lease lasts until the owning Desktop exits; closing the review does not release it.
 const OWNED_ELSEWHERE =
-  "Another Desktop owns this review's language workspaces. Quit that Desktop, then retry.";
+  "Another Whiteboard server is managing this review's language workspaces. Retry once it stops.";
 
 /** Local lifecycle only: source and authored history never depend on preparation.
  * Status/queue/process lifecycle follows #334, retaining the legacy prepare config
@@ -101,10 +100,23 @@ export class ReviewWorkspaces {
       throw error;
     }
 
-    this.stop = store.subscribeCatalog(() => {
+    const stopCatalog = store.subscribeCatalog(() => {
       this.collect();
       this.releaseTrashed();
     });
+
+    const stopDeleted = store.subscribe(({ reviewId, deleted }) => {
+      if (!deleted) return;
+      const repositories = this.repositoryDirs();
+      repositories.catch(() => undefined);
+      this.release(reviewId, repositories, () => !this.hasReview(reviewId));
+    });
+
+    this.stop = () => {
+      stopCatalog();
+      stopDeleted();
+    };
+
     this.collect();
     this.releaseTrashed();
   }
@@ -131,7 +143,13 @@ export class ReviewWorkspaces {
     // Each release awaits this only after earlier cleanup and logs its failure.
     repositories.catch(() => undefined);
 
-    for (const reviewId of released) this.release(reviewId, repositories);
+    for (const reviewId of released)
+      this.release(reviewId, repositories, () => this.stillTrashed(reviewId));
+  }
+
+  /** Restored since the move to Trash: its checkouts may be in use. */
+  private stillTrashed(reviewId: string) {
+    return this.store.trashedIds().includes(reviewId);
   }
 
   private async repositoryDirs(): Promise<string[]> {
@@ -151,18 +169,26 @@ export class ReviewWorkspaces {
     return this.releasing.get(reviewId) ?? Promise.resolve();
   }
 
-  private release(reviewId: string, repositories = this.repositoryDirs()) {
+  private release(
+    reviewId: string,
+    repositories: Promise<string[]>,
+    stillReleased: () => boolean,
+  ) {
     // Requests started later wait for this release; earlier ones finish first.
     const requests = [...this.requests.values()];
 
     const done = this.cleanup
       .then(async () => {
         await Promise.allSettled(requests);
-        await this.releaseCheckouts(reviewId, await repositories);
+        await this.releaseCheckouts(
+          reviewId,
+          await repositories,
+          stillReleased,
+        );
       })
       .catch((error) => {
         console.error(
-          `Could not free the pinned checkouts of trashed review ${reviewId}:`,
+          `Could not free the pinned checkouts of review ${reviewId}:`,
           error,
         );
       })
@@ -175,9 +201,12 @@ export class ReviewWorkspaces {
     this.cleanup = done;
   }
 
-  private async releaseCheckouts(reviewId: string, repositories: string[]) {
-    // Restored since the move to Trash: its checkouts may be in use.
-    if (!this.store.trashedIds().includes(reviewId)) return;
+  private async releaseCheckouts(
+    reviewId: string,
+    repositories: string[],
+    stillReleased: () => boolean,
+  ) {
+    if (!stillReleased()) return;
 
     const environments = this.all().filter(
       (item) => item.reviewId === reviewId,
@@ -365,7 +394,9 @@ export class ReviewWorkspaces {
 
     // A trashed review keeps its record, so collection would skip it.
     if (this.store.has(environment.reviewId))
-      this.release(environment.reviewId);
+      this.release(environment.reviewId, this.repositoryDirs(), () =>
+        this.stillTrashed(environment.reviewId),
+      );
     else this.collect(id);
     await this.cleanup;
   }
@@ -647,6 +678,20 @@ export class ReviewWorkspaces {
           if (environment.rootPath)
             await removeReviewPrepareArtifacts(environment.rootPath);
 
+          if (
+            environment.repository &&
+            !this.all().some(
+              (other) =>
+                other.id !== environment.id &&
+                other.reviewId === environment.reviewId &&
+                other.repository === environment.repository,
+            )
+          )
+            await removeReviewManagedCheckouts(
+              environment.repository,
+              environment.reviewId,
+            );
+
           this.db
             .prepare("DELETE FROM pinned_environments WHERE id=?")
             .run(environment.id);

package/src/review-app-launcher.ts

@@ -1,6 +1,13 @@
-import { type SpawnOptions, spawn } from "node:child_process";
-import { closeSync, fstatSync, mkdtempSync, openSync, readSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { type SpawnOptions, execFileSync, spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  fstatSync,
+  mkdtempSync,
+  openSync,
+  readSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 
 import {
@@ -19,10 +26,12 @@ import {
 const RELEASE_APPS = {
   stable: {
     bundleId: "dev.fast.review",
+    macApp: "Whiteboard.app",
     linuxLauncher: "/usr/bin/review-desktop",
   },
   preview: {
     bundleId: "dev.fast.review.preview",
+    macApp: "Whiteboard Preview.app",
     linuxLauncher: "/usr/bin/review-preview-desktop",
   },
 };
@@ -227,6 +236,55 @@ export async function focusReviewDesktop(
   }
 }
 
+export function desktopApplicationInstalled(
+  input: Pick<
+    LaunchDesktopApplicationInput,
+    "platform" | "electron" | "env"
+  > & {
+    exists?: (path: string) => boolean;
+    spotlight?: (bundleId: string) => boolean;
+  } = {},
+): boolean {
+  const env = input.env ?? process.env;
+  const platform = input.platform ?? process.platform;
+  const exists = input.exists ?? existsSync;
+  const apps = Object.values(RELEASE_APPS);
+
+  if (
+    (platform !== "linux" && platform !== "darwin") ||
+    (input.electron ?? Boolean(process.versions.electron)) ||
+    env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()
+  )
+    return true;
+
+  if (platform === "linux")
+    return apps.some(({ linuxLauncher }) => exists(linuxLauncher));
+
+  // Spotlight can be off on a headless Mac, so the usual folders come first.
+  return (
+    apps.some(({ macApp }) =>
+      ["/Applications", path.join(homedir(), "Applications")].some((dir) =>
+        exists(path.join(dir, macApp)),
+      ),
+    ) ||
+    apps.some(({ bundleId }) => (input.spotlight ?? spotlightFinds)(bundleId))
+  );
+}
+
+function spotlightFinds(bundleId: string): boolean {
+  try {
+    return (
+      execFileSync(
+        "/usr/bin/mdfind",
+        [`kMDItemCFBundleIdentifier == '${bundleId}'`],
+        { encoding: "utf8", timeout: 2_000 },
+      ).trim() !== ""
+    );
+  } catch {
+    return false;
+  }
+}
+
 export function launchDesktopApplication(
   input: LaunchDesktopApplicationInput = {},
 ): DesktopLaunchAttempt {