stim 1.0.0 → 1.2.0

package/dist/ios-D1h1Di39.mjs

@@ -0,0 +1,451 @@
+import { t as getExecutor } from "./exec-CyylIdq9.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/host-memory.ts
+function readHostMemoryPressure(exec = getExecutor(), platform = process.platform) {
+	if (platform !== "darwin") return null;
+	try {
+		switch (exec.runFile("/usr/sbin/sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], { timeoutMs: 2e3 }).trim()) {
+			case "1": return "normal";
+			case "2": return "warning";
+			case "4": return "critical";
+			default: return null;
+		}
+	} catch {
+		return null;
+	}
+}
+function hostMemoryPressureAdvice(pressure) {
+	if (pressure === null || pressure === "normal") return null;
+	return `macOS reports ${pressure} host memory pressure. Simulator processes can stall even when the device is Booted. Free memory before retrying: use \`stim stop\` only in workspaces you own, and ask before closing other apps or devices. For parallel iOS work, consider a reviewed SimSlim profile (\`stim guide lifecycle simslim\`). This observation does not establish an OOM crash.`;
+}
+//#endregion
+//#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 = 3e4, includeUnavailable = false } = {}) {
+	return parseSimctlList(getExecutor().runFile("xcrun", [
+		"simctl",
+		"list",
+		"devices",
+		"--json"
+	], {
+		timeoutMs,
+		killSignal: "SIGKILL"
+	}), { 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 iosSimulatorFailureAdvice(exec = getExecutor()) {
+	return hostMemoryPressureAdvice(readHostMemoryPressure(exec)) ?? "The simulator may be unresponsive. Check Activity Monitor for memory pressure and free host memory before retrying.";
+}
+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 exited = new Promise((resolve) => child.once("exit", () => resolve()));
+	const result = await Promise.race([waitForChild(child), attempt]);
+	clearTimeout(timer);
+	reader.flush();
+	if (result === "timeout") {
+		try {
+			child.kill("SIGKILL");
+		} catch {}
+		const stopped = await Promise.race([exited.then(() => true), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(false), 1e4);
+		})]);
+		clearTimeout(timer);
+		if (!stopped) {
+			child.stdout?.destroy?.();
+			child.stderr?.destroy?.();
+			child.unref();
+			throw new Error(`Timed out waiting for simctl bootstatus ${udid}; its process could not be confirmed stopped. Inspect pid ${child.pid ?? "unknown"} before retrying.`);
+		}
+		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();
+	const deadline = Date.now() + timeoutMs;
+	try {
+		exec.runFile("xcrun", [
+			"simctl",
+			"boot",
+			udid
+		], {
+			timeoutMs,
+			killSignal: "SIGKILL"
+		});
+	} catch (e) {
+		if (!String(e?.message || e).includes("Booted")) throw e;
+	}
+	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.runFileQuiet("open", ["-a", "Simulator"], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	});
+}
+function shutdownIosSim(udid) {
+	getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`);
+}
+function listIosDeviceTypes() {
+	const out = getExecutor().runFile("xcrun", [
+		"simctl",
+		"list",
+		"devicetypes",
+		"--json"
+	], {
+		timeoutMs: 3e4,
+		killSignal: "SIGKILL"
+	});
+	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().runFile("xcrun", [
+		"simctl",
+		"list",
+		"runtimes",
+		"--json"
+	], {
+		timeoutMs: 3e4,
+		killSignal: "SIGKILL"
+	});
+	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 { shutdownIosSim as C, readHostMemoryPressure as E, sanitizeDeviceLabel as S, hostMemoryPressureAdvice as T, renameIosSim as _, deleteIosSim as a, resolveIosCreation as b, iosRuntimeMatches as c, listIosDeviceTypes as d, listIosRuntimes as f, parseRuntimeVersion as g, parkedSimName as h, createOwnedIosSim as i, iosSimulatorFailureAdvice as l, ownedSimName as m, bootIosSim as n, deleteParkedIosSim as o, listUserApps as p, clearAppDataContainer as r, findAppDataContainer as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSims as u, resetIosKeychain as v, uninstallIosApp as w, resolveOwnedIosSim as x, resetIosPrivacy as y };

package/dist/ios-device-D3pzTKQE.mjs

@@ -0,0 +1,81 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+//#region src/collector/ios-device.ts
+const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
+const DEV_MENU_LAUNCH_ARGS = [
+	"-EXDevMenuShowsAtLaunch",
+	"0",
+	"-EXDevMenuShowFloatingActionButton",
+	"0"
+];
+const FATAL_MARKERS = [
+	/^\*\*\* Terminating app due to uncaught exception/,
+	/^libc\+\+abi: terminating/,
+	/^\*\*\* Assertion failure in/,
+	/^(?:\S+:\d+: )?Fatal error: /
+];
+const MIRROR_LINE = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+[+-]\d{4}) (.+?)\[(\d+):(\d+)\] ?(?:\[([^\]\s]+)\] )?([\s\S]*)$/;
+function deviceConsoleLevel(message) {
+	const text = typeof message === "string" ? message : "";
+	return FATAL_MARKERS.some((marker) => marker.test(text)) ? "fatal" : "info";
+}
+function parseDeviceConsoleLine(line, { now = Date.now } = {}) {
+	if (typeof line !== "string") return null;
+	const text = line.replace(/\r$/, "").trimEnd();
+	if (!text.trim()) return null;
+	const match = MIRROR_LINE.exec(text);
+	const record = {
+		ts: now(),
+		src: "device",
+		level: "info",
+		msg: text,
+		raw: true
+	};
+	if (!match) {
+		record.level = text.startsWith("ERROR: ") ? "error" : deviceConsoleLevel(text);
+		return record;
+	}
+	const [, timestamp, proc, pid, , category, message] = match;
+	if (message === void 0 || !message.trim()) return null;
+	const parsed = Date.parse(timestamp);
+	if (Number.isFinite(parsed)) record.ts = parsed;
+	record.msg = message;
+	record.level = deviceConsoleLevel(message);
+	record.proc = `${proc}(${pid})`;
+	if (category) record.category = category;
+	return record;
+}
+function deviceConsoleArgs({ udid, bundleId, payloadUrl = null }) {
+	const args = [
+		"devicectl",
+		"device",
+		"process",
+		"launch",
+		"--quiet",
+		"--device",
+		udid,
+		"--console",
+		"--terminate-existing",
+		"--environment-variables",
+		JSON.stringify(CONSOLE_ENV)
+	];
+	if (payloadUrl) args.push("--payload-url", payloadUrl);
+	args.push(bundleId);
+	if (payloadUrl) args.push("--", ...DEV_MENU_LAUNCH_ARGS);
+	return args;
+}
+function startIosDeviceConsole({ udid, bundleId, payloadUrl = null, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("xcrun", deviceConsoleArgs({
+		udid,
+		bundleId,
+		payloadUrl
+	}), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+//#endregion
+export { startIosDeviceConsole as i, deviceConsoleLevel as n, parseDeviceConsoleLine as r, DEV_MENU_LAUNCH_ARGS as t };