stim 0.0.0 → 1.1.0

package/dist/project-COj6nzzh.mjs

@@ -0,0 +1,243 @@
+import { c as findEnclosingWorktreeRoot, f as getProject } from "./config-D7uu8Gbq.mjs";
+import { g as repoRoot } from "./worktree-Dx3ZC5lS.mjs";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+import { createRequire } from "module";
+//#region src/project.ts
+const requireFromHere = createRequire(import.meta.url);
+function resolvePackageJson(projectRoot, name) {
+	try {
+		return requireFromHere.resolve(`${name}/package.json`, { paths: [projectRoot] });
+	} catch {
+		try {
+			const main = requireFromHere.resolve(name, { paths: [projectRoot] });
+			const marker = `/node_modules/${name}/`;
+			const at = main.lastIndexOf(marker);
+			if (at === -1) return null;
+			const candidate = join(main.slice(0, at + marker.length), "package.json");
+			return existsSync(candidate) ? candidate : null;
+		} catch {
+			return null;
+		}
+	}
+}
+function isPackageResolvable(projectRoot, name) {
+	return resolvePackageJson(projectRoot, name) !== null;
+}
+function projectShortcut(path, proj) {
+	if (proj?.label) return proj.label;
+	const rootPath = findEnclosingWorktreeRoot(path);
+	if (rootPath && rootPath !== path) return `${projectShortcut(rootPath, getProject(rootPath))}/${path.split("/").pop() || path}`;
+	return path.split("/").pop() || path;
+}
+function ownedDeviceLabel(projectPath) {
+	const app = realpathSync(projectPath);
+	const root = repoRoot(app);
+	const appLabel = basename(app);
+	if (!root) return appLabel;
+	const worktreeLabel = basename(realpathSync(root));
+	return worktreeLabel === appLabel ? appLabel : `${worktreeLabel}-${appLabel}`;
+}
+function findProjectRoot(startDir) {
+	let dir;
+	try {
+		dir = realpathSync(resolve(startDir));
+	} catch {
+		dir = resolve(startDir);
+	}
+	while (true) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function loadPackageJson(projectRoot) {
+	const p = join(projectRoot, "package.json");
+	if (!existsSync(p)) return {
+		pkg: null,
+		parseError: null
+	};
+	try {
+		return {
+			pkg: JSON.parse(readFileSync(p, "utf-8")),
+			parseError: null
+		};
+	} catch (error) {
+		return {
+			pkg: null,
+			parseError: error?.message || String(error)
+		};
+	}
+}
+function readPackageJson(projectRoot) {
+	return loadPackageJson(projectRoot).pkg;
+}
+const APP_DEPENDENCIES = ["react-native", "expo"];
+function declaresAppDependency(pkg) {
+	if (!pkg || typeof pkg !== "object") return false;
+	const { dependencies, devDependencies } = pkg;
+	const deps = {
+		...dependencies,
+		...devDependencies
+	};
+	return APP_DEPENDENCIES.some((name) => name in deps);
+}
+function appProjectProblem(projectRoot) {
+	const file = join(projectRoot, "package.json");
+	const { pkg, parseError } = loadPackageJson(projectRoot);
+	if (parseError) return {
+		kind: "unreadable",
+		message: `${file} is not valid JSON (${parseError}), so Stim cannot tell whether this is a React Native or Expo app.`,
+		remedy: `Fix the JSON in ${file} -- an unfinished edit or a merge conflict leaves it unparseable -- then run the command again.`
+	};
+	if (declaresAppDependency(pkg)) return null;
+	return {
+		kind: "not-an-app",
+		message: `${file} depends on neither react-native nor expo, so this is not a React Native or Expo app.`,
+		remedy: "Run this from the app directory -- the one whose package.json depends on react-native or expo -- or from that directory inside a worktree."
+	};
+}
+function detectIsExpo(projectRoot) {
+	const pkg = readPackageJson(projectRoot);
+	const iosScript = pkg?.scripts?.ios;
+	if (typeof iosScript === "string") {
+		if (/\bexpo\s+run:ios\b/.test(iosScript)) return true;
+		if (/\breact-native\s+run-ios\b/.test(iosScript)) return false;
+	}
+	if (!pkg) return false;
+	const hasExpoDep = "expo" in {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const resolvable = () => isPackageResolvable(projectRoot, "expo");
+	if (!hasExpoDep && !resolvable()) return false;
+	const appJson = readAppJson(projectRoot);
+	if (appJson?.expo) return true;
+	const text = readAppConfigText(projectRoot);
+	if (text && /\b(?:from\s+['"]expo['"]|expo\/config|ExpoConfig)\b/.test(text)) return true;
+	if (hasExpoDep && resolvable()) return true;
+	if (looksLikeExpoConfig(appJson)) return true;
+	if (podfileUsesExpoModules(projectRoot)) return true;
+	return false;
+}
+function looksLikeExpoConfig(appJson) {
+	if (!appJson || typeof appJson !== "object" || Array.isArray(appJson)) return false;
+	if (appJson.expo) return true;
+	if ([
+		"slug",
+		"plugins",
+		"sdkVersion",
+		"experiments",
+		"runtimeVersion",
+		"updates",
+		"buildCacheProvider",
+		"assetBundlePatterns",
+		"splash",
+		"orientation",
+		"userInterfaceStyle"
+	].some((key) => appJson[key] !== void 0)) return true;
+	return Boolean(appJson.extra && typeof appJson.extra === "object" && appJson.extra.eas);
+}
+function podfileUsesExpoModules(projectRoot) {
+	const p = join(projectRoot, "ios", "Podfile");
+	if (!existsSync(p)) return false;
+	try {
+		return /^[^#\n]*use_expo_modules!/m.test(readFileSync(p, "utf-8"));
+	} catch {
+		return false;
+	}
+}
+function readAppJson(projectRoot) {
+	const p = join(projectRoot, "app.json");
+	if (!existsSync(p)) return null;
+	try {
+		return JSON.parse(readFileSync(p, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function readAppConfigText(projectRoot) {
+	for (const name of [
+		"app.config.js",
+		"app.config.ts",
+		"app.config.cjs",
+		"app.config.mjs"
+	]) {
+		const p = join(projectRoot, name);
+		if (existsSync(p)) try {
+			return readFileSync(p, "utf-8");
+		} catch {}
+	}
+	return null;
+}
+function detectBundleId(projectRoot) {
+	const fromJson = readAppJson(projectRoot)?.expo?.ios?.bundleIdentifier;
+	if (typeof fromJson === "string" && fromJson) return fromJson;
+	const text = readAppConfigText(projectRoot);
+	if (text) {
+		const id = text.match(/bundleIdentifier\s*:\s*["']([^"']+)["']/)?.[1];
+		if (id) return id;
+	}
+	return detectBundleIdFromPbxproj(projectRoot);
+}
+function detectAndroidPackage(projectRoot) {
+	const fromJson = readAppJson(projectRoot)?.expo?.android?.package;
+	if (typeof fromJson === "string" && fromJson) return fromJson;
+	const text = readAppConfigText(projectRoot);
+	if (text) {
+		const pkg = text.match(/package\s*:\s*["']([^"']+)["']/)?.[1];
+		if (pkg) return pkg;
+	}
+	return detectAndroidPackageFromGradle(projectRoot);
+}
+function detectBundleIdFromPbxproj(projectRoot) {
+	const iosDir = join(projectRoot, "ios");
+	if (!existsSync(iosDir)) return null;
+	let entries;
+	try {
+		entries = readdirSync(iosDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.endsWith(".xcodeproj")) continue;
+		const pbx = join(iosDir, entry.name, "project.pbxproj");
+		if (!existsSync(pbx)) continue;
+		let text;
+		try {
+			text = readFileSync(pbx, "utf-8");
+		} catch {
+			continue;
+		}
+		const concrete = [...text.matchAll(/PRODUCT_BUNDLE_IDENTIFIER\s*=\s*([^;\s"]+)\s*;/g)].map((m) => m[1]).filter((id) => !!id && !id.startsWith("$") && !id.includes("("));
+		if (concrete.length === 0) continue;
+		const counts = {};
+		for (const id of concrete) counts[id] = (counts[id] || 0) + 1;
+		let best = null, bestCount = 0, bestLen = Infinity;
+		for (const [id, count] of Object.entries(counts)) if (count > bestCount || count === bestCount && id.length < bestLen) {
+			best = id;
+			bestCount = count;
+			bestLen = id.length;
+		}
+		return best;
+	}
+	return null;
+}
+function detectAndroidPackageFromGradle(projectRoot) {
+	const gradle = join(projectRoot, "android", "app", "build.gradle");
+	if (!existsSync(gradle)) return null;
+	let text;
+	try {
+		text = readFileSync(gradle, "utf-8");
+	} catch {
+		return null;
+	}
+	const nsId = text.match(/namespace\s+["']([^"']+)["']/)?.[1];
+	if (nsId) return nsId;
+	const appId = text.match(/applicationId\s+["']([^"']+)["']/)?.[1];
+	if (appId) return appId;
+	return null;
+}
+//#endregion
+export { findProjectRoot as a, projectShortcut as c, detectIsExpo as i, resolvePackageJson as l, detectAndroidPackage as n, isPackageResolvable as o, detectBundleId as r, ownedDeviceLabel as s, appProjectProblem as t };

package/dist/reclaim-BPvN2HlP.mjs

@@ -0,0 +1,347 @@
+import { D as sameProcessRecord, O as waitForProcessExit, f as getProject, v as removeProject } from "./config-D7uu8Gbq.mjs";
+import { T as workspaceDir, a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, p as readWorkspaceState } from "./state-IYEY-zi8.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, x as parkedMaxSetting } from "./remote-cache-DOi5-zLj.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 { existsSync, rmSync } from "node:fs";
+//#region src/reclaim.ts
+async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
+	const skippedDevices = [];
+	const failedDevices = [];
+	for (const [platform, record] of Object.entries(collectors)) {
+		const rec = record;
+		const pid = rec?.pid;
+		if (typeof pid !== "number" || pid <= 0 || pid === process.pid || !pidExists(pid)) continue;
+		const ownership = verify({
+			pid,
+			platform,
+			root,
+			expected: rec
+		});
+		if (ownership.status === "gone") continue;
+		if (ownership.status === "unverified") {
+			const name = `${platform} log collector (pid ${pid})`;
+			const entry = {
+				platform: platform === "android" ? "android" : "ios",
+				name,
+				reason: `${ownership.reason}; keeping the record without signalling the process`
+			};
+			skippedDevices.push(entry);
+			failedDevices.push(entry);
+			continue;
+		}
+		try {
+			process.kill(pid, "SIGTERM");
+			if (await waitForProcessExit(rec, 5e3)) continue;
+		} catch (error) {
+			if (error.code === "ESRCH") continue;
+		}
+		const entry = {
+			platform: platform === "android" ? "android" : "ios",
+			name: `${platform} log collector (pid ${pid})`,
+			reason: "Collector exit could not be confirmed; keeping its ownership record."
+		};
+		skippedDevices.push(entry);
+		failedDevices.push(entry);
+	}
+	return {
+		skippedDevices,
+		failedDevices
+	};
+}
+function reclaimRemoteSession(root, { stopSession = defaultStopSession } = {}) {
+	const sessionId = readRemoteSessionId(root);
+	if (!sessionId) return {
+		stopped: null,
+		failed: null
+	};
+	let result;
+	try {
+		result = stopSession(root, sessionId);
+	} catch (err) {
+		result = {
+			status: "failed",
+			reason: String(err?.message ?? err)
+		};
+	}
+	if (result.status === "torn-down") {
+		if (result.reason) return {
+			stopped: sessionId,
+			failed: {
+				platform: "ios",
+				name: `remote session ${sessionId}`,
+				reason: `${result.reason} The session is stopped. Re-run cleanup to reconcile its retained ownership claim.`
+			}
+		};
+		clearRemoteSession(root, sessionId);
+		return {
+			stopped: sessionId,
+			failed: null
+		};
+	}
+	return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: `remote session ${sessionId}`,
+			reason: `${result.reason ?? "stop failed"} -- it keeps billing until its max duration. Stop it by hand from any directory of this project: eas simulator:stop --id ${sessionId}`
+		}
+	};
+}
+function defaultStopSession(root, sessionId) {
+	return endRecordedSession({
+		root,
+		sessionId,
+		easBin: resolveEasCliBin(root)?.file ?? null
+	});
+}
+function defaultStopMetroTunnel(record) {
+	return stopTunnel(record);
+}
+async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunnel } = {}) {
+	const record = readMetroTunnel(root);
+	if (record?.kind !== "managed") return {
+		stopped: null,
+		failed: null
+	};
+	let result;
+	try {
+		result = await stopMetroTunnel(record);
+	} catch (err) {
+		result = {
+			status: "failed",
+			reason: String(err?.message ?? err)
+		};
+	}
+	if (result.status === "failed") return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: `${record.provider} tunnel (pid ${record.pid})`,
+			reason: `${result.reason ?? "stop failed"} The process identity could not be verified or the stop could not be confirmed. The ownership record is kept. Inspect the process and retry \`stim worktree remove\`.`
+		}
+	};
+	if (!clearManagedMetroTunnel(root, record)) return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: "replacement managed tunnel",
+			reason: "A replacement managed tunnel record appeared during cleanup and is retained for a later stop."
+		}
+	};
+	return {
+		stopped: record.provider,
+		failed: null
+	};
+}
+function describeDereferenced(project) {
+	const devices = [];
+	const ios = project?.platforms?.ios;
+	if (ios?.deviceUdid) devices.push(`ios sim ${ios.deviceUdid}`);
+	const android = project?.platforms?.android;
+	if (android?.avdName) devices.push(`android avd ${android.avdName}`);
+	else if (android?.serial) devices.push(`android device ${android.serial}`);
+	return devices;
+}
+function parkedIosCacheKey(lastBuild) {
+	if (lastBuild === null || typeof lastBuild !== "object" || Array.isArray(lastBuild)) return null;
+	const build = lastBuild;
+	return build.platform === "ios" && typeof build.cacheKey === "string" ? build.cacheKey : null;
+}
+function parkRequest(project, projectPath) {
+	const { max, error } = parkedMaxSetting("ios");
+	if (error || max <= 0) return void 0;
+	const cacheKey = parkedIosCacheKey(readWorkspaceState(projectPath)?.lastBuild);
+	return {
+		projectPath,
+		max,
+		bundleId: typeof project?.bundleId === "string" ? project.bundleId : null,
+		cacheKey,
+		simslimManaged: Boolean(project?.platforms?.ios?.simslimManaged)
+	};
+}
+function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
+	const deletedDevices = [];
+	const parkedDevices = [];
+	const evictedDevices = [];
+	const poolNotes = [];
+	const skippedDevices = [];
+	const failedDevices = [];
+	const ios = project?.platforms?.ios;
+	if (ios?.owned && ios.deviceUdid) {
+		const udid = ios.deviceUdid;
+		const label = ios.deviceName || udid;
+		const r = teardownOwnedIosSim(udid, {
+			del: true,
+			label,
+			...park ? { park: parkRequest(project, projectPath) } : {}
+		});
+		if (r.parkFallback) poolNotes.push(`could not park ${label}: ${r.parkFallback} -- deleted it instead`);
+		for (const failure of r.evictionFailures ?? []) poolNotes.push(failure);
+		if (r.parked) {
+			parkedDevices.push(r.parked);
+			evictedDevices.push(...r.evicted ?? []);
+		} else if (r.status === "torn-down") deletedDevices.push(r.label);
+		if (r.status === "skipped") skippedDevices.push({
+			platform: "ios",
+			name: label,
+			udid,
+			reason: `${r.reason} -- not touched`
+		});
+		else if (r.status === "failed") {
+			const entry = {
+				platform: "ios",
+				name: label,
+				udid,
+				reason: `teardown failed: ${r.reason}`
+			};
+			skippedDevices.push(entry);
+			failedDevices.push(entry);
+		}
+	}
+	const android = project?.platforms?.android;
+	if (android?.owned && android.avdName) {
+		const bound = parkedMaxSetting("android");
+		const r = teardownOwnedAvd(android.avdName, {
+			del: true,
+			...park && !bound.error && bound.max > 0 ? { park: {
+				projectPath,
+				max: bound.max,
+				configuration: typeof android.poolConfiguration === "string" ? android.poolConfiguration : void 0
+			} } : {}
+		});
+		if (r.parkFallback) poolNotes.push(`could not park ${android.avdName}: ${r.parkFallback} -- deleted it instead`);
+		for (const failure of r.evictionFailures ?? []) poolNotes.push(failure);
+		if (r.parked) {
+			parkedDevices.push(r.parked);
+			evictedDevices.push(...r.evicted ?? []);
+		} else if (r.status === "torn-down") deletedDevices.push(android.avdName);
+		else if (r.status === "skipped") skippedDevices.push({
+			platform: "android",
+			name: android.avdName,
+			reason: `${r.reason} -- not touched`
+		});
+		else if (r.status === "failed") {
+			const entry = {
+				platform: "android",
+				name: android.avdName,
+				reason: `teardown failed: ${r.reason}`
+			};
+			skippedDevices.push(entry);
+			failedDevices.push(entry);
+		}
+	}
+	return {
+		deletedDevices,
+		parkedDevices,
+		evictedDevices,
+		poolNotes,
+		skippedDevices,
+		failedDevices
+	};
+}
+async function reclaimProject(path, { deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership } = {}) {
+	const project = getProject(path);
+	const dereferenced = describeDereferenced(project);
+	const initialState = readWorkspaceState(path);
+	let killedPid = null;
+	let skippedMetro = null;
+	let supervisorHeld = false;
+	const supervisor = resolveSupervisorTarget({
+		state: initialState?.supervisor,
+		record: project?.supervisor,
+		reservedPort: project?.metroPort
+	});
+	if (supervisor.status === "ours") {
+		if (killMetroTree(supervisor.pid, supervisor.processToken) && await waitForProcessExit(supervisor, 1e4)) killedPid = supervisor.pid;
+		else {
+			skippedMetro = `could not confirm supervisor pid ${supervisor.pid} exited`;
+			supervisorHeld = true;
+		}
+	} else if (supervisor.status === "unverified") {
+		skippedMetro = supervisor.reason ?? "supervisor identity could not be verified";
+		supervisorHeld = true;
+	} else if (typeof project?.metroPort === "number") {
+		if (!(await resolveProjectMetro(project.metroPort, path)).missing) skippedMetro = "Externally started server left alone; no verified Stim supervisor owns it";
+	}
+	const { skippedDevices: skippedCollectors, failedDevices: failedCollectors } = await reapCollectors(path, {
+		verify: verifyCollector,
+		collectors: initialState?.collectors ?? {}
+	});
+	function retainReplacementProcesses() {
+		const currentState = readWorkspaceState(path);
+		const currentProject = getProject(path);
+		if (Boolean(currentState?.supervisor && !sameProcessRecord(currentState.supervisor, initialState?.supervisor) || currentProject?.supervisor && !sameProcessRecord(currentProject.supervisor, project?.supervisor) || Object.entries(currentState?.collectors ?? {}).some(([platform, record]) => !sameProcessRecord(record, initialState?.collectors?.[platform])))) {
+			supervisorHeld = true;
+			skippedMetro = "A replacement process appeared during cleanup; its ownership records are retained";
+		}
+	}
+	retainReplacementProcesses();
+	const { deletedDevices, parkedDevices, evictedDevices, poolNotes, skippedDevices, failedDevices } = deleteOwnedDevices && !supervisorHeld && failedCollectors.length === 0 ? reclaimOwnedDevices(project, path, { park: parkOwnedDevices }) : {
+		deletedDevices: [],
+		parkedDevices: [],
+		evictedDevices: [],
+		poolNotes: [],
+		skippedDevices: [],
+		failedDevices: []
+	};
+	skippedDevices.push(...skippedCollectors);
+	failedDevices.push(...failedCollectors);
+	const remote = reclaimRemoteSession(path, { stopSession });
+	if (remote.failed) {
+		skippedDevices.push(remote.failed);
+		failedDevices.push(remote.failed);
+	}
+	const tunnel = await reclaimMetroTunnel(path, { stopMetroTunnel });
+	if (tunnel.failed) {
+		skippedDevices.push(tunnel.failed);
+		failedDevices.push(tunnel.failed);
+	}
+	let releasedLeases = [];
+	try {
+		releasedLeases = releaseLeases(path);
+	} catch {
+		releasedLeases = [];
+	}
+	retainReplacementProcesses();
+	const removedWorkspaceDirs = [];
+	const failedWorkspaceDirs = [];
+	if (failedDevices.length === 0 && !supervisorHeld) {
+		const dir = workspaceDir(path);
+		if (existsSync(dir)) try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+			removedWorkspaceDirs.push(dir);
+		} catch {
+			failedWorkspaceDirs.push(dir);
+		}
+	}
+	const keptEntry = supervisorHeld || failedDevices.length > 0 || failedWorkspaceDirs.length > 0;
+	if (project && !keptEntry && !preserveProjectRecord) removeProject(path);
+	return {
+		path,
+		dereferenced,
+		killedPid,
+		skippedMetro,
+		metroPort: project?.metroPort ?? null,
+		deletedDevices,
+		parkedDevices,
+		evictedDevices,
+		poolNotes,
+		skippedDevices,
+		failedDevices,
+		keptEntry,
+		stoppedSession: remote.stopped,
+		stoppedTunnel: tunnel.stopped,
+		releasedLeases,
+		removedWorkspaceDirs,
+		failedWorkspaceDirs
+	};
+}
+//#endregion
+export { reclaimProject as n, describeDereferenced as t };