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

package/src/server-discovery.ts

@@ -15,6 +15,8 @@ const discoverySchema = z.object({
   }),
   serverPid: z.number().int().positive(),
   token: z.string().min(1),
+  // Older servers wrote no startedBy; only a person ran those.
+  startedBy: z.enum(["user", "cli", "desktop"]).default("user"),
 });
 
 export type ReviewServerDiscovery = z.infer<typeof discoverySchema>;
@@ -29,6 +31,9 @@ export function reviewServerDiscoveryPath(stateDir: string) {
   return path.join(stateDir, "review-server", "server.json");
 }
 
+/** Sent by a Desktop taking over the server's state directory. */
+export const DESKTOP_TAKEOVER_SIGNAL = "SIGUSR2";
+
 export function headlessServerLockPath(stateDir: string) {
   return path.join(stateDir, "headless-server.lock");
 }
@@ -76,7 +81,9 @@ export async function readReviewServerHealth(
         ok: z.literal(true),
         instanceId: z.string(),
         serverId: z.string().optional(),
+        serverPid: z.number().optional(),
         version: z.string().optional(),
+        commit: z.string().nullable().optional(),
       })
       .safeParse(await response.json());
 
@@ -88,6 +95,10 @@ export async function readReviewServerHealth(
   }
 }
 
+export function desktopOwnsHome(stateDir: string) {
+  return `Whiteboard Desktop is serving ${stateDir}, so no other Whiteboard server can start there. Quit Desktop, or choose another --state-dir.`;
+}
+
 export function serverNotReady(stateDir: string) {
   return new Error(
     `Whiteboard server is not ready in ${stateDir}. Run whiteboard server start --state-dir ${JSON.stringify(stateDir)}, then retry.`,

package/src/sharing/import.ts

@@ -79,6 +79,7 @@ export const sharedSnapshotSchema = z.strictObject({
       baseRef: z.string().optional(),
       pullRequestNumber: z.number().int().positive().optional(),
       pullRequestUrl: z.string().optional(),
+      pullRequestTitle: z.string().optional(),
       revision: z.string().optional(),
     })
     .optional(),

package/src/ui-telemetry-events.ts

@@ -19,6 +19,7 @@
 import {
   type JsonObject,
   REVIEW_DIFF_LAYOUTS,
+  REVIEW_DIFF_LAYOUT_SCOPES,
   REVIEW_THEME_CHOICES,
   isJsonObject,
   jsonBoolean,
@@ -369,7 +370,10 @@ export const UI_TELEMETRY_EVENTS = {
   },
   diff_layout_changed: {
     event: "review_diff_layout_changed",
-    properties: { layout: REVIEW_DIFF_LAYOUTS },
+    properties: {
+      layout: REVIEW_DIFF_LAYOUTS,
+      scope: REVIEW_DIFF_LAYOUT_SCOPES,
+    },
   },
   // Dismissal replaced the old reject decision: the reader is finished with the
   // review, whether or not they liked the change.

package/src/vsix.ts

@@ -0,0 +1,122 @@
+// Plain Node and yauzl only: apps/review-desktop/scripts imports this file directly.
+import { createWriteStream } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+import yauzl from "yauzl";
+import { z } from "zod";
+
+const manifestSchema = z.looseObject({
+  publisher: z.string(),
+  name: z.string(),
+  engines: z.looseObject({ vscode: z.string().optional() }).optional(),
+});
+
+/** Unpacks a VSIX's `extension/` payload into `destination`. */
+export async function extractVsix(
+  vsix: string,
+  destination: string,
+  maxBytes = Number.POSITIVE_INFINITY,
+) {
+  let unpacked = 0;
+
+  const zip = await new Promise<yauzl.ZipFile>((resolve, reject) =>
+    yauzl.open(vsix, { lazyEntries: true }, (error, opened) =>
+      error ? reject(error) : resolve(opened),
+    ),
+  );
+
+  const openReadStream = (entry: yauzl.Entry) =>
+    new Promise<Readable>((resolve, reject) =>
+      zip.openReadStream(entry, (error, stream) =>
+        error ? reject(error) : resolve(stream),
+      ),
+    );
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      zip.on("error", reject);
+      zip.on("end", () => resolve());
+      zip.on("entry", (entry: yauzl.Entry) => {
+        void (async () => {
+          const name = entry.fileName.replaceAll("\\", "/");
+
+          if (name.endsWith("/") || !name.startsWith("extension/")) return;
+
+          const relative = name.slice("extension/".length);
+          const parts = relative.split("/");
+          const mode = (entry.externalFileAttributes >>> 16) & 0o177777;
+
+          if (
+            parts.some(
+              (part) =>
+                part === ".." ||
+                part === "." ||
+                part === "" ||
+                part.includes(":"),
+            ) ||
+            path.posix.isAbsolute(relative)
+          )
+            throw new Error(`VSIX contains an unsafe path: ${name}`);
+
+          if ((mode & 0o170000) === 0o120000)
+            throw new Error(`VSIX contains a symlink: ${name}`);
+
+          unpacked += entry.uncompressedSize;
+
+          if (unpacked > maxBytes)
+            throw new Error(`VSIX unpacks to more than ${maxBytes} bytes`);
+
+          const output = path.join(destination, ...parts);
+          await mkdir(path.dirname(output), { recursive: true });
+          await pipeline(
+            await openReadStream(entry),
+            createWriteStream(output),
+          );
+
+          if (process.platform !== "win32" && mode & 0o111)
+            await chmod(output, mode & 0o777);
+        })().then(() => zip.readEntry(), reject);
+      });
+      zip.readEntry();
+    });
+  } finally {
+    zip.close();
+  }
+}
+
+/**
+ * Drops the `scripts` and `dependencies` a payload ships prebundled, and
+ * `extensionPack` when Review does not ship the pack's members.
+ */
+export async function sanitizeVsixManifest(
+  directory: string,
+  extension: { id: string; stripExtensionPack: boolean },
+) {
+  const file = path.join(directory, "package.json");
+
+  const manifest = manifestSchema.parse(
+    JSON.parse(await readFile(file, "utf8")),
+  );
+
+  const declared = `${manifest.publisher}.${manifest.name}`;
+
+  if (declared.toLowerCase() !== extension.id.toLowerCase())
+    throw new Error(`${extension.id}: the VSIX declares ${declared}`);
+
+  const { scripts, dependencies, devDependencies, extensionPack, ...kept } =
+    manifest;
+
+  await writeFile(
+    file,
+    `${JSON.stringify(
+      extension.stripExtensionPack ? kept : { ...kept, extensionPack },
+      undefined,
+      2,
+    )}\n`,
+  );
+
+  return manifest.engines?.vscode;
+}

package/dist/agent-cli-BR_Jw5BL.js

@@ -1,2 +0,0 @@
-import { n as runReviewAgentCli } from "./agent-cli-04xbDj23.js";
-export { runReviewAgentCli };

package/dist/headless-host-BLLJ7Dyu.js

@@ -1,95 +0,0 @@
-import { p as isObjectValue } from "./src-X9phtB2j.js";
-import "./review-home-paths-Y9mYWkCI.js";
-import { O as withFileLock, P as writePrivateJsonAtomic } from "./s3-config-CAxhO9u_.js";
-import { t as openReviewProfile } from "./profile-tbGWuWHu.js";
-import { i as createWhiteboardCore, l as createNodeRequestListener, m as migrateDiffrConfig, n as installProcessErrorTelemetry, p as GlobalReviewDesktopVerbRelay, t as drainServerCrashReport } from "./process-error-telemetry-BCBYp2t4.js";
-import { i as reviewServerDiscoveryPath, t as headlessServerLockPath } from "./server-discovery-ZVi8Ay8J.js";
-import { randomBytes, randomUUID } from "node:crypto";
-import { mkdir, realpath, rm } from "node:fs/promises";
-import { createServer } from "node:http";
-import { once } from "node:events";
-//#region src/server/headless-host.ts
-/** One foreground headless endpoint per profile; Desktop shares its database. */
-async function runHeadlessServer(input) {
-	await mkdir(input.stateDir, {
-		recursive: true,
-		mode: 448
-	});
-	const stateDir = await realpath(input.stateDir);
-	const stopErrorTelemetry = input.telemetry && installProcessErrorTelemetry(input.telemetry);
-	if (!(await withHeadlessServerLock(stateDir, () => serve({
-		...input,
-		stateDir
-	})).finally(() => stopErrorTelemetry?.())).acquired) throw new Error(`A Whiteboard server already owns ${stateDir}. Stop it first, or choose another --state-dir.`);
-}
-/** Held by a running server, so also by anything that must not run beside one. */
-function withHeadlessServerLock(stateDir, operation) {
-	return withFileLock(headlessServerLockPath(stateDir), {
-		timeoutMs: 0,
-		retryMs: 20,
-		staleMs: Infinity,
-		unownedGraceMs: 1e3,
-		identifyOwner: true
-	}, operation);
-}
-async function serve(input) {
-	if (input.signal.aborted) return;
-	await migrateDiffrConfig(input.signal);
-	if (input.telemetry) await drainServerCrashReport(input.telemetry);
-	const local = await openReviewProfile(input.stateDir, { manageWorkspaces: false });
-	const discovery = {
-		version: 1,
-		instanceId: randomUUID(),
-		url: "http://127.0.0.1:0",
-		serverPid: process.pid,
-		token: randomBytes(32).toString("base64url")
-	};
-	const relay = new GlobalReviewDesktopVerbRelay();
-	const { app, api } = createWhiteboardCore({
-		profile: local,
-		relay,
-		token: discovery.token,
-		instanceId: discovery.instanceId,
-		softwareMapEnabled: input.softwareMapEnabled,
-		scratchpad: () => false,
-		status: () => ({
-			key: "headless",
-			home: input.stateDir
-		})
-	});
-	app.route("/reviews-api", api);
-	const server = createServer(createNodeRequestListener(app));
-	let published = false;
-	try {
-		const listening = once(server, "listening");
-		server.listen(input.port ?? 0, "127.0.0.1");
-		await listening;
-		const address = server.address();
-		if (!isObjectValue(address)) throw new Error("Whiteboard server did not bind a TCP port.");
-		discovery.url = `http://127.0.0.1:${address.port}`;
-		await writePrivateJsonAtomic(reviewServerDiscoveryPath(input.stateDir), discovery);
-		published = true;
-		input.onReady(discovery);
-		await new Promise((resolve) => {
-			if (input.signal.aborted) resolve();
-			else input.signal.addEventListener("abort", () => resolve(), { once: true });
-		});
-	} finally {
-		const forceClose = setTimeout(() => server.closeAllConnections(), 5e3);
-		forceClose.unref();
-		try {
-			if (published) await rm(reviewServerDiscoveryPath(input.stateDir), { force: true });
-		} finally {
-			relay.close();
-			await new Promise((resolve) => server.close(() => resolve()));
-			clearTimeout(forceClose);
-			try {
-				await local.data.close();
-			} finally {
-				await local.store.close();
-			}
-		}
-	}
-}
-//#endregion
-export { runHeadlessServer, withHeadlessServerLock };

package/dist/profile-aMSw1oCM.js

@@ -1,2 +0,0 @@
-import { t as openReviewProfile } from "./profile-tbGWuWHu.js";
-export { openReviewProfile };

package/dist/server-discovery-ZVi8Ay8J.js

@@ -1,66 +0,0 @@
-import "./review-home-paths-Y9mYWkCI.js";
-import { A as devReviewHome } from "./s3-config-CAxhO9u_.js";
-import { z } from "zod";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-//#region src/server-discovery.ts
-const discoverySchema = z.object({
-	version: z.literal(1),
-	instanceId: z.uuid(),
-	url: z.url().refine((value) => {
-		const url = new URL(value);
-		return url.protocol === "http:" && url.hostname === "127.0.0.1";
-	}),
-	serverPid: z.number().int().positive(),
-	token: z.string().min(1)
-});
-function reviewServerStateDir(env = process.env) {
-	return env.DEV_REVIEW_SERVER_DIR?.trim() ? path.resolve(env.DEV_REVIEW_SERVER_DIR.trim()) : devReviewHome(env);
-}
-function reviewServerDiscoveryPath(stateDir) {
-	return path.join(stateDir, "review-server", "server.json");
-}
-function headlessServerLockPath(stateDir) {
-	return path.join(stateDir, "headless-server.lock");
-}
-async function readReviewServerDiscovery(stateDir) {
-	let source;
-	try {
-		source = await readFile(reviewServerDiscoveryPath(stateDir), "utf8");
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
-		throw error;
-	}
-	try {
-		return discoverySchema.parse(JSON.parse(source));
-	} catch {
-		throw new Error(`Whiteboard server discovery in ${stateDir} is invalid or incompatible. Restart it with this version of whiteboard server start.`);
-	}
-}
-async function reviewServerIsHealthy(discovery) {
-	return await readReviewServerHealth(discovery) !== null;
-}
-/** The recorded server's /health, or null when another or none answers. */
-async function readReviewServerHealth(discovery) {
-	try {
-		const response = await fetch(`${discovery.url}/health`, {
-			headers: { "x-review-token": discovery.token },
-			signal: AbortSignal.timeout(1500)
-		});
-		if (!response.ok) return null;
-		const health = z.object({
-			ok: z.literal(true),
-			instanceId: z.string(),
-			serverId: z.string().optional(),
-			version: z.string().optional()
-		}).safeParse(await response.json());
-		return health.success && health.data.instanceId === discovery.instanceId ? health.data : null;
-	} catch {
-		return null;
-	}
-}
-function serverNotReady(stateDir) {
-	return /* @__PURE__ */ new Error(`Whiteboard server is not ready in ${stateDir}. Run whiteboard server start --state-dir ${JSON.stringify(stateDir)}, then retry.`);
-}
-//#endregion
-export { reviewServerIsHealthy as a, reviewServerDiscoveryPath as i, readReviewServerDiscovery as n, reviewServerStateDir as o, readReviewServerHealth as r, serverNotReady as s, headlessServerLockPath as t };

package/src/fixtures/blocks/tutorial.json

@@ -1,14 +0,0 @@
-[
-  {
-    "type": "tutorial",
-    "kind": "keymap",
-    "id": "block-1"
-  },
-  {
-    "type": "tutorial",
-    "kind": "view",
-    "view": "diff",
-    "label": "Open the diff",
-    "id": "block-2"
-  }
-]

package/src/review-api/blocks/tutorial.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-
-import { type BlockDefinition, defineBlock } from "./definition.js";
-
-type TutorialContent =
-  | { kind: "keymap" }
-  | { kind: "view"; view: "diff"; label: string };
-
-export type TutorialBlock = { id?: string; type: "tutorial" } & TutorialContent;
-
-export const tutorialSchema = z.discriminatedUnion("kind", [
-  defineBlock("tutorial", { kind: z.literal("keymap") }),
-  defineBlock("tutorial", {
-    kind: z.literal("view"),
-    view: z.literal("diff"),
-    label: z.string(),
-  }),
-]);
-
-export const tutorial: BlockDefinition<TutorialBlock> = {
-  type: "tutorial",
-  schema: tutorialSchema,
-};

package/src/server/tutorial-service.ts

@@ -1,217 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { cp, mkdir, readFile, rename, rm } from "node:fs/promises";
-import path from "node:path";
-
-import { resolveRevision } from "@dev.fast/local-vcs";
-import { writePrivateJsonAtomic } from "@dev.fast/trace-core";
-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";
-import { z } from "zod";
-
-const authoredSchema = z.strictObject({
-  title: z.string().min(1),
-  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}$/),
-});
-
-const stampSchema = z.object({
-  version: z.literal(10),
-  reviewUuid: z.string(),
-  contentHash: z.string(),
-});
-
-export async function readTutorialAssets(assetsRoot: string) {
-  const names = ["document.json", "lenses.json", "pins.json"];
-
-  const bytes = await Promise.all(
-    names.map((name) => readFile(path.join(assetsRoot, name), "utf8")),
-  );
-
-  return {
-    authored: authoredSchema.parse(JSON.parse(bytes[0]!)),
-    lenses: lensesSchema.parse(JSON.parse(bytes[1]!)),
-    pins: pinsSchema.parse(JSON.parse(bytes[2]!)),
-    contentHash: createHash("sha256")
-      .update(JSON.stringify(bytes))
-      .digest("hex"),
-  };
-}
-
-/** Create the shipped document through the same strict validation as authored reviews. */
-export async function createNativeTutorial(input: {
-  assetsRoot: string;
-  sampleRoot: string;
-  store: ReviewStore;
-  data: LocalReviewData;
-}) {
-  const assets = await readTutorialAssets(input.assetsRoot);
-  const repository = await input.data.register(input.sampleRoot);
-
-  const pins = await input.data.resolvePins(
-    repository.id,
-    assets.pins.base,
-    assets.pins.head,
-  );
-
-  const result = await input.store.execute(
-    {
-      operation: {
-        type: "create",
-        title: assets.authored.title,
-        target: { kind: "commits", ...pins },
-      },
-    },
-    { 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,
-  };
-}
-
-export function createTutorialService(input: {
-  packageRoot: string;
-  store: ReviewStore;
-  data: LocalReviewData;
-}) {
-  const tutorialRoot = path.join(devReviewHome(), "tutorial");
-  const sampleRoot = path.join(tutorialRoot, "sample-service");
-  const stampPath = path.join(tutorialRoot, "stamp.json");
-  const assetsRoot = path.join(input.packageRoot, "tutorial");
-
-  const readStamp = async () =>
-    stampSchema.safeParse(
-      await readFile(stampPath, "utf8")
-        .then((value) => JSON.parse(value))
-        .catch(() => null),
-    ).data;
-
-  async function find(): Promise<Snapshot | null> {
-    try {
-      const stamp = await readStamp();
-
-      if (!stamp || !input.store.has(stamp.reviewUuid)) return null;
-      const snapshot = input.store.read(stamp.reviewUuid);
-      const assets = await readTutorialAssets(assetsRoot);
-
-      const [head, base] = await Promise.all([
-        resolveRevision(sampleRoot, "HEAD"),
-        resolveRevision(sampleRoot, "HEAD^"),
-      ]);
-
-      return snapshot.origin?.tutorial &&
-        stamp.contentHash === assets.contentHash &&
-        head &&
-        base &&
-        snapshot.pins?.head === head.commit &&
-        snapshot.pins?.base === base.commit &&
-        head.commit === assets.pins.head &&
-        base.commit === assets.pins.base
-        ? snapshot
-        : null;
-    } catch {
-      return null;
-    }
-  }
-
-  async function cleanup() {
-    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.
-    for (const repository of input.store.repositories()) {
-      const relative = path.relative(tutorialRoot, repository.path);
-
-      if (relative && !relative.startsWith("..") && !path.isAbsolute(relative))
-        await input.data.forgetRepository(repository.id);
-    }
-
-    await rm(tutorialRoot, { recursive: true, force: true, maxRetries: 10 });
-  }
-
-  return {
-    async status() {
-      return {
-        version: 1 as const,
-        reviewUuid: (await find())?.reviewId ?? null,
-      };
-    },
-    async referencesReview(id: string) {
-      return (
-        input.store.has(id) && input.store.read(id).origin?.tutorial === true
-      );
-    },
-    async prepare(options?: { beforeReset(): Promise<void> }) {
-      const current = await find();
-
-      if (current) return current;
-
-      await readTutorialAssets(assetsRoot);
-      await options?.beforeReset();
-      await cleanup();
-      await mkdir(tutorialRoot, { recursive: true, mode: 0o700 });
-
-      const temporaryRoot = path.join(
-        tutorialRoot,
-        `.sample-service-${randomUUID()}`,
-      );
-
-      try {
-        await cp(path.join(assetsRoot, "sample-service"), temporaryRoot, {
-          recursive: true,
-        });
-        await cp(
-          path.join(assetsRoot, "git-stub"),
-          path.join(temporaryRoot, ".git"),
-          { recursive: true },
-        );
-        await rename(temporaryRoot, sampleRoot);
-
-        const { snapshot, contentHash } = await createNativeTutorial({
-          assetsRoot,
-          sampleRoot,
-          store: input.store,
-          data: input.data,
-        });
-
-        await writePrivateJsonAtomic(stampPath, {
-          version: 10,
-          reviewUuid: snapshot.reviewId,
-          contentHash,
-        });
-
-        return snapshot;
-      } finally {
-        await rm(temporaryRoot, { recursive: true, force: true });
-      }
-    },
-    cleanup,
-  };
-}