stim 0.0.0 → 1.1.0

package/dist/build-slots-CgacA9zQ.mjs

@@ -0,0 +1,152 @@
+import { u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { a as formatElapsed } from "./command-output-8wHMEde0.mjs";
+import { d as readClaimSet, f as releaseClaim, h as tryAcquireClaim, s as isClaimRefusal } from "./ownership-claim-CeJLEpjD.mjs";
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+//#region src/engine/build-slots.ts
+const SLOT_PREFIX = "slot-";
+const SLOT_LABEL = "build slot";
+const SLOT_POLL_MS = 1e3;
+const SLOT_PROGRESS_MS = 3e4;
+const SLOT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildSlotsDir() {
+	return join(getConfigDir(), "build-slots");
+}
+function buildSlotPath(index) {
+	return join(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		index: typeof details.index === "number" ? details.index : null,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	let refusal = null;
+	let busy = false;
+	for (let index = 0; index < max; index++) {
+		const path = buildSlotPath(index);
+		let attempt;
+		try {
+			attempt = tryAcquireClaim({
+				root: path,
+				mode: "exclusive",
+				label: SLOT_LABEL,
+				details: {
+					index,
+					projectRoot: root,
+					logFile
+				}
+			});
+		} catch (err) {
+			if (!isClaimRefusal(err)) throw err;
+			refusal ??= err;
+			continue;
+		}
+		if (attempt.pending) releaseClaim(attempt.pending);
+		if (!attempt.acquired) {
+			busy = true;
+			continue;
+		}
+		return {
+			acquired: true,
+			path,
+			index,
+			slot: {
+				pid: attempt.acquired.owner.pid,
+				index,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+	}
+	if (refusal && !busy) throw refusal;
+	return null;
+}
+function slotWaitingLine({ max, elapsedMs }) {
+	return `${"build".padEnd(11)} waiting for a build slot (all ${max} in use, ${formatElapsed(elapsedMs)} elapsed)`;
+}
+async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.now, out = () => {}, sleep = sleepAsync, intervalMs = SLOT_POLL_MS, progressMs = SLOT_PROGRESS_MS, ceilingMs = SLOT_CEILING_MS }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const started = now();
+	let lastProgress = started;
+	for (;;) {
+		const got = tryAcquireBuildSlot({
+			max,
+			root,
+			logFile
+		});
+		if (got) return got;
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for one of ${max} build slots, and every slot is held by a process that is still running, or by a holder Stim cannot identify. Slots live under ` + buildSlotsDir() + "; remove a slot directory whose builder is not really building, or raise concurrency.maxBuilds.");
+			err.code = "STIM_BUILD_SLOT_TIMEOUT";
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(slotWaitingLine({
+				max,
+				elapsedMs: elapsed
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+function releaseBuildSlot(handle) {
+	if (!handle || handle.unlimited) return false;
+	return releaseClaim(handle.claim);
+}
+function listBuildSlots() {
+	const dir = buildSlotsDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const slots = [];
+	for (const name of names) {
+		if (!name.startsWith(SLOT_PREFIX)) continue;
+		const path = join(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const survey = readClaimSet(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		const index = Number(name.slice(5));
+		slots.push({
+			path,
+			name,
+			index: Number.isFinite(index) ? index : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return slots;
+}
+//#endregion
+export { listBuildSlots as n, releaseBuildSlot as r, acquireBuildSlot as t };

package/dist/cache-manifest-oeH18ERr.mjs

@@ -0,0 +1,66 @@
+import { u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";
+//#region src/cache-manifest.ts
+function manifestPath() {
+	return join(getConfigDir(), "caches.json");
+}
+function expand(dir) {
+	return resolve(dir.startsWith("~") ? join(homedir(), dir.slice(1)) : dir);
+}
+function readManifest(path = manifestPath()) {
+	return {
+		version: 1,
+		caches: cacheEntries(readCacheManifest(path).caches)
+	};
+}
+function cacheEntries(caches) {
+	return caches.filter((cache) => typeof cache.dir === "string");
+}
+function register(entry, path = manifestPath()) {
+	if (!entry?.dir) throw new Error("a cache registration needs a `dir`");
+	const dir = expand(entry.dir);
+	const record = {
+		dir,
+		name: entry.name || dir,
+		prune: entry.prune === "atomic" ? "atomic" : "entries",
+		entriesDepth: normalizeDepth(entry.entriesDepth),
+		note: entry.note || "registered by the project",
+		registeredBy: entry.registeredBy || process.cwd()
+	};
+	if (entry.layout) record.layout = entry.layout;
+	updateCacheManifest(path, (caches) => {
+		return [...cacheEntries(caches).filter((cache) => expand(cache.dir) !== dir), record];
+	});
+	return record;
+}
+function normalizeDepth(value) {
+	const n = Number(value);
+	if (!Number.isInteger(n) || n < 1) return 1;
+	return n;
+}
+function unregister(dir, path = manifestPath()) {
+	const target = expand(dir);
+	let removed = false;
+	updateCacheManifest(path, (caches) => {
+		const entries = cacheEntries(caches);
+		const remaining = entries.filter((cache) => expand(cache.dir) !== target);
+		removed = remaining.length !== entries.length;
+		return remaining;
+	});
+	return removed;
+}
+function registeredCaches(path = manifestPath()) {
+	return readManifest(path).caches.filter((c) => c.dir && existsSync(c.dir)).map((c) => ({
+		name: c.name,
+		dir: c.dir,
+		prune: c.prune === "atomic" ? "atomic" : "entries",
+		entriesDepth: normalizeDepth(c.entriesDepth),
+		note: c.note,
+		layout: c.layout
+	}));
+}
+//#endregion
+export { unregister as a, registeredCaches as i, readManifest as n, register as r, manifestPath as t };

package/dist/cache-manifest.d.mts

@@ -0,0 +1,27 @@
+//#region src/cache-manifest.d.ts
+interface CacheEntry {
+  dir: string;
+  name?: string;
+  prune?: "atomic" | "entries";
+  entriesDepth?: number;
+  note?: string;
+  registeredBy?: string;
+  layout?: string;
+}
+declare function manifestPath(): string;
+declare function readManifest(path?: string): {
+  version: number;
+  caches: CacheEntry[];
+};
+declare function register(entry: CacheEntry, path?: string): CacheEntry;
+declare function unregister(dir: string, path?: string): boolean;
+declare function registeredCaches(path?: string): {
+  name: string | undefined;
+  dir: string;
+  prune: "atomic" | "entries";
+  entriesDepth: number;
+  note: string | undefined;
+  layout: string | undefined;
+}[];
+//#endregion
+export { CacheEntry, manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cache-manifest.mjs

@@ -0,0 +1,2 @@
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-oeH18ERr.mjs";
+export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { Command } from "commander";
+//#region bin/cli.ts
+const commands = /* @__PURE__ */ new Map([
+	["doctor", () => import("./doctor-BRF9aAJ3.mjs")],
+	["worktree", () => import("./worktree-DxEmUI_n.mjs")],
+	["start", () => import("./start-ByCylYtB.mjs")],
+	["stop", () => import("./stop-D6o5zAdm.mjs")],
+	["ios", () => import("./ios-CK1Vrk6Q.mjs")],
+	["android", () => import("./android-DnZlT3aU.mjs")],
+	["reload", () => import("./reload-DYZEBbZy.mjs")],
+	["device", () => import("./device-DJKv5Qej.mjs")],
+	["logs", () => import("./logs-Dxoy16Qv.mjs")],
+	["status", () => import("./status-Dia0XTqG.mjs")],
+	["stats", () => import("./stats-DZ4Q5J-7.mjs")],
+	["gc", () => import("./gc-DhXdgSdt.mjs")],
+	["guide", () => import("./guide-DrhrDBo5.mjs")]
+]);
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+const program = new Command();
+program.name("stim").description("Isolated React Native dev environments per project/worktree").version(pkg.version);
+try {
+	const first = process.argv[2];
+	const loadCommand = commands.get((first === "help" ? process.argv[3] : first) ?? "");
+	if (loadCommand) (await loadCommand()).default(program, pkg.version);
+	else if (first !== "--version" && first !== "-V") {
+		const modules = await Promise.all([...commands.values()].map((load) => load()));
+		for (const module of modules) module.default(program, pkg.version);
+	}
+	await program.parseAsync();
+} catch (err) {
+	if (err?.code === "STIM_CONFIG_CORRUPT") {
+		console.error(err.message);
+		process.exit(1);
+	}
+	throw err;
+}
+//#endregion
+export {};

package/dist/collector-run.d.mts

@@ -0,0 +1,119 @@
+import { t as NdjsonWriter } from "./ndjson-DvHSsNU9.mjs";
+import { ChildProcess, SpawnOptions } from "child_process";
+import { ChildProcess as ChildProcess$1 } from "node:child_process";
+//#region src/exec.d.ts
+interface ExecOptions {
+  timeoutMs?: number;
+  cwd?: string;
+  env?: Record<string, string>;
+  omitEnv?: readonly string[];
+}
+interface Executor {
+  run(cmd: string, opts?: ExecOptions): string;
+  runFile(file: string, args?: string[], opts?: ExecOptions): string;
+  runQuiet(cmd: string, opts?: ExecOptions): string | null;
+  runFileQuiet(file: string, args?: string[], opts?: ExecOptions): string | null;
+  spawn(cmd: string, args?: readonly string[], opts?: SpawnOptions): ChildProcess;
+}
+//#endregion
+//#region src/collector/android.d.ts
+declare function androidClockOffset(serial: string, { exec, now }?: {
+  exec?: Executor;
+  now?: () => number;
+}): number | null;
+interface PidResolution {
+  ok?: boolean;
+  pid?: number;
+  failed?: boolean;
+  reason?: string;
+}
+interface PidWatcher {
+  stop(): void;
+  probe(): number | null;
+  readonly pid: number | null;
+}
+declare function watchAppPid({ serial, packageName, pid, intervalMs, exec, onChange, resolve, setTimer, clearTimer }: {
+  serial: string;
+  packageName: string;
+  pid: number | null;
+  intervalMs?: number | null;
+  exec?: Executor | null;
+  onChange: (nextPid: number) => void | Promise<void>;
+  resolve?: (serial: string, packageName: string, opts: {
+    exec?: Executor | null;
+  }) => number | null;
+  setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+  clearTimer?: (t: ReturnType<typeof setTimeout>) => void;
+}): PidWatcher;
+//#endregion
+//#region src/collector/state.d.ts
+declare function registerCollector(root: string, platform: string, record: Record<string, unknown>): Record<string, unknown>;
+declare function unregisterCollector(root: string, platform: string, pid: number, processToken: string): Record<string, unknown>;
+declare function readCollectors(root: string): Record<string, unknown>;
+//#endregion
+//#region src/collector/run.d.ts
+declare const PLATFORMS: string[];
+interface ParsedCollectorArgs {
+  platform?: string;
+  root?: string;
+  udid?: string;
+  bundleId?: string;
+  appName?: string;
+  appExecutable?: string | null;
+  serial?: string | null;
+  packageName?: string | null;
+  physical?: boolean;
+  payloadUrl?: string | null;
+  error?: string;
+}
+declare function parseArgs(argv: string[]): ParsedCollectorArgs;
+interface RunCollectorOptions {
+  platform: string;
+  root: string;
+  udid?: string | null;
+  appName?: string | null;
+  appExecutable?: string | null;
+  bundleId?: string | null;
+  serial?: string | null;
+  packageName?: string | null;
+  physical?: boolean;
+  payloadUrl?: string | null;
+  startStream?: ((opts: {
+    platform: string;
+    udid?: string | null;
+    appName?: string | null;
+    appExecutable?: string | null;
+    bundleId?: string | null;
+    serial?: string | null;
+    physical?: boolean;
+    payloadUrl?: string | null;
+    pid?: number | null;
+  }) => ChildProcess$1) | null;
+  resolvePid?: ((opts: {
+    serial?: string | null;
+    packageName?: string | null;
+    timeoutMs: number;
+  }) => Promise<PidResolution>) | null;
+  pidTimeoutMs?: number;
+  pidOf?: ((serial: string, packageName: string, opts: {
+    exec?: Executor | null;
+  }) => number | null) | null;
+  pidWatchMs?: number | null;
+  watchPid?: typeof watchAppPid;
+  resolveClockOffset?: typeof androidClockOffset;
+  now?: () => number;
+  onExit?: (code: number) => void;
+  attachSignals?: boolean;
+  stderr?: (line: string) => void;
+}
+interface RunCollectorHandle {
+  child: ChildProcess$1 | null;
+  writer: NdjsonWriter;
+  finish: (code: number, level: string, msg: string, event: string) => void;
+  startedAt: string;
+  pid: number | null;
+}
+declare function runCollector({ platform, root, udid, appName, appExecutable, bundleId, serial, packageName, physical, payloadUrl, startStream, resolvePid, pidTimeoutMs, pidOf, pidWatchMs, watchPid, resolveClockOffset, now, onExit, attachSignals, stderr }: RunCollectorOptions): Promise<RunCollectorHandle | null>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { PLATFORMS, ParsedCollectorArgs, RunCollectorHandle, RunCollectorOptions, main, parseArgs, readCollectors, registerCollector, runCollector, unregisterCollector };