stim 1.8.0 → 1.10.0

package/dist/app-install-CrJ6t_bv.mjs

@@ -0,0 +1,819 @@
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { T as uninstallIosApp, c as iosSimulatorFailureAdvice, p as listUserApps } from "./ios-B2Fpqvlb.mjs";
+import { closeSync, lstatSync, openSync, readSync, readdirSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/engine/installed-artifact.ts
+const READ_CHUNK_BYTES = 1048576;
+const DEVICE_PATH_TIMEOUT_MS = 3e4;
+const DEVICE_HASH_TIMEOUT_MS = 12e4;
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+function parseInstalledApkPath(text) {
+	if (typeof text !== "string") return null;
+	const paths = [];
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line.startsWith("package:")) continue;
+		const path = line.slice(8);
+		if (path.startsWith("/")) paths.push(path);
+	}
+	return paths.length === 1 ? paths[0] : null;
+}
+function parseDeviceSha256(text) {
+	if (typeof text !== "string") return null;
+	const first = text.trim().split(/\s+/)[0] ?? "";
+	return SHA256_HEX.test(first) ? first : null;
+}
+function parseAppContainerPath(text) {
+	if (typeof text !== "string") return null;
+	const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+	return lines.length === 1 && isAbsolute(lines[0]) ? lines[0] : null;
+}
+function artifactsMatch(local, installed) {
+	return Boolean(local) && local === installed;
+}
+function hashFile(file) {
+	let fd = null;
+	try {
+		fd = openSync(file, "r");
+		const digest = createHash("sha256");
+		const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+		for (;;) {
+			const read = readSync(fd, buffer, 0, READ_CHUNK_BYTES, null);
+			if (read <= 0) break;
+			digest.update(buffer.subarray(0, read));
+		}
+		return digest.digest("hex");
+	} catch {
+		return null;
+	} finally {
+		if (fd !== null) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+function hashBundle(dir) {
+	const digest = createHash("sha256");
+	const walk = (abs, rel) => {
+		let names;
+		try {
+			names = readdirSync(abs);
+		} catch {
+			return false;
+		}
+		for (const name of names.toSorted()) {
+			const child = join(abs, name);
+			const path = rel === "" ? name : `${rel}/${name}`;
+			let stat;
+			try {
+				stat = lstatSync(child);
+			} catch {
+				return false;
+			}
+			if (stat.isDirectory()) {
+				if (!walk(child, path)) return false;
+				continue;
+			}
+			if (!stat.isFile()) return false;
+			const file = hashFile(child);
+			if (file === null) return false;
+			digest.update(`${path}\0${file}\n`);
+		}
+		return true;
+	};
+	return walk(dir, "") ? digest.digest("hex") : null;
+}
+function deviceHoldsApk({ serial, packageName, apkPath }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let path;
+	try {
+		path = parseInstalledApkPath(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"pm",
+			"path",
+			packageName
+		], { timeoutMs: DEVICE_PATH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!path) return false;
+	let installed;
+	try {
+		installed = parseDeviceSha256(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"sha256sum",
+			path
+		], { timeoutMs: DEVICE_HASH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!installed) return false;
+	return artifactsMatch(hashFile(apkPath), installed);
+}
+function deviceHoldsBundle({ udid, bundleId, appPath }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let container;
+	try {
+		container = parseAppContainerPath(e.runFile("xcrun", [
+			"simctl",
+			"get_app_container",
+			udid,
+			bundleId
+		], { timeoutMs: DEVICE_PATH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!container) return false;
+	const installed = hashBundle(container);
+	if (!installed) return false;
+	return artifactsMatch(hashBundle(appPath), installed);
+}
+//#endregion
+//#region src/engine/app-install.ts
+const INSTALL_ERROR = "STIM_INSTALL_FAILED";
+const LAUNCH_ERROR = "STIM_LAUNCH_FAILED";
+const DEFAULT_METRO_PORT = 8081;
+const IOS_SCHEME_APPROVAL_DOMAIN = "com.apple.launchservices.schemeapproval";
+const IOS_SCHEME_APPROVAL_OPENER = "com.apple.CoreSimulator.CoreSimulatorBridge";
+const IOS_DEV_MENU_OFF_KEYS = ["EXDevMenuShowsAtLaunch", "EXDevMenuShowFloatingActionButton"];
+const DEV_CLIENT_ONBOARDING_QUERY = "disableOnboarding=1";
+const DEV_CLIENT_DISABLE_FAB_QUERY = "disableFab=1";
+const ANDROID_DISABLE_AUTO_LAUNCH_EXTRA = "EXDevMenuDisableAutoLaunch";
+function describeIosSimulatorFailure(error, exec) {
+	const detail = describe(error);
+	return error?.code === "ETIMEDOUT" ? `${detail}. ${iosSimulatorFailureAdvice(exec)}` : detail;
+}
+function installIosApp({ udid, appPath, bundleId = null, devClientScheme = null, proveInstalled = true }, { exec = null, now = null } = {}) {
+	const e = exec || getExecutor();
+	const artifactStartedAt = now?.();
+	const skipped = bundleId && proveInstalled ? deviceHoldsBundle({
+		udid,
+		bundleId,
+		appPath
+	}, { exec: e }) : false;
+	if (!skipped) try {
+		e.runFile("xcrun", [
+			"simctl",
+			"install",
+			udid,
+			appPath
+		], {
+			timeoutMs: 3e5,
+			killSignal: "SIGKILL"
+		});
+	} catch (err) {
+		return {
+			failed: true,
+			code: INSTALL_ERROR,
+			reason: `simctl install failed for ${appPath}: ${describeIosSimulatorFailure(err, e)}`
+		};
+	}
+	const artifactFinishedAt = now?.();
+	const artifactDurationMs = artifactStartedAt !== void 0 && artifactFinishedAt !== void 0 ? artifactFinishedAt - artifactStartedAt : void 0;
+	const preparationStartedAt = bundleId && devClientScheme ? artifactFinishedAt : void 0;
+	if (bundleId && devClientScheme) try {
+		for (const key of IOS_DEV_MENU_OFF_KEYS) e.runFile("xcrun", [
+			"simctl",
+			"spawn",
+			udid,
+			"defaults",
+			"write",
+			bundleId,
+			key,
+			"-bool",
+			"false"
+		], { timeoutMs: 6e4 });
+		for (const key of iosSchemeApprovalKeys(bundleId, devClientScheme)) e.runFile("xcrun", [
+			"simctl",
+			"spawn",
+			udid,
+			"defaults",
+			"write",
+			IOS_SCHEME_APPROVAL_DOMAIN,
+			key,
+			"-string",
+			bundleId
+		], { timeoutMs: 6e4 });
+	} catch (err) {
+		return {
+			failed: true,
+			code: INSTALL_ERROR,
+			reason: `Installed ${bundleId}, but could not prepare the dev client: ${describeIosSimulatorFailure(err, e)}`
+		};
+	}
+	const devClientPreparationDurationMs = now && preparationStartedAt !== void 0 ? now() - preparationStartedAt : void 0;
+	const timing = {
+		...artifactDurationMs === void 0 ? {} : { artifactDurationMs },
+		...devClientPreparationDurationMs === void 0 ? {} : { devClientPreparationDurationMs }
+	};
+	return skipped ? {
+		ok: true,
+		appPath,
+		skipped: true,
+		...timing
+	} : {
+		ok: true,
+		appPath,
+		...timing
+	};
+}
+function clearOtherUserApps({ udid, keep }, { list = listUserApps, uninstall = uninstallIosApp } = {}) {
+	const removed = [];
+	const failed = [];
+	let installed;
+	try {
+		installed = list(udid);
+	} catch {
+		return {
+			listed: false,
+			removed,
+			failed
+		};
+	}
+	for (const bundleId of installed) {
+		if (bundleId === keep) continue;
+		try {
+			uninstall(udid, bundleId);
+			removed.push(bundleId);
+		} catch {
+			failed.push(bundleId);
+		}
+	}
+	return {
+		listed: true,
+		removed,
+		failed
+	};
+}
+function jsLocationValue(metroPort) {
+	return `localhost:${metroPort}`;
+}
+function devClientDeepLink(scheme, projectOrigin) {
+	const projectUrl = `${projectOrigin.replace(/\/+$/, "")}/?${DEV_CLIENT_ONBOARDING_QUERY}`;
+	return `${scheme}://expo-development-client/?url=${encodeURIComponent(projectUrl)}&${DEV_CLIENT_DISABLE_FAB_QUERY}`;
+}
+function devClientUrl(scheme, metroPort, host = "localhost") {
+	return devClientDeepLink(scheme, `http://${host}:${metroPort}`);
+}
+function iosSchemeApprovalKeys(bundleId, devClientScheme) {
+	return [.../* @__PURE__ */ new Set([bundleId, devClientScheme])].map((target) => `${IOS_SCHEME_APPROVAL_OPENER}-->${target}`);
+}
+function parseLaunchedPid(text) {
+	if (typeof text !== "string") return null;
+	const match = text.trim().match(/:\s*(\d+)\s*$/);
+	if (!match) return null;
+	const pid = Number(match[1]);
+	return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function iosAppProcess(udid, bundleId, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let out = "";
+	try {
+		out = e.runFile("xcrun", [
+			"simctl",
+			"spawn",
+			udid,
+			"launchctl",
+			"list"
+		], { timeoutMs: 2e3 });
+	} catch {
+		return;
+	}
+	const label = `UIKitApplication:${bundleId}[`;
+	for (const line of out.split("\n")) {
+		if (!line.includes(label)) continue;
+		const pid = Number(line.trim().split(/\s+/)[0]);
+		if (Number.isInteger(pid) && pid > 0) return pid;
+	}
+	return null;
+}
+function launchedIosAppAfterNoHandle(error, udid, bundleId, exec) {
+	const stderr = String(error?.stderr ?? "");
+	if (!stderr.includes("domain=NSPOSIXErrorDomain, code=3") || !stderr.includes(`Application launch for '${bundleId}' did not return a process handle nor launch error.`)) return null;
+	return iosAppProcess(udid, bundleId, { exec }) ?? null;
+}
+function launchIosApp({ udid, bundleId, metroPort, devClientScheme = null, consolePaths }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const launchArgs = [
+		"simctl",
+		"launch",
+		...consolePaths ? [`--stdout=${consolePaths.stdout}`, `--stderr=${consolePaths.stderr}`] : [],
+		udid,
+		bundleId
+	];
+	if (metroPort !== null) {
+		try {
+			e.runFile("xcrun", [
+				"simctl",
+				"spawn",
+				udid,
+				"defaults",
+				"write",
+				bundleId,
+				"RCT_jsLocation",
+				jsLocationValue(metroPort)
+			], { timeoutMs: 6e4 });
+		} catch (err) {
+			return {
+				failed: true,
+				code: LAUNCH_ERROR,
+				reason: `Could not point ${bundleId} at Metro port ${metroPort} (defaults write RCT_jsLocation): ${describeIosSimulatorFailure(err, e)}`
+			};
+		}
+		if (devClientScheme) {
+			const url = devClientUrl(devClientScheme, metroPort);
+			let launchedWithInitialUrl = false;
+			try {
+				if (consolePaths && iosAppProcess(udid, bundleId, { exec: e }) === null) {
+					const initialUrl = new URL(url).searchParams.get("url");
+					launchedWithInitialUrl = true;
+					const pid = parseLaunchedPid(e.runFile("xcrun", [
+						...launchArgs,
+						"--initialUrl",
+						initialUrl
+					], { timeoutMs: 6e4 }));
+					return {
+						ok: true,
+						mode: "launch",
+						url,
+						jsLocation: jsLocationValue(metroPort),
+						pid
+					};
+				}
+				e.runFile("xcrun", [
+					"simctl",
+					"openurl",
+					udid,
+					url
+				], { timeoutMs: 6e4 });
+				return {
+					ok: true,
+					mode: "openurl",
+					url,
+					jsLocation: jsLocationValue(metroPort)
+				};
+			} catch (err) {
+				const pid = launchedWithInitialUrl ? launchedIosAppAfterNoHandle(err, udid, bundleId, e) : null;
+				if (pid) return {
+					ok: true,
+					mode: "launch",
+					url,
+					jsLocation: jsLocationValue(metroPort),
+					pid
+				};
+				return {
+					failed: true,
+					code: LAUNCH_ERROR,
+					reason: `simctl ${launchedWithInitialUrl ? `launch ${bundleId}` : `openurl ${url}`} failed: ${describeIosSimulatorFailure(err, e)}`
+				};
+			}
+		}
+	}
+	const preLaunchPid = iosAppProcess(udid, bundleId, { exec: e });
+	try {
+		const result = {
+			ok: true,
+			mode: "launch",
+			pid: parseLaunchedPid(e.runFile("xcrun", launchArgs, { timeoutMs: 6e4 }))
+		};
+		if (metroPort !== null) result.jsLocation = jsLocationValue(metroPort);
+		return result;
+	} catch (err) {
+		const pid = preLaunchPid === null ? launchedIosAppAfterNoHandle(err, udid, bundleId, e) : null;
+		if (pid) {
+			const result = {
+				ok: true,
+				mode: "launch",
+				pid
+			};
+			if (metroPort !== null) result.jsLocation = jsLocationValue(metroPort);
+			return result;
+		}
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `simctl launch ${bundleId} failed: ${describeIosSimulatorFailure(err, e)}`
+		};
+	}
+}
+function installConflictKind(text) {
+	const out = String(text ?? "");
+	if (/INSTALL_FAILED_UPDATE_INCOMPATIBLE|INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES|signatures do not match/i.test(out)) return "signature";
+	if (/INSTALL_FAILED_VERSION_DOWNGRADE/i.test(out)) return "downgrade";
+	return null;
+}
+const ADB_INSTALL_TIMEOUT_MS = 3e5;
+const ADB_UNINSTALL_TIMEOUT_MS = 12e4;
+const ADB_SHELL_OPTIONS = {
+	timeoutMs: 3e4,
+	killSignal: "SIGKILL"
+};
+function installAndroidApp({ serial, apkPath, packageName = null, allowUninstall = false }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	if (packageName && deviceHoldsApk({
+		serial,
+		packageName,
+		apkPath
+	}, { exec: e })) return {
+		ok: true,
+		apkPath,
+		skipped: true
+	};
+	const install = () => {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"install",
+			"-r",
+			apkPath
+		], { timeoutMs: ADB_INSTALL_TIMEOUT_MS });
+	};
+	try {
+		install();
+		return {
+			ok: true,
+			apkPath
+		};
+	} catch (err) {
+		const conflict = installConflictKind(describe(err));
+		if (!conflict || !allowUninstall || !packageName) return {
+			failed: true,
+			code: INSTALL_ERROR,
+			reason: `adb install failed for ${apkPath}: ${describe(err)}`
+		};
+		try {
+			e.runFile("adb", [
+				"-s",
+				serial,
+				"uninstall",
+				packageName
+			], {
+				timeoutMs: ADB_UNINSTALL_TIMEOUT_MS,
+				killSignal: "SIGKILL"
+			});
+		} catch (uninstallErr) {
+			return {
+				failed: true,
+				code: INSTALL_ERROR,
+				reason: `adb install failed for ${apkPath} (${conflict}) and ${packageName} could not be uninstalled: ` + describe(uninstallErr)
+			};
+		}
+		try {
+			install();
+		} catch (retryErr) {
+			return {
+				failed: true,
+				code: INSTALL_ERROR,
+				reason: `adb install failed for ${apkPath} even after uninstalling ${packageName}: ${describe(retryErr)}`
+			};
+		}
+		return {
+			ok: true,
+			apkPath,
+			uninstalled: true,
+			note: conflict === "signature" ? `${packageName} was already installed with a different signer, so it was uninstalled (its data went with it) before this APK could be installed` : `${packageName} was already installed at a higher versionCode, so it was uninstalled (its data went with it) before this APK could be installed`
+		};
+	}
+}
+function parseResolvedActivity(text) {
+	if (typeof text !== "string") return null;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line) continue;
+		if (/^No activity found/i.test(line)) return null;
+		if (line.includes("=")) continue;
+		if (!line.includes("/")) continue;
+		return line;
+	}
+	return null;
+}
+function resolveLaunchActivity(serial, packageName, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	try {
+		return parseResolvedActivity(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"cmd",
+			"package",
+			"resolve-activity",
+			"--brief",
+			"-c",
+			"android.intent.category.LAUNCHER",
+			packageName
+		], ADB_SHELL_OPTIONS));
+	} catch {
+		return null;
+	}
+}
+function reverseMetroPorts({ serial, metroPort, devicePorts = null }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const pairs = (devicePorts ?? [metroPort]).map((device) => [device, metroPort]);
+	for (const [device, host] of pairs) try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"reverse",
+			`tcp:${device}`,
+			`tcp:${host}`
+		], ADB_SHELL_OPTIONS);
+	} catch (err) {
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `adb reverse tcp:${device} tcp:${host} failed on ${serial}: ${describe(err)}`
+		};
+	}
+	return {
+		ok: true,
+		reversed: pairs.map(([device, host]) => `tcp:${device}->tcp:${host}`)
+	};
+}
+const EMULATOR_HOST_LOOPBACK = "127.0.0.1";
+const PHYSICAL_HOST_LOOPBACK = "localhost";
+function androidMetroHost(physical) {
+	return physical ? PHYSICAL_HOST_LOOPBACK : EMULATOR_HOST_LOOPBACK;
+}
+function deviceShellArg(text) {
+	return `'${String(text).replace(/'/g, "'\\''")}'`;
+}
+function debugHttpHostScript({ packageName, host, dataDir = null }) {
+	const dir = dataDir || `/data/data/${packageName}`;
+	const prefs = `shared_prefs/${packageName}_preferences.xml`;
+	const tmp = `${prefs}.stim.tmp`;
+	return [
+		`cd ${dir} || exit 1`,
+		"mkdir -p shared_prefs || exit 1",
+		`printf '%s\\n' '<?xml version="1.0" encoding="utf-8" standalone="yes" ?>' '<map>' > ${tmp} || exit 1`,
+		`if [ -f ${prefs} ]; then grep -v 'debug_http_host' ${prefs} | grep -v '<?xml' | grep -v '<map' | grep -v '</map>' >> ${tmp}; fi`,
+		`printf '%s\\n' '    <string name="debug_http_host">${host}</string>' '</map>' >> ${tmp} || exit 1`,
+		`mv ${tmp} ${prefs} || exit 1`,
+		`grep -q '>${host}<' ${prefs} || exit 1`
+	].join("\n");
+}
+function writeDebugHttpHost({ serial, packageName, metroPort, physical = false }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const host = `${androidMetroHost(physical)}:${metroPort}`;
+	const script = debugHttpHostScript({
+		packageName,
+		host
+	});
+	try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"run-as",
+			packageName,
+			"sh",
+			"-c",
+			deviceShellArg(script)
+		], ADB_SHELL_OPTIONS);
+		return {
+			ok: true,
+			host
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			reason: `debug_http_host not written (${describe(err)}); relying on adb reverse`
+		};
+	}
+}
+function androidDevClientUrl(scheme, metroPort, physical = false) {
+	return devClientUrl(scheme, metroPort, androidMetroHost(physical));
+}
+function amStartError(text) {
+	const out = String(text ?? "");
+	for (const raw of out.split("\n")) {
+		const line = raw.trim();
+		if (/^Error:/i.test(line)) return line;
+	}
+	return null;
+}
+function openAndroidDevClientUrl({ serial, url, packageName }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let out;
+	try {
+		const args = [
+			"-s",
+			serial,
+			"shell",
+			"am",
+			"start",
+			"-a",
+			"android.intent.action.VIEW",
+			"-d",
+			deviceShellArg(url),
+			...packageName ? ["-p", packageName] : [],
+			"--ez",
+			ANDROID_DISABLE_AUTO_LAUNCH_EXTRA,
+			"true"
+		];
+		out = e.runFile("adb", args, ADB_SHELL_OPTIONS);
+	} catch (err) {
+		return {
+			failed: true,
+			reason: `am start -d ${url} failed on ${serial}: ${describe(err)}`
+		};
+	}
+	const error = amStartError(out);
+	if (error) return {
+		failed: true,
+		reason: `am start -d ${url} did not start anything on ${serial}: ${error}`
+	};
+	return {
+		ok: true,
+		url
+	};
+}
+function launchAndroidApp({ serial, packageName, metroPort, devClientScheme = null, physical = false }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const reversed = reverseMetroPorts({
+		serial,
+		metroPort
+	}, { exec: e });
+	if (reversed.failed) return reversed;
+	const prefs = writeDebugHttpHost({
+		serial,
+		packageName,
+		metroPort,
+		physical
+	}, { exec: e });
+	let reversedPairs = reversed.reversed ?? [];
+	if (!prefs.ok && Number(metroPort) !== 8081) {
+		const fallback = reverseMetroPorts({
+			serial,
+			metroPort,
+			devicePorts: [DEFAULT_METRO_PORT]
+		}, { exec: e });
+		if (fallback.failed) return fallback;
+		reversedPairs = [...reversedPairs, ...fallback.reversed ?? []];
+	}
+	const wiring = {
+		reversed: reversedPairs,
+		debugHttpHost: prefs.ok ? prefs.host : null,
+		debugHttpHostNote: prefs.ok ? null : prefs.reason
+	};
+	let devClientNote = null;
+	if (devClientScheme) {
+		const url = androidDevClientUrl(devClientScheme, metroPort, physical);
+		const opened = openAndroidDevClientUrl({
+			serial,
+			url
+		}, { exec: e });
+		if (opened.ok) return {
+			ok: true,
+			mode: "deep-link",
+			devClientUrl: url,
+			...wiring
+		};
+		devClientNote = `${opened.reason}; fell back to the launcher activity`;
+	}
+	const component = resolveLaunchActivity(serial, packageName, { exec: e });
+	if (component) try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"am",
+			"start",
+			"-n",
+			component
+		], ADB_SHELL_OPTIONS);
+		return {
+			ok: true,
+			mode: "am-start",
+			component,
+			devClientNote,
+			...wiring
+		};
+	} catch (err) {
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `am start -n ${component} failed on ${serial}: ${describe(err)}`
+		};
+	}
+	try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"monkey",
+			"-p",
+			packageName,
+			"1"
+		], ADB_SHELL_OPTIONS);
+		return {
+			ok: true,
+			mode: "monkey",
+			devClientNote,
+			...wiring
+		};
+	} catch (err) {
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `Could not launch ${packageName} on ${serial}: no launcher activity resolved and monkey failed: ${describe(err)}`
+		};
+	}
+}
+function launchAndroidReleaseApp({ serial, packageName }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const component = resolveLaunchActivity(serial, packageName, { exec: e });
+	if (component) try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"am",
+			"start",
+			"-n",
+			component
+		], ADB_SHELL_OPTIONS);
+		return {
+			ok: true,
+			mode: "am-start",
+			component
+		};
+	} catch (err) {
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `am start -n ${component} failed on ${serial}: ${describe(err)}`
+		};
+	}
+	try {
+		e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"monkey",
+			"-p",
+			packageName,
+			"1"
+		], ADB_SHELL_OPTIONS);
+		return {
+			ok: true,
+			mode: "monkey"
+		};
+	} catch (err) {
+		return {
+			failed: true,
+			code: LAUNCH_ERROR,
+			reason: `Could not launch ${packageName} on ${serial}: no launcher activity resolved and monkey failed: ${describe(err)}`
+		};
+	}
+}
+function describe(err) {
+	const e = err;
+	const stderr = e?.stderr ? String(e.stderr).trim() : "";
+	const message = e?.message ? String(e.message).trim() : String(err);
+	return stderr ? `${message}: ${stderr}` : message;
+}
+function parsePidof(text) {
+	const first = String(text ?? "").trim().split(/\s+/)[0];
+	const pid = Number(first);
+	return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+function parsePsPid(text, packageName) {
+	for (const raw of String(text ?? "").split("\n")) {
+		const cols = raw.trim().split(/\s+/);
+		if (cols.length < 2) continue;
+		if (cols[cols.length - 1] !== packageName) continue;
+		const pid = Number(cols[1]);
+		if (Number.isFinite(pid) && pid > 0) return pid;
+	}
+	return null;
+}
+function androidAppProcess(serial, packageName, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	try {
+		const pid = parsePidof(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"pidof",
+			packageName
+		], ADB_SHELL_OPTIONS));
+		if (pid !== null) return pid;
+	} catch {}
+	try {
+		return parsePsPid(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"ps",
+			"-A"
+		], ADB_SHELL_OPTIONS), packageName);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { launchAndroidReleaseApp as _, LAUNCH_ERROR as a, clearOtherUserApps as c, deviceShellArg as d, installAndroidApp as f, launchAndroidApp as g, iosAppProcess as h, INSTALL_ERROR as i, devClientDeepLink as l, installIosApp as m, ANDROID_DISABLE_AUTO_LAUNCH_EXTRA as n, androidAppProcess as o, installConflictKind as p, DEFAULT_METRO_PORT as r, androidDevClientUrl as s, ADB_INSTALL_TIMEOUT_MS as t, devClientUrl as u, launchIosApp as v };