stim 1.3.1 → 1.5.0

package/dist/guide-status-BF6RsJJp.mjs

@@ -0,0 +1,271 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { S as upsertProject, f as getProject, u as getConfigDir } from "./config-DMP7L7H6.mjs";
+import { accessSync, constants, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { delimiter, join, resolve } from "node:path";
+//#region src/stim-installations.ts
+const VERSION_OUTPUT_LIMIT = 4096;
+function parsedVersion(version) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+	if (!match) return null;
+	const core = [
+		match[1],
+		match[2],
+		match[3]
+	];
+	if (core.some((part) => part.length > 1 && part.startsWith("0"))) return null;
+	const prereleaseParts = match[4]?.split(".");
+	if (prereleaseParts?.some((part) => !part || /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null;
+	const prerelease = prereleaseParts?.map((part) => /^\d+$/.test(part) ? Number(part) : part);
+	return {
+		core: core.map(Number),
+		prerelease: prerelease ?? null
+	};
+}
+function compareStimVersions(left, right) {
+	const a = parsedVersion(left);
+	const b = parsedVersion(right);
+	if (!a || !b) return null;
+	for (let index = 0; index < a.core.length; index += 1) {
+		const difference = (a.core[index] ?? 0) - (b.core[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	if (!a.prerelease && !b.prerelease) return 0;
+	if (!a.prerelease) return 1;
+	if (!b.prerelease) return -1;
+	for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+		const x = a.prerelease[index];
+		const y = b.prerelease[index];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		if (x === y) continue;
+		if (typeof x === "number" && typeof y === "number") return x - y;
+		if (typeof x === "number") return -1;
+		if (typeof y === "number") return 1;
+		return x < y ? -1 : 1;
+	}
+	return 0;
+}
+function parseStimVersionOutput(output) {
+	const version = output?.split("\n")[0]?.trim() ?? "";
+	return parsedVersion(version) ? version.replace(/^v/, "") : null;
+}
+function executableNames(platform) {
+	return platform === "win32" ? [
+		"stim.cmd",
+		"stim.exe",
+		"stim"
+	] : ["stim"];
+}
+function stimExecutablePaths(pathValue, { platform = process.platform, cwd = process.cwd() } = {}) {
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of pathValue.split(delimiter)) {
+		const directory = resolve(cwd, entry || ".");
+		for (const name of executableNames(platform)) {
+			const path = join(directory, name);
+			try {
+				accessSync(path, platform === "win32" ? constants.F_OK : constants.X_OK);
+				if (!statSync(path).isFile()) continue;
+				const realPath = realpathSync(path);
+				if (seen.has(realPath)) continue;
+				seen.add(realPath);
+				found.push({
+					path,
+					realPath
+				});
+			} catch {}
+		}
+	}
+	return found;
+}
+function canonicalPath(path) {
+	if (!path) return null;
+	try {
+		return realpathSync(resolve(path));
+	} catch {
+		return resolve(path);
+	}
+}
+function analyzeStimVersions(runningVersion, runningPath, installations) {
+	const candidates = [runningVersion, ...installations.map((entry) => entry.version)];
+	const versions = [...new Set(candidates)].filter((version) => version !== null && compareStimVersions(version, version) !== null).toSorted((left, right) => -(compareStimVersions(left, right) ?? 0));
+	const highestVersion = versions[0] ?? null;
+	const resolved = installations[0] ?? null;
+	return {
+		runningVersion,
+		runningPath,
+		resolved,
+		installations,
+		versions,
+		highestVersion,
+		resolvedIsOlder: Boolean(resolved?.version && highestVersion && (compareStimVersions(resolved.version, highestVersion) ?? 0) < 0)
+	};
+}
+function probeStimVersion(path, timeoutMs) {
+	return new Promise((resolveProbe) => {
+		let settled = false;
+		let output = "";
+		const finish = (version) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolveProbe(version);
+		};
+		let child;
+		try {
+			child = getExecutor().spawn(path, ["--version"], {
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				],
+				detached: process.platform !== "win32"
+			});
+		} catch {
+			resolveProbe(null);
+			return;
+		}
+		const timer = setTimeout(() => {
+			try {
+				if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
+				else child.kill("SIGKILL");
+			} catch {}
+			finish(null);
+		}, timeoutMs);
+		child.stdout?.on("data", (chunk) => {
+			if (output.length < VERSION_OUTPUT_LIMIT) output += String(chunk).slice(0, VERSION_OUTPUT_LIMIT - output.length);
+		});
+		child.on("error", () => finish(null));
+		child.on("close", (code) => finish(code === 0 ? parseStimVersionOutput(output) : null));
+	});
+}
+async function inspectStimVersions(runningVersion, { pathValue = process.env.PATH ?? "", runningPath = process.argv[1], probeTimeoutMs = 5e3 } = {}) {
+	const paths = stimExecutablePaths(pathValue);
+	const versions = await Promise.all(paths.map((entry) => probeStimVersion(entry.path, probeTimeoutMs)));
+	const installations = paths.map((entry, index) => ({
+		path: entry.path,
+		realPath: entry.realPath,
+		version: versions[index] ?? null
+	}));
+	return analyzeStimVersions(runningVersion, canonicalPath(runningPath), installations);
+}
+//#endregion
+//#region src/guide-status.ts
+const DAY_MS = 864e5;
+const DOCTOR_STALE_MS = 7 * DAY_MS;
+const UPDATE_CHECK_INTERVAL_MS = DAY_MS;
+const UPDATE_CHECK_TIMEOUT_MS = 2e3;
+const LATEST_URL = "https://registry.npmjs.org/stim/latest";
+const PLATFORMS = ["ios", "android"];
+function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date()) {
+	const run = {
+		at: now.toISOString(),
+		version
+	};
+	try {
+		upsertProject(projectRoot, (existing) => {
+			const doctorRuns = { ...existing.doctorRuns };
+			for (const target of platform ? [platform] : PLATFORMS) doctorRuns[target] = run;
+			return { doctorRuns };
+		});
+	} catch {}
+}
+function doctorDueReason(record, running, now) {
+	const at = record ? Date.parse(record.at) : NaN;
+	if (!record || Number.isNaN(at)) return "never run";
+	if (record.version !== running) return `last run with stim ${record.version}`;
+	const age = now.getTime() - at;
+	if (age > DOCTOR_STALE_MS) return `last run ${Math.floor(age / DAY_MS)} days ago`;
+	return null;
+}
+function updateCacheFile() {
+	return join(getConfigDir(), "update-check.json");
+}
+function readUpdateCache() {
+	try {
+		const parsed = JSON.parse(readFileSync(updateCacheFile(), "utf-8"));
+		if (typeof parsed?.checkedAt !== "string") return null;
+		return {
+			checkedAt: parsed.checkedAt,
+			latest: typeof parsed.latest === "string" ? parsed.latest : null
+		};
+	} catch {
+		return null;
+	}
+}
+function writeUpdateCache(cache) {
+	const target = updateCacheFile();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		mkdirSync(getConfigDir(), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(cache)}\n`);
+		renameSync(tmp, target);
+	} catch {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+	}
+}
+async function fetchLatest(fetchImpl) {
+	const res = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
+	if (!res.ok) return null;
+	const body = await res.json();
+	return typeof body.version === "string" ? body.version : null;
+}
+async function checkForUpdate(running, { now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch } = {}) {
+	if (process.env.STIM_NO_UPDATE_CHECK) return null;
+	const cached = readUpdateCache();
+	const checkedAt = cached ? Date.parse(cached.checkedAt) : NaN;
+	let latest = cached?.latest ?? null;
+	if (Number.isNaN(checkedAt) || now.getTime() - checkedAt > UPDATE_CHECK_INTERVAL_MS) {
+		try {
+			latest = await fetchLatest(fetchImpl);
+		} catch {
+			latest = null;
+		}
+		writeUpdateCache({
+			checkedAt: now.toISOString(),
+			latest
+		});
+	}
+	if (!latest) return null;
+	const comparison = compareStimVersions(latest, running);
+	return comparison !== null && comparison > 0 ? latest : null;
+}
+function renderGuideStatus({ running, doctor, latest }) {
+	const lines = [];
+	if (doctor.length) {
+		const named = doctor.map((due) => `${due.platform} (${due.reason})`).join(" and ");
+		const command = doctor.length === 1 ? `stim doctor --platform ${doctor[0]?.platform}` : "stim doctor";
+		lines.push(`  Doctor is due for ${named}.`, `  Run before native work:  ${command}`);
+	}
+	if (latest) lines.push(`  stim ${latest} is available (running ${running}):  npm install -g stim@latest`);
+	if (!lines.length) return null;
+	return ["STATUS", ...lines].join("\n");
+}
+async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
+	const doctor = [];
+	if (projectRoot) {
+		let runs = null;
+		try {
+			runs = getProject(projectRoot)?.doctorRuns ?? {};
+		} catch {}
+		if (runs) for (const platform of PLATFORMS) {
+			const reason = doctorDueReason(runs[platform], running, now);
+			if (reason) doctor.push({
+				platform,
+				reason
+			});
+		}
+	}
+	return renderGuideStatus({
+		running,
+		doctor,
+		latest: await checkForUpdate(running, {
+			now,
+			fetch: fetchImpl
+		})
+	});
+}
+//#endregion
+export { inspectStimVersions as i, recordDoctorRun as n, compareStimVersions as r, guideStatus as t };