stim 1.0.0 → 1.1.0

package/dist/ios-BZxKPuqP.mjs

@@ -0,0 +1,382 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/sim/ios.ts
+function parseSimctlList(jsonOutput, { includeUnavailable = false } = {}) {
+	const parsed = JSON.parse(jsonOutput);
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Expected simctl list to return a JSON object with a devices object.");
+	const data = parsed;
+	if (data.devices === null || typeof data.devices !== "object" || Array.isArray(data.devices)) throw new Error("Expected simctl list to return a JSON object with a devices object.");
+	const sims = [];
+	for (const [runtime, devices] of Object.entries(data.devices)) {
+		if (!Array.isArray(devices)) throw new Error(`Expected simctl devices for ${runtime} to be an array.`);
+		if (!/\.iOS-/.test(runtime)) continue;
+		for (const dev of devices) {
+			if (dev === null || typeof dev !== "object" || Array.isArray(dev)) throw new Error(`Expected every simctl device for ${runtime} to be an object.`);
+			const record = dev;
+			for (const field of [
+				"udid",
+				"name",
+				"state",
+				"deviceTypeIdentifier"
+			]) if (typeof record[field] !== "string" || record[field].length === 0) throw new Error(`Expected simctl device field ${field} for ${runtime} to be a non-empty string.`);
+			if (typeof record.isAvailable !== "boolean") throw new Error(`Expected simctl device field isAvailable for ${runtime} to be a boolean.`);
+			if (record.dataPath !== void 0 && typeof record.dataPath !== "string") throw new Error(`Expected simctl device field dataPath for ${runtime} to be a string.`);
+			if (record.dataPathSize !== void 0 && (typeof record.dataPathSize !== "number" || !Number.isFinite(record.dataPathSize))) throw new Error(`Expected simctl device field dataPathSize for ${runtime} to be a finite number.`);
+			const typed = record;
+			const available = Boolean(typed.isAvailable);
+			if (!available && !includeUnavailable) continue;
+			sims.push({
+				udid: typed.udid,
+				name: typed.name,
+				state: typed.state,
+				runtime,
+				deviceTypeIdentifier: typed.deviceTypeIdentifier,
+				available,
+				...typed.dataPath !== void 0 ? { dataPath: typed.dataPath } : {},
+				...typed.dataPathSize !== void 0 ? { dataPathSize: typed.dataPathSize } : {}
+			});
+		}
+	}
+	return sims;
+}
+function listAllIosSims({ timeoutMs, includeUnavailable = false } = {}) {
+	return parseSimctlList(getExecutor().run("xcrun simctl list devices --json", { timeoutMs }), { includeUnavailable });
+}
+function parseRuntimeVersion(runtimeId) {
+	const m = runtimeId.match(/iOS-(\d+)(?:-(\d+))?$/);
+	if (!m) return runtimeId;
+	const major = m[1];
+	if (major === void 0) return runtimeId;
+	const minor = m[2];
+	return minor ? `${major}.${minor}` : major;
+}
+const IOS_BOOT_TIMEOUT_MS = 6e5;
+const BOOTSTATUS_ATTEMPT_MS = 24e4;
+const BOOTSTATUS_ATTEMPT_FLOOR_MS = 1e3;
+const BOOT_STATE_LIST_TIMEOUT_MS = 3e4;
+function bootstatusTimeout(udid) {
+	const e = /* @__PURE__ */ new Error(`xcrun simctl bootstatus ${udid} -b timed out`);
+	e.code = "ETIMEDOUT";
+	return e;
+}
+async function awaitBootstatus(udid, attemptMs) {
+	const lines = [];
+	const reader = createLineReader((raw) => {
+		const line = stripAnsi(raw).trim();
+		if (!line) return;
+		lines.push(line);
+		if (lines.length > 10) lines.shift();
+	});
+	const child = getExecutor().spawn("xcrun", [
+		"simctl",
+		"bootstatus",
+		udid,
+		"-b"
+	], { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	child.stdout?.on("data", (chunk) => reader.push(chunk));
+	child.stderr?.on("data", (chunk) => reader.push(chunk));
+	let timer;
+	const attempt = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("timeout"), attemptMs);
+	});
+	const result = await Promise.race([waitForChild(child), attempt]);
+	clearTimeout(timer);
+	reader.flush();
+	if (result === "timeout") {
+		child.kill("SIGKILL");
+		throw bootstatusTimeout(udid);
+	}
+	if (result.error) throw result.error;
+	if (result.code === 0) return;
+	const detail = lines.length ? `: ${lines.join(" | ")}` : "";
+	throw new Error(`xcrun simctl bootstatus ${udid} -b failed with exit code ${result.code ?? "unknown"}${detail}`);
+}
+async function bootIosSim(udid, { timeoutMs = IOS_BOOT_TIMEOUT_MS, attemptMs = BOOTSTATUS_ATTEMPT_MS } = {}) {
+	const exec = getExecutor();
+	try {
+		exec.run(`xcrun simctl boot ${udid}`);
+	} catch (e) {
+		if (!String(e?.message || e).includes("Booted")) throw e;
+	}
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const remaining = deadline - Date.now();
+		if (remaining > 0) try {
+			await awaitBootstatus(udid, Math.min(Math.max(remaining, BOOTSTATUS_ATTEMPT_FLOOR_MS), attemptMs));
+			break;
+		} catch (e) {
+			if (e?.code !== "ETIMEDOUT") throw e;
+		}
+		let state;
+		try {
+			state = listAllIosSims({ timeoutMs: BOOT_STATE_LIST_TIMEOUT_MS }).find((s) => s.udid === udid)?.state ?? null;
+		} catch {
+			state = void 0;
+		}
+		if (state === "Booted") break;
+		const waited = Math.round((timeoutMs - Math.max(0, deadline - Date.now())) / 1e3);
+		if (state !== "Booting" && state !== void 0) throw new Error(`Simulator ${udid} reports "${state ?? "missing"}" after ${waited}s of boot wait.`);
+		if (deadline - Date.now() <= 0) throw new Error(`Simulator ${udid} did not finish booting within ${Math.round(timeoutMs / 1e3)}s.`);
+	}
+	exec.runQuiet("open -a Simulator");
+}
+function shutdownIosSim(udid) {
+	getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`);
+}
+function listIosDeviceTypes() {
+	const out = getExecutor().run("xcrun simctl list devicetypes --json");
+	return (JSON.parse(out).devicetypes || []).map((dt) => ({
+		identifier: dt.identifier,
+		name: dt.name
+	}));
+}
+function rankIphone(name) {
+	const gen = /^iPhone\s+(\d+)/i.exec(name);
+	return {
+		gen: gen ? Number(gen[1]) : -1,
+		variant: -name.length
+	};
+}
+function iosRuntimeMatches(runtime, requested) {
+	return runtime.version === requested || runtime.name === requested;
+}
+function pickDefaultIosCreation(_deviceTypes, runtimes, { deviceType, runtime } = {}) {
+	const rts = runtimes.toSorted((a, b) => String(b.version).localeCompare(String(a.version), void 0, { numeric: true }));
+	const wantedRts = runtime ? rts.filter((r) => iosRuntimeMatches(r, runtime)) : rts;
+	for (const rt of wantedRts) {
+		const supported = (rt.supportedDeviceTypes || []).filter((d) => deviceType ? d.name === deviceType : /^iPhone/i.test(d.name));
+		if (supported.length === 0) continue;
+		const best = supported.toSorted((a, b) => {
+			const ra = rankIphone(a.name), rb = rankIphone(b.name);
+			return rb.gen - ra.gen || rb.variant - ra.variant || b.name.localeCompare(a.name, void 0, { numeric: true });
+		})[0];
+		if (best === void 0) continue;
+		return {
+			deviceTypeId: best.identifier,
+			runtimeId: rt.identifier
+		};
+	}
+	return null;
+}
+function sanitizeDeviceLabel(label) {
+	return String(label).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+const SIM_NAME_MAX = 60;
+const PARKED_SIM_LABEL = "parked";
+function fitSimName(label, { model, runtime }, suffix = "", preserveLabel = false) {
+	const version = runtime ?? "";
+	const modelName = model ?? "";
+	if (!version && !modelName) return `stim-${label}${suffix}`;
+	let over = `stim-`.length + 2 + 1 + 1 + version.length + suffix.length + label.length + modelName.length - SIM_NAME_MAX;
+	let shortLabel = label;
+	if (over > 0 && !preserveLabel) {
+		const cut = Math.min(over, label.length);
+		shortLabel = label.slice(0, label.length - cut).replace(/[._-]+$/g, "");
+		over -= cut;
+	}
+	const shortModel = over > 0 ? modelName.slice(0, Math.max(0, modelName.length - over)) : modelName;
+	return `stim-${shortLabel} (${shortModel} ${version})${suffix}`;
+}
+function ownedSimName(label, model = {
+	model: null,
+	runtime: null
+}, suffix = "") {
+	const clean = sanitizeDeviceLabel(label);
+	return fitSimName(clean.startsWith("stim-") ? clean.slice(5) : clean, model, suffix);
+}
+function parkedSimName(udid, model) {
+	return fitSimName(PARKED_SIM_LABEL, model, ` ${udid.replace(/-/g, "").slice(0, 4).toLowerCase()}`, true);
+}
+function resolveIosCreation({ deviceType, runtime } = {}) {
+	const deviceTypes = listIosDeviceTypes();
+	const runtimes = listIosRuntimes();
+	const pick = pickDefaultIosCreation(deviceTypes, runtimes, {
+		deviceType,
+		runtime
+	});
+	if (!pick) throw new Error("No matching simulator device type / runtime is installed. Install one via Xcode, or pass --device-type / --runtime.");
+	return {
+		deviceTypeId: pick.deviceTypeId,
+		runtimeId: pick.runtimeId,
+		deviceType: deviceTypes.find((d) => d.identifier === pick.deviceTypeId)?.name ?? null,
+		runtime: runtimes.find((r) => r.identifier === pick.runtimeId)?.version ?? null
+	};
+}
+function createOwnedIosSim(label, { deviceType, runtime, suffix = "" } = {}, choice = resolveIosCreation({
+	deviceType,
+	runtime
+})) {
+	const name = ownedSimName(label, {
+		model: choice.deviceType,
+		runtime: choice.runtime
+	}, suffix);
+	return {
+		udid: getExecutor().run(`xcrun simctl create "${name}" "${choice.deviceTypeId}" "${choice.runtimeId}"`).trim(),
+		name,
+		deviceType: choice.deviceType,
+		runtime: choice.runtime
+	};
+}
+function renameIosSim(udid, name) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"rename",
+		udid,
+		name
+	]);
+}
+function resetIosPrivacy(udid) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"privacy",
+		udid,
+		"reset",
+		"all"
+	]);
+}
+function resetIosKeychain(udid) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"keychain",
+		udid,
+		"reset"
+	]);
+}
+function uninstallIosApp(udid, bundleId) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"uninstall",
+		udid,
+		bundleId
+	]);
+}
+function parseUserApps(jsonOutput) {
+	const data = JSON.parse(jsonOutput);
+	if (data === null || typeof data !== "object" || Array.isArray(data)) throw new Error("Expected simctl listapps to convert to a JSON object.");
+	const userApps = [];
+	for (const [bundleId, app] of Object.entries(data)) {
+		if (app === null || typeof app !== "object" || Array.isArray(app)) throw new Error(`Expected simctl listapps entry ${JSON.stringify(bundleId)} to be an object.`);
+		const applicationType = app.ApplicationType;
+		if (applicationType !== "User" && applicationType !== "System") throw new Error(`Expected simctl listapps entry ${JSON.stringify(bundleId)} to name a known ApplicationType.`);
+		if (applicationType === "User") userApps.push(bundleId);
+	}
+	return userApps;
+}
+const LISTAPPS_TIMEOUT_MS = 6e4;
+function listUserApps(udid) {
+	const exec = getExecutor();
+	const dir = mkdtempSync(join(tmpdir(), "stim-listapps-"));
+	const plist = join(dir, "apps.plist");
+	try {
+		writeFileSync(plist, exec.runFile("xcrun", [
+			"simctl",
+			"listapps",
+			udid
+		], { timeoutMs: LISTAPPS_TIMEOUT_MS }));
+		return parseUserApps(exec.runFile("plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			plist
+		]));
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const CONTAINER_METADATA = ".com.apple.mobile_container_manager.metadata.plist";
+const CLEARED_CONTAINER_DIRS = [
+	"Documents",
+	"Library",
+	"tmp",
+	"SystemData"
+];
+const PLUTIL_TIMEOUT_MS = 1e4;
+function findAppDataContainer(dataPath, bundleId) {
+	const root = join(dataPath, "Containers", "Data", "Application");
+	let entries;
+	try {
+		entries = readdirSync(root);
+	} catch (error) {
+		if (error?.code === "ENOENT") return null;
+		throw error;
+	}
+	const exec = getExecutor();
+	for (const entry of entries) {
+		const dir = join(root, entry);
+		if (exec.runFile("plutil", [
+			"-extract",
+			"MCMMetadataIdentifier",
+			"raw",
+			join(dir, CONTAINER_METADATA)
+		], { timeoutMs: PLUTIL_TIMEOUT_MS }).trim() === bundleId) return dir;
+	}
+	return null;
+}
+function clearAppDataContainer(container) {
+	for (const name of CLEARED_CONTAINER_DIRS) {
+		const dir = join(container, name);
+		let children;
+		try {
+			if (!statSync(dir).isDirectory()) throw new Error(`Expected app data path ${dir} to be a directory.`);
+			children = readdirSync(dir);
+		} catch (error) {
+			if (error?.code === "ENOENT") continue;
+			throw error;
+		}
+		for (const child of children) rmSync(join(dir, child), {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function resolveOwnedIosSim(udid) {
+	const sim = listAllIosSims().find((s) => s.udid === udid);
+	if (!sim) return { missing: true };
+	if (!sim.name?.startsWith("stim-")) return { notOwned: sim.name };
+	return { sim };
+}
+function deleteIosSim(udid) {
+	const result = resolveOwnedIosSim(udid);
+	if (result.missing) return;
+	if (result.notOwned) throw new Error(`Refusing to delete simulator "${result.notOwned}" (${udid}): not a Stim-owned sim (name must start with "stim-").`);
+	getExecutor().run(`xcrun simctl delete ${udid}`);
+}
+const PARKED_DELETE_TIMEOUT_MS = 3e4;
+function deleteParkedIosSim(udid) {
+	const sim = listAllIosSims({
+		includeUnavailable: true,
+		timeoutMs: PARKED_DELETE_TIMEOUT_MS
+	}).find((entry) => entry.udid === udid);
+	if (!sim) return;
+	if (!sim.name.startsWith("stim-")) throw new Error(`Simulator ${udid} is now named "${sim.name}" and is not Stim-owned; refusing to delete it.`);
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"delete",
+		udid
+	], { timeoutMs: PARKED_DELETE_TIMEOUT_MS });
+}
+function listIosRuntimes() {
+	const out = getExecutor().run("xcrun simctl list runtimes --json");
+	return (JSON.parse(out).runtimes || []).filter((r) => r.isAvailable && r.platform === "iOS").map((r) => ({
+		identifier: r.identifier,
+		name: r.name,
+		version: r.version,
+		supportedDeviceTypes: (r.supportedDeviceTypes || []).map((d) => ({
+			identifier: d.identifier,
+			name: d.name
+		}))
+	}));
+}
+//#endregion
+export { uninstallIosApp as C, shutdownIosSim as S, resetIosKeychain as _, deleteIosSim as a, resolveOwnedIosSim as b, iosRuntimeMatches as c, listIosRuntimes as d, listUserApps as f, renameIosSim as g, parseRuntimeVersion as h, createOwnedIosSim as i, listAllIosSims as l, parkedSimName as m, bootIosSim as n, deleteParkedIosSim as o, ownedSimName as p, clearAppDataContainer as r, findAppDataContainer as s, IOS_BOOT_TIMEOUT_MS as t, listIosDeviceTypes as u, resetIosPrivacy as v, sanitizeDeviceLabel as x, resolveIosCreation as y };