stim 0.0.0 → 1.1.0

package/dist/stop-BApyaF21.mjs

@@ -0,0 +1,591 @@
+import { C as withConfigLock, D as sameProcessRecord, E as inspectProcessIdentity, O as waitForProcessExit, S as upsertProject, a as clearSupervisor, f as getProject } from "./config-D7uu8Gbq.mjs";
+import { _ as writeWorkspaceState, a as clearRemoteSession, c as readMetroTunnel, i as clearManagedMetroTunnel, m as withWorkspaceStateLock, o as clearWorkspaceStateKeys, p as readWorkspaceState, s as clearWorkspaceSupervisor, u as readRemoteSession } from "./state-IYEY-zi8.mjs";
+import { a as findProjectRoot } from "./project-COj6nzzh.mjs";
+import { i as resolveProjectMetro, n as killMetroTree, r as pidExists } from "./metro-B01H3EuD.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-D8HmSv2E.mjs";
+import { d as resolveEasCliBin, h as teardownOwnedIosSim, m as teardownOwnedAvd } from "./remote-cache-DOi5-zLj.mjs";
+import { f as releasedLeaseFact, l as phaseLine, u as plural } from "./command-output-8wHMEde0.mjs";
+import { l as releaseWorkspaceLeases } from "./device-lease-D-G3SgVe.mjs";
+import { i as endRecordedSession } from "./device-remote-CCgkG82J.mjs";
+import { r as stopTunnel, t as resolveSupervisorTarget } from "./ownership-B9QIdQOw.mjs";
+import chalk from "chalk";
+//#region src/commands/stop.ts
+const DEFAULT_WAIT_MS = 1e4;
+function readSupervisorState(root) {
+	const sup = readWorkspaceState(root)?.supervisor;
+	return sup && typeof sup === "object" ? sup : null;
+}
+function readCollectorState(root) {
+	const collectors = readWorkspaceState(root)?.collectors;
+	return collectors && typeof collectors === "object" ? collectors : {};
+}
+function clearSupervisorState(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		if (!clearWorkspaceSupervisor(root, expected)) return false;
+		clearWorkspaceStateKeys(root, ["launches"]);
+		return true;
+	});
+}
+function clearCollectorState(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		const current = { ...readWorkspaceState(root)?.collectors };
+		if (expected === void 0) {
+			clearWorkspaceStateKeys(root, ["collectors"]);
+			return true;
+		}
+		for (const [platform, record] of Object.entries(expected ?? {})) if (sameProcessRecord(current[platform], record)) delete current[platform];
+		if (Object.keys(current).length) writeWorkspaceState(root, { collectors: current });
+		else clearWorkspaceStateKeys(root, ["collectors"]);
+		return Object.keys(current).length === 0;
+	});
+}
+function numberOrNull(v) {
+	return typeof v === "number" && Number.isSafeInteger(v) && v > 0 ? v : null;
+}
+function resolveCollectorTargets({ root, collectors, isAlive = pidExists, selfPid = process.pid, verify = verifyCollectorOwnership }) {
+	const targets = [];
+	for (const [platform, record] of Object.entries(collectors || {})) {
+		const pid = numberOrNull(Number(record?.pid));
+		if (!pid || pid === selfPid) {
+			targets.push({
+				platform,
+				pid: pid ?? null,
+				status: "invalid"
+			});
+			continue;
+		}
+		if (!isAlive(pid)) {
+			targets.push({
+				platform,
+				pid,
+				status: "stale"
+			});
+			continue;
+		}
+		const ownership = verify({
+			pid,
+			platform,
+			root,
+			isAlive,
+			expected: record
+		});
+		if (ownership.status === "gone") {
+			targets.push({
+				platform,
+				pid,
+				status: "stale"
+			});
+			continue;
+		}
+		if (ownership.status === "unverified") {
+			targets.push({
+				platform,
+				pid,
+				status: "unverified",
+				reason: ownership.reason
+			});
+			continue;
+		}
+		targets.push({
+			platform,
+			pid,
+			status: "running"
+		});
+	}
+	return targets;
+}
+function defaultTeardownRemoteSession(root, sessionId) {
+	return endRecordedSession({
+		root,
+		sessionId,
+		easBin: resolveEasCliBin(root)?.file ?? null
+	});
+}
+async function runStop({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => process.kill(pid, "SIGTERM"), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, inspectIdentity = inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+	const proj = project === void 0 ? getProject(root) : project;
+	const sup = state === void 0 ? readSupervisorState(root) : state;
+	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
+	const reservedPort = typeof proj?.metroPort === "number" ? proj.metroPort : null;
+	const waiter = waitForDeath ?? ((pid, processToken) => waitForProcessExit({
+		pid,
+		processToken
+	}, waitMs));
+	const outcomes = {
+		supervisor: { status: "none" },
+		collectors: {
+			status: "none",
+			entries: []
+		},
+		metro: { status: "none" },
+		device: {
+			ios: null,
+			android: null
+		},
+		port: {
+			status: "none",
+			port: reservedPort
+		},
+		metroTunnel: { status: "none" },
+		releasedLeases: []
+	};
+	let ok = true;
+	let stillHolding = null;
+	const target = resolveSupervisorTarget({
+		state: sup,
+		record: proj?.supervisor ?? null,
+		reservedPort,
+		isAlive,
+		inspectIdentity
+	});
+	if (target.status === "none") report(chalk.dim(phaseLine("stop", "no supervisor recorded")));
+	else if (target.status === "stale") {
+		outcomes.supervisor = {
+			status: "already-stopped",
+			pid: target.pid,
+			reason: `recorded pid ${target.pid} is not running`
+		};
+		report(chalk.dim(phaseLine("stop", `supervisor pid ${target.pid} is already gone (stale record)`)));
+	} else if (target.status === "unverified") {
+		outcomes.supervisor = {
+			status: "unverified",
+			pid: target.pid,
+			reason: target.reason
+		};
+		report(chalk.yellow(phaseLine("stop", `refusing to signal supervisor pid ${target.pid}: ${target.reason}`)));
+		ok = false;
+		stillHolding = `supervisor pid ${target.pid} could not be verified`;
+	} else {
+		outcomes.supervisor = await stopSupervisor(target, {
+			killGroup,
+			waiter,
+			report
+		});
+		if (outcomes.supervisor.status !== "stopped") {
+			ok = false;
+			stillHolding = outcomes.supervisor.reason;
+		}
+	}
+	outcomes.collectors = await reapCollectors(root, collectorRecords, {
+		isAlive,
+		signal: signalCollector,
+		report,
+		verify: verifyCollector,
+		waiter
+	});
+	const unverifiedCollectors = outcomes.collectors.entries.filter((e) => e.status === "unverified");
+	if (unverifiedCollectors.length) {
+		report(chalk.dim(phaseLine("stop", `keeping the collector records; ${plural(unverifiedCollectors.length, "pid")} could not be verified, and a later \`ios\` / \`android\` run replaces them`)));
+		ok = false;
+		stillHolding ??= "collector process identity could not be verified";
+	} else if (outcomes.collectors.entries.some((entry) => entry.status === "failed")) {
+		ok = false;
+		stillHolding ??= "a collector could not be stopped";
+	} else if (outcomes.collectors.entries.length && clearCollectors(root, collectorRecords) === false) {
+		ok = false;
+		stillHolding ??= "a replacement collector appeared during cleanup";
+	}
+	if (outcomes.supervisor.status === "stopped" || outcomes.supervisor.status === "timeout" || outcomes.supervisor.status === "unverified" || outcomes.supervisor.status === "failed") outcomes.metro = {
+		status: "skipped",
+		reason: "the supervisor owns the dev server on this port"
+	};
+	else if (reservedPort === null) report(chalk.dim(phaseLine("metro", "no port reserved")));
+	else {
+		outcomes.metro = await stopMetro(reservedPort, root, {
+			resolveMetro,
+			report
+		});
+		if (outcomes.metro.status === "refused" || outcomes.metro.status === "failed") {
+			ok = false;
+			stillHolding = outcomes.metro.reason;
+		}
+	}
+	const releaseStoppedSupervisor = async () => {
+		const stateCleared = clearState(root, sup);
+		const registrationCleared = await clearRegistration(root, proj?.supervisor ?? null);
+		if (stateCleared === false || registrationCleared === false) {
+			ok = false;
+			outcomes.port = {
+				status: "kept",
+				port: reservedPort,
+				reason: "a replacement supervisor appeared during cleanup"
+			};
+			return;
+		}
+		if (reservedPort !== null) {
+			if (freePort(root, reservedPort) === false) {
+				ok = false;
+				outcomes.port = {
+					status: "kept",
+					port: reservedPort,
+					reason: "the port reservation changed during cleanup"
+				};
+				return;
+			}
+			outcomes.port = {
+				status: "freed",
+				port: reservedPort
+			};
+			report(chalk.dim(phaseLine("port", `released ${reservedPort}`)));
+		}
+	};
+	if (stillHolding) report(chalk.dim(phaseLine("device", "left alone (something is still running)")));
+	else {
+		outcomes.device = shutDownDevices(proj, {
+			teardownIos,
+			teardownAvd,
+			report
+		});
+		if ([outcomes.device.ios, outcomes.device.android].some((device) => device?.status === "failed")) ok = false;
+	}
+	const remote = remoteDevice === void 0 ? readRemoteSession(root) : remoteDevice;
+	const sessionId = typeof remote?.sessionId === "string" ? remote.sessionId : null;
+	if (sessionId) {
+		const result = teardownRemoteSession(root, sessionId);
+		outcomes.device.remote = {
+			status: result.status,
+			label: sessionId,
+			reason: result.reason
+		};
+		if (result.status === "failed") {
+			ok = false;
+			report(chalk.red(phaseLine("device", result.reason ?? `could not stop remote session ${sessionId}`)));
+		} else {
+			report(chalk.dim(phaseLine("device", `stopped remote session ${sessionId}`)));
+			if (result.reason) {
+				ok = false;
+				report(chalk.yellow(phaseLine("device", result.reason)));
+			} else clearRemoteSession(root, sessionId);
+		}
+	}
+	const tunnel = metroTunnel === void 0 ? readMetroTunnel(root) : metroTunnel;
+	let tunnelHolding = null;
+	if (tunnel?.kind === "managed") {
+		const result = await stopMetroTunnel(tunnel);
+		outcomes.metroTunnel = {
+			status: result.status,
+			provider: tunnel.provider,
+			reason: result.reason
+		};
+		if (result.status === "failed") {
+			ok = false;
+			tunnelHolding = result.reason ?? `could not stop the ${tunnel.provider} tunnel`;
+			if (!stillHolding) stillHolding = tunnelHolding;
+			report(chalk.red(phaseLine("lan", tunnelHolding)));
+		} else if (!clearManagedMetroTunnel(root, tunnel)) {
+			tunnelHolding = "a replacement managed tunnel record appeared during cleanup and remains active";
+			stillHolding = stillHolding ?? tunnelHolding;
+			ok = false;
+			outcomes.metroTunnel = {
+				status: "failed",
+				provider: tunnel.provider,
+				reason: tunnelHolding
+			};
+			report(chalk.red(phaseLine("lan", tunnelHolding)));
+		} else report(chalk.dim(phaseLine("lan", result.status === "missing" ? "tunnel already gone" : `stopped the ${tunnel.provider} tunnel`)));
+	} else if (tunnel?.kind === "expo") outcomes.metroTunnel = { status: "not-managed" };
+	outcomes.releasedLeases = releaseLeases(root);
+	for (const lease of outcomes.releasedLeases) report(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
+	if (stillHolding) {
+		outcomes.port = {
+			status: "kept",
+			port: reservedPort,
+			reason: stillHolding
+		};
+		report(chalk.yellow(phaseLine("port", `keeping reservation ${reservedPort ?? "(none)"} -- ${stillHolding}`)));
+		const supervisorIsDown = outcomes.supervisor.status === "none" || outcomes.supervisor.status === "already-stopped" || outcomes.supervisor.status === "stopped";
+		if (tunnelHolding && supervisorIsDown) {
+			clearState(root, sup);
+			await clearRegistration(root, proj?.supervisor ?? null);
+		}
+	} else await releaseStoppedSupervisor();
+	return {
+		ok,
+		outcomes,
+		summary: summarize(root, outcomes, ok)
+	};
+}
+async function reapCollectors(root, collectors, { isAlive, signal, report, verify = verifyCollectorOwnership, waiter }) {
+	const targets = resolveCollectorTargets({
+		root,
+		collectors,
+		isAlive,
+		verify
+	});
+	const entries = [];
+	for (const target of targets) {
+		if (target.status === "invalid") {
+			entries.push({
+				platform: target.platform,
+				pid: target.pid,
+				status: "invalid"
+			});
+			report(chalk.dim(phaseLine("stop", `ignoring an unusable ${target.platform} collector record`)));
+			continue;
+		}
+		if (target.status === "stale") {
+			entries.push({
+				platform: target.platform,
+				pid: target.pid,
+				status: "already-stopped"
+			});
+			report(chalk.dim(phaseLine("stop", `collector ${target.platform} pid ${target.pid} is already gone`)));
+			continue;
+		}
+		if (target.status === "unverified") {
+			entries.push({
+				platform: target.platform,
+				pid: target.pid,
+				status: "unverified",
+				reason: target.reason
+			});
+			report(chalk.yellow(phaseLine("stop", `refusing to signal collector ${target.platform} pid ${target.pid}: ${target.reason}`)));
+			continue;
+		}
+		try {
+			const ownership = verify({
+				pid: target.pid,
+				platform: target.platform,
+				root,
+				isAlive,
+				expected: collectors?.[target.platform]
+			});
+			if (ownership.status !== "ours") {
+				entries.push({
+					platform: target.platform,
+					pid: target.pid,
+					status: ownership.status === "gone" ? "already-stopped" : "unverified",
+					...ownership.status === "unverified" ? { reason: ownership.reason } : {}
+				});
+				continue;
+			}
+			signal(target.pid);
+			if (!await waiter(target.pid, collectors?.[target.platform]?.processToken)) {
+				entries.push({
+					platform: target.platform,
+					pid: target.pid,
+					status: "failed",
+					reason: "collector exit could not be confirmed"
+				});
+				continue;
+			}
+			entries.push({
+				platform: target.platform,
+				pid: target.pid,
+				status: "stopped"
+			});
+			report(chalk.green(phaseLine("stop", `collector ${target.platform} pid ${target.pid}`)));
+		} catch (error) {
+			const gone = error.code === "ESRCH";
+			entries.push({
+				platform: target.platform,
+				pid: target.pid,
+				status: gone ? "already-stopped" : "failed"
+			});
+			report(chalk.dim(phaseLine("stop", gone ? `collector ${target.platform} pid ${target.pid} exited before it could be signalled` : `could not signal collector ${target.platform} pid ${target.pid}`)));
+		}
+	}
+	if (entries.length === 0) {
+		report(chalk.dim(phaseLine("stop", "no collectors recorded")));
+		return {
+			status: "none",
+			entries
+		};
+	}
+	return {
+		status: "stopped",
+		entries
+	};
+}
+async function stopSupervisor(target, { killGroup, waiter, report }) {
+	report(chalk.dim(phaseLine("stop", `sending SIGTERM to supervisor process group ${target.pid}`)));
+	let signalled = false;
+	try {
+		signalled = killGroup(target.pid, target.processToken);
+	} catch (e) {
+		signalled = false;
+		report(chalk.red(phaseLine("stop", `could not signal supervisor pid ${target.pid}: ${String(e?.message || e)}`)));
+	}
+	if (!signalled) {
+		const reason = `could not signal supervisor pid ${target.pid}`;
+		report(chalk.red(phaseLine("stop", reason)));
+		return {
+			status: "failed",
+			pid: target.pid,
+			port: target.port ?? null,
+			reason
+		};
+	}
+	if (await waiter(target.pid, target.processToken)) {
+		report(chalk.green(phaseLine("stop", `supervisor pid ${target.pid}`)));
+		return {
+			status: "stopped",
+			pid: target.pid,
+			port: target.port ?? null,
+			mode: target.mode ?? null
+		};
+	}
+	const reason = `supervisor pid ${target.pid} did not exit within ${Math.round(DEFAULT_WAIT_MS / 1e3)}s of SIGTERM`;
+	report(chalk.red(phaseLine("stop", reason)));
+	report(chalk.dim(phaseLine("", `inspect it with \`ps -p ${target.pid}\`, or signal it yourself: kill -9 -${target.pid}`)));
+	return {
+		status: "timeout",
+		pid: target.pid,
+		port: target.port ?? null,
+		reason
+	};
+}
+async function stopMetro(port, root, { resolveMetro, report }) {
+	const resolution = await resolveMetro(port, root);
+	if (resolution.missing) {
+		report(chalk.dim(phaseLine("metro", `nothing listening on port ${port}`)));
+		return {
+			status: "missing",
+			port
+		};
+	}
+	const reason = resolution.notOurs || "no recorded Stim supervisor owns this server; stop it with the tool that started it";
+	report(chalk.yellow(phaseLine("metro", `leaving port ${port} alone: ${reason}`)));
+	return {
+		status: "not-managed",
+		port,
+		reason
+	};
+}
+const OCCUPANCY_HINT = "often a UI-test runner or device tool still attached";
+function occupiedSkipReason(reason, holders) {
+	const named = (holders || []).filter(Boolean);
+	return named.length ? `${reason} -- held by UI-test runner ${named.join(", ")}` : `${reason} -- ${OCCUPANCY_HINT}`;
+}
+function shutDownDevices(project, { teardownIos, teardownAvd, report }) {
+	const device = {
+		ios: null,
+		android: null
+	};
+	const ios = project?.platforms?.ios;
+	const iosUdid = ios?.deviceUdid;
+	const iosName = ios?.deviceName;
+	if (iosUdid) {
+		if (!ios?.owned) {
+			device.ios = {
+				status: "skipped",
+				kind: "not-owned",
+				label: iosUdid,
+				reason: "Stim does not own this device"
+			};
+			report(chalk.dim(phaseLine("device", `${iosUdid} is not Stim-owned, leaving it running`)));
+		} else device.ios = reportDevice(iosUdid, teardownIos(iosUdid, {
+			del: false,
+			label: iosName
+		}), report);
+	}
+	const android = project?.platforms?.android;
+	if (android?.avdName) {
+		if (!android.owned) {
+			device.android = {
+				status: "skipped",
+				kind: "not-owned",
+				label: android.avdName,
+				reason: "Stim does not own this device"
+			};
+			report(chalk.dim(phaseLine("device", `${android.avdName} is not Stim-owned, leaving it running`)));
+		} else device.android = reportDevice(android.avdName, teardownAvd(android.avdName, { del: false }), report);
+	}
+	return device;
+}
+function reportDevice(label, r, report) {
+	if (r.status === "torn-down") {
+		report(chalk.green(phaseLine("device", `shut down ${r.label ?? label}`)));
+		return {
+			status: "shut-down",
+			label: r.label ?? label
+		};
+	}
+	if (r.status === "missing") {
+		report(chalk.dim(phaseLine("device", `${label} is already gone`)));
+		return {
+			status: "missing",
+			label
+		};
+	}
+	if (r.status === "skipped") {
+		const reason = r.kind === "occupied" ? occupiedSkipReason(r.reason, r.holders) : r.reason;
+		report(chalk.yellow(phaseLine("device", `skipped ${label}: ${reason}`)));
+		return {
+			status: "skipped",
+			kind: r.kind ?? null,
+			label,
+			reason
+		};
+	}
+	report(chalk.red(phaseLine("device", `failed to shut down ${label}: ${r.reason}`)));
+	return {
+		status: "failed",
+		label,
+		reason: r.reason
+	};
+}
+function summarize(root, outcomes, ok) {
+	const parts = [];
+	if (outcomes.supervisor.status === "stopped") parts.push(`supervisor pid ${outcomes.supervisor.pid} stopped`);
+	if (outcomes.supervisor.status === "already-stopped") parts.push("supervisor already stopped");
+	if (outcomes.supervisor.status === "timeout") parts.push(`supervisor pid ${outcomes.supervisor.pid} still running`);
+	if (outcomes.supervisor.status === "unverified") parts.push(`supervisor pid ${outcomes.supervisor.pid} unverified`);
+	if (outcomes.supervisor.status === "failed") parts.push(`supervisor pid ${outcomes.supervisor.pid} could not be signalled`);
+	const reaped = outcomes.collectors.entries.filter((e) => e.status === "stopped").length;
+	if (reaped) parts.push(`${reaped} collector${reaped === 1 ? "" : "s"} stopped`);
+	const unverified = outcomes.collectors.entries.filter((e) => e.status === "unverified").length;
+	if (unverified) parts.push(`${unverified} collector${unverified === 1 ? "" : "s"} left unsignalled`);
+	if (outcomes.metro.status === "stopped") parts.push(`metro on port ${outcomes.metro.port} stopped`);
+	if (outcomes.metro.status === "not-managed") parts.push(`external server on port ${outcomes.metro.port} left alone`);
+	if (outcomes.metro.status === "refused") parts.push(`port ${outcomes.metro.port} refused`);
+	if (outcomes.metro.status === "failed") parts.push(`port ${outcomes.metro.port} could not be freed`);
+	const devicesByPlatform = [["ios", outcomes.device.ios], ["android", outcomes.device.android]];
+	for (const [platform, o] of devicesByPlatform) {
+		if (!o) continue;
+		if (o.status === "shut-down") parts.push(`${platform} ${o.label} shut down`);
+		if (o.status === "skipped") parts.push(`${platform} ${o.label} skipped`);
+		if (o.status === "failed") parts.push(`${platform} ${o.label} failed`);
+	}
+	if (outcomes.port.status === "freed") parts.push(`port ${outcomes.port.port} freed`);
+	if (outcomes.port.status === "kept") parts.push(`port ${outcomes.port.port} kept`);
+	if (outcomes.metroTunnel.status === "stopped") parts.push(`${outcomes.metroTunnel.provider} tunnel stopped`);
+	if (outcomes.metroTunnel.status === "failed") parts.push(`${outcomes.metroTunnel.provider} tunnel could not be stopped`);
+	for (const lease of outcomes.releasedLeases) parts.push(`${lease.platform} lease on ${lease.id} released`);
+	const what = parts.length ? parts.join(", ") : "nothing was running";
+	return `${ok ? "Stopped" : "Stopped with problems"}: ${what} (${root})`;
+}
+function defaultFreePort(root, port) {
+	return withConfigLock(() => {
+		const current = getProject(root);
+		if (!current) return true;
+		if (current.supervisor || current.metroPort !== port) return false;
+		upsertProject(root, { metroPort: null });
+		return true;
+	});
+}
+async function defaultClearRegistration(root, expected) {
+	try {
+		return clearSupervisor(root, expected);
+	} catch {
+		return false;
+	}
+}
+function stopCommand(program) {
+	program.command("stop").description("The inverse of `start`: halt this workspace's supervisor, shut the owned device down (never deleted), and free the reserved port. Non-destructive -- the device stays assigned, so coming back costs a boot. Acts on the current workspace.").option("--json", "print the per-step outcomes as JSON").action(async (opts) => {
+		const root = findProjectRoot(process.cwd());
+		if (!root) {
+			console.error(chalk.red("Not inside a project (no package.json found above the current directory)."));
+			process.exit(1);
+		}
+		const { ok, outcomes, summary } = await runStop({ root });
+		if (opts.json) console.log(JSON.stringify({
+			root,
+			ok,
+			...outcomes
+		}));
+		else console.log(ok ? chalk.green(summary) : chalk.yellow(summary));
+		if (!ok) process.exit(1);
+	});
+}
+//#endregion
+export { resolveCollectorTargets as a, readSupervisorState as i, clearSupervisorState as n, runStop as o, readCollectorState as r, stopCommand as s, clearCollectorState as t };

package/dist/stop-D6o5zAdm.mjs

@@ -0,0 +1,3 @@
+import { t as resolveSupervisorTarget } from "./ownership-B9QIdQOw.mjs";
+import { a as resolveCollectorTargets, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BApyaF21.mjs";
+export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop };

package/dist/supervisor-run.d.mts

@@ -0,0 +1,84 @@
+import { t as NdjsonWriter } from "./ndjson-DvHSsNU9.mjs";
+//#region src/process-identity.d.ts
+interface ProcessRecord {
+  pid?: unknown;
+  processToken?: unknown;
+}
+//#endregion
+//#region src/supervisor/state.d.ts
+declare const MODE_BARE = "bare-inproc";
+declare const MODE_EXPO = "expo-child";
+interface WorkspaceState {
+  metroCacheGeneration?: string;
+  supervisor?: Record<string, unknown>;
+  collectors?: Record<string, unknown>;
+  lastBuild?: Record<string, unknown>;
+  launches?: Partial<Record<WorkspaceLaunchPlatform, WorkspaceLaunchRecord>>;
+  remoteDevice?: Record<string, unknown>;
+  metroTunnel?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+type WorkspaceLaunchPlatform = "ios" | "android";
+interface WorkspaceLaunchRecord {
+  appId: string;
+  deviceId: string;
+  metroPort: number | null;
+  release: boolean;
+  launchedAt: string;
+}
+declare function readWorkspaceState(root: string): WorkspaceState | null;
+declare function withWorkspaceStateLock<T>(root: string, fn: () => T): T;
+declare function writeWorkspaceState(root: string, patch: WorkspaceState): WorkspaceState;
+declare function clearWorkspaceSupervisor(root: string, expected?: ProcessRecord | null): boolean;
+declare function clearExpoMetroTunnel(root: string): void;
+declare function writePidFile(root: string, pid: number): string;
+declare function readPidFile(root: string): number | null;
+//#endregion
+//#region src/supervisor/run.d.ts
+interface ParsedSupervisorArgs {
+  root?: string;
+  port?: number;
+  tunnel?: boolean;
+  error?: string;
+}
+declare function parseArgs(argv: string[]): ParsedSupervisorArgs;
+interface ServerExitInfo {
+  code?: number | null;
+  signal?: NodeJS.Signals | null;
+  reason?: string;
+  error?: Error;
+}
+interface ServerHandle {
+  close(): Promise<void> | void;
+  onExit?(cb: (info?: ServerExitInfo | null) => void): void;
+  serverPid?: number | null;
+}
+type ServerStarter = (opts: {
+  root: string;
+  port: number;
+  logsDir: string;
+  writer?: NdjsonWriter | null;
+  tunnel?: boolean;
+  onTunnelUrl?: ((url: string) => void) | null;
+}) => Promise<ServerHandle>;
+interface RunSupervisorOptions {
+  root: string;
+  port: number;
+  tunnel?: boolean;
+  isExpo?: (projectRoot: string) => boolean;
+  startBare?: ServerStarter | null;
+  startExpo?: ServerStarter | null;
+  now?: () => number;
+  onExit?: (code: number) => void;
+  attachSignals?: boolean;
+  stderr?: (line: string) => void;
+}
+declare function runSupervisor({ root, port, tunnel, isExpo, startBare, startExpo, now, onExit, attachSignals, stderr }: RunSupervisorOptions): Promise<{
+  mode: string;
+  server: ServerHandle | undefined;
+  shutdown: (code: number, event: string, msg: string) => Promise<void>;
+  startedAt: string;
+} | null>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { MODE_BARE, MODE_EXPO, RunSupervisorOptions, ServerExitInfo, ServerHandle, type WorkspaceState, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, readWorkspaceState, runSupervisor, withWorkspaceStateLock, writePidFile, writeWorkspaceState };