stim 1.17.2 → 1.19.0

package/dist/idle-BXG__1BA.mjs

@@ -1,176 +0,0 @@
-import { H as projectDeviceSlots } from "./config-D0DbpZtM.mjs";
-import { o as formatLongDuration } from "./command-output-CDAIFD-8.mjs";
-import { r as readWorkspaceState } from "./workspace-state-DqcCbpE7.mjs";
-import { i as recordGcResult } from "./in-use-CvGOUn-x.mjs";
-import { o as idleForMs, r as createActivityReader } from "./activity-IRvJY_ru.mjs";
-import { z as ownedAvdSerialResolver } from "./android-B_YNZy61.mjs";
-import { g as teardownOwnedIosSim, m as teardownOwnedAvd } from "./ownership-BMLqyBgJ.mjs";
-import { r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-D0WkjCPd.mjs";
-import chalk from "chalk";
-//#region src/commands/gc/idle.ts
-function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
-	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
-	const dead = new Set(deadProjects);
-	const found = [];
-	for (const [project, record] of Object.entries(config?.projects ?? {})) {
-		if (dead.has(project)) continue;
-		for (const { slot, platforms } of projectDeviceSlots(record)) {
-			const ios = platforms.ios;
-			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
-				kind: "ios",
-				id: ios.deviceUdid,
-				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
-				project,
-				slot,
-				activity: readActivity({
-					platform: "ios",
-					id: ios.deviceUdid,
-					slot,
-					workspace: project
-				})
-			});
-			const android = platforms.android;
-			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
-			if (android?.avdName && serial) found.push({
-				kind: "android",
-				id: android.avdName,
-				name: android.avdName,
-				project,
-				slot,
-				activity: readActivity({
-					platform: "android",
-					id: serial,
-					slot,
-					workspace: project
-				})
-			});
-		}
-	}
-	return found;
-}
-function findIdleDevices({ buildInProgress, now, ...inputs }) {
-	return findOwnedDeviceActivity(inputs).filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
-		kind,
-		id,
-		name,
-		project,
-		slot,
-		lastActivityAt: activity.lastActivityAt ?? null,
-		idleForMs: idleForMs(activity, now),
-		buildInProgress: buildInProgress(project)
-	}));
-}
-function idleShutdownCandidates(devices, idleMs) {
-	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
-}
-function parseIdleDuration(value) {
-	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
-	if (!match) return null;
-	const unit = {
-		m: 6e4,
-		h: 36e5,
-		d: 864e5
-	}[match[2]];
-	return Number(match[1]) * unit;
-}
-function workspaceBuildInProgress(project) {
-	const record = parseActiveBuild(readWorkspaceState(project)?.[ACTIVE_BUILD_KEY]);
-	if (!record) return false;
-	try {
-		return activeBuildState(record.claim) !== "stale";
-	} catch {
-		return true;
-	}
-}
-function deviceActivityInputs(config, sims, now) {
-	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
-	return {
-		config,
-		sims,
-		readActivity: createActivityReader({ now }),
-		androidSerial: (avdName) => {
-			try {
-				return resolve(avdName).serial ?? null;
-			} catch {
-				return null;
-			}
-		}
-	};
-}
-function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
-	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
-}
-function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
-	return findIdleDevices({
-		...deviceActivityInputs(config, sims, now),
-		deadProjects,
-		now,
-		buildInProgress: workspaceBuildInProgress
-	});
-}
-function idleDeviceLines(devices) {
-	if (devices.length === 0) return [];
-	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
-		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
-		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
-		const build = d.buildInProgress ? ", build in progress" : "";
-		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
-	})];
-}
-function shutDownIdleDevices(devices, idleMs, recollect) {
-	const candidates = idleShutdownCandidates(devices, idleMs);
-	const shutDown = [];
-	if (candidates.length === 0) {
-		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
-		return {
-			failures: 0,
-			shutDown
-		};
-	}
-	const fresh = idleShutdownCandidates(recollect(), idleMs);
-	let failures = 0;
-	for (const device of candidates) {
-		const what = `${device.kind} ${device.name}`;
-		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
-		if (!current) {
-			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
-			recordGcResult("idleDevice", "kept", device.name, {
-				id: device.id,
-				detail: `it is no longer idle for ${formatLongDuration(idleMs)}`
-			});
-			continue;
-		}
-		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
-			projectPath: device.project,
-			slot: device.slot
-		} });
-		if (outcome.status === "torn-down") {
-			shutDown.push(device);
-			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
-			recordGcResult("idleDevice", "done", device.name, {
-				id: device.id,
-				detail: `idle ${formatLongDuration(current.idleForMs)}`
-			});
-		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
-		else if (outcome.status === "skipped") {
-			console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
-			recordGcResult("idleDevice", "kept", device.name, {
-				id: device.id,
-				detail: outcome.reason
-			});
-		} else {
-			failures++;
-			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
-			recordGcResult("idleDevice", "failed", device.name, {
-				id: device.id,
-				detail: outcome.reason
-			});
-		}
-	}
-	return {
-		failures,
-		shutDown
-	};
-}
-//#endregion
-export { parseIdleDuration as a, idleShutdownCandidates as i, collectOwnedDeviceActivity as n, shutDownIdleDevices as o, idleDeviceLines as r, workspaceBuildInProgress as s, collectIdleDevices as t };

package/dist/in-use-CvGOUn-x.mjs

@@ -1,130 +0,0 @@
-import { p as getProject } from "./config-D0DbpZtM.mjs";
-import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
-import { r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { o as readWebRecord, u as webFacts } from "./state-PeQiJuIu.mjs";
-import { h as listBuildLocks } from "./device-lease-DpoS36_u.mjs";
-import { n as listBuildSlots } from "./build-slots-41v_d2x9.mjs";
-import { n as managedLockHolders, t as resolveSupervisorTarget } from "./ownership-BMLqyBgJ.mjs";
-import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-import { i as macosRuntimeClaim } from "./state-DyaNTgfR.mjs";
-import { lstatSync, readdirSync, rmSync, rmdirSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { realpathSync as realpathSync$1 } from "fs";
-import { resolve as resolve$1 } from "path";
-import { hostedNativeRecords, macosAppState, parseHostedNativePlacement, readMacosRecord, unreadableHostedNative } from "@stim-cli/core/state";
-//#region src/commands/gc/paths.ts
-function canonicalPath(p) {
-	try {
-		return realpathSync$1(p);
-	} catch {
-		return resolve$1(p);
-	}
-}
-//#endregion
-//#region src/commands/gc/results.ts
-const results = [];
-function recordGcResult(kind, status, label, { id = null, bytes = null, detail = null } = {}) {
-	results.push({
-		kind,
-		status,
-		label,
-		id,
-		bytes,
-		detail
-	});
-}
-function takeGcResults() {
-	return results.splice(0);
-}
-//#endregion
-//#region src/workspace/in-use.ts
-const NATIVE_RUN = "native-run";
-const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
-function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted = true, nativeRun = true } = {}) {
-	const reasons = [];
-	if (supervisor) {
-		const project = getProject(root);
-		const target = resolveSupervisorTarget({
-			state: readWorkspaceState$1(root)?.supervisor,
-			record: project?.supervisor,
-			reservedPort: project?.metroPort
-		});
-		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
-		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
-		const macos = macosAppState(readMacosRecord(root));
-		if (macos?.host) reasons.push(`its macOS app runs on ${macos.host.machine}`);
-		else if (macos?.state === "running" || macos?.state === "orphaned" || macos?.build.state === "running") reasons.push("its macOS app or build is running");
-		else if (macos?.state === "unverified" || !macos && readWorkspaceState$1(root)?.macos !== void 0) reasons.push("its macOS process owner cannot be verified");
-		const runtime = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
-		if (runtime.live.length) reasons.push("its macOS runtime claim is held");
-		else if (runtime.unresolved[0]) reasons.push(`its macOS runtime cannot be verified: ${runtime.unresolved[0].reason}`);
-		const browser = webFacts(readWebRecord(root));
-		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
-		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
-	}
-	if (nativeRun) {
-		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
-		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
-		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
-	}
-	for (const platform of ["ios", "android"]) for (const [slot, record] of Object.entries(hosted ? hostedNativeRecords(readWorkspaceState$1(root), platform) : {})) {
-		const placement = parseHostedNativePlacement(record, platform);
-		reasons.push(placement ? `its ${platform === "ios" ? "iOS simulator" : "Android emulator"} runs on ${placement.machine}` : unreadableHostedNative(slot, platform));
-	}
-	const self = canonicalPath(root);
-	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
-		if (!entry.alive && !entry.unresolved) continue;
-		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
-	}
-	if (managedLocks) reasons.push(...managedLockHolders(root));
-	return reasons;
-}
-function emptyWorkspaceDir(dir) {
-	if (lstatSync(dir).isSymbolicLink()) {
-		unlinkSync(dir);
-		return;
-	}
-	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join(dir, name), {
-		recursive: true,
-		force: true
-	});
-}
-async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
-	try {
-		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
-			const reasons = workspaceInUse(root, {
-				...checks,
-				nativeRun: false
-			});
-			if (reasons.length) return {
-				ran: false,
-				reasons
-			};
-			return {
-				ran: true,
-				value: await fn()
-			};
-		}, {
-			external: true,
-			waitMs: 0,
-			ownerPurpose: purpose
-		});
-	} catch (error) {
-		if (workspaceProcessLockError(error)) return {
-			ran: false,
-			reasons: [NATIVE_RUN_HELD]
-		};
-		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
-			ran: false,
-			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
-		};
-		throw error;
-	} finally {
-		try {
-			const dir = workspaceDir(root);
-			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
-		} catch {}
-	}
-}
-//#endregion
-export { takeGcResults as a, recordGcResult as i, withIdleWorkspace as n, canonicalPath as o, workspaceInUse as r, emptyWorkspaceDir as t };