stim 1.17.2 → 1.19.0

package/dist/device-ios-C2Um-XUR.mjs

@@ -1,412 +0,0 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { C as saveConfig, D as withConfigLock, H as projectDeviceSlots, _ as loadConfig, a as clearDevice, d as getConfigDir, w as setDevice, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
-import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
-import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { v as iosSimSlimProfileSetting } from "./settings-Cfd-0r2d.mjs";
-import { y as workspaceId } from "./workspace-state-DqcCbpE7.mjs";
-import { ct as dropParked, ft as parkedMaxSetting, ht as selectParked, pt as readParked, st as adoptParked } from "./android-B_YNZy61.mjs";
-import { A as hostMemoryPressureAdvice, C as resolveIosCreation, O as configuredIosSimulatorViewer, S as resetIosPrivacy, _ as parseRuntimeVersion, b as renameIosSim, f as listIosDeviceTypes, h as ownedSimName, i as createOwnedIosSim, j as readHostMemoryPressure, l as iosSimulatorFailureAdvice, n as bootIosSim, p as listIosRuntimes, u as listAllIosSims, w as resolveOwnedIosSim, x as resetIosKeychain } from "./ios-DSfnPfse.mjs";
-import { v as teardownParkedIosSim } from "./ownership-BMLqyBgJ.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-import { a as deviceTypeMismatch, c as runtimeMismatch, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission } from "./device-capacity-ZC4XSZ4R.mjs";
-import chalk from "chalk";
-//#region src/engine/device-ios.ts
-function startIosBoot(udid, configure, label, out, simulatorApp, root, deviceSlotWait) {
-	const done = withDeviceBootAdmission({
-		platform: "ios",
-		key: udid
-	}, async () => {
-		out(chalk.dim(phaseLine("device", `booting ${label} (${udid})`)));
-		await bootIosSim(udid, {
-			label,
-			out,
-			simulatorApp
-		});
-		await configure();
-	}, {
-		...deviceSlotWait,
-		root,
-		out
-	});
-	done.catch(() => {});
-	return {
-		udid,
-		done
-	};
-}
-var IosDeviceMismatchError = class extends Error {
-	remedy = "Run `stim worktree remove` (or `stim gc --delete`) to reap the current sim, then `stim ios` again to create the requested one, or pass `--slot <name>` to create it beside the current one.";
-};
-async function ensureOwnedIosDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, reconcileIosSimulator }) {
-	const memoryAdvice = hostMemoryPressureAdvice(readHostMemoryPressure());
-	if (memoryAdvice) out(chalk.yellow(phaseLine("memory", memoryAdvice)));
-	const simslimProfile = iosSimSlimProfileSetting(settings, settingsRoot);
-	if (record?.deviceUdid) {
-		if (record.owned) {
-			const listed = listAllIosSims({ includeUnavailable: true });
-			const resolved = resolveOwnedIosSim(record.deviceUdid, listed);
-			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned -- creating a fresh owned sim instead of booting it.`));
-			else if (resolved.missing) {} else {
-				const sim = resolved.sim;
-				const wantedType = flags.deviceType || settings?.ios?.deviceType;
-				const deviceTypes = listIosDeviceTypes();
-				const mismatch = deviceTypeMismatch(sim.deviceTypeIdentifier, wantedType, deviceTypes);
-				if (mismatch) throw new IosDeviceMismatchError(`${mismatch}. Stim will not silently boot a different model.`);
-				const versionMismatch = flags.runtimeFlag ? runtimeMismatch(sim.runtime, flags.runtimeFlag, listIosRuntimes()) : null;
-				if (versionMismatch) throw new IosDeviceMismatchError(`${versionMismatch}. Stim will not silently boot a different iOS version.`);
-				const model = {
-					model: deviceTypes.find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null,
-					runtime: parseRuntimeVersion(sim.runtime)
-				};
-				const name = ownedIosName(sim, label, model, projectPath, listed) === sim.name ? sim.name : await withIosDeviceNameLock(() => renameToOwnedName(sim, label, model, projectPath));
-				const updated = {
-					deviceUdid: sim.udid,
-					owned: true,
-					deviceName: name,
-					...record.simslimManaged ? { simslimManaged: true } : {},
-					...record.adopted ? { adopted: true } : {},
-					...record.adoptionPending ? { adoptionPending: true } : {},
-					...record.parkedCacheKey ? { parkedCacheKey: record.parkedCacheKey } : {},
-					...record.schemeApprovals ? { schemeApprovals: record.schemeApprovals } : {}
-				};
-				const configure = async () => {
-					if (record.adoptionPending) resetAdoptedSim(sim.udid, out);
-					return configureOwnedIosSim({
-						record: updated,
-						projectPath,
-						slot,
-						profile: simslimProfile,
-						out,
-						reconcileIosSimulator
-					});
-				};
-				const facts = {
-					deviceType: model.model,
-					runtime: model.runtime
-				};
-				if (sim.state !== "Booted") return {
-					...updated,
-					booting: startIosBoot(sim.udid, configure, name, out, flags.simulatorApp, projectPath, flags.deviceSlotWait),
-					...facts
-				};
-				return {
-					...await configure(),
-					...facts,
-					booted: sim.udid
-				};
-			}
-		} else {
-			const sim = listAllIosSims().find((s) => s.udid === record.deviceUdid);
-			if (sim) {
-				if (sim.state !== "Booted") {
-					note(chalk.yellow(`Note: assigned sim ${sim.name} (${sim.udid}) is shut down and is not owned by Stim, so it will not be booted automatically.`));
-					note(chalk.dim("Boot it yourself, or run `stim gc --delete` to clear the assignment so Stim can create an owned sim."));
-				}
-				return record;
-			}
-		}
-		withConfigLock(() => {
-			const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.ios;
-			if (!current) return;
-			if (current.deviceUdid !== record.deviceUdid || current.owned !== record.owned) throw new Error("The simulator assignment changed during recovery. Run `stim ios` again.");
-			clearDevice(projectPath, "ios", slot);
-		});
-	}
-	const choice = resolveIosCreation({
-		deviceType: flags.deviceType || settings.ios?.deviceType,
-		runtime: flags.runtime || settings.ios?.runtime
-	});
-	const adopted = parkedMaxSetting("ios").max > 0 ? await withIosDeviceNameLock(() => takeParkedIosSim({
-		projectPath,
-		slot,
-		label,
-		choice,
-		out
-	})) : null;
-	if (adopted) {
-		const booting = startIosBoot(adopted.deviceUdid, async () => {
-			resetAdoptedSim(adopted.deviceUdid, out);
-			await configureOwnedIosSim({
-				record: adopted,
-				projectPath,
-				slot,
-				profile: simslimProfile,
-				out,
-				reconcileIosSimulator
-			});
-		}, adopted.deviceName, out, flags.simulatorApp, projectPath, flags.deviceSlotWait);
-		return {
-			...adopted,
-			booting,
-			deviceType: choice.deviceType,
-			runtime: choice.runtime
-		};
-	}
-	const created = await withIosDeviceNameLock(() => {
-		const suffix = ownedIosNameSuffix(label, {
-			model: choice.deviceType,
-			runtime: choice.runtime
-		}, projectPath);
-		const result = createOwnedIosSim(label, { suffix }, choice);
-		setDevice(projectPath, "ios", {
-			deviceUdid: result.udid,
-			owned: true,
-			deviceName: result.name
-		}, slot);
-		return result;
-	});
-	const newRecord = {
-		deviceUdid: created.udid,
-		owned: true,
-		deviceName: created.name
-	};
-	const booting = startIosBoot(created.udid, () => configureOwnedIosSim({
-		record: newRecord,
-		projectPath,
-		slot,
-		profile: simslimProfile,
-		out,
-		reconcileIosSimulator
-	}), created.name, out, flags.simulatorApp, projectPath, flags.deviceSlotWait);
-	return {
-		...newRecord,
-		created: true,
-		booting,
-		deviceType: created.deviceType,
-		runtime: created.runtime
-	};
-}
-function withIosDeviceNameLock(fn) {
-	return withWorkspaceProcessLock(getConfigDir(), "ios-device-names", async () => fn(), { external: true });
-}
-function ownedIosNameSuffix(label, model, projectPath, udid, listed = listAllIosSims({ includeUnavailable: true })) {
-	const names = new Set(listed.filter((sim) => sim.udid !== udid).map((sim) => sim.name));
-	for (const project of Object.values(loadConfig()?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
-		const record = platforms.ios;
-		if (record?.deviceUdid !== udid && record?.deviceName) names.add(record.deviceName);
-	}
-	for (const parked of readParked("ios")) if (parked.udid !== udid) names.add(parked.name);
-	let suffix = "";
-	for (let attempt = 0; names.has(ownedSimName(label, model, suffix)); attempt++) suffix = ` ${workspaceId(projectPath)}${attempt ? `-${attempt}` : ""}`;
-	return suffix;
-}
-function ownedIosName(sim, label, model, projectPath, listed) {
-	return ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, sim.udid, listed));
-}
-function renameToOwnedName(sim, label, model, projectPath) {
-	const wanted = ownedIosName(sim, label, model, projectPath);
-	if (sim.name === wanted) return wanted;
-	try {
-		renameIosSim(sim.udid, wanted);
-		return wanted;
-	} catch {
-		return sim.name;
-	}
-}
-function resetAdoptedSim(udid, out) {
-	out(chalk.dim(phaseLine("device", `resetting privacy grants and the keychain on ${udid}`)));
-	resetIosPrivacy(udid);
-	resetIosKeychain(udid);
-}
-function takeParkedIosSim({ projectPath, slot, label, choice, out }) {
-	const candidates = selectParked(readParked("ios"), {
-		deviceTypeIdentifier: choice.deviceTypeId,
-		runtimeIdentifier: choice.runtimeId
-	});
-	if (candidates.length === 0) return null;
-	const listed = new Map(listAllIosSims({ includeUnavailable: true }).map((sim) => [sim.udid, sim]));
-	for (const parked of candidates) {
-		const sim = listed.get(parked.udid);
-		if (!sim || !sim.available) {
-			const result = sim ? teardownParkedIosSim(parked.udid, { label: parked.name }) : null;
-			if (sim ? result?.status === "torn-down" : dropParked("ios", parked.udid)) out(chalk.dim(phaseLine("device", `deleted parked ${parked.name} (${parked.udid}): ${sim ? "unavailable" : "gone"}`)));
-			else if (result?.status === "failed") out(chalk.yellow(phaseLine("device", `could not delete unavailable parked ${parked.name} (${parked.udid}): ${result.reason}`)));
-			continue;
-		}
-		if (!sim.name.startsWith("stim-")) {
-			out(chalk.yellow(phaseLine("device", `kept parked record for ${parked.udid}: simulator is now named ${JSON.stringify(sim.name)} and is not Stim-owned`)));
-			continue;
-		}
-		const model = {
-			model: choice.deviceType,
-			runtime: choice.runtime
-		};
-		const name = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, parked.udid));
-		const device = {
-			deviceUdid: parked.udid,
-			owned: true,
-			deviceName: name,
-			adopted: true,
-			adoptionPending: true,
-			...parked.simslimManaged ? { simslimManaged: true } : {},
-			...parked.cacheKey ? { parkedCacheKey: parked.cacheKey } : {}
-		};
-		const adopted = adoptParked({
-			platform: "ios",
-			projectPath,
-			slot,
-			udid: parked.udid,
-			device
-		});
-		if (!adopted) continue;
-		try {
-			renameIosSim(parked.udid, name);
-		} catch {}
-		return adopted.schemeApprovals && adopted.schemeApprovals.length > 0 ? {
-			...device,
-			schemeApprovals: adopted.schemeApprovals
-		} : device;
-	}
-	return null;
-}
-function clearIosAdoptionPending(projectPath, slot = "default") {
-	withConfigLock(() => {
-		const cfg = loadConfig();
-		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
-		if (!cfg || !ios?.adoptionPending) return;
-		delete ios.adopted;
-		delete ios.adoptionPending;
-		delete ios.parkedCacheKey;
-		saveConfig(cfg);
-	});
-}
-async function configureOwnedIosSim({ record, projectPath, slot, profile, out, reconcileIosSimulator }) {
-	if (profile) out(chalk.dim(phaseLine("device", `applying the SimSlim profile to ${record.deviceUdid}`)));
-	else if (record.simslimManaged) out(chalk.dim(phaseLine("device", `restoring stock simulator services on ${record.deviceUdid}`)));
-	const previouslyManaged = Boolean(record.simslimManaged);
-	if (profile && !record.simslimManaged) {
-		const pending = {
-			...record,
-			simslimManaged: true
-		};
-		setDevice(projectPath, "ios", pending, slot);
-		record = pending;
-	}
-	const result = await reconcileIosSimulator({
-		udid: record.deviceUdid,
-		profile,
-		previouslyManaged,
-		out
-	});
-	const updated = { ...record };
-	if (result.managed) updated.simslimManaged = true;
-	else delete updated.simslimManaged;
-	setDevice(projectPath, "ios", updated, slot);
-	return updated;
-}
-async function ensureIosBooted({ device, projectPath, deviceSlotWait, simulatorApp, timeoutMs, pollMs, out }) {
-	const udid = device?.deviceUdid;
-	if (!udid) return {
-		failed: true,
-		reason: "No iOS simulator is recorded for this project."
-	};
-	const ready = () => {
-		try {
-			getExecutor().runFile("xcrun", [
-				"simctl",
-				"spawn",
-				udid,
-				"launchctl",
-				"list"
-			], { timeoutMs: 3e4 });
-			return {
-				ok: true,
-				udid
-			};
-		} catch (error) {
-			return {
-				failed: true,
-				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
-			};
-		}
-	};
-	const booting = device?.booting;
-	if (booting?.udid === udid) {
-		try {
-			await booting.done;
-		} catch (e) {
-			return bootFailure(udid, e);
-		}
-		return ready();
-	}
-	const readiness = device?.booted === udid ? ready() : null;
-	if (readiness?.ok) {
-		if (simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
-		return readiness;
-	}
-	let resolved;
-	try {
-		resolved = resolveOwnedIosSim(udid);
-	} catch (e) {
-		return {
-			failed: true,
-			reason: `Could not list simulators: ${e?.message || e}`
-		};
-	}
-	if (resolved.missing) return {
-		failed: true,
-		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
-	};
-	if (resolved.notOwned) return {
-		failed: true,
-		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
-	};
-	const sim = resolved.sim;
-	if (sim.state === "Booted") {
-		const result = readiness ?? ready();
-		if (result.ok && simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
-		return result;
-	}
-	const bootDeadline = Date.now() + timeoutMs;
-	try {
-		await withDeviceBootAdmission({
-			platform: "ios",
-			key: udid
-		}, () => {
-			out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
-			return bootIosSim(udid, {
-				timeoutMs,
-				label: sim.name,
-				out,
-				simulatorApp
-			});
-		}, {
-			...deviceSlotWait,
-			root: projectPath,
-			out
-		});
-	} catch (e) {
-		return bootFailure(udid, e);
-	}
-	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
-	while (Date.now() < deadline) {
-		await sleep(pollMs);
-		let state = null;
-		try {
-			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
-		} catch {}
-		if (state === "Booted") return ready();
-	}
-	return {
-		failed: true,
-		reason: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
-	};
-}
-function bootFailure(udid, error) {
-	const refusal = error instanceof DeviceAdmissionRefusal ? error : (0, ownership_claim_exports.claimFailure)(error, "stim ios");
-	if (refusal) return {
-		failed: true,
-		code: refusal.code,
-		reason: refusal.message,
-		remedy: refusal.remedy
-	};
-	return {
-		failed: true,
-		reason: `Could not boot simulator ${udid}: ${error?.message || error}`
-	};
-}
-function sleep(ms) {
-	return new Promise((r) => setTimeout(r, ms));
-}
-//#endregion
-export { ensureOwnedIosDevice as i, clearIosAdoptionPending as n, ensureIosBooted as r, IosDeviceMismatchError as t };

package/dist/errors-B6W7FkxQ.mjs

@@ -1,15 +0,0 @@
-//#region src/supervisor/errors.ts
-function supervisorError(code, message, remedy) {
-	const err = new Error(message);
-	err.code = code;
-	if (remedy) err.remedy = remedy;
-	return err;
-}
-function describeError(err) {
-	if (!err) return "unknown error";
-	const e = err;
-	const message = e.message || String(err);
-	return `${e.code ? `${e.code}: ` : ""}${message}${e.remedy ? ` Remedy: ${e.remedy}` : ""}`;
-}
-//#endregion
-export { supervisorError as n, describeError as t };

package/dist/guide-status-Du-ZQ3FD.mjs

@@ -1,125 +0,0 @@
-import { E as upsertProject, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
-import { n as appProjectProblem } from "./project-D47Rh0ly.mjs";
-import { t as compareStimVersions } from "./stim-installations-QMEI32v1.mjs";
-import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-//#region src/guide-status.ts
-const DAY_MS = 864e5;
-const DOCTOR_STALE_MS = 7 * DAY_MS;
-const UPDATE_CHECK_INTERVAL_MS = DAY_MS;
-const UPDATE_CHECK_TIMEOUT_MS = 2e3;
-const LATEST_URL = "https://registry.npmjs.org/stim/latest";
-const PLATFORMS = ["ios", "android"];
-function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date()) {
-	const run = {
-		at: now.toISOString(),
-		version
-	};
-	try {
-		if (appProjectProblem(projectRoot)) return;
-		upsertProject(projectRoot, (existing) => {
-			const doctorRuns = { ...existing.doctorRuns };
-			for (const target of platform ? [platform] : PLATFORMS) doctorRuns[target] = run;
-			return { doctorRuns };
-		});
-	} catch {}
-}
-function doctorDueReason(record, running, now) {
-	const at = record ? Date.parse(record.at) : NaN;
-	if (!record || Number.isNaN(at)) return "never run";
-	if (record.version !== running) return `last run with stim ${record.version}`;
-	const age = now.getTime() - at;
-	if (age > DOCTOR_STALE_MS) return `last run ${Math.floor(age / DAY_MS)} days ago`;
-	return null;
-}
-function updateCacheFile() {
-	return join(getConfigDir(), "update-check.json");
-}
-function readUpdateCache() {
-	try {
-		const parsed = JSON.parse(readFileSync(updateCacheFile(), "utf-8"));
-		if (typeof parsed?.checkedAt !== "string") return null;
-		return {
-			checkedAt: parsed.checkedAt,
-			latest: typeof parsed.latest === "string" ? parsed.latest : null
-		};
-	} catch {
-		return null;
-	}
-}
-function writeUpdateCache(cache) {
-	const target = updateCacheFile();
-	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-	try {
-		mkdirSync(getConfigDir(), { recursive: true });
-		writeFileSync(tmp, `${JSON.stringify(cache)}\n`);
-		renameSync(tmp, target);
-	} catch {
-		try {
-			unlinkSync(tmp);
-		} catch {}
-	}
-}
-async function fetchLatest(fetchImpl) {
-	const res = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
-	if (!res.ok) return null;
-	const body = await res.json();
-	return typeof body.version === "string" ? body.version : null;
-}
-async function checkForUpdate(running, { now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch } = {}) {
-	if (process.env.STIM_NO_UPDATE_CHECK) return null;
-	const cached = readUpdateCache();
-	const checkedAt = cached ? Date.parse(cached.checkedAt) : NaN;
-	let latest = cached?.latest ?? null;
-	if (Number.isNaN(checkedAt) || now.getTime() - checkedAt > UPDATE_CHECK_INTERVAL_MS) {
-		try {
-			latest = await fetchLatest(fetchImpl);
-		} catch {
-			latest = null;
-		}
-		writeUpdateCache({
-			checkedAt: now.toISOString(),
-			latest
-		});
-	}
-	if (!latest) return null;
-	const comparison = compareStimVersions(latest, running);
-	return comparison !== null && comparison > 0 ? latest : null;
-}
-function renderGuideStatus({ running, doctor, latest }) {
-	const lines = [];
-	if (doctor.length) {
-		const named = doctor.map((due) => `${due.platform} (${due.reason})`).join(" and ");
-		const command = doctor.length === 1 ? `stim doctor --platform ${doctor[0]?.platform}` : "stim doctor";
-		lines.push(`  Doctor is due for ${named}.`, `  Run before native work:  ${command}`);
-	}
-	if (latest) lines.push(`  stim ${latest} is available (running ${running}):  npm install -g stim@latest`);
-	if (!lines.length) return null;
-	return ["STATUS", ...lines].join("\n");
-}
-async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
-	const doctor = [];
-	if (projectRoot && !appProjectProblem(projectRoot)) {
-		let runs = null;
-		try {
-			runs = getProject(projectRoot)?.doctorRuns ?? {};
-		} catch {}
-		if (runs) for (const platform of PLATFORMS) {
-			const reason = doctorDueReason(runs[platform], running, now);
-			if (reason) doctor.push({
-				platform,
-				reason
-			});
-		}
-	}
-	return renderGuideStatus({
-		running,
-		doctor,
-		latest: await checkForUpdate(running, {
-			now,
-			fetch: fetchImpl
-		})
-	});
-}
-//#endregion
-export { recordDoctorRun as n, guideStatus as t };