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

package/dist/{mcp-t7VN9R3k.js → mcp-DBbDwG4y.js}

@@ -1,7 +1,7 @@
-import { C as ReviewInputError } from "./src-DiHP11l3.js";
-import { a as toolResultText, s as ReviewApiError } from "./agent-client-P3J4y8Zn.js";
-import { n as REVIEW_STATUS_TOOL, t as authoringTools } from "./authoring-tools-D8WXsm_g.js";
-import { i as publicTool, n as RECOVERY, r as callPublicTool, t as toolFailure } from "./tool-failure-CJHBCHMh.js";
+import { a as toolResultText, s as ReviewApiError } from "./agent-client-DVd-prfp.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { n as REVIEW_STATUS_TOOL, t as authoringTools } from "./authoring-tools-BXKEwhfi.js";
+import { i as publicTool, n as RECOVERY, r as callPublicTool, t as toolFailure } from "./tool-failure-BXWzQG8T.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

package/dist/{package-paths-B9PDoAl6.js → package-paths-BsuI4WUf.js}

@@ -1,5 +1,5 @@
 import { c as jsonString, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
-import "./review-home-paths-Y9mYWkCI.js";
+import "./review-home-paths-zwevIq4I.js";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/profile-BSOkA6A-.js

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

package/dist/{profile-BsYDBr7t.js → profile-pAzg7fxC.js}

@@ -1,6 +1,6 @@
-import { o as initializeReviewStoreSchema, t as openLocalReviewStore } from "./local-data-BlERtVm2.js";
-import "./review-home-paths-Y9mYWkCI.js";
-import { O as withFileLock } from "./s3-config-CAxhO9u_.js";
+import { o as initializeReviewStoreSchema, t as openLocalReviewStore } from "./local-data-yfLp5PiJ.js";
+import "./review-home-paths-zwevIq4I.js";
+import { A as withFileLock } from "./s3-config-DDWWMh5x.js";
 import { access, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";

package/dist/remote-attach-BAt2eZx3.js

@@ -0,0 +1,137 @@
+import { i as readReviewPackageVersion } from "./package-paths-BsuI4WUf.js";
+import { a as readReviewServerHealth, l as serverNotReady } from "./server-discovery-CifQ3yQS.js";
+import { c as stopBackgroundServer, o as recordedBackgroundServer, r as ensureBackgroundServer } from "./background-server-Cw7CcfaZ.js";
+import { t as ensureRemoteLanguageServer } from "./remote-language-server-DQgWUNeV.js";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { gt, valid } from "semver";
+//#region src/remote-toolchains.ts
+const PROBE_TIMEOUT_MS = 1e4;
+const TOOLCHAINS = {
+	rust: [["cargo", "--version"], ["rustc", "--version"]],
+	swift: [["swift", "--version"]],
+	csharp: [["dotnet", "--version"]],
+	go: [["go", "version"]]
+};
+function probe(command, env, timeoutMs) {
+	const shell = env.SHELL || "/bin/sh";
+	const flags = ["csh", "tcsh"].includes(path.basename(shell)) ? ["-ic"] : [
+		"-i",
+		"-l",
+		"-c"
+	];
+	return new Promise((resolve) => {
+		const child = spawn(shell, [...flags, command.join(" ")], {
+			env,
+			detached: true,
+			stdio: "ignore"
+		});
+		const timer = setTimeout(() => {
+			child.removeAllListeners("exit");
+			try {
+				process.kill(-child.pid, "SIGKILL");
+			} catch {}
+			resolve(`${command.join(" ")} did not answer within ${timeoutMs / 1e3} s`);
+		}, timeoutMs);
+		child.once("error", (error) => {
+			clearTimeout(timer);
+			resolve(`the login shell ${shell} did not run: ${error.message}`);
+		});
+		child.once("exit", (code) => {
+			clearTimeout(timer);
+			resolve(code === 0 ? "found" : code === 127 ? "missing" : `${command.join(" ")} failed with exit code ${code ?? "none"}`);
+		});
+	});
+}
+async function missingToolchains(groups, env, { timeoutMs = PROBE_TIMEOUT_MS, toolchains = TOOLCHAINS } = {}) {
+	const entries = await Promise.all(groups.map(async (group) => {
+		const commands = Object.hasOwn(toolchains, group) ? toolchains[group] : [];
+		const outcomes = await Promise.all(commands.map((command) => probe(command, env, timeoutMs)));
+		const missing = commands.filter((_, i) => outcomes[i] === "missing").map(([tool]) => tool);
+		const failures = outcomes.filter((outcome) => outcome !== "found" && outcome !== "missing");
+		const details = [...missing.length > 0 ? [`${missing.join(" and ")} ${missing.length > 1 ? "were" : "was"} not found on the login shell's PATH`] : [], ...failures];
+		return details.length > 0 ? [[group, details.join("; ")]] : [];
+	}));
+	return new Map(entries.flat());
+}
+//#endregion
+//#region src/remote-attach.ts
+async function remoteAttach(input) {
+	const extensions = new AbortController();
+	const language = ensureRemoteLanguageServer({
+		env: input.env,
+		packageRoot: input.packageRoot,
+		groups: input.groups,
+		signal: extensions.signal,
+		ensure: input.ensureExtensions,
+		installTimeoutMs: input.installTimeoutMs,
+		cli: input.cli
+	});
+	const toolchains = missingToolchains(input.groups ?? [], input.env);
+	let server;
+	let previousVersion;
+	let incompatibleRunning;
+	try {
+		const version = input.version ?? readReviewPackageVersion(import.meta.url);
+		const other = input.replace ? await otherVersionRunning(input.stateDir, version) : void 0;
+		if (other && (other.startedBy === "user" || newer(other.version, version))) incompatibleRunning = other;
+		else if (other) {
+			await stopBackgroundServer({ serverPid: other.pid });
+			previousVersion = other.version;
+		}
+		server = await ensureBackgroundServer({
+			stateDir: input.stateDir,
+			env: input.env,
+			startedBy: "desktop",
+			cli: input.cli
+		});
+	} catch (error) {
+		extensions.abort();
+		await Promise.all([language, toolchains]);
+		throw error;
+	}
+	const { discovery, started } = server;
+	const { languageServer, languageServerDetail, languageServerPending, languageGroups } = await language;
+	const missing = await toolchains;
+	const health = await readReviewServerHealth(discovery);
+	if (!health) throw serverNotReady(input.stateDir);
+	return {
+		event: "remote.attach",
+		version: health.version ?? null,
+		commit: health.commit ?? null,
+		serverId: health.serverId ?? null,
+		url: discovery.url,
+		token: discovery.token,
+		startedServer: started,
+		languageServer,
+		...languageServerDetail !== void 0 && { languageServerDetail },
+		...languageServerPending && { languageServerPending },
+		languageGroups: languageGroups.map(({ group, installed, detail }) => {
+			const details = [detail, missing.get(group)].filter(Boolean).join("; ");
+			return {
+				group,
+				installed,
+				...details && { detail: details }
+			};
+		}),
+		...previousVersion !== void 0 && {
+			replaced: true,
+			previousVersion
+		},
+		...incompatibleRunning && { incompatibleRunning }
+	};
+}
+const newer = (running, own) => valid(running) !== null && valid(own) !== null && gt(running, own);
+async function otherVersionRunning(stateDir, version) {
+	const recorded = await recordedBackgroundServer(stateDir);
+	if (!recorded) return void 0;
+	const { discovery, health } = recorded;
+	const running = health.version ?? "unknown";
+	return running === version ? void 0 : {
+		version: running,
+		pid: discovery.serverPid,
+		startedBy: discovery.startedBy
+	};
+}
+//#endregion
+export { remoteAttach };

package/dist/remote-extensions-2Cxf3hMo.js

@@ -0,0 +1,2 @@
+import { t as ensureRemoteExtensions } from "./remote-extensions-BiNx6NQK.js";
+export { ensureRemoteExtensions };

package/dist/remote-extensions-BiNx6NQK.js

@@ -0,0 +1,323 @@
+import { u as parseJsonText } from "./src-X9phtB2j.js";
+import "./review-home-paths-zwevIq4I.js";
+import { M as devReviewHome } from "./s3-config-DDWWMh5x.js";
+import { t as findReviewPackageRoot } from "./package-paths-BsuI4WUf.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import yauzl from "yauzl";
+//#region src/pinned-download.ts
+const DOWNLOAD_TIMEOUT_MS = 12e4;
+/** Streams `url` into `file` through a temporary file and returns its sha256. */
+async function downloadFile(url, file, { size, timeoutMs = DOWNLOAD_TIMEOUT_MS, signal } = {}) {
+	const { host } = new URL(url);
+	const partial = `${file}.${process.pid}.part`;
+	let response;
+	await mkdir(path.dirname(file), { recursive: true });
+	try {
+		response = await fetch(url, { signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...signal ? [signal] : []]) });
+	} catch (error) {
+		throw new Error(`Network error reaching ${host}: ${error instanceof Error ? networkCause(error) : String(error)}`);
+	}
+	if (!response.ok || !response.body) throw new Error(`${host} answered ${response.status} for ${url}`);
+	const hash = createHash("sha256");
+	let received = 0;
+	const tooLarge = /* @__PURE__ */ new Error(`${url} is larger than its pinned ${size} bytes`);
+	try {
+		await pipeline(Readable.fromWeb(response.body), async function* (chunks) {
+			for await (const chunk of chunks) {
+				received += chunk.length;
+				if (size !== void 0 && received > size) throw tooLarge;
+				hash.update(chunk);
+				yield chunk;
+			}
+		}, createWriteStream(partial));
+		await rename(partial, file);
+	} catch (error) {
+		await rm(partial, { force: true });
+		if (error === tooLarge) throw error;
+		throw new Error(`Network error downloading from ${host}: ${error instanceof Error ? networkCause(error) : String(error)}`);
+	}
+	return hash.digest("hex");
+}
+/** Leaves a matching `file` in place; otherwise downloads it and checks the pin. */
+async function downloadPinned(pin, file, options = {}) {
+	if (await sha256File(file).catch(() => void 0) === pin.sha256) return;
+	const actual = await downloadFile(pin.url, file, {
+		...options,
+		size: pin.size
+	});
+	if (actual !== pin.sha256) {
+		await rm(file, { force: true });
+		throw new Error(`Checksum mismatch for ${pin.url}: expected ${pin.sha256}, got ${actual}. The download was deleted.`);
+	}
+}
+async function sha256File(file) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(file)) hash.update(chunk);
+	return hash.digest("hex");
+}
+const networkCauseSchema = z.object({ code: z.string() });
+const networkCause = (error) => error.name === "TimeoutError" ? "timed out" : networkCauseSchema.safeParse(error.cause).data?.code ?? error.message;
+//#endregion
+//#region src/vsix.ts
+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`. */
+async function extractVsix(vsix, destination, maxBytes = Number.POSITIVE_INFINITY) {
+	let unpacked = 0;
+	const zip = await new Promise((resolve, reject) => yauzl.open(vsix, { lazyEntries: true }, (error, opened) => error ? reject(error) : resolve(opened)));
+	const openReadStream = (entry) => new Promise((resolve, reject) => zip.openReadStream(entry, (error, stream) => error ? reject(error) : resolve(stream)));
+	try {
+		await new Promise((resolve, reject) => {
+			zip.on("error", reject);
+			zip.on("end", () => resolve());
+			zip.on("entry", (entry) => {
+				(async () => {
+					const name = entry.fileName.replaceAll("\\", "/");
+					if (name.endsWith("/") || !name.startsWith("extension/")) return;
+					const relative = name.slice(10);
+					const parts = relative.split("/");
+					const mode = entry.externalFileAttributes >>> 16 & 65535;
+					if (parts.some((part) => part === ".." || part === "." || part === "" || part.includes(":")) || path.posix.isAbsolute(relative)) throw new Error(`VSIX contains an unsafe path: ${name}`);
+					if ((mode & 61440) === 40960) 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 & 73) await chmod(output, mode & 511);
+				})().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.
+*/
+async function sanitizeVsixManifest(directory, extension) {
+	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
+	}, void 0, 2)}\n`);
+	return manifest.engines?.vscode;
+}
+//#endregion
+//#region src/remote-extensions.ts
+const EXECUTABLE_TIMEOUT_MS = 15e3;
+const STAMP_FILE = ".curated.json";
+const curatedDownloadSchema = z.object({
+	universal: z.boolean(),
+	url: z.string(),
+	sha256: z.string(),
+	size: z.number()
+});
+const curatedExtensionSchema = z.object({
+	id: z.string(),
+	version: z.string(),
+	tier: z.enum(["bundled", "optional"]),
+	group: z.string(),
+	executables: z.array(z.string()),
+	stripExtensionPack: z.boolean(),
+	targets: z.object({
+		"linux-x64": curatedDownloadSchema,
+		"linux-arm64": curatedDownloadSchema
+	})
+});
+const stampSchema = z.object({
+	id: z.string(),
+	version: z.string(),
+	target: z.string(),
+	sha256: z.string(),
+	installedTimestamp: z.number()
+});
+function whiteboardRemoteHome(env = process.env) {
+	return path.join(devReviewHome(env), "whiteboard-remote");
+}
+function remoteServerPaths(env = process.env) {
+	const home = whiteboardRemoteHome(env);
+	return {
+		extensionsDir: path.join(home, "extensions"),
+		serverDataDir: path.join(home, "server")
+	};
+}
+function remoteExtensionTarget(platform = process.platform, arch = process.arch) {
+	if (platform === "linux" && (arch === "x64" || arch === "arm64")) return `linux-${arch}`;
+	throw new Error(`Language features on a remote need Linux on x64 or arm64; this machine is ${platform}-${arch}.`);
+}
+async function ensureRemoteExtensions(input = {}) {
+	const target = input.target ?? remoteExtensionTarget();
+	const curated = input.curated ?? await readPackagedCurated();
+	const { extensionsDir, serverDataDir } = remoteServerPaths(input.env);
+	const installed = [];
+	const skipped = [];
+	const failed = [];
+	const listed = [];
+	await mkdir(extensionsDir, { recursive: true });
+	for (const extension of curated) {
+		if (extension.tier === "optional" && !input.groups?.includes(extension.group)) {
+			skipped.push({
+				id: extension.id,
+				reason: `optional group "${extension.group}" not requested`
+			});
+			continue;
+		}
+		const download = extension.targets[target];
+		const folder = `${extension.id}-${extension.version}`;
+		const directory = path.join(extensionsDir, folder);
+		const stamp = {
+			id: extension.id,
+			version: extension.version,
+			target,
+			sha256: download.sha256
+		};
+		try {
+			const current = await readStamp(directory);
+			if (current && sameStamp(current, stamp) && await checkExecutables(directory, extension).then(() => true, () => false)) {
+				skipped.push({
+					id: extension.id,
+					reason: "up to date"
+				});
+				listed.push(storedExtension(extension, directory, folder, target, current.installedTimestamp));
+				continue;
+			}
+			const installedTimestamp = Date.now();
+			await install(extension, download, directory, {
+				...stamp,
+				installedTimestamp
+			}, input.timeoutMs, input.signal);
+			installed.push(extension.id);
+			listed.push(storedExtension(extension, directory, folder, target, installedTimestamp));
+		} catch (error) {
+			failed.push({
+				id: extension.id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	const list = `${JSON.stringify(listed)}\n`;
+	const listFile = path.join(extensionsDir, "extensions.json");
+	if (await readFile(listFile, "utf8").catch(() => void 0) !== list) {
+		const temporary = `${listFile}.${process.pid}.tmp`;
+		await writeFile(temporary, list);
+		await rename(temporary, listFile);
+		await rm(path.join(serverDataDir, "data", "CachedProfilesData"), {
+			recursive: true,
+			force: true
+		});
+	}
+	const kept = new Set(listed.map((entry) => entry.relativeLocation));
+	for (const folder of await readdir(extensionsDir)) if (!kept.has(folder) && curated.some(({ id }) => folder.startsWith(`${id}-`) && /^\d/.test(folder.slice(id.length + 1)))) await rm(path.join(extensionsDir, folder), {
+		recursive: true,
+		force: true
+	});
+	return {
+		event: "remote.extensions",
+		target,
+		installed,
+		skipped,
+		failed,
+		groups: requestedGroups(curated, input.groups ?? [], failed)
+	};
+}
+function requestedGroups(curated, groups, failed) {
+	return groups.flatMap((group) => {
+		const members = curated.filter((extension) => extension.tier === "optional" && extension.group === group);
+		if (members.length === 0) return [];
+		const errors = failed.filter(({ id }) => members.some((extension) => extension.id === id));
+		return [errors.length === 0 ? {
+			group,
+			installed: true
+		} : {
+			group,
+			installed: false,
+			detail: errors.map(({ id, error }) => `${id}: ${error}`).join("; ")
+		}];
+	});
+}
+async function readPackagedCurated() {
+	const file = path.join(findReviewPackageRoot(import.meta.url), "vscode-server", "curated.json");
+	const text = await readFile(file, "utf8").catch(() => {
+		throw new Error(`This package has no VS Code server (${file} is missing).`);
+	});
+	return z.object({ extensions: z.array(curatedExtensionSchema) }).parse(JSON.parse(text)).extensions;
+}
+async function readStamp(directory) {
+	return readFile(path.join(directory, STAMP_FILE), "utf8").then((text) => stampSchema.safeParse(parseJsonText(text)).data).catch(() => void 0);
+}
+function sameStamp(current, expected) {
+	return current.id === expected.id && current.version === expected.version && current.target === expected.target && current.sha256 === expected.sha256;
+}
+async function install(extension, download, directory, stamp, timeoutMs, signal) {
+	const part = `${directory}.${process.pid}.vsix`;
+	const staging = `${directory}.${process.pid}.staging`;
+	try {
+		await downloadPinned(download, part, {
+			timeoutMs,
+			signal
+		});
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		await extractVsix(part, staging, download.size * 8);
+		await sanitizeVsixManifest(staging, extension);
+		await checkExecutables(staging, extension);
+		await writeFile(path.join(staging, STAMP_FILE), `${JSON.stringify(stamp)}\n`);
+		await rm(directory, {
+			recursive: true,
+			force: true
+		});
+		await rename(staging, directory);
+	} finally {
+		await rm(part, { force: true });
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function checkExecutables(directory, extension) {
+	for (const relative of extension.executables) await promisify(execFile)(path.join(directory, relative), ["--version"], {
+		timeout: EXECUTABLE_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	}).catch((error) => {
+		throw new Error(`${extension.id}: ${relative} does not run here: ${error.message}`);
+	});
+}
+function storedExtension(extension, directory, folder, target, installedTimestamp) {
+	return {
+		identifier: { id: extension.id },
+		version: extension.version,
+		location: {
+			$mid: 1,
+			scheme: "file",
+			path: directory
+		},
+		relativeLocation: folder,
+		metadata: {
+			installedTimestamp,
+			targetPlatform: extension.targets[target].universal ? "universal" : target
+		}
+	};
+}
+//#endregion
+export { whiteboardRemoteHome as i, remoteExtensionTarget as n, remoteServerPaths as r, ensureRemoteExtensions as t };