@stim-cli/core 1.9.0 → 1.10.0

package/README.md

@@ -29,4 +29,10 @@ they are free. Verify the holder before manually
 removing the named claim or legacy directory. Long operations that spawn native
 children use an explicit claim and record the child's identity.
 
+`@stim-cli/core/state` holds the read side of Stim's state: the `$STIM_HOME`
+path layout, the config and workspace state types and readers, the settings
+registry and its JSON Schema, the created-device and EAS session ledger readers,
+NDJSON log records and queries, and the status and settings payload types. The
+CLI owns every write to that state. The cache packages do not import it.
+
 The npm scope remains `@stim-cli` until the `@stim` scope is available.

package/dist/core-CJWLJIr6.mjs

@@ -0,0 +1,421 @@
+import { _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-O31Y5iIb.mjs";
+import fs, { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path, { basename, dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+//#region dir-lock.ts
+const DEFAULT_LOCK_WAIT_MS = 12e3;
+const DEFAULT_LOCK_POLL_MS = 25;
+const lockDepths = /* @__PURE__ */ new Map();
+const OWNER_MARKER = /^\.stim-claim-[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/;
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+* Whether Windows refused a call on the lock directory because another process is removing it at that
+* moment. NTFS answers ERROR_ACCESS_DENIED, which Node reports as EPERM, until that removal completes,
+* where POSIX answers EEXIST or ENOENT: https://github.com/appandflow/stim/issues/883.
+*/
+function removalInFlight(error) {
+	return process.platform === "win32" && error?.code === "EPERM";
+}
+function createLockDirectory(lockPath) {
+	try {
+		mkdirSync(lockPath);
+		return true;
+	} catch (error) {
+		if (error?.code === "EEXIST" || removalInFlight(error)) return false;
+		throw error;
+	}
+}
+function removeLockDirectory(lockPath, marker) {
+	try {
+		unlinkSync(marker);
+	} catch (error) {
+		if (error?.code === "ENOENT" || removalInFlight(error)) return false;
+		throw error;
+	}
+	try {
+		rmdirSync(lockPath);
+		return true;
+	} catch (error) {
+		if ([
+			"ENOENT",
+			"ENOTEMPTY",
+			"EEXIST"
+		].includes(error?.code ?? "")) return false;
+		if (removalInFlight(error)) return false;
+		throw error;
+	}
+}
+function takeLockDirectory(lockPath, claim) {
+	if (!createLockDirectory(lockPath)) {
+		let entries;
+		try {
+			entries = readdirSync(lockPath);
+		} catch (error) {
+			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
+			throw error;
+		}
+		const name = entries.length === 1 ? entries[0] : void 0;
+		if (!name || !OWNER_MARKER.test(name)) return null;
+		const marker = join(lockPath, name);
+		let entry;
+		try {
+			entry = lstatSync(marker);
+		} catch (error) {
+			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
+			throw error;
+		}
+		if (!entry.isFile() || entry.size !== 0) throw new ClaimRefusedError({
+			root: lockPath,
+			claimPath: lockPath,
+			label: "directory lock",
+			reason: `its compatibility marker ${name} is not an empty file`
+		});
+		if (!removeLockDirectory(lockPath, marker) || !createLockDirectory(lockPath)) return null;
+	}
+	const marker = join(lockPath, `.stim-claim-${claim.claimId}`);
+	writeFileSync(marker, "", { flag: "wx" });
+	return marker;
+}
+function acquireDirLock(lockPath, { waitMs, pollMs, ensureParent }) {
+	ensureParent?.();
+	statSync(dirname(lockPath));
+	const deadline = Date.now() + waitMs;
+	let claim;
+	try {
+		for (;;) {
+			if (!claim) {
+				const attempt = tryAcquireClaim({
+					root: `${lockPath}.claims`,
+					mode: "exclusive",
+					label: "directory lock"
+				});
+				claim = attempt.acquired;
+				if (attempt.pending) releaseClaim(attempt.pending);
+			}
+			if (claim) {
+				const marker = takeLockDirectory(lockPath, claim);
+				if (marker) return {
+					claim,
+					marker
+				};
+			}
+			if (Date.now() >= deadline) {
+				const error = /* @__PURE__ */ new Error(`Timed out waiting for the lock at ${lockPath}. Another Stim process may be holding it; if none is running, remove that directory.`);
+				error.code = "STIM_LOCK_TIMEOUT";
+				error.lockPath = lockPath;
+				throw error;
+			}
+			sleepSync(pollMs);
+		}
+	} catch (error) {
+		releaseClaim(claim);
+		throw error;
+	}
+}
+function withDirLock(lockPath, fn, { waitMs = DEFAULT_LOCK_WAIT_MS, pollMs = DEFAULT_LOCK_POLL_MS, ensureParent } = {}) {
+	const depth = lockDepths.get(lockPath) || 0;
+	if (depth > 0) {
+		lockDepths.set(lockPath, depth + 1);
+		try {
+			return fn();
+		} finally {
+			lockDepths.set(lockPath, (lockDepths.get(lockPath) ?? 1) - 1);
+		}
+	}
+	const { claim, marker } = acquireDirLock(lockPath, {
+		waitMs,
+		pollMs,
+		ensureParent
+	});
+	lockDepths.set(lockPath, 1);
+	try {
+		return fn();
+	} finally {
+		lockDepths.set(lockPath, 0);
+		try {
+			removeLockDirectory(lockPath, marker);
+		} catch {}
+		releaseClaim(claim);
+	}
+}
+//#endregion
+//#region artifact-store.ts
+function artifactIn(dir) {
+	if (!existsSync(dir)) return null;
+	let found;
+	try {
+		found = readdirSync(dir).find((f) => f.endsWith(".app") || f.endsWith(".apk"));
+	} catch {
+		return null;
+	}
+	return found ? join(dir, found) : null;
+}
+function resolveArtifact(dir) {
+	const hit = artifactIn(dir);
+	if (!hit) return null;
+	try {
+		utimesSync(dir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+	} catch {}
+	return hit;
+}
+function storeArtifact(dest, buildPath, { runFile, overwrite = false, writeMetadata, onRenameError }) {
+	const existing = artifactIn(dest);
+	if (existing && !overwrite) return existing;
+	const staging = `${dest}.staging-${process.pid}`;
+	const replaced = `${dest}.replaced-${process.pid}`;
+	const target = join(staging, basename(buildPath));
+	rmSync(staging, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(staging, { recursive: true });
+	try {
+		try {
+			runFile("cp", [
+				"-c",
+				"-R",
+				buildPath,
+				target
+			]);
+		} catch {
+			rmSync(target, {
+				recursive: true,
+				force: true
+			});
+			runFile("cp", [
+				"-R",
+				buildPath,
+				target
+			]);
+		}
+		writeMetadata?.(staging);
+		const published = artifactIn(dest);
+		if (published && !overwrite) {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+			return published;
+		}
+		mkdirSync(dirname(dest), { recursive: true });
+		rmSync(replaced, {
+			recursive: true,
+			force: true
+		});
+		if (existsSync(dest)) renameSync(dest, replaced);
+	} catch (error) {
+		rmSync(staging, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+	try {
+		renameSync(staging, dest);
+	} catch (error) {
+		try {
+			renameSync(replaced, dest);
+		} catch {}
+		if (!onRenameError) {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+			rmSync(replaced, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+		onRenameError(staging);
+	}
+	rmSync(replaced, {
+		recursive: true,
+		force: true
+	});
+	return artifactIn(dest);
+}
+//#endregion
+//#region index.ts
+const warnedRelative = /* @__PURE__ */ new Set();
+function absoluteEnvPath(name) {
+	const value = process.env[name];
+	if (!value) return null;
+	if (path.isAbsolute(value)) return value;
+	if (!warnedRelative.has(name)) {
+		warnedRelative.add(name);
+		process.emitWarning(`${name}=${value} is not an absolute path and is ignored.`, { code: "STIM_RELATIVE_PATH" });
+	}
+	return null;
+}
+function configDir() {
+	return absoluteEnvPath("STIM_HOME") || path.join(os.homedir(), ".stim");
+}
+function workspaceSlug(projectRoot) {
+	return path.basename(path.resolve(projectRoot)).normalize("NFKD").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 48) || "workspace";
+}
+function workspaceId(projectRoot) {
+	return createHash("sha256").update(path.resolve(projectRoot)).digest("hex").slice(0, 16);
+}
+function workspaceName(projectRoot) {
+	return `${workspaceSlug(projectRoot)}--${workspaceId(projectRoot)}`;
+}
+function workspaceStateDir(projectRoot) {
+	return path.join(configDir(), "workspaces", workspaceName(projectRoot));
+}
+function workspaceLogDir(projectRoot) {
+	return path.join(workspaceStateDir(projectRoot), "logs");
+}
+const LOG_ROTATE_BYTES = 8388608;
+function rotatedLogPath(file) {
+	return `${file}.1`;
+}
+/** Moves `file` over its previous generation once it reaches `maxBytes`; readers read both generations. */
+function rotateLog(file, maxBytes) {
+	if (logSize(file) < maxBytes) return;
+	withDirLock(`${file}.lock`, () => {
+		if (logSize(file) >= maxBytes) fs.renameSync(file, rotatedLogPath(file));
+	}, {
+		waitMs: 100,
+		pollMs: 10
+	});
+}
+function logSize(file) {
+	try {
+		return fs.statSync(file).size;
+	} catch {
+		return 0;
+	}
+}
+function cachePathSetting(key) {
+	try {
+		const value = JSON.parse(fs.readFileSync(path.join(configDir(), "config.json"), "utf-8"))?.caches?.[key];
+		return typeof value === "string" && path.isAbsolute(value) ? value : null;
+	} catch {
+		return null;
+	}
+}
+function cacheNameSegment(name) {
+	return String(name).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "app";
+}
+function buildCacheRoot() {
+	return absoluteEnvPath("STIM_BUILD_CACHE") || cachePathSetting("buildCache") || path.join(configDir(), "build-cache");
+}
+function metroCacheRoot(name) {
+	const root = absoluteEnvPath("STIM_METRO_CACHE") || cachePathSetting("metroCache") || path.join(configDir(), "metro-cache");
+	return name === void 0 || name === null || name === "" ? root : path.join(root, cacheNameSegment(name));
+}
+const STORE_ROOT_TAG = "stimStoreRoot";
+function tagSharedStore(store, root) {
+	try {
+		Object.defineProperty(store, STORE_ROOT_TAG, {
+			value: root,
+			enumerable: false,
+			configurable: true
+		});
+	} catch {}
+	return store;
+}
+function sharedStoreRoot(store) {
+	if (store === null || typeof store !== "object") return null;
+	const tagged = store[STORE_ROOT_TAG];
+	if (typeof tagged === "string") return tagged;
+	const legacy = store._root;
+	return typeof legacy === "string" ? legacy : null;
+}
+const SIMULATOR_UDID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const EMULATOR_SERIAL = /^emulator-\d+$/;
+function slug(value) {
+	return String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildVariant(platform, options) {
+	const raw = platform === "android" ? options.variant : options.configuration ?? options.buildConfiguration;
+	return (typeof raw === "string" ? slug(raw) : "") || "debug";
+}
+function buildTarget(options) {
+	if (typeof options.isSimulator === "boolean") return options.isSimulator ? "sim" : "device";
+	const device = options.device;
+	if (device === void 0 || device === null || device === false) return "sim";
+	if (typeof device !== "string") return "prompted";
+	const name = device.trim();
+	if (name === "" || name === "generic") return "sim";
+	if (SIMULATOR_UDID.test(name) || EMULATOR_SERIAL.test(name)) return "sim";
+	return `on-${slug(name)}`;
+}
+function buildCacheKey(platform, fingerprintHash, options = {}) {
+	const opts = options && typeof options === "object" ? options : {};
+	const abi = platform === "android" && typeof opts.abi === "string" ? slug(opts.abi) : "";
+	const allArch = platform === "android" && opts.allArch === true ? "-all-arch" : "";
+	const compiler = typeof opts.compiler === "string" ? slug(opts.compiler) : "";
+	const profile = typeof opts.buildProfile === "string" ? slug(opts.buildProfile) : "";
+	const scheme = platform === "ios" && typeof opts.scheme === "string" && opts.scheme ? createHash("sha256").update(opts.scheme).digest("hex") : "";
+	return `${fingerprintHash}-${buildVariant(platform, opts)}-${buildTarget(opts)}${abi ? `-${abi}` : ""}${allArch}${compiler ? `-${compiler}` : ""}${profile ? `-${profile}` : ""}${scheme ? `-scheme-${scheme}` : ""}`;
+}
+const METRO_NAMED_CACHE_LAYOUT = "metro-named-v1";
+function cacheManifestLockPath(file) {
+	return `${file}.lock`;
+}
+function readCacheManifest(file) {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+		return {
+			version: 1,
+			caches: Array.isArray(parsed?.caches) ? parsed.caches : []
+		};
+	} catch {
+		return {
+			version: 1,
+			caches: []
+		};
+	}
+}
+function updateCacheManifest(file, mutate) {
+	const parent = path.dirname(file);
+	return withDirLock(cacheManifestLockPath(file), () => {
+		const next = {
+			version: 1,
+			caches: mutate(readCacheManifest(file).caches)
+		};
+		const temporary = path.join(parent, `.${path.basename(file)}.${process.pid}.tmp`);
+		try {
+			fs.writeFileSync(temporary, JSON.stringify(next, null, 2));
+			fs.renameSync(temporary, file);
+		} catch (error) {
+			fs.rmSync(temporary, { force: true });
+			throw error;
+		}
+		return next;
+	}, { ensureParent: () => fs.mkdirSync(parent, { recursive: true }) });
+}
+function registerCache({ dir, name, prune, note, entriesDepth, layout, replaces = [] }) {
+	if (!path.isAbsolute(dir)) return;
+	try {
+		updateCacheManifest(path.join(configDir(), "caches.json"), (caches) => {
+			const others = caches.filter((cache) => cache.dir !== dir && !replaces.some((match) => matchesCache(cache, match)));
+			const record = {
+				dir,
+				name,
+				prune,
+				note,
+				registeredBy: process.cwd()
+			};
+			if (entriesDepth) record.entriesDepth = entriesDepth;
+			if (layout) record.layout = layout;
+			others.push(record);
+			return others;
+		});
+	} catch {}
+}
+function matchesCache(cache, match) {
+	if (cache.dir !== match.dir) return false;
+	if (match.name !== void 0 && cache.name !== match.name) return false;
+	if (match.prune !== void 0 && cache.prune !== match.prune) return false;
+	if (match.entriesDepth !== void 0 && cache.entriesDepth !== match.entriesDepth) return false;
+	if (match.layout === null) return !Object.hasOwn(cache, "layout");
+	return match.layout === void 0 || cache.layout === match.layout;
+}
+//#endregion
+export { artifactIn as C, withDirLock as E, workspaceStateDir as S, storeArtifact as T, updateCacheManifest as _, buildCacheRoot as a, workspaceName as b, cachePathSetting as c, readCacheManifest as d, registerCache as f, tagSharedStore as g, sharedStoreRoot as h, buildCacheKey as i, configDir as l, rotatedLogPath as m, METRO_NAMED_CACHE_LAYOUT as n, cacheManifestLockPath as o, rotateLog as p, STORE_ROOT_TAG as r, cacheNameSegment as s, LOG_ROTATE_BYTES as t, metroCacheRoot as u, workspaceId as v, resolveArtifact as w, workspaceSlug as x, workspaceLogDir as y };