stim 0.0.0 → 1.1.0

package/dist/reload-DYZEBbZy.mjs

@@ -0,0 +1,332 @@
+import { f as getProject } from "./config-D7uu8Gbq.mjs";
+import { f as readWorkspaceLaunches } from "./state-IYEY-zi8.mjs";
+import { a as findProjectRoot } from "./project-COj6nzzh.mjs";
+import { i as resolveProjectMetro } from "./metro-B01H3EuD.mjs";
+import { l as phaseLine } from "./command-output-8wHMEde0.mjs";
+import { u as androidAppProcess, y as iosAppProcess } from "./app-install-oZIQRbdD.mjs";
+import { b as resolveOwnedIosSim } from "./ios-BZxKPuqP.mjs";
+import { A as resolveOwnedAvdSerial } from "./android-xmyGBNy5.mjs";
+import chalk from "chalk";
+import { WebSocket } from "ws";
+//#region src/engine/reload.ts
+const METRO_TIMEOUT_MS = 2e3;
+function describe$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const ROLE_NAMES = {
+	ios: "iOS",
+	android: "Android"
+};
+function peerQuery(metadata) {
+	if (typeof metadata === "string") return new URLSearchParams(metadata);
+	if (!metadata || typeof metadata !== "object") return null;
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(metadata)) if (typeof value === "string") query.set(key, value);
+	return query;
+}
+function peerMatches(query, role, appId) {
+	if (role === "ios") return query.get("role")?.toLowerCase() === "ios";
+	return query.get("app") === appId;
+}
+function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS }) {
+	const roleName = ROLE_NAMES[role];
+	return new Promise((resolve) => {
+		const requestId = `stim-reload-${process.pid}-${Date.now()}`;
+		const socket = new WebSocket(`ws://127.0.0.1:${port}/message`);
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			socket.close();
+			resolve(result);
+		};
+		const timer = setTimeout(() => finish({
+			failed: true,
+			unreachable: true,
+			reason: `Metro did not answer on port ${port}.`
+		}), timeoutMs);
+		socket.once("open", () => {
+			socket.send(JSON.stringify({
+				version: 2,
+				method: "getpeers",
+				target: "server",
+				id: requestId
+			}));
+		});
+		socket.on("message", (data) => {
+			let message;
+			try {
+				message = JSON.parse(data.toString());
+			} catch {
+				return;
+			}
+			if (message.id !== requestId) return;
+			if (message.result && typeof message.result === "object") {
+				const entries = Object.entries(message.result);
+				const peers = entries.length;
+				const rolePeers = entries.filter(([, metadata]) => {
+					const query = peerQuery(metadata);
+					return query ? peerMatches(query, role, appId) : false;
+				});
+				if (rolePeers.length === 0) {
+					socket.send(JSON.stringify({
+						version: 2,
+						method: "reload"
+					}));
+					const others = peers === 0 ? " Nothing at all is connected to it, so the broadcast Stim sent anyway reached nothing." : ` Metro has ${peers} other connected client${peers === 1 ? "" : "s"}, and Stim broadcast a reload to them in case one is this app unmatched.`;
+					finish({
+						failed: true,
+						noPeer: true,
+						peers,
+						reason: `No ${roleName} React Native app is connected to Metro on port ${port}.${others}`
+					});
+					return;
+				}
+				for (const [id] of rolePeers) socket.send(JSON.stringify({
+					version: 2,
+					method: "reload",
+					target: id
+				}));
+				finish({
+					ok: true,
+					peers,
+					targets: rolePeers.length
+				});
+				return;
+			}
+			socket.send(JSON.stringify({
+				version: 2,
+				method: "reload"
+			}));
+			finish({
+				ok: true,
+				broadcast: true
+			});
+		});
+		socket.once("error", (error) => finish({
+			failed: true,
+			unreachable: true,
+			reason: `Metro reload failed: ${describe$1(error)}`
+		}));
+	});
+}
+//#endregion
+//#region src/commands/reload.ts
+const DEFAULT_DEPS = {
+	findProjectRoot,
+	getProject,
+	readLaunches: readWorkspaceLaunches,
+	resolveIos: resolveOwnedIosSim,
+	resolveAndroid: resolveOwnedAvdSerial,
+	iosProcess: iosAppProcess,
+	androidProcess: androidAppProcess,
+	resolveMetro: resolveProjectMetro,
+	reloadMetro: reloadThroughMetro
+};
+function failure(code, message, remedy) {
+	return {
+		code,
+		message,
+		remedy
+	};
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function processFailure(platform, record, d) {
+	const process = platform === "ios" ? d.iosProcess(record.deviceId, record.appId) : d.androidProcess(record.deviceId, record.appId);
+	if (process === void 0) {
+		const probe = platform === "ios" ? `xcrun simctl spawn ${record.deviceId} launchctl list` : `adb -s ${record.deviceId} shell pidof ${record.appId}`;
+		return failure("STIM_RELOAD_PROBE_FAILED", `Stim could not determine whether ${record.appId} is running on ${record.deviceId}.`, `Run \`${probe}\` and retry when the device tool responds.`);
+	}
+	if (process === null) return failure("STIM_RELOAD_STOPPED", `${record.appId} is not running on ${record.deviceId}.`, `Run \`stim ${platform}\` to launch it.`);
+	return null;
+}
+function inspectTarget(platform, record, project, d) {
+	if (platform === "ios") {
+		const configured = project.platforms?.ios;
+		if (!configured?.owned || configured.deviceUdid !== record.deviceId) return {
+			platform,
+			error: failure("STIM_RELOAD_UNOWNED", `The recorded iOS launch on ${record.deviceId} is not this workspace's current owned simulator.`, "Run `stim ios` to launch the app on this workspace's owned simulator.")
+		};
+		let resolved;
+		try {
+			resolved = d.resolveIos(record.deviceId);
+		} catch (error) {
+			return {
+				platform,
+				error: failure("STIM_RELOAD_PROBE_FAILED", `Stim could not inspect iOS simulator ${record.deviceId}: ${describe(error)}`, "Run `xcrun simctl list devices` and retry when simctl responds.")
+			};
+		}
+		if (!resolved.sim || resolved.sim.state !== "Booted") return {
+			platform,
+			error: failure("STIM_RELOAD_STOPPED", `The recorded iOS app is not running on a booted owned simulator.`, "Run `stim ios` to boot, install, and launch it.")
+		};
+		const stopped = processFailure(platform, record, d);
+		if (stopped) return {
+			platform,
+			error: stopped
+		};
+		return {
+			platform,
+			record,
+			deviceName: resolved.sim.name
+		};
+	}
+	const configured = project.platforms?.android;
+	if (!configured?.owned || !configured.avdName) return {
+		platform,
+		error: failure("STIM_RELOAD_UNOWNED", `The recorded Android launch on ${record.deviceId} is not this workspace's current owned emulator.`, "Run `stim android` to launch the app on this workspace's owned emulator.")
+	};
+	let resolved;
+	try {
+		resolved = d.resolveAndroid(configured.avdName);
+	} catch (error) {
+		return {
+			platform,
+			error: failure("STIM_RELOAD_PROBE_FAILED", `Stim could not inspect Android emulator ${configured.avdName}: ${describe(error)}`, "Run `adb devices` and retry when adb responds.")
+		};
+	}
+	if (!resolved.serial || resolved.serial !== record.deviceId) return {
+		platform,
+		error: failure("STIM_RELOAD_STOPPED", `The recorded Android app is not running on this workspace's owned emulator.`, "Run `stim android` to boot, install, and launch it.")
+	};
+	const stopped = processFailure(platform, record, d);
+	if (stopped) return {
+		platform,
+		error: stopped
+	};
+	return {
+		platform,
+		record,
+		deviceName: configured.avdName
+	};
+}
+function isTargetFailure(value) {
+	return "error" in value;
+}
+async function runReload({ root, platform = null, deps = {} }) {
+	const d = {
+		...DEFAULT_DEPS,
+		...deps
+	};
+	const project = d.getProject(root);
+	if (!project) return {
+		ok: false,
+		error: failure("STIM_NO_PROJECT", `No Stim environment is registered for ${root}.`, "Run `stim start` first.")
+	};
+	const launches = d.readLaunches(root);
+	const inspected = (platform ? [platform] : ["ios", "android"]).flatMap((candidate) => {
+		const record = launches[candidate];
+		return record ? [inspectTarget(candidate, record, project, d)] : [];
+	});
+	const live = inspected.filter((target) => !isTargetFailure(target));
+	if (live.length > 1) return {
+		ok: false,
+		error: failure("STIM_RELOAD_AMBIGUOUS", "Both the iOS and Android apps are running.", "Choose one with `stim reload ios` or `stim reload android`.")
+	};
+	if (live.length === 0) return {
+		ok: false,
+		error: inspected.find(isTargetFailure)?.error ?? failure("STIM_RELOAD_STOPPED", platform ? `No ${platform} app launch is recorded for this workspace.` : "No live app launch is recorded.", platform ? `Run \`stim ${platform}\` first.` : "Run `stim ios` or `stim android` first.")
+	};
+	const target = live[0];
+	if (target.record.release) return {
+		ok: false,
+		error: failure("STIM_RELOAD_RELEASE", `${target.record.appId} was launched with an embedded release bundle.`, `Run \`stim ${target.platform}\` with a Debug configuration or variant before reloading JavaScript.`)
+	};
+	const port = target.record.metroPort;
+	if (!port || project.metroPort !== port) return {
+		ok: false,
+		error: failure("STIM_NO_METRO", `The launch does not point at this workspace's current Metro reservation.`, "Run `stim start`, then launch the app again.")
+	};
+	if (!(await d.resolveMetro(port, root)).metro) return {
+		ok: false,
+		error: failure("STIM_NO_METRO", `Port ${port} is not serving this workspace's Metro.`, "Run `stim start`, then retry.")
+	};
+	const stopped = processFailure(target.platform, target.record, d);
+	if (stopped) return {
+		ok: false,
+		error: stopped
+	};
+	const reloaded = await d.reloadMetro(port, {
+		role: target.platform,
+		appId: target.record.appId
+	});
+	if (!reloaded.ok) {
+		const stoppedAfterMetro = processFailure(target.platform, target.record, d);
+		if (stoppedAfterMetro) return {
+			ok: false,
+			error: stoppedAfterMetro
+		};
+		const snapshot = `agent-device snapshot -i --platform ${target.platform} --${target.platform === "ios" ? "udid" : "serial"} ${target.record.deviceId}`;
+		const relaunch = `agent-device open ${target.record.appId} --platform ${target.platform} --${target.platform === "ios" ? "udid" : "serial"} ${target.record.deviceId} --metro-port ${port} --relaunch`;
+		const firstBundle = target.platform === "ios" ? " If it stays unreachable, an error in the first bundle leaves iOS without a packager connection at all, and no retry will make it a peer." : "";
+		const device = `reload from the device in your existing automation session: run \`${snapshot}\`, then press the error screen's Reload button, or open the dev menu and press Reload when no error screen is showing. Only when neither is reachable, run \`${relaunch}\`; that restarts the app and loses in-memory state. Keep your existing --session flag, verify the expected UI afterward, and do not create another session.`;
+		const remedy = reloaded.unreachable ? `Metro is registered for this workspace but did not answer on port ${port}, so nothing is known about ${target.record.appId}. Run \`stim reload ${target.platform}\` again. If it keeps timing out, run \`stim doctor\` to check the dev server before touching the app.` : `Metro reports no peer for ${target.record.appId} right now. Stim broadcast a reload anyway, so check the expected UI on ${target.record.deviceId} first -- it may already have recovered. If not, the app reconnects every 2 seconds, so run \`stim reload ${target.platform}\` once more.${firstBundle} Then ${device}`;
+		return {
+			ok: false,
+			error: failure("STIM_RELOAD_FAILED", reloaded.reason, remedy)
+		};
+	}
+	const strategy = reloaded.broadcast ? "metro-broadcast" : "metro-websocket";
+	return {
+		ok: true,
+		facts: {
+			platform: target.platform,
+			deviceId: target.record.deviceId,
+			deviceName: target.deviceName,
+			appId: target.record.appId,
+			metroPort: port,
+			strategy,
+			targets: reloaded.targets ?? null
+		}
+	};
+}
+function registerReload(program, deps = {}) {
+	program.command("reload [platform]").description("Request a JavaScript reload in this workspace's live app without observing completion. Specify ios or android when both are live.").option("--json", "Emit the reload facts as one JSON line").action(async (value, opts) => {
+		if (value !== void 0 && value !== "ios" && value !== "android") {
+			const error = failure("STIM_BAD_ARG", `Unknown reload platform ${JSON.stringify(value)}.`, "Use ios or android.");
+			if (opts.json) console.log(JSON.stringify(error));
+			else {
+				console.error(chalk.red(phaseLine("error", `${error.code}: ${error.message}`)));
+				if (error.remedy) console.error(phaseLine("remedy", error.remedy));
+			}
+			process.exitCode = 1;
+			return;
+		}
+		const root = (deps.findProjectRoot ?? DEFAULT_DEPS.findProjectRoot)(process.cwd());
+		if (!root) {
+			const error = failure("STIM_NO_PROJECT", "Not inside a project (no package.json found above the current directory).", null);
+			if (opts.json) console.log(JSON.stringify(error));
+			else console.error(chalk.red(phaseLine("error", `${error.code}: ${error.message}`)));
+			process.exitCode = 1;
+			return;
+		}
+		const result = await runReload({
+			root,
+			platform: value ?? null,
+			deps
+		});
+		if (!result.ok) {
+			if (opts.json) console.log(JSON.stringify(result.error));
+			else {
+				console.error(chalk.red(phaseLine("error", `${result.error.code}: ${result.error.message}`)));
+				if (result.error.remedy) console.error(phaseLine("remedy", result.error.remedy));
+			}
+			process.exitCode = 1;
+			return;
+		}
+		if (opts.json) console.log(JSON.stringify(result.facts));
+		else {
+			const facts = result.facts;
+			const scope = facts.strategy === "metro-broadcast" ? ` This Metro cannot name its connected apps, so the reload request was broadcast to all of them and Stim cannot confirm ${facts.appId} was one. Check the expected UI on ${facts.deviceId}; if nothing changed, reload from the app's own error screen or dev menu.` : facts.targets && facts.targets > 1 ? ` ${facts.targets} devices are running this app on that Metro and the reload request addressed all of them, not only ${facts.deviceId}.` : "";
+			console.log(`Reload requested for ${facts.appId} on ${facts.deviceName} (${facts.deviceId}) via ${facts.strategy}; ${facts.platform} Metro port ${facts.metroPort}.${scope} Completion is not observed; verify the expected UI and run stim logs --errors.`);
+		}
+	});
+}
+function reloadCommand(program) {
+	registerReload(program);
+}
+//#endregion
+export { reloadCommand as default, registerReload, runReload };