stim 1.34.0 → 1.35.0

package/dist/device-lease-run-i3FNX4OE.mjs

@@ -1,282 +0,0 @@
-import { C as operationState } from "./exec-CGuDzt40.mjs";
-import { a as formatElapsed, r as clockTime } from "./command-output-DjExb_tZ.mjs";
-import { dt as deviceSlotKey } from "./config-BW0fAtoK.mjs";
-import { Xt as APP_READINESS_TIMEOUT_MS, zt as MANIFEST_VERIFY_TIMEOUT_MS } from "./ccache-ChBMXlBq.mjs";
-import { E as releaseRunLease, S as parseLease, T as raiseLease, b as leaseIsExpired, j as takeLease, v as deviceLeasePath, y as fileLeaseIo } from "./activity-DkS-Ir6V.mjs";
-//#region src/engine/device-lease-run.ts
-const LEASE_STEP_FLOOR_MS = 6e4;
-const DEBUG_VERIFY_STEP_MS = MANIFEST_VERIFY_TIMEOUT_MS + APP_READINESS_TIMEOUT_MS;
-const DEVICE_WAIT_POLL_MS = 2e3;
-const DEVICE_WAIT_LINE_MS = 3e4;
-const DEVICE_BUSY = "STIM_DEVICE_BUSY";
-const DEVICE_LOST = "STIM_DEVICE_LOST";
-function leaseStepMs(boundMs = 0) {
-	return Math.max(LEASE_STEP_FLOOR_MS, boundMs);
-}
-function parseDeviceWait(value) {
-	if (value === void 0 || value === null) return { seconds: 60 };
-	const seconds = String(value).trim() === "" ? NaN : Number(value);
-	if (!Number.isInteger(seconds) || seconds < 0) return { error: `Invalid --wait value ${JSON.stringify(value)}. Pass a whole number of seconds, e.g. --wait 90.` };
-	return { seconds };
-}
-function waitFlagConflict(argv) {
-	return argv.some((arg) => arg === "--wait" || arg.startsWith("--wait=")) && argv.includes("--no-wait");
-}
-function leaseExpiryText(expiresAt, now) {
-	const remaining = Date.parse(expiresAt) - now;
-	return `${clockTime(expiresAt)} (${formatElapsed(Math.max(0, remaining))} from now)`;
-}
-function describeDevice(lease) {
-	return lease.deviceName ? `${lease.deviceName} (${lease.id})` : lease.id;
-}
-function facts(lease) {
-	return {
-		platform: lease.platform,
-		id: lease.id,
-		deviceName: lease.deviceName,
-		holder: lease.holder,
-		expiresAt: lease.expiresAt
-	};
-}
-function waitingLine(lease, now) {
-	return `waiting for ${lease.holder} to release ${describeDevice(lease)}; its lease runs until ${leaseExpiryText(lease.expiresAt, now)} -- stim guide lifecycle lease`;
-}
-function appIdMatch(ours, theirs) {
-	if (!ours || !theirs) return "unknown";
-	return ours === theirs ? "same" : "different";
-}
-function bypassLines(lease, now, match) {
-	const consequence = {
-		same: "Both workspaces build the same app id, so this install terminates the app that workspace is running.",
-		different: "The other workspace's app id differs, so the launch below backgrounds it rather than ending it.",
-		unknown: "Stim cannot tell whether the two workspaces build the same app id; if they do, this install terminates the holder's running app."
-	}[match];
-	return [`--no-wait: ${lease.holder} holds ${describeDevice(lease)} until ${leaseExpiryText(lease.expiresAt, now)}, and this run is proceeding without a lease.`, consequence];
-}
-function busyRefusal({ lease, now, idLabel, waitSeconds }) {
-	return {
-		code: DEVICE_BUSY,
-		message: `${lease.holder} holds ${describeDevice(lease)} until ${leaseExpiryText(lease.expiresAt, now)}` + (waitSeconds > 0 ? `, and this command waited ${waitSeconds}s for it.` : "."),
-		remedy: `Wait longer with \`--wait <seconds>\`, pick another device with \`--device <${idLabel}>\`, or pass \`--no-wait\` to install anyway -- which takes no lease and, when both workspaces build the same app id, terminates the holder's running app.`,
-		lease: facts(lease)
-	};
-}
-function unreadableRefusal(path) {
-	return {
-		code: DEVICE_BUSY,
-		message: `The lease file at ${path} does not parse, so Stim cannot tell who holds that device.`,
-		remedy: `Read ${path} and, once you know no run depends on it, delete it. \`stim gc\` reports it on every run.`,
-		lease: {
-			platform: null,
-			id: null,
-			deviceName: null,
-			holder: null,
-			expiresAt: null
-		}
-	};
-}
-function untokenedRefusal(lease, now) {
-	return {
-		code: DEVICE_BUSY,
-		message: `This workspace holds ${describeDevice(lease)} until ${leaseExpiryText(lease.expiresAt, now)}, but its own record of that lease is gone, so this run cannot prove the lease is still its own.`,
-		remedy: "Run `stim device unlock`, which releases by holder, then run this command again.",
-		lease: facts(lease)
-	};
-}
-function otherDeviceRefusal(leasedId, requestedId) {
-	return {
-		code: "STIM_NO_DEVICE",
-		message: `This workspace already leases ${leasedId}, and this run asked for ${requestedId}.`,
-		remedy: `Run \`stim device unlock\` to give up ${leasedId}, or use it with \`--device ${leasedId}\`.`,
-		lease: null
-	};
-}
-function lostLine(holder, expiresAt, now) {
-	return `${holder ?? "another workspace"} took this device's lease${expiresAt ? ` until ${leaseExpiryText(expiresAt, now)}` : ""}. The app is already installed, so this run continues without one.`;
-}
-function lostRefusal(holder, expiresAt, now) {
-	const who = holder ?? "another workspace";
-	const until = expiresAt ? ` until ${leaseExpiryText(expiresAt, now)}` : "";
-	return {
-		code: DEVICE_LOST,
-		message: `${who} took this device's lease${until} before this run could install.`,
-		remedy: "Run this command again; it waits for that lease with `--wait <seconds>`.",
-		lease: null
-	};
-}
-function runLease({ root, platform, slot = "default", kind, expiresAt, io = fileLeaseIo }) {
-	const handle = {
-		kind,
-		expiresAt,
-		lost: false,
-		raise(boundMs) {
-			if (handle.kind === null || handle.lost) return {
-				ok: !handle.lost,
-				holder: null,
-				expiresAt: handle.expiresAt
-			};
-			const result = raiseLease({
-				root,
-				platform,
-				slot,
-				minMs: leaseStepMs(boundMs)
-			}, io);
-			if (result.status === "raised") {
-				handle.expiresAt = result.lease.expiresAt;
-				return {
-					ok: true,
-					holder: result.lease.holder,
-					expiresAt: result.lease.expiresAt
-				};
-			}
-			handle.lost = true;
-			const taken = result.status === "lost" ? result.lease : null;
-			return {
-				ok: false,
-				holder: taken?.holder ?? null,
-				expiresAt: taken?.expiresAt ?? null
-			};
-		},
-		release() {
-			if (handle.kind === null) return;
-			releaseRunLease({
-				root,
-				platform,
-				slot
-			}, io);
-		},
-		facts() {
-			if (handle.kind === null || handle.lost || handle.expiresAt === null) return null;
-			return {
-				kind: handle.kind,
-				expiresAt: handle.expiresAt
-			};
-		}
-	};
-	return handle;
-}
-/** Release the run's lease as soon as `context`'s operation is aborted; returns a function that stops listening. */
-function releaseLeaseOnAbort(context, release) {
-	const onAbort = () => {
-		operationState(context).handled = true;
-		release();
-	};
-	if (context.signal.aborted) onAbort();
-	else context.signal.addEventListener("abort", onAbort, { once: true });
-	return () => context.signal.removeEventListener("abort", onAbort);
-}
-async function waitForDevice({ root, platform, slot = "default", id, idLabel, waitSeconds, noWait = false, appId = null, holderAppId = () => null, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), warn = () => {}, io = fileLeaseIo, deadline, lastLine }) {
-	const path = deviceLeasePath(platform, id);
-	for (;;) {
-		const raw = io.readLease(path);
-		const current = parseLease(raw);
-		if (raw !== null && !current) return {
-			status: "refused",
-			refusal: unreadableRefusal(path)
-		};
-		if (!current || leaseIsExpired(current, now())) return { status: "free" };
-		if (current.holder === root && (current.slot ?? "default") === slot) return {
-			status: "ours",
-			lease: current
-		};
-		if (noWait) {
-			for (const line of bypassLines(current, now(), appIdMatch(appId, holderAppId(current.holder)))) warn(line);
-			return {
-				status: "bypassed",
-				lease: current
-			};
-		}
-		if (now() >= deadline) return {
-			status: "refused",
-			refusal: busyRefusal({
-				lease: current,
-				now: now(),
-				idLabel,
-				waitSeconds
-			})
-		};
-		if (lastLine.at === null || now() - lastLine.at >= 3e4) {
-			lastLine.at = now();
-			warn(waitingLine(current, now()));
-		}
-		await sleep(DEVICE_WAIT_POLL_MS);
-	}
-}
-async function acquireRunLease({ root, platform, slot = "default", id, deviceName = null, idLabel, waitSeconds, noWait, installBoundMs, appId = null, holderAppId = () => null, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), warn = () => {}, io = fileLeaseIo }) {
-	const recorded = io.readHolder(root)[deviceSlotKey(platform, slot)];
-	let held = recorded;
-	if (recorded && recorded.id !== id) {
-		const other = parseLease(io.readLease(deviceLeasePath(platform, recorded.id)));
-		if (other && other.token === recorded.token && !leaseIsExpired(other, now())) return {
-			status: "refused",
-			refusal: otherDeviceRefusal(recorded.id, id)
-		};
-		held = void 0;
-	}
-	const path = deviceLeasePath(platform, id);
-	const deadline = now() + waitSeconds * 1e3;
-	const lastLine = { at: null };
-	for (;;) {
-		const current = parseLease(io.readLease(path));
-		const mine = current && held && current.token === held.token ? {
-			lease: current,
-			record: held
-		} : null;
-		if (mine && (mine.record.kind === "run" || !leaseIsExpired(mine.lease, now()))) {
-			const raised = raiseLease({
-				root,
-				platform,
-				slot,
-				minMs: leaseStepMs(installBoundMs)
-			}, io);
-			if (raised.status === "raised") return {
-				status: "leased",
-				kind: mine.record.kind,
-				expiresAt: raised.lease.expiresAt
-			};
-		}
-		const outcome = await waitForDevice({
-			root,
-			platform,
-			slot,
-			id,
-			idLabel,
-			waitSeconds,
-			noWait,
-			appId,
-			holderAppId,
-			now,
-			sleep,
-			warn,
-			io,
-			deadline,
-			lastLine
-		});
-		if (outcome.status === "refused") return outcome;
-		if (outcome.status === "bypassed") return { status: "unleased" };
-		if (outcome.status === "ours") return {
-			status: "refused",
-			refusal: untokenedRefusal(outcome.lease, now())
-		};
-		const taken = takeLease({
-			root,
-			platform,
-			slot,
-			id,
-			deviceName,
-			kind: "run",
-			durationMs: leaseStepMs(installBoundMs)
-		}, io);
-		if (taken.status === "unreadable") return {
-			status: "refused",
-			refusal: unreadableRefusal(taken.path)
-		};
-		if (taken.status === "taken" || taken.status === "set") return {
-			status: "leased",
-			kind: taken.status === "set" ? held?.kind ?? "run" : "run",
-			expiresAt: taken.lease.expiresAt
-		};
-	}
-}
-//#endregion
-export { acquireRunLease as a, lostRefusal as c, runLease as d, waitFlagConflict as f, DEVICE_WAIT_POLL_MS as i, parseDeviceWait as l, DEVICE_BUSY as n, leaseExpiryText as o, waitForDevice as p, DEVICE_WAIT_LINE_MS as r, lostLine as s, DEBUG_VERIFY_STEP_MS as t, releaseLeaseOnAbort as u };

package/dist/idle-shutdown-DPD8oV36.mjs

@@ -1,142 +0,0 @@
-import { k as workspaceLogsDir$1, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-BdZ-QgmB.mjs";
-import { o as formatLongDuration } from "./command-output-DjExb_tZ.mjs";
-import { dt as deviceSlotKey, v as loadConfig$1 } from "./config-BW0fAtoK.mjs";
-import { i as createNdjsonWriter } from "./ndjson-CrjIsGzw.mjs";
-import { B as workspaceBuildInProgress, P as collectOwnedDeviceActivity, ht as teardownOwnedIosSim, pt as teardownOwnedAvd } from "./workspaces-B9v5V7Es.mjs";
-import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { _ as workspaceDeviceLastUseAt } from "./activity-DkS-Ir6V.mjs";
-import { d as listAllIosSims } from "./ios-BdZdNsAj.mjs";
-import { join } from "node:path";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
-import { DEVICE_IDLE_SHUTDOWN_KEY, DEVICE_RECLAIM_REASON, readDeviceIdleShutdowns } from "@stim-cli/core/state";
-//#region src/devices/idle-shutdown.ts
-const SIM_LIST_TIMEOUT_MS = 1e4;
-const MINUTE_MS = 6e4;
-/**
-* How long a booted owned device has been idle, when that is at least `idleMs` and nothing keeps it in use: no
-* driver, Stim or agent-device lock, or unreadable activity evidence, no build in the workspace, and no activity
-* (including an open stim-server viewer) for `idleMs`. Null keeps the device running.
-*/
-function idleShutdownDueMs(activity, { idleMs, now, buildInProgress, platform = process.platform }) {
-	if (buildInProgress || activity.state === "driven") return null;
-	const unknown = platform === "win32" ? activity.basis.filter((basis) => basis !== "driver-process") : activity.basis;
-	if (activity.state === "unknown" && unknown.length > 0) return null;
-	const last = Date.parse(activity.lastActivityAt ?? "");
-	if (!Number.isFinite(last)) return null;
-	const idle = now - last;
-	return idle >= idleMs ? idle : null;
-}
-function listSims() {
-	try {
-		return listAllIosSims({ timeoutMs: SIM_LIST_TIMEOUT_MS });
-	} catch {
-		return [];
-	}
-}
-/** Booted owned devices idle for `idleMs`, in one workspace or all registered workspaces when root is absent. */
-function dueIdleDevices(root, idleMs, now = Date.now()) {
-	const config = loadConfig$1();
-	if (!config) return [];
-	const self = root === void 0 ? void 0 : canonicalPath(root);
-	const projects = Object.fromEntries(Object.entries(config.projects).filter(([path]) => {
-		if (self !== void 0 && canonicalPath(path) !== self) return false;
-		const usedAt = workspaceDeviceLastUseAt(path);
-		return !Number.isFinite(usedAt) || now - usedAt >= idleMs;
-	}));
-	if (!Object.keys(projects).length) return [];
-	const builds = new Map(Object.keys(projects).map((path) => [path, workspaceBuildInProgress(path)]));
-	return collectOwnedDeviceActivity({
-		...config,
-		projects
-	}, listSims(), now).flatMap((device) => {
-		const idleForMs = idleShutdownDueMs(device.activity, {
-			idleMs,
-			now,
-			buildInProgress: builds.get(device.project) ?? true
-		});
-		return idleForMs === null ? [] : [{
-			device,
-			idleForMs
-		}];
-	});
-}
-/** Appends an idle shutdown record to the workspace's metro.ndjson, where the supervisor writes its own. */
-function writeIdleShutdownEvent(root, event) {
-	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
-	writer.write({
-		src: "metro",
-		...event
-	});
-	writer.close();
-}
-/**
-* Shuts down, through centralized teardown, each of the workspace's owned devices that is still idle for `idleMs`,
-* and records why. The caller holds the workspace's native-run lock, so no `ios` or `android` run is booting or
-* installing on them.
-*/
-async function shutDownIdleDevices(root, idleMs, log, now = Date.now(), { only, reason } = {}) {
-	let shutDown = 0;
-	for (const { device, idleForMs } of dueIdleDevices(root, idleMs, now)) {
-		if (only && (device.kind !== only.kind || device.id !== only.id || device.project !== only.project || device.slot !== only.slot)) continue;
-		const what = `${device.kind === "ios" ? "simulator" : "emulator"} ${device.name}`;
-		const outcome = device.kind === "ios" ? await teardownOwnedIosSim(device.id, {
-			label: device.name,
-			workspace: root
-		}) : await teardownOwnedAvd(device.id, {
-			owner: {
-				projectPath: device.project,
-				slot: device.slot
-			},
-			workspace: root
-		});
-		if (outcome.status === "torn-down") {
-			shutDown++;
-			const idleMinutes = Math.floor(idleForMs / MINUTE_MS);
-			try {
-				await updateWorkspaceStateAsync(root, (state) => ({
-					...state,
-					[DEVICE_IDLE_SHUTDOWN_KEY]: {
-						...readDeviceIdleShutdowns(state),
-						[deviceSlotKey(device.kind, device.slot)]: {
-							at: new Date(now).toISOString(),
-							idleMinutes,
-							...reason ? { reason } : {}
-						}
-					}
-				}));
-			} catch (error) {
-				log({
-					level: "warn",
-					event: "device_idle_shutdown_failed",
-					msg: `shut down idle ${what} but could not record it: ${error?.message || error}`
-				});
-			}
-			log({
-				level: "info",
-				event: "device_idle_shutdown",
-				msg: `shut down ${what}, idle ${formatLongDuration(idleForMs)}${reason === DEVICE_RECLAIM_REASON ? ", reclaimed for a waiting run" : ""}`
-			});
-		} else if (outcome.status !== "missing") log({
-			level: "warn",
-			event: "device_idle_shutdown_failed",
-			msg: `could not shut down idle ${what}: ${outcome.reason}`,
-			...outcome.status === "skipped" ? { skipped: true } : {}
-		});
-	}
-	return shutDown;
-}
-/** Forgets the slot's idle shutdown once a run boots its device again. */
-async function clearDeviceIdleShutdown(root, platform, slot = "default") {
-	const key = deviceSlotKey(platform, slot);
-	if (!(key in readDeviceIdleShutdowns(readWorkspaceState$1(root)))) return;
-	await updateWorkspaceStateAsync(root, (state) => {
-		const { [key]: _cleared, ...rest } = readDeviceIdleShutdowns(state);
-		const { [DEVICE_IDLE_SHUTDOWN_KEY]: _all, ...others } = state;
-		return Object.keys(rest).length ? {
-			...others,
-			[DEVICE_IDLE_SHUTDOWN_KEY]: rest
-		} : others;
-	});
-}
-//#endregion
-export { writeIdleShutdownEvent as i, dueIdleDevices as n, shutDownIdleDevices as r, clearDeviceIdleShutdown as t };