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

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 };

package/dist/remote-language-server-DQgWUNeV.js

@@ -0,0 +1,252 @@
+import "./review-home-paths-zwevIq4I.js";
+import { A as withFileLock, k as processStartIdentity } from "./s3-config-DDWWMh5x.js";
+import { t as findReviewPackageRoot } from "./package-paths-BsuI4WUf.js";
+import { n as cliSpawn, s as spawnDetached } from "./background-server-Cw7CcfaZ.js";
+import { r as remoteServerPaths, t as ensureRemoteExtensions } from "./remote-extensions-BiNx6NQK.js";
+import { randomBytes } from "node:crypto";
+import { z } from "zod";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/remote-language-server.ts
+const START_TIMEOUT_MS = 15e3;
+const VERSION_TIMEOUT_MS = 3e3;
+const INSTALL_TIMEOUT_MS = 35e3;
+const SHUTDOWN_WITHOUT_DELAY_ENV = "DEV_FAST_REVIEW_REMOTE_SHUTDOWN_WITHOUT_DELAY";
+const GRACE_ENV = "DEV_FAST_REVIEW_REMOTE_RECONNECTION_GRACE_SECONDS";
+const PENDING = {
+	languageServer: null,
+	languageServerDetail: "Installing the language extensions on this host; they will be available on the next connection.",
+	languageServerPending: true
+};
+function idleArgs(env) {
+	const grace = env[GRACE_ENV] ?? "";
+	return [
+		"--enable-remote-auto-shutdown",
+		"--reconnection-grace-time",
+		/^[1-9]\d{0,3}$/.test(grace) ? grace : "600"
+	];
+}
+const LISTENING = /Extension host agent listening on (\d+)/;
+const LOCK = {
+	retryMs: 100,
+	staleMs: 6e4,
+	unownedGraceMs: 5e3,
+	identifyOwner: true
+};
+const installingSchema = z.object({
+	pid: z.number(),
+	started: z.string().nullable()
+});
+const runningSchema = z.object({
+	pid: z.number(),
+	started: z.string().nullable(),
+	port: z.number()
+});
+function remoteLanguageServerFiles(env) {
+	const { serverDataDir } = remoteServerPaths(env);
+	return {
+		serverDataDir,
+		tokenFile: path.join(serverDataDir, "connection-token"),
+		runningFile: path.join(serverDataDir, "server.json"),
+		logFile: path.join(serverDataDir, "server.log"),
+		lock: path.join(serverDataDir, "start.lock"),
+		installingFile: path.join(serverDataDir, "install.json"),
+		installLog: path.join(serverDataDir, "install.log"),
+		installLock: path.join(serverDataDir, "install.lock")
+	};
+}
+async function ensureRemoteLanguageServer(input) {
+	const root = path.join(input.packageRoot ?? findReviewPackageRoot(import.meta.url), "vscode-server");
+	const files = remoteLanguageServerFiles(input.env);
+	const capped = new AbortController();
+	let languageGroups = (input.groups ?? []).map((group) => ({
+		group,
+		installed: false
+	}));
+	const cap = setTimeout(() => capped.abort(), input.installTimeoutMs ?? INSTALL_TIMEOUT_MS);
+	try {
+		const commit = await readCommit(root);
+		const ensure = input.ensure ?? ensureRemoteExtensions;
+		await mkdir(files.serverDataDir, {
+			recursive: true,
+			mode: 448
+		});
+		if (await installing(files)) return {
+			...PENDING,
+			languageGroups
+		};
+		const { failed, groups } = await ensure({
+			env: input.env,
+			groups: input.groups,
+			signal: AbortSignal.any([capped.signal, ...input.signal ? [input.signal] : []])
+		});
+		if (failed.length > 0 && capped.signal.aborted && !input.signal?.aborted && await installDetached(files, input)) return {
+			...PENDING,
+			languageGroups
+		};
+		if (groups) languageGroups = groups;
+		if (failed.length > 0) throw new Error(`Could not install the language extensions: ${failed.map(({ id, error }) => `${id}: ${error}`).join("; ")}`);
+		const outcome = await withFileLock(files.lock, {
+			...LOCK,
+			timeoutMs: (input.timeoutMs ?? START_TIMEOUT_MS) * 2
+		}, async () => {
+			return {
+				port: (await healthy(files.runningFile, commit))?.port ?? await startServer(root, files, input.env, input.timeoutMs),
+				connectionToken: (await readFile(files.tokenFile, "utf8")).trim(),
+				commit
+			};
+		});
+		if (!outcome.acquired) throw new Error("Another start of the VS Code server did not finish.");
+		return {
+			languageServer: outcome.result,
+			languageGroups
+		};
+	} catch (error) {
+		return {
+			languageServer: null,
+			languageServerDetail: error instanceof Error ? error.message : String(error),
+			languageGroups
+		};
+	} finally {
+		clearTimeout(cap);
+	}
+}
+async function readInstalling(files) {
+	return readFile(files.installingFile, "utf8").then((text) => installingSchema.safeParse(JSON.parse(text)).data).catch(() => void 0);
+}
+async function installing(files) {
+	const running = await readInstalling(files);
+	return running !== void 0 && ours(running);
+}
+async function remoteLanguageServerGroups(env) {
+	const files = remoteLanguageServerFiles(env);
+	return (await Promise.all([readRunning(files.runningFile), readInstalling(files)])).flatMap((entry) => entry && ours(entry) ? [entry.pid] : []);
+}
+async function stopProcessGroup(leader) {
+	for (const signal of ["SIGTERM", "SIGKILL"]) {
+		try {
+			process.kill(-leader, signal);
+		} catch {
+			return;
+		}
+		for (let i = 0; i < 50; i++) {
+			if (!groupAlive(leader)) return;
+			await setTimeout$1(100);
+		}
+	}
+}
+function groupAlive(leader) {
+	try {
+		process.kill(-leader, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+}
+async function installDetached(files, input) {
+	return (await withFileLock(files.installLock, {
+		...LOCK,
+		timeoutMs: 1e4
+	}, async () => {
+		if (await installing(files)) return;
+		const { command, args, env } = cliSpawn(input.cli, input.env);
+		const child = await spawnDetached({
+			command,
+			args: [
+				...args,
+				"remote",
+				"extensions",
+				"ensure",
+				"--json",
+				...input.groups?.length ? ["--groups", input.groups.join(",")] : []
+			],
+			cwd: files.serverDataDir,
+			env,
+			log: files.installLog
+		});
+		if (child.pid !== void 0) await writeFile(files.installingFile, `${JSON.stringify({
+			pid: child.pid,
+			started: processStartIdentity(child.pid)
+		})}\n`, { mode: 384 });
+	})).acquired;
+}
+async function readCommit(root) {
+	const file = path.join(root, "product.json");
+	const text = await readFile(file, "utf8").catch(() => {
+		throw new Error(`This Whiteboard install has no VS Code server (${file} is missing).`);
+	});
+	const { commit } = z.object({ commit: z.string().regex(/^[0-9a-f]{40}$/) }).parse(JSON.parse(text));
+	return commit;
+}
+async function readRunning(file) {
+	return readFile(file, "utf8").then((text) => runningSchema.safeParse(JSON.parse(text)).data).catch(() => void 0);
+}
+const ours = (running) => running.started !== null && processStartIdentity(running.pid) === running.started;
+async function healthy(file, commit) {
+	const running = await readRunning(file);
+	if (!running) return void 0;
+	if (ours(running) && await version(running.port) === commit) return running;
+	await stop(running);
+}
+async function version(port) {
+	return fetch(`http://127.0.0.1:${port}/version`, { signal: AbortSignal.timeout(VERSION_TIMEOUT_MS) }).then((response) => response.ok ? response.text() : void 0).catch(() => void 0);
+}
+async function stop(running) {
+	if (!ours(running)) return;
+	try {
+		process.kill(running.pid, "SIGTERM");
+	} catch {
+		return;
+	}
+	for (let i = 0; i < 50 && processStartIdentity(running.pid) !== null; i++) await setTimeout$1(100);
+}
+async function startServer(root, files, env, timeoutMs = START_TIMEOUT_MS) {
+	const { extensionsDir, serverDataDir } = remoteServerPaths(env);
+	const temporary = `${files.tokenFile}.${process.pid}.tmp`;
+	await writeFile(temporary, randomBytes(32).toString("hex"), { mode: 384 });
+	await rename(temporary, files.tokenFile);
+	const logStart = (await stat(files.logFile).catch(() => null))?.size ?? 0;
+	const child = await spawnDetached({
+		command: process.execPath,
+		args: [
+			path.join(root, "out", "server-main.js"),
+			"--host",
+			"127.0.0.1",
+			"--port",
+			"0",
+			"--connection-token-file",
+			files.tokenFile,
+			"--server-data-dir",
+			serverDataDir,
+			"--extensions-dir",
+			extensionsDir,
+			"--accept-server-license-terms",
+			...idleArgs(env),
+			...env[SHUTDOWN_WITHOUT_DELAY_ENV] === "1" ? ["--remote-auto-shutdown-without-delay"] : []
+		],
+		cwd: serverDataDir,
+		env,
+		log: files.logFile
+	});
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline && !child.exited) {
+		const output = (await readFile(files.logFile)).subarray(logStart).toString("utf8");
+		const port = Number(LISTENING.exec(output)?.[1]);
+		if (port && child.pid !== void 0) {
+			const running = {
+				pid: child.pid,
+				started: processStartIdentity(child.pid),
+				port
+			};
+			await writeFile(files.runningFile, `${JSON.stringify(running)}\n`, { mode: 384 });
+			return port;
+		}
+		await setTimeout$1(100);
+	}
+	if (!child.exited && child.pid !== void 0) process.kill(child.pid, "SIGTERM");
+	const tail = (await readFile(files.logFile)).subarray(logStart).toString("utf8").trimEnd().split("\n").slice(-10).join("\n");
+	throw new Error(`The VS Code server did not start${child.error ? `: ${child.error.message}` : child.exited ? "" : ` within ${timeoutMs / 1e3} s`}. The end of ${files.logFile}:\n${tail}`);
+}
+//#endregion
+export { remoteLanguageServerGroups as n, stopProcessGroup as r, ensureRemoteLanguageServer as t };