pi-agent-browser-native 0.9.3 → 0.9.5

package/scripts/platform-smoke/crabbox-runner.mjs

@@ -18,68 +18,110 @@ function packageSlug(config = {}) {
 	return process.env.PLATFORM_SMOKE_PACKAGE_SLUG || config.packageName || "pi-agent-browser-native";
 }
 
-export function describeTarget(targetName, config = {}) {
+function targetSetting(name, configured, fallback) {
+	return env(name) || configured || fallback;
+}
+
+function describeMacTarget(config) {
 	const slug = packageSlug(config);
+	const user = env("PLATFORM_SMOKE_MAC_USER") || env("USER");
+	const host = targetSetting("PLATFORM_SMOKE_MAC_HOST", config.macos?.host, "localhost");
+	const port = String(targetSetting("PLATFORM_SMOKE_MAC_PORT", config.macos?.port, 22));
+	const workRoot =
+		env("PLATFORM_SMOKE_MAC_WORK_ROOT") ||
+		config.macos?.workRoot ||
+		`/Users/${user}/crabbox/${slug}`;
+	return {
+		provider: "ssh",
+		crabboxTarget: "macos",
+		shell: "posix",
+		workRoot,
+		args: [
+			"--provider",
+			"ssh",
+			"--target",
+			"macos",
+			"--static-host",
+			host,
+			"--static-user",
+			user,
+			"--static-port",
+			port,
+			"--static-work-root",
+			workRoot,
+		],
+	};
+}
+
+function describeUbuntuTarget(config) {
+	const image =
+		env("PLATFORM_SMOKE_UBUNTU_IMAGE") || config.ubuntuContainerImage || DEFAULT_UBUNTU_IMAGE;
+	return {
+		provider: "local-container",
+		crabboxTarget: "linux",
+		shell: "posix",
+		image,
+		workRoot: config.localContainer?.workRoot || "/work/crabbox",
+		args: ["--provider", "local-container", "--target", "linux", "--local-container-image", image],
+	};
+}
+
+function describeWindowsTarget(config) {
+	const slug = packageSlug(config);
+	const vm = targetSetting(
+		"PLATFORM_SMOKE_WINDOWS_VM",
+		config.windowsParallels?.sourceVm,
+		"pi-extension-windows-template",
+	);
+	const snapshot = targetSetting(
+		"PLATFORM_SMOKE_WINDOWS_SNAPSHOT",
+		config.windowsParallels?.snapshot,
+		"crabbox-ready",
+	);
+	const user = targetSetting(
+		"PLATFORM_SMOKE_WINDOWS_USER",
+		config.windowsParallels?.user,
+		env("USER"),
+	);
+	const workRoot =
+		env("PLATFORM_SMOKE_WINDOWS_WORK_ROOT") ||
+		config.windowsParallels?.workRoot ||
+		`C:\\crabbox\\${slug}`;
+	return {
+		provider: "parallels",
+		crabboxTarget: "windows",
+		shell: "powershell",
+		workRoot,
+		windowsMode: "normal",
+		sourceVm: vm,
+		snapshot,
+		args: [
+			"--provider",
+			"parallels",
+			"--target",
+			"windows",
+			"--windows-mode",
+			"normal",
+			"--parallels-source",
+			vm,
+			"--parallels-source-snapshot",
+			snapshot,
+			"--parallels-user",
+			user,
+			"--parallels-work-root",
+			workRoot,
+		],
+	};
+}
+
+export function describeTarget(targetName, config = {}) {
 	switch (targetName) {
-		case "macos": {
-			const user = env("PLATFORM_SMOKE_MAC_USER") || env("USER");
-			const host = env("PLATFORM_SMOKE_MAC_HOST") || config.macos?.host || "localhost";
-			const port = String(env("PLATFORM_SMOKE_MAC_PORT") || config.macos?.port || 22);
-			const workRoot = env("PLATFORM_SMOKE_MAC_WORK_ROOT") || config.macos?.workRoot || `/Users/${user}/crabbox/${slug}`;
-			return {
-				provider: "ssh",
-				crabboxTarget: "macos",
-				shell: "posix",
-				workRoot,
-				args: [
-					"--provider", "ssh",
-					"--target", "macos",
-					"--static-host", host,
-					"--static-user", user,
-					"--static-port", port,
-					"--static-work-root", workRoot,
-				],
-			};
-		}
-		case "ubuntu": {
-			const image = env("PLATFORM_SMOKE_UBUNTU_IMAGE") || config.ubuntuContainerImage || DEFAULT_UBUNTU_IMAGE;
-			return {
-				provider: "local-container",
-				crabboxTarget: "linux",
-				shell: "posix",
-				image,
-				workRoot: config.localContainer?.workRoot || "/work/crabbox",
-				args: [
-					"--provider", "local-container",
-					"--target", "linux",
-					"--local-container-image", image,
-				],
-			};
-		}
-		case "windows-native": {
-			const vm = env("PLATFORM_SMOKE_WINDOWS_VM") || config.windowsParallels?.sourceVm || "pi-extension-windows-template";
-			const snapshot = env("PLATFORM_SMOKE_WINDOWS_SNAPSHOT") || config.windowsParallels?.snapshot || "crabbox-ready";
-			const user = env("PLATFORM_SMOKE_WINDOWS_USER") || config.windowsParallels?.user || env("USER");
-			const workRoot = env("PLATFORM_SMOKE_WINDOWS_WORK_ROOT") || config.windowsParallels?.workRoot || `C:\\crabbox\\${slug}`;
-			return {
-				provider: "parallels",
-				crabboxTarget: "windows",
-				shell: "powershell",
-				workRoot,
-				windowsMode: "normal",
-				sourceVm: vm,
-				snapshot,
-				args: [
-					"--provider", "parallels",
-					"--target", "windows",
-					"--windows-mode", "normal",
-					"--parallels-source", vm,
-					"--parallels-source-snapshot", snapshot,
-					"--parallels-user", user,
-					"--parallels-work-root", workRoot,
-				],
-			};
-		}
+		case "macos":
+			return describeMacTarget(config);
+		case "ubuntu":
+			return describeUbuntuTarget(config);
+		case "windows-native":
+			return describeWindowsTarget(config);
 		default:
 			throw new Error(`unknown platform smoke target: ${targetName}`);
 	}
@@ -90,14 +132,14 @@ export function buildTargetBaseArgs(targetName, config = {}) {
 }
 
 export function leaseIdFor(targetName, slug) {
-	if (targetName === "macos") return "static_localhost";
+	if (targetName === "macos") {
+		return "static_localhost";
+	}
 	return slug;
 }
 
 function parseLeaseId(text) {
-	return text.match(/\bleased\s+(\S+)/)?.[1]
-		?? text.match(/\blease=(\S+)/)?.[1]
-		?? null;
+	return text.match(/\bleased\s+(\S+)/)?.[1] ?? text.match(/\blease=(\S+)/)?.[1] ?? null;
 }
 
 export function execCrabbox(args, options = {}) {
@@ -112,31 +154,63 @@ export function execCrabbox(args, options = {}) {
 		let killTimeout;
 		if (options.timeout) {
 			timeout = setTimeout(() => {
-				stderr.push(Buffer.from(`\n[platform-smoke] crabbox timed out after ${options.timeout}ms\n`));
-				try { child.kill("SIGTERM"); } catch {}
+				stderr.push(
+					Buffer.from(`\n[platform-smoke] crabbox timed out after ${options.timeout}ms\n`),
+				);
+				try {
+					child.kill("SIGTERM");
+				} catch {
+					// A concurrently exited child needs no signal; its close/error receipt settles the run.
+				}
 				killTimeout = setTimeout(() => {
-					try { child.kill("SIGKILL"); } catch {}
+					try {
+						child.kill("SIGKILL");
+					} catch {
+						// A concurrently exited child needs no signal; its close/error receipt settles the run.
+					}
 				}, 10_000);
 			}, options.timeout);
 		}
 		child.stdout.on("data", (chunk) => stdout.push(chunk));
 		child.stderr.on("data", (chunk) => stderr.push(chunk));
 		child.on("error", (error) => {
-			if (timeout) clearTimeout(timeout);
-			if (killTimeout) clearTimeout(killTimeout);
-			resolvePromise({ stdout: Buffer.concat(stdout).toString(), stderr: `${Buffer.concat(stderr).toString()}${error.message}\n`, code: 1, signal: null });
+			if (timeout) {
+				clearTimeout(timeout);
+			}
+			if (killTimeout) {
+				clearTimeout(killTimeout);
+			}
+			resolvePromise({
+				stdout: Buffer.concat(stdout).toString(),
+				stderr: `${Buffer.concat(stderr).toString()}${error.message}\n`,
+				code: 1,
+				signal: null,
+			});
 		});
 		child.on("close", (code, signal) => {
-			if (timeout) clearTimeout(timeout);
-			if (killTimeout) clearTimeout(killTimeout);
-			resolvePromise({ stdout: Buffer.concat(stdout).toString(), stderr: Buffer.concat(stderr).toString(), code: code ?? (signal ? 1 : 0), signal });
+			if (timeout) {
+				clearTimeout(timeout);
+			}
+			if (killTimeout) {
+				clearTimeout(killTimeout);
+			}
+			resolvePromise({
+				stdout: Buffer.concat(stdout).toString(),
+				stderr: Buffer.concat(stderr).toString(),
+				code: code ?? (signal ? 1 : 0),
+				signal,
+			});
 		});
 	});
 }
 
 function isRetryableWarmupFailure(targetName, result) {
-	if (targetName !== "windows-native" || result.code === 0) return false;
-	return /Could not create a linked clone of the virtual hard disk|due to an internal error|context canceled|timed out after 300000ms/i.test(`${result.stdout}\n${result.stderr}`);
+	if (targetName !== "windows-native" || result.code === 0) {
+		return false;
+	}
+	return /Could not create a linked clone of the virtual hard disk|due to an internal error|context canceled|timed out after 300000ms/i.test(
+		`${result.stdout}\n${result.stderr}`,
+	);
 }
 
 export async function warmupLease(targetName, slug, config = {}) {
@@ -144,8 +218,14 @@ export async function warmupLease(targetName, slug, config = {}) {
 	let result;
 	for (let attempt = 1; attempt <= 2; attempt += 1) {
 		console.log(`  [crabbox] ${args.join(" ")}${attempt > 1 ? ` (retry ${attempt})` : ""}`);
+		// The retry depends on the prior warmup receipt and its completed stale-lease cleanup.
+		// oxlint-disable-next-line no-await-in-loop
 		result = await execCrabbox(args, { timeout: 300_000 });
-		if (!isRetryableWarmupFailure(targetName, result)) break;
+		if (!isRetryableWarmupFailure(targetName, result)) {
+			break;
+		}
+		// Stop stale target resources before a retry can acquire another lease.
+		// oxlint-disable-next-line no-await-in-loop
 		await cleanupStaleTargetState(targetName, config);
 	}
 	return {
@@ -160,10 +240,15 @@ export async function runOnLease(targetName, leaseId, command, options = {}) {
 	for (const name of options.allowEnv ?? []) {
 		args.push("--allow-env", name);
 	}
-	if (options.sync === false) args.push("--no-sync");
-	else args.push("--fresh-sync");
+	if (options.sync === false) {
+		args.push("--no-sync");
+	} else {
+		args.push("--fresh-sync");
+	}
 	args.push("--shell", command);
-	console.log(`  [crabbox] run ${targetName} ${options.sync === false ? "--no-sync" : "--fresh-sync"}`);
+	console.log(
+		`  [crabbox] run ${targetName} ${options.sync === false ? "--no-sync" : "--fresh-sync"}`,
+	);
 	return execCrabbox(args, { timeout: options.timeout ?? 900_000 });
 }
 
@@ -174,7 +259,9 @@ export async function stopLease(targetName, leaseId, config = {}) {
 }
 
 export async function cleanupStaleTargetState(targetName, config = {}) {
-	if (targetName === "macos") return null;
+	if (targetName === "macos") {
+		return null;
+	}
 	const args = ["cleanup", ...buildTargetBaseArgs(targetName, config)];
 	console.log(`  [crabbox] ${args.join(" ")}`);
 	return execCrabbox(args, { timeout: 120_000 });

package/scripts/platform-smoke/doctor-support.mjs

@@ -0,0 +1,157 @@
+/** Read-only host/process inspection and platform-doctor report ownership. */
+import { execFileSync, execSync } from "node:child_process";
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export function env(name) {
+	return process.env[name] ?? "";
+}
+export function setting(name, configured, fallback) {
+	return env(name) || configured || fallback;
+}
+
+export function createReporter() {
+	let count = 0;
+	return {
+		ok(label) {
+			console.log(`  ✓ ${label}`);
+		},
+		warn(label) {
+			console.log(`  ⚠ ${label}`);
+		},
+		fail(label) {
+			console.error(`  ✗ ${label}`);
+			count += 1;
+		},
+		get count() {
+			return count;
+		},
+	};
+}
+
+export function silent(cmd, args, options = {}) {
+	try {
+		return execFileSync(cmd, args, { timeout: 20_000, stdio: "pipe", ...options })
+			.toString()
+			.trim();
+	} catch {
+		return null;
+	}
+}
+export function shell(command, options = {}) {
+	try {
+		return execSync(command, { timeout: 20_000, stdio: "pipe", ...options })
+			.toString()
+			.trim();
+	} catch {
+		return null;
+	}
+}
+export function commandPath(name) {
+	return silent("which", [name]);
+}
+
+function parseVersion(version) {
+	const match = String(version).match(/\d+(?:\.\d+){0,2}/);
+	return match ? match[0].split(".").map((part) => Number(part)) : null;
+}
+export function versionAtLeast(actual, minimum) {
+	const a = parseVersion(actual);
+	const b = parseVersion(minimum);
+	if (!a || !b) {
+		return false;
+	}
+	for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+		const left = a[index] ?? 0;
+		const right = b[index] ?? 0;
+		if (left > right) {
+			return true;
+		}
+		if (left < right) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function isForbiddenProjectPath(path) {
+	return (
+		/(^|\/)\.env(?:\..*)?$/.test(path) ||
+		/(^|\/)[^/]+\.tgz$/.test(path) ||
+		/(^|\/)\.artifacts(?:\/|$)/.test(path) ||
+		/(^|\/)\.crabbox(?:\/|$)/.test(path) ||
+		/(^|\/)\.debug(?:\/|$)/.test(path) ||
+		/(^|\/)\.platform-smoke-runs(?:\/|$)/.test(path)
+	);
+}
+function npmPackFiles() {
+	const output = silent("npm", ["pack", "--dry-run", "--json"]);
+	if (!output) {
+		return null;
+	}
+	try {
+		return JSON.parse(output)[0]?.files?.map((file) => file.path) ?? [];
+	} catch {
+		return null;
+	}
+}
+
+export function checkForbiddenProjectFiles(report) {
+	const tracked = shell("git ls-files")?.split(/\r?\n/).filter(Boolean) ?? [];
+	const trackedForbidden = tracked.filter(isForbiddenProjectPath);
+	if (trackedForbidden.length === 0) {
+		report.ok("tracked source files exclude forbidden local artifacts");
+	} else {
+		report.fail(`forbidden tracked source path(s): ${trackedForbidden.join(", ")}`);
+	}
+	const localForbidden =
+		shell(
+			"find . -maxdepth 2 \\( -name '.env' -o -name '.env.*' -o -name '*.tgz' \\) -not -path './node_modules/*' 2>/dev/null",
+		)
+			?.split(/\r?\n/)
+			.filter(Boolean) ?? [];
+	if (localForbidden.length === 0) {
+		report.ok("no local .env or package tarball artifacts at repo top level");
+	} else {
+		report.fail(`forbidden local artifact(s): ${localForbidden.join(", ")}`);
+	}
+	const packFiles = npmPackFiles();
+	if (!packFiles) {
+		report.fail("could not inspect npm pack contents");
+		return;
+	}
+	const packedForbidden = packFiles.filter(isForbiddenProjectPath);
+	if (packedForbidden.length === 0) {
+		report.ok("npm package excludes forbidden local artifacts");
+	} else {
+		report.fail(`forbidden npm package path(s): ${packedForbidden.join(", ")}`);
+	}
+}
+
+export function checkArtifactRoot(artifactRoot, report) {
+	console.log("\n── Artifact root ──");
+	const artRoot = resolve(process.cwd(), artifactRoot);
+	try {
+		mkdirSync(artRoot, { recursive: true });
+		const probe = resolve(artRoot, ".doctor-write-test");
+		writeFileSync(probe, "ok");
+		unlinkSync(probe);
+		report.ok(`writable: ${artRoot}`);
+	} catch (error) {
+		report.fail(`artifact root not writable: ${error.message}`);
+	}
+}
+
+export function checkAgentBrowserVersion(expectedVersion, report, command = "agent-browser") {
+	const version = shell(`${command} --version`);
+	if (!version) {
+		report.fail(`${command} not found or did not report a version`);
+		return;
+	}
+	const firstLine = version.split(/\r?\n/)[0];
+	if (!expectedVersion || firstLine.includes(expectedVersion)) {
+		report.ok(`${command}: ${firstLine}`);
+	} else {
+		report.fail(`${command} version ${firstLine} does not match expected ${expectedVersion}`);
+	}
+}

package/scripts/platform-smoke/doctor-windows.mjs

@@ -0,0 +1,230 @@
+/** Disposable Windows/Parallels doctor probes with native lease cleanup receipts. */
+import { execFileSync } from "node:child_process";
+import { buildTargetBaseArgs } from "./crabbox-runner.mjs";
+import { commandPath, setting, shell } from "./doctor-support.mjs";
+
+function crabbox(cbox, args, timeout = 300_000) {
+	try {
+		return {
+			ok: true,
+			stdout: execFileSync(cbox, args, {
+				timeout,
+				stdio: "pipe",
+				env: { ...process.env, CRABBOX_SYNC_GIT_SEED: "false" },
+			}).toString(),
+			stderr: "",
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			stdout: error.stdout?.toString?.() ?? "",
+			stderr: error.stderr?.toString?.() ?? error.message,
+		};
+	}
+}
+
+const PROBE_SCRIPT = `$ErrorActionPreference = "Stop"
+$cmd = Get-Command "agent-browser.cmd" -ErrorAction SilentlyContinue | Select-Object -First 1
+if (-not $cmd) { throw "agent-browser.cmd missing" }
+$version = & $cmd.Source --version
+Write-Output "PLATFORM_DOCTOR_AGENT_BROWSER_PATH=$($cmd.Source)"
+Write-Output "PLATFORM_DOCTOR_AGENT_BROWSER_VERSION=$version"
+$roots = @((Join-Path $env:USERPROFILE ".agent-browser\\browsers"), "C:\\WINDOWS\\system32\\config\\systemprofile\\.agent-browser\\browsers")
+$chrome = Get-ChildItem -Path $roots -Recurse -Filter chrome.exe -ErrorAction SilentlyContinue | Select-Object -First 1
+if (-not $chrome) { throw "agent-browser browser cache missing chrome.exe" }
+Write-Output "PLATFORM_DOCTOR_AGENT_BROWSER_CHROME=$($chrome.FullName)"`;
+
+function probeOutcome(run, expectedVersion) {
+	if (!run.ok) {
+		return { ok: false, message: `probe failed: ${(run.stderr || run.stdout).slice(-700)}` };
+	}
+	const output = run.stdout;
+	const marker = (name) =>
+		output.match(new RegExp(`^PLATFORM_DOCTOR_AGENT_BROWSER_${name}=(.*)$`, "m"))?.[1]?.trim() ??
+		"";
+	const versionLine = marker("VERSION");
+	const pathLine = marker("PATH");
+	const chromeLine = marker("CHROME");
+	if (versionLine !== `agent-browser ${expectedVersion}`) {
+		return {
+			ok: false,
+			message: `expected agent-browser ${expectedVersion}, got ${versionLine || "missing version"}`,
+		};
+	}
+	if (!pathLine || !chromeLine) {
+		return { ok: false, message: "agent-browser path or browser cache marker missing" };
+	}
+	return { ok: true, message: `${versionLine} | ${pathLine} | ${chromeLine}` };
+}
+
+function leaseIdFromWarmup(warm, fallback) {
+	const text = `${warm.stdout}\n${warm.stderr}`;
+	return text.match(/\bleased\s+(\S+)/)?.[1] ?? text.match(/\blease=(\S+)/)?.[1] ?? fallback;
+}
+
+export function disposableWindowsAgentBrowserProbe(cbox, config, expectedVersion) {
+	const slug = "piab-doctor-agent-browser";
+	const baseArgs = buildTargetBaseArgs("windows-native", config);
+	const warm = crabbox(
+		cbox,
+		["warmup", ...baseArgs, "--slug", slug, "--keep", "--reclaim"],
+		300_000,
+	);
+	const leaseId = leaseIdFromWarmup(warm, slug);
+	if (!warm.ok) {
+		return { ok: false, message: `warmup failed: ${(warm.stderr || warm.stdout).slice(-500)}` };
+	}
+	let outcome;
+	try {
+		const probeCommand = `powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -EncodedCommand ${Buffer.from(PROBE_SCRIPT, "utf16le").toString("base64")}`;
+		outcome = probeOutcome(
+			crabbox(
+				cbox,
+				["run", ...baseArgs, "--id", leaseId, "--no-sync", "--shell", probeCommand],
+				180_000,
+			),
+			expectedVersion,
+		);
+	} finally {
+		const stop = crabbox(cbox, ["stop", ...baseArgs, "--id", leaseId], 90_000);
+		if (!stop.ok) {
+			const prior = outcome?.ok === false ? `; prior result: ${outcome.message}` : "";
+			outcome = {
+				ok: false,
+				message: `cleanup failed: ${(stop.stderr || stop.stdout).slice(-500)}${prior}`,
+			};
+		}
+	}
+	return outcome;
+}
+
+function checkSnapshot(vmName, snapshot, report) {
+	const snapshotsJson = shell(
+		`prlctl snapshot-list "${vmName.replace(/"/g, '\\"')}" -j 2>/dev/null`,
+	);
+	let snapshotMatch = null;
+	try {
+		const snapshots = JSON.parse(snapshotsJson ?? "{}");
+		snapshotMatch = Object.entries(snapshots).find(
+			([id, data]) => id === snapshot || data?.name === snapshot,
+		);
+	} catch {
+		// Invalid native snapshot output falls through to the explicit failure below.
+	}
+	if (!snapshotMatch) {
+		report.fail(`snapshot ${snapshot} not found on ${vmName}`);
+		return;
+	}
+	report.ok(`snapshot ${snapshot} found`);
+	const snapshotState = snapshotMatch[1]?.state ?? "unknown";
+	if (snapshotState === "poweroff") {
+		report.ok(`snapshot ${snapshot} state is poweroff`);
+	} else {
+		report.fail(`snapshot ${snapshot} must be poweroff; current snapshot state: ${snapshotState}`);
+	}
+}
+
+function windowsSettings(config, packageName) {
+	return {
+		sourceVm: setting(
+			"PLATFORM_SMOKE_WINDOWS_VM",
+			config?.windowsParallels?.sourceVm,
+			"pi-extension-windows-template",
+		),
+		snapshot: setting(
+			"PLATFORM_SMOKE_WINDOWS_SNAPSHOT",
+			config?.windowsParallels?.snapshot,
+			"crabbox-ready",
+		),
+		user: setting(
+			"PLATFORM_SMOKE_WINDOWS_USER",
+			config?.windowsParallels?.user,
+			process.env.USER ?? "",
+		),
+		workRoot: setting(
+			"PLATFORM_SMOKE_WINDOWS_WORK_ROOT",
+			config?.windowsParallels?.workRoot,
+			`C:\\crabbox\\${packageName}`,
+		),
+	};
+}
+
+function checkWindowsTemplate(windows, report) {
+	const vmName = windows.sourceVm;
+	const list = shell("prlctl list -a --no-header 2>/dev/null");
+	if (!list) {
+		report.fail("prlctl list returned no VMs");
+		return false;
+	}
+	if (!list.includes(vmName)) {
+		report.fail(`Windows VM ${vmName} not found`);
+		return false;
+	}
+	report.ok(`Windows VM ${vmName} found`);
+	const status = shell(`prlctl status "${vmName.replace(/"/g, '\\"')}" 2>/dev/null`);
+	if (/\bstopped\b/i.test(status ?? "")) {
+		report.ok(`Windows source VM ${vmName} is stopped`);
+	} else {
+		report.fail(
+			`Windows source VM ${vmName} must be stopped for forkable snapshot use; current status: ${status ?? "unknown"}`,
+		);
+	}
+	checkSnapshot(vmName, windows.snapshot, report);
+	return true;
+}
+
+export function checkWindows({
+	cbox,
+	config,
+	packageName,
+	agentBrowserVersion,
+	report,
+	checkCrabboxProvider,
+}) {
+	console.log("\n── Windows native / Parallels ──");
+	if (!(config?.requiredTargets ?? []).includes("windows-native")) {
+		report.warn("windows-native is not listed in requiredTargets for this configuration");
+		return;
+	}
+	if (!commandPath("prlctl")) {
+		report.fail("prlctl not found");
+		return;
+	}
+	report.ok("prlctl found");
+	const windows = windowsSettings(config, packageName);
+	const vmName = windows.sourceVm;
+	if (!checkWindowsTemplate(windows, report)) {
+		return;
+	}
+	checkCrabboxProvider(
+		cbox,
+		[
+			"--provider",
+			"parallels",
+			"--target",
+			"windows",
+			"--windows-mode",
+			"normal",
+			"--parallels-source",
+			vmName,
+			"--parallels-source-snapshot",
+			windows.snapshot,
+			"--parallels-user",
+			windows.user,
+			"--parallels-work-root",
+			windows.workRoot,
+		],
+		"windows parallels",
+		report,
+	);
+	const probe = disposableWindowsAgentBrowserProbe(
+		cbox,
+		{ ...config, windowsParallels: { ...config?.windowsParallels, ...windows } },
+		agentBrowserVersion,
+	);
+	if (probe.ok) {
+		report.ok(`Windows disposable agent-browser: ${probe.message}`);
+	} else {
+		report.fail(`Windows disposable agent-browser probe failed: ${probe.message}`);
+	}
+}