stim 1.29.0 → 1.30.0

package/dist/device-ChnO7bR9.mjs

@@ -0,0 +1,761 @@
+import { t as getExecutor } from "./exec-aULwtNly.mjs";
+import { r as readWorkspaceState$1 } from "./workspace-state-DGwkPXwq.mjs";
+import { G as projectDeviceSlots, H as deviceSlotPlatforms, V as deviceSlotKey, W as parseDeviceSlotOption, p as getProject } from "./config-AbUjIBOQ.mjs";
+import { r as clockTime } from "./command-output-BBW8eWPL.mjs";
+import { I as readWorkspaceLaunches, P as readRemoteSession, i as findProjectRoot$1, t as NO_PROJECT_REFUSAL } from "./project-DPQjnpcI.mjs";
+import { M as listAdbDevicesAsync, T as emulatorProbeSession, Y as physicalDeviceModel, Z as probeEmulatorSerial, c as androidPoolNoCandidatesRefusal, d as androidToolPath, k as getAvdNameForSerialAsync, nt as resolveOwnedAvdSerialAsync, rt as resolvePhysicalDevice, s as androidPoolCandidates, u as androidToolCwd } from "./android-DdKG6lyD.mjs";
+import { En as runProcessOperation } from "./ccache-B8gY50-h.mjs";
+import { C as parseLeaseDuration, D as releaseWorkspaceLeases, j as takeLease, y as fileLeaseIo } from "./activity-BTaUf0tc.mjs";
+import { D as resolveOwnedIosSim, f as listAllIosSimsAsync } from "./ios-CXnoVO_z.mjs";
+import { l as parseDeviceWait, p as waitForDevice } from "./device-lease-run-Do6zYA7y.mjs";
+import { n as runProvision } from "./device-provision-B5Ms94qY.mjs";
+import { a as iosPoolCandidates, c as isWirelessIosDevice, f as resolveIosPhysicalDevice, l as listIosDevices, o as iosPoolNoCandidatesRefusal } from "./ios-device-ClSfuu-_.mjs";
+import { t as selectFromPool } from "./device-pool-CpoYiCGO.mjs";
+import { hostedNativeRecords } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/device-tools.ts
+const IOS_SERVICES = [
+	"all",
+	"calendar",
+	"contacts",
+	"contacts-limited",
+	"location",
+	"location-always",
+	"media-library",
+	"microphone",
+	"motion",
+	"photos",
+	"photos-add",
+	"reminders",
+	"siri"
+];
+const ANDROID_SERVICES = {
+	calendar: ["android.permission.READ_CALENDAR", "android.permission.WRITE_CALENDAR"],
+	camera: ["android.permission.CAMERA"],
+	contacts: ["android.permission.READ_CONTACTS", "android.permission.WRITE_CONTACTS"],
+	location: ["android.permission.ACCESS_FINE_LOCATION", "android.permission.ACCESS_COARSE_LOCATION"],
+	microphone: ["android.permission.RECORD_AUDIO"],
+	motion: ["android.permission.ACTIVITY_RECOGNITION"],
+	notifications: ["android.permission.POST_NOTIFICATIONS"],
+	photos: ["android.permission.READ_MEDIA_IMAGES", "android.permission.READ_EXTERNAL_STORAGE"]
+};
+const SIMCTL_OPTIONS = {
+	timeoutMs: 3e4,
+	killSignal: "SIGKILL"
+};
+const ADB_OPTIONS = {
+	timeoutMs: 15e3,
+	killSignal: "SIGKILL"
+};
+const NETWORK_READS = 5;
+const NETWORK_READ_INTERVAL_MS = 400;
+const TARGET = "STIM_DEVICE_TOOL_TARGET";
+const UNSUPPORTED = "STIM_DEVICE_TOOL_UNSUPPORTED";
+const FAILED = "STIM_DEVICE_TOOL_FAILED";
+const DEFAULT_DEPS$1 = {
+	findProjectRoot: findProjectRoot$1,
+	getProject,
+	hostedSlots: (root, platform) => Object.keys(hostedNativeRecords(readWorkspaceState$1(root), platform)),
+	readRemotePlatform: (root) => readRemoteSession(root),
+	readLaunch: (root, platform, slot) => readWorkspaceLaunches(root)[deviceSlotKey(platform, slot)] ?? null,
+	resolveIos: async (udid) => {
+		const resolved = resolveOwnedIosSim(udid, await listAllIosSimsAsync({}));
+		if (resolved.sim) return {
+			name: resolved.sim.name,
+			booted: resolved.sim.state === "Booted"
+		};
+		return resolved.notOwned === void 0 ? "missing" : "notOwned";
+	},
+	resolveAndroid: async (avdName, preferredSerial) => (await resolveOwnedAvdSerialAsync(avdName, { preferredSerial })).serial ?? null,
+	run: (file, args, options) => getExecutor().runFileAsync(file, args, options),
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+	out: (line) => console.log(line),
+	note: (line) => console.error(line)
+};
+function failure(code, message, remedy) {
+	return {
+		code,
+		message,
+		remedy
+	};
+}
+function badArg(message, remedy) {
+	return failure("STIM_BAD_ARG", message, remedy);
+}
+function readPlatform$1(value) {
+	return value === "ios" || value === "android" ? value : null;
+}
+const COORDINATE = /^\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/;
+function parseCoordinate(value) {
+	const match = COORDINATE.exec(value);
+	if (!match) return null;
+	const latitude = Number(match[1]);
+	const longitude = Number(match[2]);
+	return Math.abs(latitude) <= 90 && Math.abs(longitude) <= 180 ? {
+		latitude,
+		longitude
+	} : null;
+}
+function parseLocationRequest(platformArg, opts) {
+	const platform = readPlatform$1(platformArg);
+	if (!platform) return badArg(`\`stim device location\` takes ios or android, not ${JSON.stringify(platformArg)}.`, "Run `stim device location ios --set 45.5,-73.6` or `stim device location android --set 45.5,-73.6`.");
+	if (opts.set === void 0 === !opts.clear) return badArg("Pass exactly one of --set <lat,lng> or --clear.", "Run `stim device location <ios|android> --set 45.5,-73.6`, or `--clear` on iOS.");
+	if (opts.clear) return platform === "android" ? failure(UNSUPPORTED, "The Android emulator has no way to clear a simulated location: `adb emu geo fix` only sets one.", "Set another coordinate with `stim device location android --set <lat,lng>`, or restart the emulator with `stim stop` and `stim android`.") : {
+		tool: "location",
+		platform,
+		clear: true
+	};
+	const coordinate = parseCoordinate(opts.set ?? "");
+	if (!coordinate) return badArg(`${JSON.stringify(opts.set)} is not a coordinate.`, "Pass latitude and longitude in degrees as one value, such as --set 45.5,-73.6 (latitude within 90, longitude within 180).");
+	return {
+		tool: "location",
+		platform,
+		...coordinate
+	};
+}
+function parsePermissionRequest(platformArg, actionArg, serviceArg) {
+	const platform = readPlatform$1(platformArg);
+	if (!platform) return badArg(`\`stim device permission\` takes ios or android, not ${JSON.stringify(platformArg)}.`, "Run `stim device permission ios grant photos` or `stim device permission android grant camera`.");
+	if (actionArg !== "grant" && actionArg !== "revoke" && actionArg !== "reset") return badArg(`${JSON.stringify(actionArg)} is not a permission action.`, "Use grant, revoke or reset: `stim device permission <ios|android> <grant|revoke|reset> <service>`.");
+	const services = platform === "ios" ? IOS_SERVICES : Object.keys(ANDROID_SERVICES);
+	if (!services.includes(serviceArg)) return badArg(`${JSON.stringify(serviceArg)} is not a ${platform} permission service.`, `The ${platform} services are ${services.join(", ")}.`);
+	return {
+		tool: "permission",
+		platform,
+		action: actionArg,
+		service: serviceArg
+	};
+}
+function parsePushRequest(platformArg, opts) {
+	const platform = readPlatform$1(platformArg);
+	if (!platform) return badArg(`\`stim device push\` takes ios, not ${JSON.stringify(platformArg)}.`, "Run `stim device push ios --payload '{\"aps\":{\"alert\":\"Hello\"}}'`.");
+	if (platform === "android") return failure(UNSUPPORTED, "Android has no simulated push: the emulator does not deliver notifications from the host.", "Send the notification through the app's own push provider, or use `adb shell cmd notification post` for a local one.");
+	let parsed;
+	try {
+		parsed = JSON.parse(opts.payload ?? "");
+	} catch {
+		parsed = null;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || !("aps" in parsed)) return badArg("--payload must be a JSON object with an \"aps\" key.", "Pass something like --payload '{\"aps\":{\"alert\":{\"title\":\"Hello\",\"body\":\"World\"}}}'. simctl accepts at most 4096 bytes.");
+	return {
+		tool: "push",
+		platform,
+		payload: JSON.stringify(parsed)
+	};
+}
+function parseNetworkRequest(platformArg, stateArg) {
+	const platform = readPlatform$1(platformArg);
+	if (!platform) return badArg(`\`stim device network\` takes android, not ${JSON.stringify(platformArg)}.`, "Run `stim device network android off`.");
+	if (platform === "ios") return failure(UNSUPPORTED, "The iOS simulator shares the Mac's network; `simctl` has no switch to turn it off.", "Disconnect the Mac, or use Network Link Conditioner on the Mac.");
+	if (stateArg !== "on" && stateArg !== "off") return badArg(`${JSON.stringify(stateArg)} is not on or off.`, "Run `stim device network android on` or `off`.");
+	return {
+		tool: "network",
+		platform,
+		enabled: stateArg === "on"
+	};
+}
+function describeError(error) {
+	const stderr = error instanceof Error && "stderr" in error && typeof error.stderr === "string" ? error.stderr.trim() : "";
+	const message = error instanceof Error ? error.message : String(error);
+	return stderr && !message.includes(stderr) ? `${message} ${stderr}` : message;
+}
+async function resolveToolTarget(platform, slot, root, d) {
+	const slotText = slot === "default" ? "" : ` --slot ${slot}`;
+	const runCommand = `stim ${platform}${slotText}`;
+	const project = d.getProject(root);
+	if (!project) return failure("STIM_NO_PROJECT", `No Stim environment is registered for ${root}.`, "Run `stim start` first.");
+	if (d.hostedSlots(root, platform).includes(slot)) return failure(TARGET, `This workspace's ${platform} device${slotText ? ` in slot ${slot}` : ""} is hosted on another Mac, and device tools act only on the workspace's own local simulator or emulator.`, `Run \`${runCommand} --remote local\` to use a local device.`);
+	const remote = d.readRemotePlatform(root);
+	if (remote && (remote.platform === null || remote.platform === platform)) return failure(TARGET, `This workspace's remote device is EAS Simulator session ${remote.sessionId}, and device tools act only on the workspace's own local simulator or emulator.`, `Run \`${runCommand} --remote local\` to use a local device.`);
+	const records = deviceSlotPlatforms(project, slot);
+	const launch = d.readLaunch(root, platform, slot);
+	if (platform === "ios") {
+		const udid = records?.ios?.owned ? records.ios.deviceUdid : void 0;
+		if (!udid) return noOwnedDevice(platform, slot, runCommand);
+		const sim = await d.resolveIos(udid);
+		if (sim === "missing" || sim === "notOwned") return failure(TARGET, `The recorded iOS simulator ${udid} is ${sim === "missing" ? "gone" : "not owned by this Stim home"}.`, `Run \`${runCommand}\` to boot, install and launch this workspace's owned simulator.`);
+		if (!sim.booted) return failure(TARGET, `The owned iOS simulator ${sim.name} is not booted.`, `Run \`${runCommand}\` to boot it.`);
+		const appId = launch?.deviceId === udid ? launch.appId : project.bundleId ?? null;
+		return {
+			platform,
+			slot,
+			deviceId: udid,
+			deviceName: sim.name,
+			appId
+		};
+	}
+	const avdName = records?.android?.owned ? records.android.avdName : void 0;
+	if (!avdName) return noOwnedDevice(platform, slot, runCommand);
+	const serial = await d.resolveAndroid(avdName, launch?.deviceId ?? records?.android?.serial);
+	if (!serial) return failure(TARGET, `The owned Android emulator ${avdName} is not running.`, `Run \`${runCommand}\` to boot it.`);
+	return {
+		platform,
+		slot,
+		deviceId: serial,
+		deviceName: avdName,
+		appId: launch?.deviceId === serial ? launch.appId : project.androidPackage ?? null
+	};
+}
+function noOwnedDevice(platform, slot, runCommand) {
+	return failure(TARGET, `This workspace has no owned ${platform} ${platform === "ios" ? "simulator" : "emulator"}${slot === "default" ? "" : ` in slot ${slot}`}. Device tools do not act on physical devices or devices Stim does not own.`, `Run \`${runCommand}\` to create and boot one.`);
+}
+/** Reads each permission's grant state out of `dumpsys package <id>`; a permission the dump does not list is omitted. */
+function parsePackagePermissions(dump, names) {
+	const states = [];
+	for (const name of names) {
+		const match = new RegExp(`^\\s*${name.replaceAll(".", "\\.")}: granted=(true|false)(?:, flags=\\[([^\\]]*)\\])?`, "m").exec(dump);
+		if (match) states.push({
+			name,
+			granted: match[1] === "true",
+			flags: (match[2] ?? "").split("|").map((flag) => flag.trim())
+		});
+	}
+	return states;
+}
+function hasUserFlag(state) {
+	return state.flags.some((flag) => /^USER_(SET|FIXED)$/.test(flag));
+}
+function parseSettingFlag(output) {
+	const value = output.trim();
+	return value === "1" ? true : value === "0" ? false : null;
+}
+function noApp(target) {
+	return failure(TARGET, `No app is recorded for this workspace's ${target.platform} device.`, `Run \`stim ${target.platform}${target.slot === "default" ? "" : ` --slot ${target.slot}`}\` to install and launch the app first.`);
+}
+async function runIos(request, target, d) {
+	const simctl = (verb, args, input) => d.run("xcrun", [
+		"simctl",
+		verb,
+		target.deviceId,
+		...args
+	], {
+		...SIMCTL_OPTIONS,
+		...input === void 0 ? {} : { input }
+	});
+	const base = {
+		platform: target.platform,
+		slot: target.slot,
+		deviceId: target.deviceId,
+		deviceName: target.deviceName
+	};
+	if (request.tool === "location") {
+		await simctl("location", "clear" in request ? ["clear"] : ["set", `${request.latitude},${request.longitude}`]);
+		return {
+			...base,
+			tool: "location",
+			..."clear" in request ? { action: "clear" } : {
+				action: "set",
+				latitude: request.latitude,
+				longitude: request.longitude
+			},
+			readBack: null
+		};
+	}
+	if (request.tool === "permission") {
+		if (!target.appId) return noApp(target);
+		await simctl("privacy", [
+			request.action,
+			request.service,
+			target.appId
+		]);
+		return {
+			...base,
+			tool: "permission",
+			action: request.action,
+			service: request.service,
+			appId: target.appId,
+			readBack: null
+		};
+	}
+	if (request.tool === "push") {
+		if (!target.appId) return noApp(target);
+		await simctl("push", [target.appId, "-"], request.payload);
+		return {
+			...base,
+			tool: "push",
+			appId: target.appId,
+			readBack: null
+		};
+	}
+	return failure(UNSUPPORTED, `iOS has no ${request.tool} tool.`, null);
+}
+async function runAndroid(request, target, d) {
+	const adb = (args) => d.run(androidToolPath("adb"), [
+		"-s",
+		target.deviceId,
+		...args
+	], {
+		...ADB_OPTIONS,
+		cwd: androidToolCwd()
+	});
+	const base = {
+		platform: target.platform,
+		slot: target.slot,
+		deviceId: target.deviceId,
+		deviceName: target.deviceName
+	};
+	if (request.tool === "location" && !("clear" in request)) {
+		const reply = await adb([
+			"emu",
+			"geo",
+			"fix",
+			String(request.longitude),
+			String(request.latitude)
+		]);
+		if (/^KO\b/m.test(reply)) return failure(FAILED, `The emulator console refused the location: ${reply.trim()}`, null);
+		return {
+			...base,
+			tool: "location",
+			action: "set",
+			latitude: request.latitude,
+			longitude: request.longitude,
+			readBack: null
+		};
+	}
+	if (request.tool === "permission") {
+		const appId = target.appId;
+		if (!appId) return noApp(target);
+		const requested = ANDROID_SERVICES[request.service] ?? [];
+		const pm = (args) => adb([
+			"shell",
+			"pm",
+			...args
+		]).catch(() => "");
+		for (const name of requested) if (request.action === "grant") await pm([
+			"grant",
+			appId,
+			name
+		]);
+		else {
+			await pm([
+				"revoke",
+				appId,
+				name
+			]);
+			if (request.action === "reset") await pm([
+				"clear-permission-flags",
+				appId,
+				name,
+				"user-set",
+				"user-fixed"
+			]);
+		}
+		const states = parsePackagePermissions(await adb([
+			"shell",
+			"dumpsys",
+			"package",
+			appId
+		]), requested);
+		const permissions = states.map(({ name, granted }) => ({
+			name,
+			granted
+		}));
+		if (permissions.length === 0) return failure(FAILED, `${appId} declares none of the ${request.service} permissions (${requested.join(", ")}).`, `Add one to the app's manifest and rebuild with \`stim android\`; Stim cannot ${request.action} a permission the app does not declare.`);
+		const wanted = request.action === "grant";
+		if (!(wanted ? states.some((state) => state.granted) : states.every((state) => !state.granted && (request.action !== "reset" || !hasUserFlag(state))))) return failure(FAILED, `${target.deviceName} did not report ${request.service} as ${wanted ? "granted" : request.action === "reset" ? "reset" : "revoked"} for ${appId} after the change: ${JSON.stringify(states)}`, `Run \`adb shell dumpsys package ${appId}\` to read the device state.`);
+		const skipped = requested.filter((name) => !permissions.some((permission) => permission.name === name));
+		return {
+			...base,
+			tool: "permission",
+			action: request.action,
+			service: request.service,
+			appId,
+			readBack: { permissions },
+			...skipped.length > 0 ? { skipped } : {}
+		};
+	}
+	if (request.tool === "network") {
+		const verb = request.enabled ? "enable" : "disable";
+		await adb([
+			"shell",
+			"svc",
+			"wifi",
+			verb
+		]);
+		await adb([
+			"shell",
+			"svc",
+			"data",
+			verb
+		]);
+		let wifi = null;
+		let data = null;
+		for (let attempt = 0; attempt < NETWORK_READS; attempt++) {
+			if (attempt > 0) await d.sleep(NETWORK_READ_INTERVAL_MS);
+			wifi = parseSettingFlag(await adb([
+				"shell",
+				"settings",
+				"get",
+				"global",
+				"wifi_on"
+			]));
+			data = parseSettingFlag(await adb([
+				"shell",
+				"settings",
+				"get",
+				"global",
+				"mobile_data"
+			]));
+			if (wifi === request.enabled && data === request.enabled) break;
+		}
+		if (wifi !== request.enabled || data !== request.enabled) return failure(FAILED, `${target.deviceName} reports Wi-Fi ${wifi === null ? "unknown" : wifi ? "on" : "off"} and mobile data ${data === null ? "unknown" : data ? "on" : "off"} after asking for ${request.enabled ? "on" : "off"}.`, "Run `adb shell settings get global wifi_on` and `mobile_data` to read the device state.");
+		return {
+			...base,
+			tool: "network",
+			enabled: request.enabled,
+			readBack: {
+				wifi,
+				data
+			}
+		};
+	}
+	return failure(UNSUPPORTED, `Android has no ${request.tool} tool.`, null);
+}
+function summary(result) {
+	const device = `${result.deviceName} (${result.deviceId})`;
+	switch (result.tool) {
+		case "location": return result.action === "clear" ? `cleared the simulated location on ${device}.` : `set the simulated location on ${device} to ${result.latitude},${result.longitude}.`;
+		case "permission": return `${result.action} ${result.service} for ${result.appId} on ${device}.`;
+		case "push": return `sent a push to ${result.appId} on ${device}.`;
+		case "network": return `turned the network ${result.enabled ? "on" : "off"} on ${device}.`;
+	}
+}
+async function runDeviceTool(request, opts = {}, overrides = {}) {
+	const d = {
+		...DEFAULT_DEPS$1,
+		...overrides
+	};
+	const report = (problem) => {
+		d.note(chalk.red(`${problem.code}: ${problem.message}`));
+		if (problem.remedy) d.note(chalk.dim(problem.remedy));
+		if (opts.json) d.out(JSON.stringify(problem));
+		return problem;
+	};
+	if ("code" in request) return report(request);
+	const root = d.findProjectRoot(process.cwd());
+	if (!root) return report(NO_PROJECT_REFUSAL);
+	let target;
+	try {
+		target = await resolveToolTarget(request.platform, opts.slot ?? "default", root, d);
+	} catch (error) {
+		return report(failure(FAILED, `Stim could not inspect this workspace's ${request.platform} device: ${describeError(error)}`, "Run `stim status` and retry when simctl or adb responds."));
+	}
+	if ("code" in target) return report(target);
+	let result;
+	try {
+		result = request.platform === "ios" ? await runIos(request, target, d) : await runAndroid(request, target, d);
+	} catch (error) {
+		const reason = describeError(error);
+		result = failure(FAILED, `${request.platform === "ios" ? "simctl" : "adb"} did not complete the ${request.tool} change on ${target.deviceName}: ${reason}`, request.tool === "push" && /not authorized/i.test(reason) ? "The app has no notification permission on this simulator, and `simctl privacy` cannot grant it. Open the app, accept its notification prompt, and send the push again." : `Check that ${target.deviceName} is responsive with \`stim status\`, then retry.`);
+	}
+	if ("code" in result) return report(result);
+	d.out(opts.json ? JSON.stringify(result) : chalk.green(summary(result)));
+	return result;
+}
+const finish = (result) => {
+	if ("code" in result) process.exit(1);
+};
+function registerDeviceTools(device, deps = {}) {
+	device.command("location").argument("<platform>", "ios or android").description("Set or clear the simulated location of this workspace's own simulator or emulator. Android cannot clear one.").option("--set <lat,lng>", "latitude and longitude in degrees, as one value such as 45.5,-73.6").option("--clear", "stop simulating a location (iOS only)").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the result as JSON on stdout").action(async (platform, opts) => finish(await runDeviceTool(parseLocationRequest(platform, opts), opts, deps)));
+	device.command("permission").argument("<platform>", "ios or android").argument("<action>", "grant, revoke or reset").argument("<service>", "the permission service, such as camera, photos or location").description("Grant, revoke or reset one privacy permission for the app on this workspace's own simulator or emulator. Android reads the grant state back; iOS has no read.").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the result as JSON on stdout").action(async (platform, action, service, opts) => finish(await runDeviceTool(parsePermissionRequest(platform, action, service), opts, deps)));
+	device.command("push").argument("<platform>", "ios").description("Send a test push notification to the app on this workspace's own iOS simulator.").requiredOption("--payload <json>", "the APNs payload: a JSON object with an \"aps\" key, at most 4096 bytes").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the result as JSON on stdout").action(async (platform, opts) => finish(await runDeviceTool(parsePushRequest(platform, opts), opts, deps)));
+	device.command("network").argument("<platform>", "android").argument("<state>", "on or off").description("Turn Wi-Fi and mobile data on or off on this workspace's own Android emulator, and read them back.").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the result as JSON on stdout").action(async (platform, state, opts) => finish(await runDeviceTool(parseNetworkRequest(platform, state), opts, deps)));
+}
+//#endregion
+//#region src/commands/device.ts
+const DEFAULT_FOR = "5m";
+const DEFAULT_DEPS = {
+	findProjectRoot: findProjectRoot$1,
+	getProject,
+	avdNameOf: getAvdNameForSerialAsync,
+	listIosDevices,
+	listAdbDevices: listAdbDevicesAsync,
+	physicalDeviceModel,
+	probeEmulatorSerial,
+	takeLease,
+	releaseLeases: releaseWorkspaceLeases,
+	waitForDevice,
+	selectFromPool,
+	io: fileLeaseIo,
+	now: () => Date.now(),
+	sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+	out: (line) => console.log(line),
+	note: (line) => console.error(line)
+};
+function grantLine(facts, durationText) {
+	return `locked ${facts.deviceName ? `${facts.deviceName} (${facts.id})` : facts.id} for ${facts.holder} until ${clockTime(facts.expiresAt)} (${durationText}). Renew: stim device lock ${facts.platform}${facts.slot ? ` --slot ${facts.slot}` : ""} --for ${durationText}. Release: stim device unlock${facts.slot ? ` --slot ${facts.slot}` : ""}.`;
+}
+function releasedLine(lease) {
+	return `unlocked ${lease.deviceName ? `${lease.deviceName} (${lease.id})` : lease.id} -- the ${lease.platform} lease ran until ${clockTime(lease.expiresAt)}.`;
+}
+function readPlatform(value) {
+	return value === "ios" || value === "android" ? value : null;
+}
+async function resolveDevice(platform, requested, d) {
+	if (platform === "ios") {
+		const resolved = resolveIosPhysicalDevice(requested, await d.listIosDevices());
+		if (!resolved.udid) return {
+			code: "STIM_NO_DEVICE",
+			message: resolved.error,
+			remedy: resolved.remedy ?? null
+		};
+		return {
+			id: resolved.udid,
+			deviceName: resolved.name ?? resolved.udid
+		};
+	}
+	const adb = await d.listAdbDevices();
+	const resolved = await emulatorProbeSession(d.probeEmulatorSerial)((isEmulator) => resolvePhysicalDevice(requested, adb, isEmulator));
+	if (!resolved.serial) return {
+		code: "STIM_NO_DEVICE",
+		message: resolved.error,
+		remedy: resolved.remedy ?? null
+	};
+	return {
+		id: resolved.serial,
+		deviceName: await d.physicalDeviceModel(resolved.serial) ?? resolved.serial
+	};
+}
+async function findOwnedVirtualDevice(project, platform, id, avdNameOf) {
+	let running;
+	for (const { slot, platforms } of projectDeviceSlots(project)) {
+		if (platform === "ios") {
+			const sim = platforms.ios;
+			if (sim?.owned && sim.deviceUdid && sim.deviceUdid.toLowerCase() === id.toLowerCase()) return {
+				id: sim.deviceUdid,
+				deviceName: sim.deviceName ?? null,
+				slot
+			};
+			continue;
+		}
+		const emulator = platforms.android;
+		if (!emulator?.owned || !emulator.avdName || !/^emulator-\d+$/.test(id)) continue;
+		running ??= { name: await avdNameOf(id) };
+		if (running.name === emulator.avdName) return {
+			id,
+			deviceName: emulator.deviceName ?? emulator.avdName,
+			slot
+		};
+	}
+	return null;
+}
+function isFailure(value) {
+	return "code" in value;
+}
+async function poolDevice(platform, idLabel, waitSeconds, deadline, root, d, slot) {
+	const probed = emulatorProbeSession(d.probeEmulatorSerial);
+	const pooled = await d.selectFromPool({
+		...slot ? { slot } : {},
+		root,
+		platform,
+		idLabel,
+		list: async () => {
+			if (platform === "ios") return iosPoolCandidates(await d.listIosDevices()).map((entry) => ({
+				id: entry.udid,
+				name: entry.name,
+				fallback: isWirelessIosDevice(entry)
+			}));
+			const adb = await d.listAdbDevices();
+			return (await probed((isEmulator) => androidPoolCandidates(adb, isEmulator))).map((entry) => ({ id: entry.serial }));
+		},
+		noCandidates: async () => {
+			let resolved;
+			if (platform === "ios") resolved = iosPoolNoCandidatesRefusal(await d.listIosDevices());
+			else {
+				const adb = await d.listAdbDevices();
+				resolved = await probed((isEmulator) => androidPoolNoCandidatesRefusal(adb, isEmulator));
+			}
+			return {
+				message: resolved.error,
+				remedy: resolved.remedy
+			};
+		},
+		waitSeconds,
+		deadline,
+		now: d.now,
+		sleep: d.sleep,
+		warn: (line) => d.note(chalk.yellow(line)),
+		io: d.io
+	});
+	if (pooled.status === "refused") return {
+		code: pooled.refusal.code,
+		message: pooled.refusal.message,
+		remedy: pooled.refusal.remedy,
+		...pooled.refusal.lease === null ? {} : { lease: pooled.refusal.lease }
+	};
+	const name = pooled.candidate.name ?? (platform === "ios" ? pooled.candidate.id : await d.physicalDeviceModel(pooled.candidate.id));
+	return {
+		id: pooled.candidate.id,
+		deviceName: name ?? pooled.candidate.id
+	};
+}
+async function runLock(platformArg, idArg, opts = {}, overrides = {}) {
+	const d = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const json = Boolean(opts.json);
+	const report = (failure) => {
+		d.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) d.note(chalk.dim(failure.remedy));
+		if (json) d.out(JSON.stringify({
+			code: failure.code,
+			message: failure.message,
+			remedy: failure.remedy,
+			...failure.lease === void 0 ? {} : { lease: failure.lease }
+		}));
+		return failure;
+	};
+	const platform = readPlatform(platformArg);
+	if (!platform) return report({
+		code: "STIM_BAD_ARG",
+		message: `\`stim device lock\` takes ios or android, not ${JSON.stringify(platformArg)}.`,
+		remedy: "Run `stim device lock ios` or `stim device lock android`."
+	});
+	const root = d.findProjectRoot(process.cwd());
+	if (!root) return report(NO_PROJECT_REFUSAL);
+	const durationText = String(opts.for ?? DEFAULT_FOR).trim();
+	const duration = parseLeaseDuration(durationText);
+	if ("error" in duration) return report({
+		code: "STIM_BAD_ARG",
+		message: duration.error,
+		remedy: "Pass a whole number of seconds or minutes from 10s to 30m, e.g. --for 90s or --for 10m."
+	});
+	const wait = parseDeviceWait(opts.wait);
+	if ("error" in wait) return report({
+		code: "STIM_BAD_ARG",
+		message: wait.error,
+		remedy: "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a leased device at once."
+	});
+	const idLabel = platform === "ios" ? "udid" : "serial";
+	const deadline = d.now() + wait.seconds * 1e3;
+	const lastLine = { at: null };
+	const owned = idArg ? await findOwnedVirtualDevice(d.getProject(root), platform, idArg, d.avdNameOf) : null;
+	if (owned && opts.slot && opts.slot !== owned.slot) return report({
+		code: "STIM_BAD_ARG",
+		message: `${owned.id} is this workspace's ${platform} device in slot ${owned.slot}, not ${opts.slot}.`,
+		remedy: `Run \`stim device lock ${platform} ${owned.id}\` without --slot, or with --slot ${owned.slot}.`
+	});
+	const held = owned ? d.io.readHolder(root)[deviceSlotKey(platform, owned.slot)] : void 0;
+	if (owned && held && held.id !== owned.id) return report({
+		code: "STIM_DEVICE_BUSY",
+		message: `This workspace already leases ${held.id} for ${platform} in slot ${owned.slot}, and a workspace holds one lease per platform and slot.`,
+		remedy: `Release it with \`stim device unlock ${platform}${owned.slot === "default" ? "" : ` --slot ${owned.slot}`}\` once nothing depends on it, then lock ${owned.id}.`
+	});
+	const slot = owned ? owned.slot === "default" ? void 0 : owned.slot : opts.slot;
+	const device = owned ? owned : idArg ? await resolveDevice(platform, idArg, d) : await poolDevice(platform, idLabel, wait.seconds, deadline, root, d, opts.slot);
+	if (isFailure(device)) return report(device);
+	for (;;) {
+		const outcome = await d.waitForDevice({
+			...slot ? { slot } : {},
+			root,
+			platform,
+			id: device.id,
+			idLabel,
+			waitSeconds: wait.seconds,
+			now: d.now,
+			sleep: d.sleep,
+			warn: (line) => d.note(chalk.yellow(line)),
+			io: d.io,
+			deadline,
+			lastLine
+		});
+		if (outcome.status === "refused") return report({
+			...outcome.refusal,
+			lease: outcome.refusal.lease
+		});
+		const taken = d.takeLease({
+			...slot ? { slot } : {},
+			root,
+			platform,
+			id: device.id,
+			deviceName: device.deviceName,
+			kind: "declared",
+			durationMs: duration.ms
+		}, d.io);
+		if (taken.status === "unreadable") return report({
+			code: "STIM_DEVICE_BUSY",
+			message: `The lease file at ${taken.path} does not parse, so Stim cannot tell who holds that device.`,
+			remedy: `Read ${taken.path} and, once you know no run depends on it, delete it. \`stim gc\` reports it on every run.`,
+			lease: {
+				platform: null,
+				id: null,
+				deviceName: null,
+				holder: null,
+				expiresAt: null
+			}
+		});
+		if (taken.status === "held") continue;
+		const facts = {
+			...taken.lease.slot ? { slot: taken.lease.slot } : {},
+			platform,
+			id: taken.lease.id,
+			deviceName: taken.lease.deviceName,
+			holder: taken.lease.holder,
+			kind: "declared",
+			grantedAt: taken.lease.grantedAt,
+			expiresAt: taken.lease.expiresAt,
+			leaseSeconds: Math.round(duration.ms / 1e3)
+		};
+		if (json) d.out(JSON.stringify(facts));
+		else d.out(chalk.green(grantLine(facts, durationText)));
+		return facts;
+	}
+}
+async function runUnlock(platformArg, opts = {}, overrides = {}) {
+	const d = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const json = Boolean(opts.json);
+	const report = (failure) => {
+		d.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) d.note(chalk.dim(failure.remedy));
+		if (json) d.out(JSON.stringify({
+			code: failure.code,
+			message: failure.message,
+			remedy: failure.remedy
+		}));
+		return failure;
+	};
+	const platform = platformArg === void 0 ? null : readPlatform(platformArg);
+	if (platformArg !== void 0 && !platform) return report({
+		code: "STIM_BAD_ARG",
+		message: `\`stim device unlock\` takes ios or android, not ${JSON.stringify(platformArg)}.`,
+		remedy: "Run `stim device unlock` for every lease this workspace holds, or name one platform."
+	});
+	const root = d.findProjectRoot(process.cwd());
+	if (!root) return report(NO_PROJECT_REFUSAL);
+	const released = d.releaseLeases(root, {
+		platform,
+		...opts.slot ? { slot: opts.slot } : {}
+	}, d.io);
+	if (released.length === 0) d.note(chalk.dim(`No ${platform ? `${platform} ` : ""}device lease to release for ${root}. \`stim status\` lists every lease on this machine.`));
+	if (json) d.out(JSON.stringify(released.map((lease) => ({
+		...lease,
+		holder: root
+	}))));
+	else for (const lease of released) d.out(chalk.green(releasedLine(lease)));
+	return released;
+}
+function registerDevice(program, deps = {}) {
+	const device = program.command("device").description("Lease a connected physical device to this workspace, give it back, provision iOS signing for it, or change the workspace's own simulator or emulator");
+	device.command("lock").argument("<platform>", "ios or android").argument("[id]", "the UDID or serial to lease, a connected device or this workspace's own simulator or emulator; without one, the first free connected device is used").description("Lease a connected physical device, or this workspace's own simulator or emulator, to this workspace for a declared time, so another workspace's `--device` run waits and agents see the device as driven. Nothing but this command and a `--device` run moves the expiry.").option("--for <duration>", `How long to hold it: a whole number of seconds or minutes from 10s to 30m (default ${DEFAULT_FOR})`).option("--wait <seconds>", "How long to wait for a device another workspace holds, before refusing with STIM_DEVICE_BUSY (default 60, 0 refuses at once)").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the lease as JSON on stdout").action(async (platform, id, opts) => {
+		if ("code" in await runLock(platform, id, opts, deps)) process.exit(1);
+	});
+	device.command("unlock").argument("[platform]", "ios or android; without one, every lease this workspace holds is released").description("Release the device lease or leases this workspace holds. Releasing nothing is not an error.").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the released leases as JSON on stdout").action(async (platform, opts) => {
+		const result = await runUnlock(platform, opts, deps);
+		if (!Array.isArray(result)) process.exit(1);
+	});
+	device.command("provision").argument("<platform>", "ios").argument("[udid]", "the connected iPhone or iPad to provision for; required when more than one is connected").description("Register a connected iPhone with the project's Apple Developer team and create or refresh its iOS App Development profile, through xcodebuild -allowProvisioningUpdates. It lists the account changes and asks first; no build ever does this.").option("--scheme <name>", "Xcode scheme whose signed targets to provision (default: ios.scheme, then detected)").option("--configuration <name>", "build configuration to provision (default: ios.configuration, then Debug)").option("--yes", "confirm the listed Apple Developer account changes without a prompt").option("--json", "print the plan and result, or the refusal, as JSON on stdout").action(async (platform, udid, opts) => {
+		const root = findProjectRoot$1(process.cwd()) ?? process.cwd();
+		const { value: result, interrupted } = await runProcessOperation(root, (operation) => runProvision(platform, udid, opts, { operation }));
+		if ("code" in result) process.exit(interrupted ?? 1);
+	});
+	registerDeviceTools(device);
+}
+function deviceCommand(program) {
+	registerDevice(program);
+}
+//#endregion
+export { deviceCommand as default, grantLine, registerDevice, releasedLine, runLock, runUnlock };