stim 1.0.0 → 1.1.0

package/dist/device-DJKv5Qej.mjs

@@ -0,0 +1,250 @@
+import { a as findProjectRoot } from "./project-COj6nzzh.mjs";
+import { r as clockTime } from "./command-output-8wHMEde0.mjs";
+import { f as takeLease, l as releaseWorkspaceLeases, n as fileLeaseIo, o as parseLeaseDuration } from "./device-lease-D-G3SgVe.mjs";
+import { d as waitForDevice, s as parseDeviceWait, t as selectFromPool } from "./device-pool-BlHXnYYs.mjs";
+import { E as physicalDeviceModel, O as probeEmulatorSerial, _ as listAdbDevices, b as memoizeEmulatorProbe, i as androidPoolNoCandidatesRefusal, j as resolvePhysicalDevice, r as androidPoolCandidates } from "./android-xmyGBNy5.mjs";
+import { c as listIosDevices, o as iosPoolCandidates, s as iosPoolNoCandidatesRefusal, u as resolveIosPhysicalDevice } from "./ios-device-CdSm0GDw.mjs";
+import chalk from "chalk";
+//#region src/commands/device.ts
+const DEFAULT_FOR = "5m";
+const DEFAULT_DEPS = {
+	findProjectRoot,
+	listIosDevices,
+	listAdbDevices,
+	physicalDeviceModel,
+	probeEmulatorSerial,
+	takeLease,
+	releaseLeases: releaseWorkspaceLeases,
+	waitForDevice,
+	selectFromPool,
+	io: fileLeaseIo,
+	now: () => Date.now(),
+	sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+	out: (line) => console.log(line),
+	note: (line) => console.error(line)
+};
+function grantLine(facts, durationText) {
+	return `locked ${facts.deviceName ? `${facts.deviceName} (${facts.id})` : facts.id} for ${facts.holder} until ${clockTime(facts.expiresAt)} (${durationText}). Renew: stim device lock ${facts.platform} --for ${durationText}. Release: stim device unlock.`;
+}
+function releasedLine(lease) {
+	return `unlocked ${lease.deviceName ? `${lease.deviceName} (${lease.id})` : lease.id} -- the ${lease.platform} lease ran until ${clockTime(lease.expiresAt)}.`;
+}
+function readPlatform(value) {
+	return value === "ios" || value === "android" ? value : null;
+}
+function resolveDevice(platform, requested, d) {
+	if (platform === "ios") {
+		const resolved = resolveIosPhysicalDevice(requested, d.listIosDevices());
+		if (!resolved.udid) return {
+			code: "STIM_NO_DEVICE",
+			message: resolved.error,
+			remedy: resolved.remedy ?? null
+		};
+		return {
+			id: resolved.udid,
+			deviceName: resolved.name ?? resolved.udid
+		};
+	}
+	const resolved = resolvePhysicalDevice(requested, d.listAdbDevices(), d.probeEmulatorSerial);
+	if (!resolved.serial) return {
+		code: "STIM_NO_DEVICE",
+		message: resolved.error,
+		remedy: resolved.remedy ?? null
+	};
+	return {
+		id: resolved.serial,
+		deviceName: d.physicalDeviceModel(resolved.serial) ?? resolved.serial
+	};
+}
+function isFailure(value) {
+	return "code" in value;
+}
+async function poolDevice(platform, idLabel, waitSeconds, deadline, root, d) {
+	const isEmulator = memoizeEmulatorProbe(d.probeEmulatorSerial);
+	const pooled = await d.selectFromPool({
+		root,
+		platform,
+		idLabel,
+		list: () => platform === "ios" ? iosPoolCandidates(d.listIosDevices()).map((entry) => ({
+			id: entry.udid,
+			name: entry.name
+		})) : androidPoolCandidates(d.listAdbDevices(), isEmulator).map((entry) => ({ id: entry.serial })),
+		noCandidates: () => {
+			const resolved = platform === "ios" ? iosPoolNoCandidatesRefusal(d.listIosDevices()) : androidPoolNoCandidatesRefusal(d.listAdbDevices(), isEmulator);
+			return {
+				message: resolved.error,
+				remedy: resolved.remedy
+			};
+		},
+		waitSeconds,
+		deadline,
+		now: d.now,
+		sleep: d.sleep,
+		warn: (line) => d.note(chalk.yellow(line)),
+		io: d.io
+	});
+	if (pooled.status === "refused") return {
+		code: pooled.refusal.code,
+		message: pooled.refusal.message,
+		remedy: pooled.refusal.remedy,
+		...pooled.refusal.lease === null ? {} : { lease: pooled.refusal.lease }
+	};
+	const name = pooled.candidate.name ?? (platform === "ios" ? pooled.candidate.id : d.physicalDeviceModel(pooled.candidate.id));
+	return {
+		id: pooled.candidate.id,
+		deviceName: name ?? pooled.candidate.id
+	};
+}
+async function runLock(platformArg, idArg, opts = {}, overrides = {}) {
+	const d = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const json = Boolean(opts.json);
+	const report = (failure) => {
+		d.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) d.note(chalk.dim(failure.remedy));
+		if (json) d.out(JSON.stringify({
+			code: failure.code,
+			message: failure.message,
+			remedy: failure.remedy,
+			...failure.lease === void 0 ? {} : { lease: failure.lease }
+		}));
+		return failure;
+	};
+	const platform = readPlatform(platformArg);
+	if (!platform) return report({
+		code: "STIM_BAD_ARG",
+		message: `\`stim device lock\` takes ios or android, not ${JSON.stringify(platformArg)}.`,
+		remedy: "Run `stim device lock ios` or `stim device lock android`."
+	});
+	const root = d.findProjectRoot(process.cwd());
+	if (!root) return report({
+		code: "STIM_NO_PROJECT",
+		message: "Not in a React Native project (no package.json found).",
+		remedy: "Run this from the app directory -- the one holding package.json."
+	});
+	const durationText = String(opts.for ?? DEFAULT_FOR).trim();
+	const duration = parseLeaseDuration(durationText);
+	if ("error" in duration) return report({
+		code: "STIM_BAD_ARG",
+		message: duration.error,
+		remedy: "Pass a whole number of seconds or minutes from 10s to 30m, e.g. --for 90s or --for 10m."
+	});
+	const wait = parseDeviceWait(opts.wait);
+	if ("error" in wait) return report({
+		code: "STIM_BAD_ARG",
+		message: wait.error,
+		remedy: "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a leased device at once."
+	});
+	const idLabel = platform === "ios" ? "udid" : "serial";
+	const deadline = d.now() + wait.seconds * 1e3;
+	const lastLine = { at: null };
+	const device = idArg ? resolveDevice(platform, idArg, d) : await poolDevice(platform, idLabel, wait.seconds, deadline, root, d);
+	if (isFailure(device)) return report(device);
+	for (;;) {
+		const outcome = await d.waitForDevice({
+			root,
+			platform,
+			id: device.id,
+			idLabel,
+			waitSeconds: wait.seconds,
+			now: d.now,
+			sleep: d.sleep,
+			warn: (line) => d.note(chalk.yellow(line)),
+			io: d.io,
+			deadline,
+			lastLine
+		});
+		if (outcome.status === "refused") return report({
+			...outcome.refusal,
+			lease: outcome.refusal.lease
+		});
+		const taken = d.takeLease({
+			root,
+			platform,
+			id: device.id,
+			deviceName: device.deviceName,
+			kind: "declared",
+			durationMs: duration.ms
+		}, d.io);
+		if (taken.status === "unreadable") return report({
+			code: "STIM_DEVICE_BUSY",
+			message: `The lease file at ${taken.path} does not parse, so Stim cannot tell who holds that device.`,
+			remedy: `Read ${taken.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
+			}
+		});
+		if (taken.status === "held") continue;
+		const facts = {
+			platform,
+			id: taken.lease.id,
+			deviceName: taken.lease.deviceName,
+			holder: taken.lease.holder,
+			kind: "declared",
+			grantedAt: taken.lease.grantedAt,
+			expiresAt: taken.lease.expiresAt,
+			leaseSeconds: Math.round(duration.ms / 1e3)
+		};
+		if (json) d.out(JSON.stringify(facts));
+		else d.out(chalk.green(grantLine(facts, durationText)));
+		return facts;
+	}
+}
+async function runUnlock(platformArg, opts = {}, overrides = {}) {
+	const d = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const json = Boolean(opts.json);
+	const report = (failure) => {
+		d.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) d.note(chalk.dim(failure.remedy));
+		if (json) d.out(JSON.stringify({
+			code: failure.code,
+			message: failure.message,
+			remedy: failure.remedy
+		}));
+		return failure;
+	};
+	const platform = platformArg === void 0 ? null : readPlatform(platformArg);
+	if (platformArg !== void 0 && !platform) return report({
+		code: "STIM_BAD_ARG",
+		message: `\`stim device unlock\` takes ios or android, not ${JSON.stringify(platformArg)}.`,
+		remedy: "Run `stim device unlock` for every lease this workspace holds, or name one platform."
+	});
+	const root = d.findProjectRoot(process.cwd());
+	if (!root) return report({
+		code: "STIM_NO_PROJECT",
+		message: "Not in a React Native project (no package.json found).",
+		remedy: "Run this from the app directory -- the one holding package.json."
+	});
+	const released = d.releaseLeases(root, { platform }, d.io);
+	if (released.length === 0) d.note(chalk.dim(`No ${platform ? `${platform} ` : ""}device lease to release for ${root}. \`stim status\` lists every lease on this machine.`));
+	if (json) d.out(JSON.stringify(released.map((lease) => ({
+		...lease,
+		holder: root
+	}))));
+	else for (const lease of released) d.out(chalk.green(releasedLine(lease)));
+	return released;
+}
+function registerDevice(program, deps = {}) {
+	const device = program.command("device").description("Lease a connected physical device to this workspace, and give it back");
+	device.command("lock").argument("<platform>", "ios or android").argument("[id]", "the UDID or serial to lease; without one, the first free connected device is used").description("Lease a connected physical device to this workspace for a declared time, so another workspace's `--device` run waits instead of installing over it. Nothing but this command and a `--device` run moves the expiry.").option("--for <duration>", `How long to hold it: a whole number of seconds or minutes from 10s to 30m (default ${DEFAULT_FOR})`).option("--wait <seconds>", "How long to wait for a device another workspace holds, before refusing with STIM_DEVICE_BUSY (default 60, 0 refuses at once)").option("--json", "print the lease as JSON on stdout").action(async (platform, id, opts) => {
+		if ("code" in await runLock(platform, id, opts, deps)) process.exit(1);
+	});
+	device.command("unlock").argument("[platform]", "ios or android; without one, every lease this workspace holds is released").description("Release the device lease or leases this workspace holds. Releasing nothing is not an error.").option("--json", "print the released leases as JSON on stdout").action(async (platform, opts) => {
+		const result = await runUnlock(platform, opts, deps);
+		if (!Array.isArray(result)) process.exit(1);
+	});
+}
+function deviceCommand(program) {
+	registerDevice(program);
+}
+//#endregion
+export { deviceCommand as default, grantLine, registerDevice, releasedLine, runLock, runUnlock };

package/dist/device-lease-D-G3SgVe.mjs

@@ -0,0 +1,335 @@
+import { k as withDirLock, u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { _ as writeWorkspaceState, o as clearWorkspaceStateKeys, p as readWorkspaceState } from "./state-IYEY-zi8.mjs";
+import { a as segment } from "./build-lock-vE45ZzJZ.mjs";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+const DEFAULT_LEASE_MS = 3e5;
+const LEASE_SUFFIX = ".json";
+const LOCK_SUFFIX = ".lock";
+const DURATION = /^[1-9][0-9]*(s|m)$/;
+function deviceLocksDir() {
+	return join(getConfigDir(), "device-locks");
+}
+function leaseStem(platform, id) {
+	return `${segment(platform)}-${segment(id)}`;
+}
+function deviceLeasePath(platform, id) {
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LEASE_SUFFIX}`);
+}
+function deviceLeaseLockPath(platform, id) {
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LOCK_SUFFIX}`);
+}
+const fileLeaseIo = {
+	now: () => Date.now(),
+	readLease(path) {
+		try {
+			return readFileSync(path, "utf-8");
+		} catch {
+			return null;
+		}
+	},
+	writeLease(path, body) {
+		mkdirSync(deviceLocksDir(), { recursive: true });
+		const tmp = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+		writeFileSync(tmp, body);
+		try {
+			renameSync(tmp, path);
+		} catch (error) {
+			rmSync(tmp, { force: true });
+			throw error;
+		}
+	},
+	removeLease(path) {
+		rmSync(path, { force: true });
+	},
+	listLeaseNames() {
+		try {
+			return readdirSync(deviceLocksDir());
+		} catch {
+			return [];
+		}
+	},
+	withLeaseLock(lockPath, fn) {
+		return withDirLock(lockPath, fn, { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) });
+	},
+	readHolder(root) {
+		return parseWorkspaceLeases(readWorkspaceState(root)?.deviceLeases);
+	},
+	writeHolder(root, leases) {
+		if (Object.keys(leases).length === 0) clearWorkspaceStateKeys(root, ["deviceLeases"]);
+		else writeWorkspaceState(root, { deviceLeases: leases });
+	}
+};
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function isPlatform(value) {
+	return value === "ios" || value === "android";
+}
+function parseLease(raw) {
+	if (typeof raw !== "string") return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const entry = parsed;
+	if (entry.version !== 1 || !isPlatform(entry.platform)) return null;
+	const id = text(entry.id);
+	const holder = text(entry.holder);
+	const token = text(entry.token);
+	const expiresAt = text(entry.expiresAt);
+	if (!id || !holder || !token || !expiresAt || !Number.isFinite(Date.parse(expiresAt))) return null;
+	return {
+		version: 1,
+		platform: entry.platform,
+		id,
+		deviceName: text(entry.deviceName),
+		holder,
+		token,
+		grantedAt: text(entry.grantedAt),
+		expiresAt
+	};
+}
+function parseWorkspaceLeases(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const leases = {};
+	for (const [platform, entry] of Object.entries(value)) {
+		if (!isPlatform(platform) || !entry || typeof entry !== "object") continue;
+		const record = entry;
+		const id = text(record.id);
+		const token = text(record.token);
+		if (!id || !token) continue;
+		leases[platform] = {
+			id,
+			token,
+			kind: record.kind === "run" ? "run" : "declared"
+		};
+	}
+	return leases;
+}
+function leaseIsExpired(lease, now) {
+	return Date.parse(lease.expiresAt) <= now;
+}
+function parseLeaseDuration(value) {
+	const raw = String(value ?? "").trim();
+	const match = DURATION.exec(raw);
+	if (!match) return { error: `--for must be a whole number of seconds or minutes, such as 90s or 5m (got "${raw}").` };
+	const ms = Number(raw.slice(0, -1)) * (match[1] === "s" ? 1e3 : 6e4);
+	if (ms < 1e4 || ms > 18e5) return { error: `--for must be between 10s and 30m (got "${raw}").` };
+	return { ms };
+}
+function listLeaseFiles(io = fileLeaseIo) {
+	const dir = deviceLocksDir();
+	const entries = [];
+	for (const name of io.listLeaseNames().toSorted()) {
+		if (!name.endsWith(LEASE_SUFFIX)) continue;
+		const path = join(dir, name);
+		const lease = parseLease(io.readLease(path));
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		entries.push({
+			path,
+			name,
+			platform: lease?.platform ?? (cut > 0 ? stem.slice(0, cut) : stem),
+			id: lease?.id ?? (cut > 0 ? stem.slice(cut + 1) : null),
+			lease
+		});
+	}
+	return entries;
+}
+function writeLease(lease, io) {
+	io.writeLease(deviceLeasePath(lease.platform, lease.id), `${JSON.stringify(lease, null, 2)}\n`);
+	return lease;
+}
+function takeLease({ root, platform, id, deviceName = null, kind, durationMs = DEFAULT_LEASE_MS }, io = fileLeaseIo) {
+	const previous = io.readHolder(root)[platform];
+	if (previous && previous.id !== id) releaseHeld(root, platform, previous, io);
+	for (const entry of listLeaseFiles(io)) {
+		const other = entry.lease;
+		if (!other || other.platform !== platform || other.holder !== root || other.id === id) continue;
+		releaseByRoot(root, platform, other.id, io);
+	}
+	const declared = previous?.kind === "declared" && previous.id === id;
+	const path = deviceLeasePath(platform, id);
+	const result = io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+		const now = io.now();
+		const raw = io.readLease(path);
+		const current = parseLease(raw);
+		if (raw !== null && !current) return {
+			status: "unreadable",
+			path
+		};
+		const asked = now + durationMs;
+		if (current && !leaseIsExpired(current, now)) {
+			if (current.holder !== root) return {
+				status: "held",
+				lease: current
+			};
+			const floor = declared && kind === "run" ? Math.max(asked, Date.parse(current.expiresAt)) : asked;
+			return {
+				status: "set",
+				lease: writeLease({
+					...current,
+					deviceName: deviceName ?? current.deviceName,
+					expiresAt: new Date(floor).toISOString()
+				}, io)
+			};
+		}
+		const expiresAt = new Date(asked).toISOString();
+		return {
+			status: "taken",
+			lease: writeLease({
+				version: 1,
+				platform,
+				id,
+				deviceName,
+				holder: root,
+				token: randomBytes(12).toString("hex"),
+				grantedAt: new Date(now).toISOString(),
+				expiresAt
+			}, io)
+		};
+	});
+	if (result.status === "taken" || result.status === "set") {
+		const recorded = result.status === "set" && declared ? "declared" : kind;
+		io.writeHolder(root, {
+			...io.readHolder(root),
+			[platform]: {
+				id,
+				token: result.lease.token,
+				kind: recorded
+			}
+		});
+	}
+	return result;
+}
+function raiseLease({ root, platform, minMs }, io = fileLeaseIo) {
+	const record = io.readHolder(root)[platform];
+	if (!record) return { status: "none" };
+	const path = deviceLeasePath(platform, record.id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return {
+			status: "lost",
+			lease: current
+		};
+		const floor = io.now() + minMs;
+		if (Date.parse(current.expiresAt) >= floor) return {
+			status: "raised",
+			lease: current
+		};
+		return {
+			status: "raised",
+			lease: writeLease({
+				...current,
+				expiresAt: new Date(floor).toISOString()
+			}, io)
+		};
+	});
+}
+function summarize(lease) {
+	return {
+		platform: lease.platform,
+		id: lease.id,
+		deviceName: lease.deviceName,
+		expiresAt: lease.expiresAt
+	};
+}
+function releaseHeld(root, platform, record, io) {
+	const path = deviceLeasePath(platform, record.id);
+	const released = io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return null;
+		io.removeLease(path);
+		return current;
+	});
+	const held = io.readHolder(root);
+	if (held[platform]?.token === record.token) {
+		delete held[platform];
+		io.writeHolder(root, held);
+	}
+	return released;
+}
+function releaseByRoot(root, platform, id, io) {
+	const path = deviceLeasePath(platform, id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.holder !== root) return null;
+		io.removeLease(path);
+		return current;
+	});
+}
+function releaseRunLease({ root, platform }, io = fileLeaseIo) {
+	const record = io.readHolder(root)[platform];
+	if (!record || record.kind !== "run") return null;
+	const released = releaseHeld(root, platform, record, io);
+	return released ? summarize(released) : null;
+}
+function releaseWorkspaceLeases(root, { platform = null } = {}, io = fileLeaseIo) {
+	const released = [];
+	for (const [name, record] of Object.entries(io.readHolder(root))) {
+		if (!isPlatform(name) || platform && name !== platform) continue;
+		const lease = releaseHeld(root, name, record, io);
+		if (lease) released.push(summarize(lease));
+	}
+	for (const entry of listLeaseFiles(io)) {
+		const lease = entry.lease;
+		if (!lease || lease.holder !== root) continue;
+		if (platform && lease.platform !== platform) continue;
+		const byRoot = releaseByRoot(root, lease.platform, lease.id, io);
+		if (byRoot) released.push(summarize(byRoot));
+	}
+	return released;
+}
+function removeExpiredLease(entry, io = fileLeaseIo) {
+	const lease = entry.lease;
+	if (!lease) return false;
+	return io.withLeaseLock(deviceLeaseLockPath(lease.platform, lease.id), () => {
+		const current = parseLease(io.readLease(entry.path));
+		if (!current || !leaseIsExpired(current, io.now())) return false;
+		io.removeLease(entry.path);
+		return true;
+	});
+}
+function selectPoolDevice({ candidates, leases, held = null, now }) {
+	const ordered = candidates.toSorted((a, b) => {
+		const left = a.id.toLowerCase();
+		const right = b.id.toLowerCase();
+		return left < right ? -1 : left > right ? 1 : 0;
+	});
+	if (held) {
+		const mine = ordered.find((candidate) => candidate.id === held);
+		return mine ? {
+			status: "selected",
+			candidate: mine
+		} : {
+			status: "held-disconnected",
+			id: held
+		};
+	}
+	if (ordered.length === 0) return { status: "none" };
+	const byId = new Map(leases.map((lease) => [lease.id, lease]));
+	const holders = [];
+	for (const candidate of ordered) {
+		const lease = byId.get(candidate.id);
+		if (!lease || leaseIsExpired(lease, now)) return {
+			status: "selected",
+			candidate
+		};
+		holders.push({
+			id: lease.id,
+			holder: lease.holder,
+			expiresAt: lease.expiresAt
+		});
+	}
+	return {
+		status: "busy",
+		holders
+	};
+}
+//#endregion
+export { parseLease as a, releaseRunLease as c, selectPoolDevice as d, takeLease as f, listLeaseFiles as i, releaseWorkspaceLeases as l, fileLeaseIo as n, parseLeaseDuration as o, leaseIsExpired as r, raiseLease as s, deviceLeasePath as t, removeExpiredLease as u };