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

package/dist/{cli-runner-C3men22A.js → cli-runner-PlGqBeMw.js}

@@ -1,27 +1,31 @@
-import { E as __toESM, S as setLocalVcsCommandObserver, T as __require, w as __commonJSMin } from "./src-DiHP11l3.js";
+import { C as setLocalVcsCommandObserver, E as __toESM, T as __require, w as __commonJSMin } from "./src-BMPuxWv4.js";
 import { c as jsonString, n as isJsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
-import { a as parseReviewVerbResponse } from "./src-WCbabvdS.js";
-import { $ as resolveTraceCommand, A as runTraceDeny, E as traceMachineStatus, F as describeSelection, H as resolveTraceRepositoryTarget, J as HOSTED_CAPTURE_SCOPE_DESCRIPTION, K as traceRepositoryStatus, L as loadS3TraceStorage, M as runTraceSessions, N as runTraceStoreDelete, P as runTraceStoreInfo, T as traceMachineEnabled, V as requireTraceConsent, _ as runTraceRepair, b as runTraceGitHook, c as registerTraceCommands, ct as runStoreLogout, d as runTraceList$1, dt as StoreClient, f as runTracePull$1, ft as withStoreAuthorization, g as runTraceInstallMachine, gt as jsonRequestedInArgv, h as runTraceEnable, ht as humanStream, j as runTraceOnboard, k as runTraceAllow, l as resolveTraceReadStorage, lt as runStoreWhoami, m as runTraceDisable, mt as failWithJsonError, nt as traceScope, ot as readStoreAuth, p as runTraceShow, pt as emitJsonEvent, q as readTraceUserConfig, rt as DEFAULT_STORE_ORIGIN, st as runStoreLogin, tt as traceHomeDir, u as runTraceBlame, ut as StoreApiError, v as runTraceStatus, w as readLegacyCaptureSettings, x as runTraceHook, y as runTraceSync, z as selectTraceStorage } from "./review-home-paths-Y9mYWkCI.js";
-import { o as ReviewApiClient, s as ReviewApiError } from "./agent-client-P3J4y8Zn.js";
+import { _ as REVIEW_REMOTE_AGENT_IDS, p as REVIEW_CLI_INSTALL_TARGET_LABELS, v as REVIEW_REMOTE_ATTACH_BEGIN, y as REVIEW_REMOTE_ATTACH_END } from "./src-Bgvf1sEN.js";
+import { A as runTraceDeny, E as traceMachineStatus, F as describeSelection, H as resolveTraceRepositoryTarget, J as HOSTED_CAPTURE_SCOPE_DESCRIPTION, K as traceRepositoryStatus, L as loadS3TraceStorage, M as runTraceSessions, N as runTraceStoreDelete, P as runTraceStoreInfo, T as traceMachineEnabled, V as requireTraceConsent, X as agentTraceHomeDirectory, _ as runTraceRepair, _t as jsonRequestedInArgv, b as runTraceGitHook, c as registerTraceCommands, ct as runStoreLogin, d as runTraceList$1, dt as StoreApiError, et as resolveTraceCommand, f as runTracePull$1, ft as StoreClient, g as runTraceInstallMachine, gt as humanStream, h as runTraceEnable, ht as failWithJsonError, it as DEFAULT_STORE_ORIGIN, j as runTraceOnboard, k as runTraceAllow, l as resolveTraceReadStorage, lt as runStoreLogout, m as runTraceDisable, mt as emitJsonEvent, nt as traceHomeDir, p as runTraceShow, pt as withStoreAuthorization, q as readTraceUserConfig, rt as traceScope, st as readStoreAuth, u as runTraceBlame, ut as runStoreWhoami, v as runTraceStatus, w as readLegacyCaptureSettings, x as runTraceHook, y as runTraceSync, z as selectTraceStorage } from "./review-home-paths-zwevIq4I.js";
+import { o as ReviewApiClient, s as ReviewApiError } from "./agent-client-DVd-prfp.js";
 import { t as resolveReviewRoot } from "./runtime-CKiWhGrf.js";
-import { A as devReviewHome, C as s3ProfileSchema, D as processIsAlive, E as writeTraceConfigFile, S as readTraceConfigFile, T as sameS3Profile, _ as emptyTraceConfig, c as resolveS3Setup, g as currentStore, h as TraceConfigurationError, i as isS3MockMode, j as normalizeStoreOrigin, k as DEV_REVIEW_HOME_ENV, n as clearTraceEnvCache, o as readTraceEnvFile, p as traceSettingsPath, w as s3Store } from "./s3-config-CAxhO9u_.js";
+import { C as s3ProfileSchema, E as writeTraceConfigFile, M as devReviewHome, N as normalizeStoreOrigin, S as readTraceConfigFile, T as sameS3Profile, _ as emptyTraceConfig, c as resolveS3Setup, g as currentStore, h as TraceConfigurationError, i as isS3MockMode, n as clearTraceEnvCache, o as readTraceEnvFile, p as traceSettingsPath, w as s3Store } from "./s3-config-DDWWMh5x.js";
 import { t as errorMessage } from "./error-message-OtiDonty.js";
-import { i as readReviewPackageVersion, r as readBuildInfo, t as findReviewPackageRoot } from "./package-paths-B9PDoAl6.js";
-import { a as readDefaultReviewInstance, d as selectReviewInstance, f as writeDefaultReviewInstance, i as healthyReviewInstance, l as reviewInstanceStartHint, n as ReviewInstanceUnavailableError, o as readReviewInstances, r as clearDefaultReviewInstance, s as requireHealthyReviewDesktop, t as REVIEW_INSTANCE_ENV, u as reviewInstanceUnavailable } from "./desktop-discovery-Ba3dD5Cn.js";
-import { t as ReviewTelemetry } from "./review-telemetry-CmM6tCbj.js";
-import { a as isOwnedShim, f as windowsInstallerCommand, m as connectPrompts, o as pathShimPath, p as scanLegacySkills, t as aliasInstallationToAccount } from "./account-alias-D0hF0sKk.js";
+import { i as readReviewPackageVersion, r as readBuildInfo, t as findReviewPackageRoot } from "./package-paths-BsuI4WUf.js";
+import { a as readReviewServerHealth, b as selectReviewInstance, c as reviewServerStateDir, d as ReviewInstanceUnavailableError, f as clearDefaultReviewInstance, g as requireHealthyReviewDesktop, h as readDefaultReviewInstance, i as readReviewServerDiscovery, l as serverNotReady, m as healthyReviewInstance, p as desktopUsesHome, t as DESKTOP_TAKEOVER_SIGNAL, u as REVIEW_INSTANCE_ENV, x as writeDefaultReviewInstance, y as reviewInstanceUnavailable } from "./server-discovery-CifQ3yQS.js";
+import { t as isDirectory } from "./fs-utils-BMPLt0cr.js";
+import { t as ReviewTelemetry } from "./review-telemetry-BqB4CiTD.js";
+import { _ as connectPrompts, a as isOwnedShim, f as windowsInstallerCommand, g as CONNECT_COMMANDS, h as isInstallTarget, m as ALL_INSTALL_TARGETS, o as pathShimPath, p as scanLegacySkills, t as aliasInstallationToAccount } from "./account-alias-ChZR3RIU.js";
 import { t as fuzzyRank } from "./fuzzy-match-BoAmcyak.js";
-import { n as readReviewServerDiscovery, o as reviewServerStateDir, r as readReviewServerHealth, s as serverNotReady } from "./server-discovery-ZVi8Ay8J.js";
-import { t as reviewAgentCliHelp } from "./agent-cli-04xbDj23.js";
-import { closeSync, existsSync, fstatSync, mkdirSync, mkdtempSync, openSync, readSync, renameSync, writeFileSync } from "node:fs";
-import { realpath } from "node:fs/promises";
+import { n as focusReviewDesktop, r as runReviewAppLaunch } from "./review-app-launcher-D7I4DGoH.js";
+import { t as reviewAgentCliHelp } from "./agent-cli-CR2PnA9G.js";
+import { z } from "zod";
+import { constants, existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { access, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
-import os, { tmpdir } from "node:os";
+import os from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { Writable } from "node:stream";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Argument, Command, CommanderError, Option } from "commander";
 import { emitKeypressEvents } from "node:readline";
+import { parse } from "smol-toml";
 import { createInterface as createInterface$1 } from "node:readline/promises";
 import pino from "pino";
 import { performance } from "node:perf_hooks";
@@ -44,213 +48,155 @@ function describeCliRuntime(info) {
 	return `CLI: ${info.effectivePath}${info.delegated ? ` (delegated from ${info.requestedPath})` : " (direct)"}\nBuild: ${info.version ?? "unknown"}, commit ${info.commit ?? "unknown"}, dirty ${info.dirty ?? "unknown"}, built ${info.builtAt ?? "unknown"}\n`;
 }
 //#endregion
-//#region src/install.ts
-const ALL_INSTALL_TARGETS = [
-	"claude",
-	"codex",
-	"cursor",
-	"opencode",
-	"pi",
-	"omp",
-	"copilot"
-];
-function isInstallTarget(value) {
-	return ALL_INSTALL_TARGETS.some((target) => target === value);
-}
-//#endregion
-//#region src/review-app-launcher.ts
-const RELEASE_APPS = {
-	stable: {
-		bundleId: "dev.fast.review",
-		linuxLauncher: "/usr/bin/review-desktop"
-	},
-	preview: {
-		bundleId: "dev.fast.review.preview",
-		linuxLauncher: "/usr/bin/review-preview-desktop"
+//#region src/connect-agents.ts
+const AGENT_CONNECT_TARGETS = REVIEW_REMOTE_AGENT_IDS;
+async function detectAgents(scope) {
+	const found = [];
+	for (const id of AGENT_CONNECT_TARGETS) {
+		if (!await isDirectory(agentTraceHomeDirectory(id, scope.homeDir, scope.env))) continue;
+		const manual = !await onPath(CONNECT_COMMANDS[id][0].argv[0], scope.env);
+		found.push({
+			id,
+			name: REVIEW_CLI_INSTALL_TARGET_LABELS[id],
+			connected: await connected(id, scope),
+			...manual && { manual: true }
+		});
 	}
-};
-/** "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;
+	return found;
+}
+async function connectAgents(input) {
+	const results = [];
+	for (const id of input.agents) {
+		const deadline = Date.now() + (input.timeoutMs ?? 12e4);
+		let output = "";
+		const commands = CONNECT_COMMANDS[id];
+		for (const { argv, ifAny } of commands) {
+			const left = deadline - Date.now();
+			if (left <= 0) break;
+			const step = await run(argv, input.env, left);
+			output += `$ ${argv.join(" ")}\n${step.output}`;
+			if (!step.ok && !ifAny) {
+				output += `Stopped: ${argv.join(" ")} failed.\n`;
+				break;
+			}
 		}
+		results.push({
+			id,
+			name: REVIEW_CLI_INSTALL_TARGET_LABELS[id],
+			connected: await connected(id, input),
+			output: output.slice(-4e3)
+		});
 	}
-	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);
+	return results;
 }
-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 WHITEBOARD_PLUGIN = "whiteboard@devfast";
+const ClaudePluginsSchema = z.object({ plugins: z.record(z.string(), z.unknown()) });
+const CodexConfigSchema = z.object({ plugins: z.record(z.string(), z.unknown()).optional() });
+const CodexPluginSchema = z.object({ enabled: z.boolean().optional() });
+const PiSettingsSchema = z.object({ packages: z.array(z.union([z.string(), z.object({ source: z.string() }).transform((entry) => entry.source)])) });
+const PI_PACKAGE = /^npm:@dev\.fast\/pi-whiteboard(@.*)?$/;
+const OPENCODE_PLUGIN = /"plugin"\s*:\s*\[[^\]]*"@dev\.fast\/opencode-whiteboard(@[^"]*)?"/;
+const OpenCodeConfigSchema = z.object({ mcp: z.object({
+	whiteboard: z.unknown().optional(),
+	servers: z.object({ whiteboard: z.unknown().optional() }).optional()
+}) });
+/** OpenCode's config is JSONC: drop comments and trailing commas, keep strings. */
+const JSONC_EXTRAS = /("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\/|,(?=\s*[}\]])/g;
+function openCodeConnected(text) {
+	if (OPENCODE_PLUGIN.test(text)) return true;
+	try {
+		const { mcp } = OpenCodeConfigSchema.parse(JSON.parse(text.replace(JSONC_EXTRAS, "$1")));
+		return mcp.whiteboard !== void 0 || mcp.servers?.whiteboard !== void 0;
+	} catch {
+		return false;
 	}
-	const { promise: completion, resolve, reject } = Promise.withResolvers();
-	let logPath;
-	let logFd;
+}
+async function connected(id, scope) {
+	const home = agentTraceHomeDirectory(id, scope.homeDir, scope.env);
+	const read = (...parts) => readFile(path.join(home, ...parts), "utf8");
 	try {
-		if (platform === "linux") {
-			logPath = path.join(mkdtempSync(path.join(tmpdir(), "whiteboard-launch-")), "stderr.log");
-			logFd = openSync(logPath, "wx", 384);
+		switch (id) {
+			case "claude": {
+				const installs = ClaudePluginsSchema.parse(JSON.parse(await read("plugins", "installed_plugins.json"))).plugins[WHITEBOARD_PLUGIN];
+				return Array.isArray(installs) ? installs.length > 0 : Boolean(installs);
+			}
+			case "codex": {
+				const entry = CodexConfigSchema.parse(parse(await read("config.toml"))).plugins?.[WHITEBOARD_PLUGIN];
+				return entry !== void 0 && CodexPluginSchema.parse(entry).enabled !== false;
+			}
+			case "opencode":
+				for (const name of [
+					"opencode.json",
+					"opencode.jsonc",
+					"config.json"
+				]) if (openCodeConnected(await read(name).catch(() => ""))) return true;
+				return false;
+			case "pi": return PiSettingsSchema.parse(JSON.parse(await read("agent", "settings.json"))).packages.some((entry) => PI_PACKAGE.test(entry));
 		}
-		const child = (input.spawn ?? spawn)(command, args, {
-			detached: true,
+	} catch {
+		return false;
+	}
+}
+async function onPath(command, env) {
+	for (const directory of (env.PATH ?? "").split(path.delimiter)) {
+		if (!path.isAbsolute(directory)) continue;
+		const candidate = path.join(directory, command);
+		try {
+			await access(candidate, constants.X_OK);
+			return candidate;
+		} catch {}
+	}
+}
+async function run(argv, env, timeoutMs) {
+	const [command = "", ...args] = argv;
+	const file = await onPath(command, env);
+	if (!file) return {
+		output: `${command} was not found on PATH.\n`,
+		ok: false
+	};
+	return new Promise((resolve) => {
+		let output = "";
+		const keep = (chunk) => {
+			output = (output + chunk.toString("utf8")).slice(-4e3);
+		};
+		const child = spawn(file, args, {
 			env,
-			stdio: logFd === void 0 ? "ignore" : [
+			stdio: [
 				"ignore",
-				"ignore",
-				logFd
-			]
+				"pipe",
+				"pipe"
+			],
+			detached: true
 		});
-		child.once("error", (error) => reject(error));
-		child.once("exit", (code, signal) => {
+		const timer = setTimeout(() => {
+			output += `\n${command} did not finish within ${Math.round(timeoutMs / 1e3)} seconds.\n`;
+			try {
+				process.kill(-child.pid, "SIGKILL");
+			} catch {
+				child.kill("SIGKILL");
+			}
+		}, timeoutMs);
+		child.stdout.on("data", keep);
+		child.stderr.on("data", keep);
+		child.once("error", (error) => {
+			clearTimeout(timer);
 			resolve({
-				code,
-				signal
+				output: `${output}${error.message}\n`,
+				ok: false
+			});
+		});
+		child.once("close", (code) => {
+			clearTimeout(timer);
+			resolve(code === 0 ? {
+				output,
+				ok: true
+			} : {
+				output: `${output}${output.endsWith("\n") || !output ? "" : "\n"}(exit ${code ?? "signal"})\n`,
+				ok: false
 			});
 		});
-		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
 //#region src/review-app-picker.ts
 const MAX_VISIBLE_ROWS = 10;
@@ -858,7 +804,7 @@ var require_pump = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/split2/index.js
 var require_split2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { Transform: Transform$1 } = __require("stream");
+	const { Transform: Transform$2 } = __require("stream");
 	const { StringDecoder } = __require("string_decoder");
 	const kLast = Symbol("last");
 	const kDecoder = Symbol("decoder");
@@ -929,7 +875,7 @@ var require_split2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		options.transform = transform;
 		options.flush = flush;
 		options.readableObjectMode = true;
-		const stream = new Transform$1(options);
+		const stream = new Transform$2(options);
 		stream[kLast] = "";
 		stream[kDecoder] = new StringDecoder("utf8");
 		stream.matcher = matcher;
@@ -3781,7 +3727,7 @@ var require_pretty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var import_pino_pretty = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { isColorSupported } = require_colorette();
 	const pump = require_pump();
-	const { Transform } = __require("node:stream");
+	const { Transform: Transform$1 } = __require("node:stream");
 	const abstractTransport = require_pino_abstract_transport();
 	const colors = require_colors();
 	const { ERROR_LIKE_KEYS, LEVEL_KEY, LEVEL_LABEL, MESSAGE_KEY, TIMESTAMP_KEY } = require_constants();
@@ -3912,7 +3858,7 @@ var import_pino_pretty = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(
 				pretty = prettyFactory(opts);
 				source.off("message", pinoConfigListener);
 			});
-			const stream = new Transform({
+			const stream = new Transform$1({
 				objectMode: true,
 				autoDestroy: true,
 				transform(chunk, enc, cb) {
@@ -4482,23 +4428,58 @@ async function runReviewCli(input) {
 		...env,
 		DEV_REVIEW_SERVER_DIR: path.resolve(cwd, stateDir)
 	} : env;
+	const refuse = (message, json) => {
+		if (json) emitReviewEvent(input.stdout, {
+			event: "error",
+			error: {
+				name: "Error",
+				message
+			}
+		});
+		else input.stderr.write(`${message}\n`);
+		state.exitCode = 1;
+	};
 	const serverCommand = configureOutput(program.command("server").description("Run review authoring without Desktop"), "plain");
-	configureJsonOutput(serverCommand.command("start").description("Start the foreground authoring server; stop with Ctrl-C or SIGTERM").option("--state-dir <path>", "directory for saved reviews and server discovery").option("--port <port>", "loopback port (0 chooses an available port)", "0").option("--software-maps", "allow the authoring skill to generate optional software maps").addOption(new Option("--authoring-mode <mode>").hideHelp()), "plain").action(async (_options, command) => {
+	configureJsonOutput(serverCommand.command("start").description("Start the foreground authoring server; stop with Ctrl-C or SIGTERM").option("--state-dir <path>", "directory for saved reviews and server discovery").option("--port <port>", "loopback port (0 chooses an available port)", "0").option("--software-maps", "allow the authoring skill to generate optional software maps").option("--detach", "start the server in the background, logging to review-server/server.log").addOption(new Option("--started-by <who>").choices([
+		"user",
+		"cli",
+		"desktop"
+	]).default("user").hideHelp()).addOption(new Option("--authoring-mode <mode>").hideHelp()), "plain").action(async (_options, command) => {
 		const options = command.optsWithGlobals();
 		if (options.authoringMode !== void 0) throw new ReviewCliUsageError("--authoring-mode was removed with batch authoring; the server always authors interactively. Drop the option.");
 		const port = Number(options.port);
 		if (!Number.isInteger(port) || port < 0 || port > 65535) throw new ReviewCliUsageError("--port must be an integer between 0 and 65535.");
 		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
+		if (options.detach) {
+			const { ensureBackgroundServer } = await import("./background-server-D2Rrr_e2.js");
+			const { discovery, started } = await ensureBackgroundServer({
+				stateDir,
+				env,
+				args: [
+					"--port",
+					`${port}`,
+					...options.softwareMaps ? ["--software-maps"] : []
+				]
+			});
+			await writeServerStatus(discovery, stateDir, options.json, { started });
+			return;
+		}
 		const controller = new AbortController();
 		const stop = () => controller.abort();
+		const takeover = () => {
+			input.stderr.write(`Whiteboard Desktop took over ${stateDir}; stopping this server.\n`);
+			stop();
+		};
 		process.once("SIGINT", stop);
 		process.once("SIGTERM", stop);
+		process.once(DESKTOP_TAKEOVER_SIGNAL, takeover);
+		const { HeadlessServerBusyError, runHeadlessServer } = await import("./headless-host-Cp37C-v0.js");
 		try {
-			const { runHeadlessServer } = await import("./headless-host-BLLJ7Dyu.js");
 			await runHeadlessServer({
 				stateDir,
 				port,
 				softwareMapEnabled: options.softwareMaps,
+				startedBy: options.startedBy,
 				signal: controller.signal,
 				telemetry,
 				onReady: ({ url, serverPid }) => {
@@ -4510,42 +4491,54 @@ async function runReviewCli(input) {
 					})}\n` : `Whiteboard server ready at ${url}\nSaved reviews: ${stateDir}\n`);
 				}
 			});
+		} catch (error) {
+			if (!(error instanceof HeadlessServerBusyError)) throw error;
+			refuse(error.message, options.json);
 		} finally {
 			process.off("SIGINT", stop);
 			process.off("SIGTERM", stop);
+			process.off(DESKTOP_TAKEOVER_SIGNAL, takeover);
 		}
 	});
 	configureJsonOutput(serverCommand.command("status").description("Check whether the headless server is ready").option("--state-dir <path>", "directory selected when starting the server"), "plain").action(async (_options, command) => {
 		const options = command.optsWithGlobals();
 		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
 		const discovery = await readReviewServerDiscovery(stateDir);
-		const health = discovery && await readReviewServerHealth(discovery);
-		if (!discovery || !health) throw serverNotReady(stateDir);
-		const { url, serverPid } = discovery;
-		const { version, serverId } = health;
+		if (!discovery) throw serverNotReady(stateDir);
+		await writeServerStatus(discovery, stateDir, options.json);
+	});
+	configureJsonOutput(serverCommand.command("stop").description("Stop a background server started by --detach, the CLI, or Desktop").option("--state-dir <path>", "directory selected when starting the server"), "plain").action(async (_options, command) => {
+		const options = command.optsWithGlobals();
+		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
+		const { headlessServerOwner, stopBackgroundServer } = await import("./background-server-D2Rrr_e2.js");
+		const owner = await headlessServerOwner(stateDir);
+		const discovery = await readReviewServerDiscovery(stateDir);
+		if (owner === void 0) {
+			input.stdout.write(options.json ? `${JSON.stringify({
+				event: "server.stop",
+				stopped: false,
+				stateDir
+			})}\n` : `No Whiteboard server is running in ${stateDir}.\n`);
+			return;
+		}
+		const serverPid = owner;
+		if (discovery?.serverPid !== owner) throw new Error(`Process ${owner} holds the Whiteboard server's lock in ${stateDir} but has published no server; it may be starting. Try again, or end that process.`);
+		if (discovery.startedBy === "user") throw new Error(`The Whiteboard server in ${stateDir} (process ${serverPid}) runs in the foreground of \`whiteboard server start\`. Stop it there with Ctrl-C.`);
+		await stopBackgroundServer(discovery);
 		input.stdout.write(options.json ? `${JSON.stringify({
-			event: "server.status",
-			ready: true,
-			url,
+			event: "server.stop",
+			stopped: true,
 			serverPid,
-			stateDir,
-			version,
-			serverId
-		})}\n` : `Whiteboard server ready at ${url}\nSaved reviews: ${stateDir}\n`);
+			stateDir
+		})}\n` : `Stopped the Whiteboard server (process ${serverPid}).\n`);
 	});
 	configureJsonOutput(serverCommand.command("reset-id").description("Give this machine's saved reviews a new server id; stop the server first").option("--state-dir <path>", "directory selected when starting the server"), "plain").action(async (_options, command) => {
 		const options = command.optsWithGlobals();
 		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
 		if (!existsSync(path.join(stateDir, "review-api.db"))) throw new Error(`No saved reviews in ${stateDir}, so there is no server id to reset. Check --state-dir.`);
-		const desktops = await readReviewInstances({ env: {
-			...env,
-			[DEV_REVIEW_HOME_ENV]: stateDir
-		} });
-		const [problem] = desktops.broken.values();
-		if (problem) throw new Error(`Cannot tell whether a Whiteboard Desktop is using ${stateDir}: ${problem.message}`);
-		const inUse = () => /* @__PURE__ */ new Error(`A Whiteboard server is using ${stateDir}. Stop it first, then run whiteboard server reset-id again.`);
-		if (desktops.instances.some(({ discovery }) => [discovery.appPid, discovery.serverPid].some((pid) => processIsAlive(pid)))) throw inUse();
-		const [{ openReviewProfile }, { withHeadlessServerLock }] = await Promise.all([import("./profile-aMSw1oCM.js"), import("./headless-host-BLLJ7Dyu.js")]);
+		const inUse = `A Whiteboard server is using ${stateDir}. Stop it first, then run whiteboard server reset-id again.`;
+		if (await desktopUsesHome(stateDir, env)) return refuse(inUse, options.json);
+		const [{ openReviewProfile }, { withHeadlessServerLock }] = await Promise.all([import("./profile-BSOkA6A-.js"), import("./headless-host-Cp37C-v0.js")]);
 		const reset = await withHeadlessServerLock(await realpath(stateDir), async () => {
 			const local = await openReviewProfile(stateDir, { manageWorkspaces: false });
 			try {
@@ -4555,7 +4548,7 @@ async function runReviewCli(input) {
 				await local.store.close();
 			}
 		});
-		if (!reset.acquired) throw inUse();
+		if (!reset.acquired) return refuse(inUse, options.json);
 		const serverId = reset.result;
 		input.stdout.write(options.json ? `${JSON.stringify({
 			event: "server.reset-id",
@@ -4563,6 +4556,104 @@ async function runReviewCli(input) {
 			stateDir
 		})}\n` : `New server id ${serverId}\nSaved reviews: ${stateDir}\n`);
 	});
+	const remote = configureOutput(program.command("remote").description("Serve reviews to Whiteboard Desktop over SSH"), "plain");
+	configureJsonOutput(remote.command("attach").description("Start a background server if none is healthy and report how to reach it").option("--state-dir <path>", "directory for saved reviews and server discovery").option("--groups <groups>", "comma-separated optional extension groups the Desktop has enabled, such as go").option("--replace", "stop a running server of another version that the CLI or Desktop started, and start this one"), "plain").action(async (_options, command) => {
+		const options = command.optsWithGlobals();
+		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
+		const { remoteAttach } = await import("./remote-attach-BAt2eZx3.js");
+		let attach;
+		try {
+			attach = await remoteAttach({
+				stateDir,
+				env,
+				groups: options.groups?.split(",").map((group) => group.trim()),
+				replace: options.replace
+			});
+		} catch (error) {
+			if (!options.json) throw error;
+			let line = "";
+			emitReviewEvent(new Writable({ write(chunk, _encoding, done) {
+				line += chunk;
+				done();
+			} }), {
+				event: "error",
+				error: serializeReviewError(error)
+			});
+			input.stdout.write(`${REVIEW_REMOTE_ATTACH_BEGIN}\n${ensureTrailingNewline(line)}${REVIEW_REMOTE_ATTACH_END}\n`);
+			state.exitCode = 1;
+			return;
+		}
+		input.stdout.write(options.json ? `${REVIEW_REMOTE_ATTACH_BEGIN}\n${JSON.stringify(attach)}\n${REVIEW_REMOTE_ATTACH_END}\n` : `Whiteboard server ${attach.startedServer ? "started" : "already running"} at ${attach.url}\nLanguage features: ${attach.languageServer ? `VS Code server on port ${attach.languageServer.port}` : `unavailable (${attach.languageServerDetail})`}\n`);
+	});
+	configureJsonOutput(remote.command("extensions").description("Language extensions for the VS Code server on a remote").command("ensure").description("Download the curated extensions for this machine and list them for the VS Code server").option("--groups <groups>", "comma-separated optional extension groups the Desktop has enabled, such as go"), "plain").action(async (_options, command) => {
+		const { json, groups } = command.optsWithGlobals();
+		const { ensureRemoteExtensions } = await import("./remote-extensions-2Cxf3hMo.js");
+		const result = await ensureRemoteExtensions({
+			env,
+			groups: groups?.split(",").map((group) => group.trim())
+		});
+		input.stdout.write(json ? `${JSON.stringify(result)}\n` : [
+			...result.installed.map((id) => `Installed ${id}`),
+			...result.skipped.map(({ id, reason }) => `Skipped ${id}: ${reason}`),
+			...result.failed.map(({ id, error }) => `Failed ${id}: ${error}`)
+		].map((line) => `${line}\n`).join(""));
+		state.exitCode = result.failed.length > 0 ? 1 : 0;
+	});
+	configureJsonOutput(remote.command("uninstall").description("Remove what Whiteboard Desktop installed on this host, stopping a server it started").addOption(new Option("--keep-reviews", "leave the saved reviews in place").conflicts("deleteReviews")).addOption(new Option("--delete-reviews", "also delete the saved reviews")).option("--state-dir <path>", "directory for saved reviews and server discovery"), "plain").action(async (_options, command) => {
+		const options = command.optsWithGlobals();
+		const stateDir = reviewServerStateDir(authoringEnv(options.stateDir));
+		const { remoteUninstall } = await import("./remote-uninstall-DLtDG0o7.js");
+		let deleteReviews = options.deleteReviews ? true : options.keepReviews ? false : void 0;
+		if (deleteReviews === void 0 && !options.json && input.stdin?.isTTY) {
+			const prompt = createInterface$1({
+				input: input.stdin,
+				output: input.stderr
+			});
+			try {
+				deleteReviews = /^y(es)?$/i.test((await prompt.question(`Also delete the saved reviews in ${stateDir}? [y/N] `)).trim());
+			} finally {
+				prompt.close();
+			}
+		}
+		const result = deleteReviews === void 0 ? {
+			event: "remote.uninstall",
+			ok: false,
+			reason: "Say what happens to the saved reviews: pass --keep-reviews or --delete-reviews."
+		} : await remoteUninstall({
+			home: env.HOME ?? "",
+			env,
+			stateDir,
+			deleteReviews
+		});
+		if (!result.ok) {
+			if (!options.json) throw new Error(result.reason);
+			input.stdout.write(`${JSON.stringify(result)}\n`);
+			state.exitCode = 1;
+			return;
+		}
+		input.stdout.write(options.json ? `${JSON.stringify(result)}\n` : [
+			...result.stoppedServer ? [`Stopped the Whiteboard server (process ${result.stoppedServer.pid}).`] : [],
+			...result.removed.map((removed) => `Removed ${removed}`),
+			result.keptReviews ? `Saved reviews kept in ${stateDir}` : "Saved reviews deleted.",
+			""
+		].join("\n"));
+	});
+	async function writeServerStatus(discovery, stateDir, json, extra = {}) {
+		const health = await readReviewServerHealth(discovery);
+		if (!health) throw serverNotReady(stateDir);
+		const { url, serverPid } = discovery;
+		const { version, serverId } = health;
+		input.stdout.write(json ? `${JSON.stringify({
+			event: "server.status",
+			ready: true,
+			url,
+			serverPid,
+			stateDir,
+			version,
+			serverId,
+			...extra
+		})}\n` : `Whiteboard server ${extra.started === false ? "already running" : "ready"} at ${url}\nSaved reviews: ${stateDir}\n`);
+	}
 	configureJsonOutput(program.command("version").description("Print Whiteboard package version").option("--verbose", "Show executing CLI paths and build identity"), "plain").action(async (options, command) => {
 		const { json } = command.optsWithGlobals();
 		if (options.verbose) {
@@ -4653,7 +4744,46 @@ async function runReviewCli(input) {
 		"omp",
 		"copilot",
 		"all"
-	])), "plain").action(async (targets, options) => {
+	])).addOption(new Option("--detect", "list the agents on this machine and whether each is connected; changes nothing").conflicts("yes")).option("--yes", "run the commands the prompt gives, without an agent: claude, codex, opencode or pi"), "plain").action(async (targets, options) => {
+		const output = {
+			json: options.json,
+			stdout: input.stdout,
+			stderr: input.stderr
+		};
+		if (options.detect) {
+			const agents = await detectAgents({
+				homeDir: scope.homeDir,
+				env
+			});
+			if (options.json) {
+				emitJsonEvent(output, {
+					event: "connect.detect",
+					agents
+				});
+				return;
+			}
+			humanStream(output).write(agents.length ? `${agents.map((agent) => `${agent.name}: ${agent.connected ? "connected" : "not connected"}${agent.manual ? " (its command is not on PATH)" : ""}`).join("\n")}\n` : "No agents found.\n");
+			return;
+		}
+		if (options.yes) {
+			const agents = parseTargets(targets);
+			if (targets.length === 0 || !agents.every((target) => AGENT_CONNECT_TARGETS.some((known) => known === target))) throw new Error("connect --yes takes one or more of claude, codex, opencode or pi.");
+			const results = await connectAgents({
+				agents,
+				homeDir: scope.homeDir,
+				env
+			});
+			state.exitCode = results.every((result) => result.connected) ? 0 : 1;
+			if (options.json) {
+				emitJsonEvent(output, {
+					event: "connect.run",
+					agents: results
+				});
+				return;
+			}
+			humanStream(output).write(results.map((result) => `${result.output}${result.name}: ${result.connected ? "connected" : "not connected"}\n`).join(""));
+			return;
+		}
 		const selected = parseTargets(targets);
 		const { homeDir, devHome } = scope;
 		const prompts = connectPrompts({
@@ -4666,11 +4796,6 @@ async function runReviewCli(input) {
 			fffBinaryPath: path.join(homeDir, ".local", "bin", "fff-mcp"),
 			fffCorpusRoot: path.join(devHome, "trace-search")
 		});
-		const output = {
-			json: options.json,
-			stdout: input.stdout,
-			stderr: input.stderr
-		};
 		if (options.json) {
 			emitJsonEvent(output, {
 				event: "connect",
@@ -4678,21 +4803,21 @@ async function runReviewCli(input) {
 			});
 			return;
 		}
-		const sections = selected.map((target) => selected.length > 1 ? `## ${TARGET_LABELS[target]}\n\n${prompts[target]}` : prompts[target]);
+		const sections = selected.map((target) => selected.length > 1 ? `## ${REVIEW_CLI_INSTALL_TARGET_LABELS[target]}\n\n${prompts[target]}` : prompts[target]);
 		humanStream(output).write(`${sections.join("\n\n")}\n`);
 	});
 	configureJsonOutput(configureOutput(program.command("migrate", { hidden: true }), "plain").command("apply").option("--force"), "plain").action((_options, command) => {
 		command.showHelpAfterError(false).error("Markdown review migration is no longer supported. Ask your agent to migrate your old Whiteboard reviews.");
 	});
 	configureJsonOutput(configureJsonOutput(program.command("share").description("Upload an immutable review snapshot and return its share link"), "plain").option("--review <id>", "review ID").option("--version <number>", "Saved version to share").option("--preview", "Open the share link in Whiteboard Preview by default").option("--request-id <uuid>", "Reuse this ID when retrying the same immutable upload").action(async (options) => {
-		const { runShareCli } = await import("./cli-C0ziP6hg.js");
+		const { runShareCli } = await import("./cli-CSrz_wGk.js");
 		state.exitCode = await runShareCli({
 			...input,
 			...options,
 			env: authoringEnv()
 		});
 	}).command("revoke <share-id>").description("Revoke future downloads of a share"), "plain").action(async (shareId, options) => {
-		const { runShareCli } = await import("./cli-C0ziP6hg.js");
+		const { runShareCli } = await import("./cli-CSrz_wGk.js");
 		state.exitCode = await runShareCli({
 			...input,
 			...options,
@@ -4773,7 +4898,7 @@ async function runReviewCli(input) {
 		return commands;
 	} });
 	for (const [name, description] of [["api", "Call a JSON review authoring tool on the running server"], ["mcp", "Serve the JSON review authoring tools over stdio MCP"]]) configureOutput(program.command(name).description(description).argument("[args...]", "tool name and JSON input").allowUnknownOption().allowExcessArguments().helpOption(false).passThroughOptions().addHelpText("after", `\n${reviewAgentCliHelp}`), "plain").action(async (args) => {
-		const { runReviewAgentCli } = await import("./agent-cli-BR_Jw5BL.js");
+		const { runReviewAgentCli } = await import("./agent-cli-CRPPmS3l.js");
 		state.exitCode = await runReviewAgentCli({
 			...input,
 			env: authoringEnv(),
@@ -4867,15 +4992,6 @@ async function runReviewCli(input) {
 		await attemptTelemetry(() => telemetry.shutdown(1e3));
 	}
 }
-const TARGET_LABELS = {
-	claude: "Claude Code",
-	codex: "Codex",
-	cursor: "Cursor",
-	opencode: "OpenCode",
-	pi: "Pi",
-	omp: "oh-my-pi",
-	copilot: "Copilot CLI"
-};
 function parseTargets(targets) {
 	if (targets.length === 0 || targets.includes("all")) return [...ALL_INSTALL_TARGETS];
 	return [...new Set(targets.values().map((target) => target === "claude-code" ? "claude" : target).filter(isInstallTarget))];