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

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

package/dist/remote-uninstall-DLtDG0o7.js

@@ -0,0 +1,153 @@
+import { b as REVIEW_REMOTE_INSTALL_LOCK, x as REVIEW_REMOTE_WRAPPER_MARK } from "./src-Bgvf1sEN.js";
+import "./review-home-paths-zwevIq4I.js";
+import { j as DEV_REVIEW_HOME_ENV } from "./s3-config-DDWWMh5x.js";
+import { c as stopBackgroundServer, o as recordedBackgroundServer } from "./background-server-Cw7CcfaZ.js";
+import { i as whiteboardRemoteHome } from "./remote-extensions-BiNx6NQK.js";
+import { n as remoteLanguageServerGroups, r as stopProcessGroup } from "./remote-language-server-DQgWUNeV.js";
+import { existsSync } from "node:fs";
+import { lstat, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/remote-uninstall.ts
+const LOCK_STALE_MS = 9e5;
+const REVIEW_STORE = [
+	"review-api.db",
+	"review-api.db-wal",
+	"review-api.db-shm",
+	"review-api.db.workspaces",
+	"review-api.db.workspaces-wal",
+	"review-api.db.workspaces-shm"
+];
+async function remoteUninstall(input) {
+	const refuse = (reason) => ({
+		event: "remote.uninstall",
+		ok: false,
+		reason
+	});
+	if (!path.isAbsolute(input.home)) return refuse(`HOME is ${input.home ? JSON.stringify(input.home) : "not set"}; Whiteboard removes nothing without an absolute home.`);
+	if (!path.isAbsolute(input.stateDir)) return refuse(`The review home ${JSON.stringify(input.stateDir)} is not an absolute path.`);
+	const override = input.env[DEV_REVIEW_HOME_ENV]?.trim();
+	if (override && (/[\x00-\x1f\x7f-\x9f]/.test(override) || override.includes("//") || path.resolve(override) !== (override.replace(/\/$/, "") || "/"))) return refuse(`DEV_REVIEW_HOME is ${JSON.stringify(override)}; Whiteboard removes nothing under a review home that is not an absolute, normalised path.`);
+	const install = whiteboardRemoteHome(input.env);
+	const wrapper = path.join(input.home, ".local", "bin", "whiteboard");
+	const lock = path.join(install, REVIEW_REMOTE_INSTALL_LOCK);
+	const busy = async () => refuse(`Desktop on ${await readText(path.join(lock, "owner")) || "another computer"} is installing Whiteboard here. Try again when it is done.`);
+	if (existsSync(lock)) {
+		if (!await stale(lock)) return busy();
+		await rm(lock, {
+			recursive: true,
+			force: true
+		});
+	}
+	const held = existsSync(install);
+	if (held && !await mkdir(lock).then(() => true, () => false)) return busy();
+	try {
+		return await removeInstall(input, install, wrapper, refuse);
+	} finally {
+		if (held) await rm(lock, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function removeInstall(input, install, wrapper, refuse) {
+	const server = await recordedBackgroundServer(input.stateDir);
+	const recorded = server && {
+		...server.discovery,
+		version: server.health.version ?? null
+	};
+	const stoppable = recorded && recorded.startedBy !== "user" ? recorded.serverPid : void 0;
+	const groups = await remoteLanguageServerGroups(input.env);
+	const running = await processesFrom(`${install}/`);
+	if (running === void 0) return refuse(`Cannot list this host's processes to check that none runs from ${install}.`);
+	const others = running.filter(({ pid, pgid }) => pid !== stoppable && !groups.includes(pgid)).map(({ pid }) => pid);
+	if (others.length) return refuse(`${others.map((pid) => pid === recorded?.serverPid ? `A Whiteboard server you started (process ${pid})` : `Process ${pid}`).join(", ")} ${others.length > 1 ? "run" : "runs"} from ${install}. Stop ${others.length > 1 ? "them" : "it"}, then run whiteboard remote uninstall again.`);
+	if (recorded?.startedBy === "user" && input.deleteReviews) return refuse(`A Whiteboard server you started (process ${recorded.serverPid}) uses the reviews in ${input.stateDir}. Stop it, then run whiteboard remote uninstall again.`);
+	await Promise.all(groups.map(stopProcessGroup));
+	let stoppedServer;
+	if (recorded && stoppable !== void 0) {
+		try {
+			await stopBackgroundServer({ serverPid: stoppable });
+		} catch (error) {
+			return refuse(error instanceof Error ? error.message : String(error));
+		}
+		stoppedServer = {
+			pid: stoppable,
+			version: recorded.version
+		};
+	}
+	const left = await processesFrom(`${install}/`);
+	if (left?.length !== 0) return refuse(`${left ? `Process ${left.map(({ pid }) => pid).join(", ")}` : "A process"} still runs from ${install}. Stop it, then run whiteboard remote uninstall again.`);
+	const removed = [];
+	if (existsSync(install)) {
+		await rm(install, {
+			recursive: true,
+			force: true
+		});
+		removed.push(install);
+	}
+	if (await desktopWrote(wrapper)) {
+		await rm(wrapper, { force: true });
+		removed.push(wrapper);
+	}
+	if (input.deleteReviews) for (const name of REVIEW_STORE) {
+		const file = path.join(input.stateDir, name);
+		if (existsSync(file)) {
+			await rm(file, { force: true });
+			removed.push(file);
+		}
+	}
+	const result = {
+		event: "remote.uninstall",
+		ok: true,
+		removed,
+		keptReviews: !input.deleteReviews
+	};
+	if (stoppedServer) result.stoppedServer = stoppedServer;
+	return result;
+}
+async function stale(lock) {
+	const started = await readText(path.join(lock, "started"));
+	if (started !== "") return /^\d+$/.test(started) && Date.now() - Number(started) * 1e3 >= LOCK_STALE_MS;
+	if (existsSync(path.join(lock, "started"))) return false;
+	const since = (await stat(lock).catch(() => void 0))?.mtimeMs;
+	return since !== void 0 && Date.now() - since >= LOCK_STALE_MS;
+}
+const readText = (file) => readFile(file, "utf8").then((text) => text.trim(), () => "");
+async function processesFrom(prefix) {
+	let lines;
+	try {
+		const pids = (await readdir("/proc")).filter((name) => /^\d+$/.test(name));
+		lines = await Promise.all(pids.map(async (pid) => {
+			const [args = "", stat = ""] = await Promise.all([`/proc/${pid}/cmdline`, `/proc/${pid}/stat`].map((file) => readFile(file, "utf8").catch(() => "")));
+			const pgid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[2]);
+			return {
+				pid: Number(pid),
+				pgid,
+				args: args.replaceAll("\0", " ")
+			};
+		}));
+	} catch {
+		try {
+			const { stdout } = await promisify(execFile)("ps", ["-eo", "pid=,pgid=,args="], { maxBuffer: 16 << 20 });
+			lines = stdout.split("\n").map((line) => {
+				const [, pid = "", pgid = "", args = ""] = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line) ?? [];
+				return {
+					pid: Number(pid),
+					pgid: Number(pgid),
+					args
+				};
+			});
+		} catch {
+			return;
+		}
+	}
+	return lines.filter(({ pid, args }) => pid && pid !== process.pid && args.includes(prefix));
+}
+async function desktopWrote(file) {
+	if (!(await lstat(file).catch(() => void 0))?.isFile()) return false;
+	return (await readFile(file, "utf8")).split("\n").includes(REVIEW_REMOTE_WRAPPER_MARK);
+}
+//#endregion
+export { remoteUninstall };

package/dist/{request-origin-DA4K1qWY.js → request-origin-DaRIV3cB.js}

@@ -1,5 +1,5 @@
 import { a as jsonNumber, c as jsonString, i as jsonBoolean, n as isJsonObject } from "./src-X9phtB2j.js";
-import { f as REVIEW_DIFF_LAYOUTS, p as REVIEW_THEME_CHOICES } from "./src-WCbabvdS.js";
+import { S as REVIEW_THEME_CHOICES, h as REVIEW_DIFF_LAYOUT_SCOPES, m as REVIEW_DIFF_LAYOUTS } from "./src-Bgvf1sEN.js";
 import { z } from "zod";
 //#region src/telemetry-clean-text.ts
 const USER_DATA_REGEXES = [
@@ -442,7 +442,10 @@ 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
+		}
 	},
 	review_dismissed: {
 		event: "review_review_dismissed",

package/dist/review-app-launcher-D7I4DGoH.js

@@ -0,0 +1,222 @@
+import { o as parseReviewVerbResponse } from "./src-Bgvf1sEN.js";
+import { b as selectReviewInstance, m as healthyReviewInstance, v as reviewInstanceStartHint, y as reviewInstanceUnavailable } from "./server-discovery-CifQ3yQS.js";
+import { closeSync, existsSync, fstatSync, mkdtempSync, openSync, readSync } from "node:fs";
+import path from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+//#region src/review-app-launcher.ts
+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"
+	}
+};
+/** "1" on launches without --focus; Desktop opens inactive. */
+const REVIEW_DESKTOP_BACKGROUND_ENV = "DEV_FAST_REVIEW_DESKTOP_BACKGROUND";
+const DEFAULT_LAUNCH_TIMEOUT_MS = 9e4;
+const POLL_INTERVAL_MS = 250;
+const EARLY_EXIT_GRACE_MS = 5e3;
+async function runReviewAppLaunch(input = {}, overrides = {}) {
+	const fetch = overrides.fetch ?? globalThis.fetch;
+	const runtime = {
+		selectInstance: () => selectReviewInstance({ fetch }),
+		fetch,
+		focusDesktop: (discovery) => focusReviewDesktop(discovery, fetch),
+		launchDesktop: launchDesktopApplication,
+		now: Date.now,
+		wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+		...overrides
+	};
+	const selection = await runtime.selectInstance();
+	const current = healthyReviewInstance(selection);
+	if (current) {
+		if (input.focus) await runtime.focusDesktop(current);
+		return launchEvent("running", current.instanceId);
+	}
+	const running = selection.instances.filter((instance) => instance.healthy);
+	if (selection.key !== "stable" && selection.key !== "preview") throw new Error(`${reviewInstanceStartHint(selection)}; \`whiteboard app launch\` starts only installed apps.`);
+	if (selection.source === "fallback" && running.length > 1) throw reviewInstanceUnavailable(selection);
+	const launch = {
+		focus: input.focus,
+		noSandbox: input.noSandbox
+	};
+	if (selection.source !== "fallback") launch.instance = {
+		key: selection.key,
+		appPath: selection.instance?.discovery.appPath
+	};
+	const attempt = runtime.launchDesktop(launch);
+	let completion = observedCompletion(attempt);
+	completion.catch(() => void 0);
+	const deadline = runtime.now() + (input.timeoutMs ?? DEFAULT_LAUNCH_TIMEOUT_MS);
+	let unexpectedSuccessfulExitAt;
+	while (runtime.now() < deadline) {
+		const ready = healthyReviewInstance(await runtime.selectInstance());
+		if (ready) return launchEvent("launched", ready.instanceId);
+		if (unexpectedSuccessfulExitAt !== void 0 && runtime.now() - unexpectedSuccessfulExitAt >= EARLY_EXIT_GRACE_MS) throw launchFailure(attempt, /* @__PURE__ */ new Error("the launch process exited before Desktop became ready"));
+		const remaining = Math.max(0, deadline - runtime.now());
+		const outcome = completion ? await Promise.race([completion.then((result) => ({ completion: result })), runtime.wait(Math.min(POLL_INTERVAL_MS, remaining)).then(() => ({ completion: null }))]) : await runtime.wait(Math.min(POLL_INTERVAL_MS, remaining)).then(() => ({ completion: null }));
+		if (outcome.completion) {
+			assertSuccessfulLaunchCompletion(attempt, outcome.completion);
+			unexpectedSuccessfulExitAt = runtime.now();
+			completion = void 0;
+		}
+	}
+	if (unexpectedSuccessfulExitAt !== void 0) throw launchFailure(attempt, /* @__PURE__ */ new Error("the launch process exited before Desktop became ready"));
+	throw new Error(`Whiteboard Desktop did not become ready within ${Math.ceil((input.timeoutMs ?? DEFAULT_LAUNCH_TIMEOUT_MS) / 1e3)} seconds after ${attempt.method}. Open Whiteboard Desktop once, then run \`whiteboard app launch\` again.${launchDiagnostics(attempt.logPath)}`);
+}
+async function focusReviewDesktop(discovery, fetch) {
+	const response = await fetch(`${discovery.url}/app/focus`, {
+		method: "POST",
+		headers: { "x-review-token": discovery.token },
+		signal: AbortSignal.timeout(5e3)
+	});
+	const result = parseReviewVerbResponse(await response.json());
+	if (!response.ok || !result.ok) throw new Error(result.ok ? `Whiteboard Desktop focus returned ${response.status}.` : result.error);
+}
+function desktopApplicationInstalled(input = {}) {
+	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));
+	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) {
+	try {
+		return execFileSync("/usr/bin/mdfind", [`kMDItemCFBundleIdentifier == '${bundleId}'`], {
+			encoding: "utf8",
+			timeout: 2e3
+		}).trim() !== "";
+	} catch {
+		return false;
+	}
+}
+function launchDesktopApplication(input = {}) {
+	const platform = input.platform ?? process.platform;
+	if (platform !== "darwin" && platform !== "linux") return {
+		method: `the ${platform} application launcher`,
+		completion: Promise.reject(/* @__PURE__ */ new Error("automatic launch is available only on macOS and Linux"))
+	};
+	if (input.noSandbox && platform !== "linux") return {
+		method: `the ${platform} application launcher`,
+		completion: Promise.reject(/* @__PURE__ */ new Error("--no-sandbox is only supported for Linux Desktop launches."))
+	};
+	const electron = input.electron ?? Boolean(process.versions.electron);
+	const env = { ...input.env ?? process.env };
+	const execPath = input.execPath ?? process.execPath;
+	const focus = input.focus === true;
+	if (focus) delete env[REVIEW_DESKTOP_BACKGROUND_ENV];
+	else env[REVIEW_DESKTOP_BACKGROUND_ENV] = "1";
+	delete env.ELECTRON_RUN_AS_NODE;
+	delete env.DEV_FAST_REVIEW_CHECKOUT;
+	const release = RELEASE_APPS[input.instance?.key ?? "stable"];
+	const stateRoot = env.DEV_FAST_REVIEW_DESKTOP_STATE_ROOT?.trim();
+	const profileArgs = stateRoot ? [`--user-data-dir=${path.resolve(stateRoot, "user-data")}`, `--extensions-dir=${path.resolve(stateRoot, "extensions")}`] : [];
+	let command = "/usr/bin/open";
+	let method;
+	let args;
+	if (platform === "linux") {
+		delete env.VSCODE_DEV;
+		delete env.VSCODE_CLI;
+		command = (input.instance ? "" : env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()) || release.linuxLauncher;
+		method = `the installed Linux launcher at "${command}"`;
+		if (electron && !env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()) {
+			command = execPath;
+			method = `the Desktop-managed bundle at "${command}"`;
+		}
+		args = profileArgs;
+		if (input.noSandbox) args.push("--no-sandbox");
+	} else {
+		const appPath = input.instance ? input.instance.appPath : electron ? execPath.match(/^(.*?\.app)\/Contents\/MacOS\//)?.[1] : void 0;
+		const target = appPath?.endsWith(".app") ? ["-a", appPath] : ["-b", release.bundleId];
+		method = appPath?.endsWith(".app") ? `the macOS application at "${appPath}"` : `the macOS bundle identifier "${release.bundleId}"`;
+		args = [
+			"-n",
+			"-W",
+			...focus ? [] : ["-g"],
+			...target
+		];
+		for (const [key, value] of Object.entries(env)) if (value !== void 0 && /^DEV_(REVIEW|FAST)_/.test(key)) args.push("--env", `${key}=${value}`);
+		if (profileArgs.length > 0) args.push("--args", ...profileArgs);
+	}
+	const { promise: completion, resolve, reject } = Promise.withResolvers();
+	let logPath;
+	let logFd;
+	try {
+		if (platform === "linux") {
+			logPath = path.join(mkdtempSync(path.join(tmpdir(), "whiteboard-launch-")), "stderr.log");
+			logFd = openSync(logPath, "wx", 384);
+		}
+		const child = (input.spawn ?? spawn)(command, args, {
+			detached: true,
+			env,
+			stdio: logFd === void 0 ? "ignore" : [
+				"ignore",
+				"ignore",
+				logFd
+			]
+		});
+		child.once("error", (error) => reject(error));
+		child.once("exit", (code, signal) => {
+			resolve({
+				code,
+				signal
+			});
+		});
+		child.unref();
+	} catch (error) {
+		reject(error instanceof Error ? error : new Error(String(error)));
+	} finally {
+		if (logFd !== void 0) closeSync(logFd);
+	}
+	return {
+		method,
+		logPath,
+		completion
+	};
+}
+function launchEvent(state, instanceId) {
+	return {
+		event: "app",
+		action: "launch",
+		state,
+		instanceId
+	};
+}
+function launchFailure(attempt, error) {
+	return /* @__PURE__ */ new Error(`Could not launch Whiteboard with ${attempt.method}: ${error.message}. Open Whiteboard once, then run \`whiteboard app launch\` again. A sandboxed agent must run it outside the sandbox.${launchDiagnostics(attempt.logPath)}`);
+}
+function assertSuccessfulLaunchCompletion(attempt, completion) {
+	if (completion.code === 0 && !completion.signal) return;
+	throw launchFailure(attempt, /* @__PURE__ */ new Error(completion.signal ? `the launch process exited on ${completion.signal}` : `the launch process exited with code ${completion.code ?? "unknown"}`));
+}
+function observedCompletion(attempt) {
+	return attempt.completion.catch((error) => {
+		throw launchFailure(attempt, error instanceof Error ? error : new Error(String(error)));
+	});
+}
+function launchDiagnostics(logPath) {
+	if (!logPath) return "";
+	let tail = "";
+	try {
+		const fd = openSync(logPath, "r");
+		try {
+			const size = fstatSync(fd).size;
+			const buffer = Buffer.alloc(Math.min(size, 16384));
+			const read = readSync(fd, buffer, 0, buffer.length, size - buffer.length);
+			tail = buffer.subarray(0, read).toString("utf8").trim().split("\n").slice(-20).join("\n");
+		} finally {
+			closeSync(fd);
+		}
+	} catch {}
+	return `\nDesktop log: ${logPath}${tail ? `\n${tail}` : ""}`;
+}
+//#endregion
+export { focusReviewDesktop as n, runReviewAppLaunch as r, desktopApplicationInstalled as t };