stim 0.0.0 → 1.0.0

package/dist/state-2nush3MK.mjs

@@ -0,0 +1,269 @@
+import { E as withDirLock, l as getConfigDir, w as sameProcessRecord } from "./config-7kmtuhO2.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "path";
+import { buildCacheRoot as sharedBuildCache, workspaceName, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+import { dirname as dirname$1 } from "node:path";
+//#region src/paths.ts
+const WORKSPACE_METADATA_FILE_NAME = "workspace.json";
+function workspaceMetadataFile(projectRoot) {
+	return join(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
+}
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	mkdirSync(dir, { recursive: true });
+	return withDirLock(join(dir, "metadata.lock"), () => {
+		if (!existsSync(file)) {
+			const metadata = {
+				projectRoot: canonicalRoot,
+				workspace: workspaceName(canonicalRoot),
+				version: 1
+			};
+			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
+			try {
+				renameSync(tmp, file);
+			} catch (error) {
+				rmSync(tmp, { force: true });
+				throw error;
+			}
+			return dir;
+		}
+		try {
+			if (JSON.parse(readFileSync(file, "utf-8")).projectRoot === canonicalRoot) return dir;
+		} catch {}
+		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
+		error.code = "STIM_WORKSPACE_COLLISION";
+		throw error;
+	});
+}
+function workspaceLogsDir(projectRoot) {
+	return join(workspaceDir(projectRoot), "logs");
+}
+function workspaceDerivedData(projectRoot) {
+	return join(workspaceDir(projectRoot), "derived-data");
+}
+function supervisorPidFile(projectRoot) {
+	return join(workspaceDir(projectRoot), "supervisor.pid");
+}
+function workspaceStateFile(projectRoot) {
+	return join(workspaceDir(projectRoot), "state.json");
+}
+function workspaceStateLock(projectRoot) {
+	return join(workspaceDir(projectRoot), "state.lock");
+}
+function supervisorLogFile(projectRoot) {
+	return join(workspaceLogsDir(projectRoot), "supervisor.log");
+}
+function emulatorLogFile(projectRoot) {
+	return join(workspaceLogsDir(projectRoot), "emulator.log");
+}
+function sharedCompilationCache() {
+	return join(getConfigDir(), "compilation-cache");
+}
+function sharedCcache() {
+	return join(getConfigDir(), "ccache");
+}
+//#endregion
+//#region src/supervisor/state.ts
+const MODE_BARE = "bare-inproc";
+const MODE_EXPO = "expo-child";
+function readMetroTunnel(root) {
+	const record = readWorkspaceState(root)?.metroTunnel;
+	if (!record || typeof record !== "object") return null;
+	const kind = record.kind;
+	const url = record.url;
+	if (typeof url !== "string" || url.length === 0) return null;
+	if (kind === "expo") return {
+		kind: "expo",
+		url
+	};
+	if (kind === "managed") {
+		const provider = record.provider;
+		const pid = record.pid;
+		const port = record.port;
+		const startedAt = record.startedAt;
+		const processToken = record.processToken;
+		const logFile = record.logFile;
+		if (provider !== "ngrok" && provider !== "cloudflared" || typeof pid !== "number" || typeof port !== "number") return null;
+		return {
+			kind: "managed",
+			provider,
+			pid,
+			url,
+			port,
+			startedAt: typeof startedAt === "string" ? startedAt : "",
+			processToken: typeof processToken === "string" && processToken.length > 0 ? processToken : null,
+			...typeof logFile === "string" && logFile.length > 0 ? { logFile } : {}
+		};
+	}
+	return null;
+}
+function readWorkspaceState(root) {
+	try {
+		const parsed = JSON.parse(readFileSync(workspaceStateFile(root), "utf-8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function parseWorkspaceLaunchRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.appId !== "string" || record.appId.length === 0) return null;
+	if (typeof record.deviceId !== "string" || record.deviceId.length === 0) return null;
+	if (record.metroPort !== null && typeof record.metroPort !== "number") return null;
+	if (typeof record.release !== "boolean") return null;
+	if (record.deepLinkUrl !== null && typeof record.deepLinkUrl !== "string") return null;
+	if (typeof record.launchedAt !== "string") return null;
+	return record;
+}
+function readWorkspaceLaunches(root) {
+	const launches = readWorkspaceState(root)?.launches;
+	if (!launches || typeof launches !== "object" || Array.isArray(launches)) return {};
+	const ios = parseWorkspaceLaunchRecord(launches.ios);
+	const android = parseWorkspaceLaunchRecord(launches.android);
+	return {
+		...ios ? { ios } : {},
+		...android ? { android } : {}
+	};
+}
+function writeWorkspaceLaunch(root, platform, record) {
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root) ?? {};
+		const launches = state.launches && typeof state.launches === "object" ? state.launches : {};
+		replaceWorkspaceState(root, {
+			...state,
+			launches: {
+				...launches,
+				[platform]: record
+			}
+		});
+	});
+}
+function readRemoteSession(root) {
+	const record = readWorkspaceState(root)?.remoteDevice;
+	if (!record || typeof record !== "object") return null;
+	const id = record.sessionId;
+	if (typeof id !== "string" || id.length === 0) return null;
+	const platform = record.platform;
+	const startedAt = record.startedAt;
+	return {
+		platform: platform === "ios" || platform === "android" ? platform : null,
+		sessionId: id,
+		startedAt: typeof startedAt === "string" ? startedAt : null
+	};
+}
+function readRemoteSessionId(root) {
+	return readRemoteSession(root)?.sessionId ?? null;
+}
+function clearRemoteSession(root, expectedSessionId) {
+	clearWorkspaceStateKey(root, "remoteDevice", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		return value.sessionId === expectedSessionId;
+	});
+}
+function withWorkspaceStateLock(root, fn) {
+	const file = workspaceStateFile(root);
+	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
+		ensureWorkspaceStorage(root);
+		mkdirSync(dirname$1(file), { recursive: true });
+	} });
+}
+function writeWorkspaceState(root, patch) {
+	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, {
+		...readWorkspaceState(root),
+		...patch
+	}));
+}
+function replaceWorkspaceState(root, state) {
+	const file = workspaceStateFile(root);
+	mkdirSync(dirname$1(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+	renameSync(tmp, file);
+	return state;
+}
+function clearWorkspaceSupervisor(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		const current = readWorkspaceState(root)?.supervisor;
+		if (current && expected !== void 0 && !sameProcessRecord(current, expected)) return false;
+		clearWorkspaceStateKey(root, "supervisor", () => true);
+		clearExpoMetroTunnel(root);
+		if (expected === void 0 || readPidFile(root) === expected?.pid) rmSync(supervisorPidFile(root), { force: true });
+		return true;
+	});
+}
+function clearExpoMetroTunnel(root) {
+	clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		return typeof value === "object" && value !== null && value.kind === "expo";
+	});
+}
+function clearManagedMetroTunnel(root, expected) {
+	if (!existsSync(workspaceStateFile(root))) return true;
+	return clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		const record = value;
+		return record.kind === "managed" && record.provider === expected.provider && record.pid === expected.pid && record.url === expected.url && record.port === expected.port && record.startedAt === expected.startedAt && (record.processToken ?? null) === (expected.processToken ?? null) && (record.logFile ?? null) === (expected.logFile ?? null);
+	});
+}
+function clearWorkspaceStateKeys(root, keys) {
+	if (!existsSync(workspaceStateFile(root))) return;
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		const file = workspaceStateFile(root);
+		if (!state) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return;
+		}
+		let changed = false;
+		for (const key of keys) {
+			if (!(key in state)) continue;
+			delete state[key];
+			changed = true;
+		}
+		if (!changed) return;
+		if (Object.keys(state).length === 0) {
+			rmSync(file, { force: true });
+			return;
+		}
+		replaceWorkspaceState(root, state);
+	});
+}
+function clearWorkspaceStateKey(root, key, shouldClear) {
+	return withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		if (!state || !(key in state)) return true;
+		if (!shouldClear(state[key])) return false;
+		delete state[key];
+		const file = workspaceStateFile(root);
+		if (Object.keys(state).length === 0) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return true;
+		}
+		replaceWorkspaceState(root, state);
+		return true;
+	});
+}
+function writePidFile(root, pid) {
+	const file = supervisorPidFile(root);
+	mkdirSync(dirname$1(file), { recursive: true });
+	writeFileSync(file, `${pid}\n`);
+	return file;
+}
+function readPidFile(root) {
+	try {
+		const pid = parseInt(readFileSync(supervisorPidFile(root), "utf-8").trim(), 10);
+		return Number.isFinite(pid) ? pid : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { supervisorLogFile as C, workspaceName as D, workspaceLogsDir as E, workspaceStateFile as O, sharedCompilationCache as S, workspaceDir as T, writeWorkspaceState as _, clearRemoteSession as a, sharedBuildCache as b, readMetroTunnel as c, readRemoteSessionId as d, readWorkspaceLaunches as f, writeWorkspaceLaunch as g, writePidFile as h, clearManagedMetroTunnel as i, readPidFile as l, withWorkspaceStateLock as m, MODE_EXPO as n, clearWorkspaceStateKeys as o, readWorkspaceState as p, clearExpoMetroTunnel as r, clearWorkspaceSupervisor as s, MODE_BARE as t, readRemoteSession as u, emulatorLogFile as v, workspaceDerivedData as w, sharedCcache as x, ensureWorkspaceStorage as y };

package/dist/supervisor-run.d.mts

@@ -0,0 +1,85 @@
+import { t as NdjsonWriter } from "./ndjson-DvHSsNU9.mjs";
+//#region src/process-identity.d.ts
+interface ProcessRecord {
+  pid?: unknown;
+  processToken?: unknown;
+}
+//#endregion
+//#region src/supervisor/state.d.ts
+declare const MODE_BARE = "bare-inproc";
+declare const MODE_EXPO = "expo-child";
+interface WorkspaceState {
+  metroCacheGeneration?: string;
+  supervisor?: Record<string, unknown>;
+  collectors?: Record<string, unknown>;
+  lastBuild?: Record<string, unknown>;
+  launches?: Partial<Record<WorkspaceLaunchPlatform, WorkspaceLaunchRecord>>;
+  remoteDevice?: Record<string, unknown>;
+  metroTunnel?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+type WorkspaceLaunchPlatform = "ios" | "android";
+interface WorkspaceLaunchRecord {
+  appId: string;
+  deviceId: string;
+  metroPort: number | null;
+  release: boolean;
+  deepLinkUrl: string | null;
+  launchedAt: string;
+}
+declare function readWorkspaceState(root: string): WorkspaceState | null;
+declare function withWorkspaceStateLock<T>(root: string, fn: () => T): T;
+declare function writeWorkspaceState(root: string, patch: WorkspaceState): WorkspaceState;
+declare function clearWorkspaceSupervisor(root: string, expected?: ProcessRecord | null): boolean;
+declare function clearExpoMetroTunnel(root: string): void;
+declare function writePidFile(root: string, pid: number): string;
+declare function readPidFile(root: string): number | null;
+//#endregion
+//#region src/supervisor/run.d.ts
+interface ParsedSupervisorArgs {
+  root?: string;
+  port?: number;
+  tunnel?: boolean;
+  error?: string;
+}
+declare function parseArgs(argv: string[]): ParsedSupervisorArgs;
+interface ServerExitInfo {
+  code?: number | null;
+  signal?: NodeJS.Signals | null;
+  reason?: string;
+  error?: Error;
+}
+interface ServerHandle {
+  close(): Promise<void> | void;
+  onExit?(cb: (info?: ServerExitInfo | null) => void): void;
+  serverPid?: number | null;
+}
+type ServerStarter = (opts: {
+  root: string;
+  port: number;
+  logsDir: string;
+  writer?: NdjsonWriter | null;
+  tunnel?: boolean;
+  onTunnelUrl?: ((url: string) => void) | null;
+}) => Promise<ServerHandle>;
+interface RunSupervisorOptions {
+  root: string;
+  port: number;
+  tunnel?: boolean;
+  isExpo?: (projectRoot: string) => boolean;
+  startBare?: ServerStarter | null;
+  startExpo?: ServerStarter | null;
+  now?: () => number;
+  onExit?: (code: number) => void;
+  attachSignals?: boolean;
+  stderr?: (line: string) => void;
+}
+declare function runSupervisor({ root, port, tunnel, isExpo, startBare, startExpo, now, onExit, attachSignals, stderr }: RunSupervisorOptions): Promise<{
+  mode: string;
+  server: ServerHandle | undefined;
+  shutdown: (code: number, event: string, msg: string) => Promise<void>;
+  startedAt: string;
+} | null>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { MODE_BARE, MODE_EXPO, RunSupervisorOptions, ServerExitInfo, ServerHandle, type WorkspaceState, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, readWorkspaceState, runSupervisor, withWorkspaceStateLock, writePidFile, writeWorkspaceState };

package/dist/supervisor-run.mjs

@@ -0,0 +1,210 @@
+import { S as captureProcessToken, a as clearSupervisor, y as setSupervisor } from "./config-7kmtuhO2.mjs";
+import { i as detectIsExpo } from "./project-Dit1CckW.mjs";
+import { E as workspaceLogsDir, _ as writeWorkspaceState, h as writePidFile, l as readPidFile, m as withWorkspaceStateLock, n as MODE_EXPO, p as readWorkspaceState, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-2nush3MK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-DcAtEx_K.mjs";
+import { t as describeError } from "./errors-B6W7FkxQ.mjs";
+import { existsSync, realpathSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/supervisor/run.ts
+function parseArgs(argv) {
+	let root;
+	let port;
+	let tunnel = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--root") {
+			root = argv[++i];
+			continue;
+		}
+		if (arg === "--port") {
+			port = argv[++i];
+			continue;
+		}
+		if (arg === "--tunnel") {
+			tunnel = true;
+			continue;
+		}
+		return { error: `Unknown supervisor argument "${arg}". Usage: run.js --root <path> --port <n> [--tunnel]` };
+	}
+	if (!root) return { error: "Missing --root. Usage: run.js --root <path> --port <n> [--tunnel]" };
+	if (!isAbsolute(root)) return { error: `--root must be an absolute path, got "${root}".` };
+	const parsedPort = Number(port);
+	if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) return { error: `--port must be a TCP port number, got "${port}".` };
+	return {
+		root: resolve(root),
+		port: parsedPort,
+		tunnel
+	};
+}
+async function runSupervisor({ root, port, tunnel = false, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
+	root = realpathSync(root);
+	const logsDir = workspaceLogsDir(root);
+	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"));
+	const mode = isExpo(root) ? MODE_EXPO : MODE_BARE;
+	const startedAt = new Date(now()).toISOString();
+	const processToken = captureProcessToken(process.pid);
+	if (!processToken) {
+		stderr("Stim supervisor: could not capture process identity; refusing to start an unmanaged server.");
+		writer.close();
+		onExit(1);
+		return null;
+	}
+	const record = {
+		pid: process.pid,
+		processToken,
+		port,
+		mode,
+		startedAt
+	};
+	clearExpoMetroTunnel(root);
+	writePidFile(root, process.pid);
+	writeWorkspaceState(root, { supervisor: record });
+	try {
+		setSupervisor(root, record);
+	} catch (err) {
+		writer.write({
+			src: "metro",
+			level: "warn",
+			event: "supervisor_registration_failed",
+			msg: `Could not record the supervisor in the global config: ${describeError(err)}`
+		});
+		stderr(`Stim supervisor: global registration failed: ${describeError(err)}`);
+	}
+	writer.write({
+		src: "metro",
+		level: "info",
+		event: "supervisor_started",
+		msg: `supervisor pid ${process.pid} starting the ${mode} dev server on port ${port} for ${root}`
+	});
+	let stopping = false;
+	const finish = (code, event, level, msg) => {
+		writer.write({
+			src: "metro",
+			level,
+			event,
+			msg
+		});
+		try {
+			clearSupervisor(root, record);
+		} catch {}
+		try {
+			clearWorkspaceSupervisor(root, record);
+		} catch {}
+		const closed = writer.close();
+		if (closed.dropped > 0) stderr(`Stim supervisor: dropped ${closed.dropped} log record(s); last error: ${describeError(closed.lastError)}`);
+		onExit(code);
+	};
+	let server;
+	try {
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-BZJm--wA.mjs")).startExpoServer : startBare || (await import("./server-bare-BmTVVmBB.mjs")).startBareServer)({
+			root,
+			port,
+			logsDir,
+			writer,
+			tunnel,
+			onTunnelUrl: (url) => {
+				try {
+					withWorkspaceStateLock(root, () => {
+						if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { metroTunnel: {
+							kind: "expo",
+							url
+						} });
+					});
+				} catch (err) {
+					stderr(`Stim supervisor: could not record the Expo tunnel URL: ${describeError(err)}`);
+				}
+				writer.write({
+					src: "metro",
+					level: "info",
+					event: "expo_tunnel_ready",
+					msg: `Expo tunnel ready: ${url}`
+				});
+			}
+		});
+	} catch (err) {
+		stderr(`Stim supervisor: failed to start the ${mode} dev server: ${describeError(err)}`);
+		finish(1, "supervisor_failed", "fatal", `failed to start the ${mode} dev server: ${describeError(err)}`);
+		return null;
+	}
+	const readyServer = server;
+	if (readyServer.serverPid) withWorkspaceStateLock(root, () => {
+		if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { supervisor: {
+			...record,
+			serverPid: readyServer.serverPid
+		} });
+	});
+	writer.write({
+		src: "metro",
+		level: "info",
+		event: "server_started",
+		msg: `${mode} dev server listening on port ${port}`
+	});
+	const shutdown = async (code, event, msg) => {
+		if (stopping) return;
+		stopping = true;
+		try {
+			await readyServer.close();
+		} catch (err) {
+			writer.write({
+				src: "metro",
+				level: "warn",
+				event: "server_close_failed",
+				msg: describeError(err)
+			});
+		}
+		finish(code, event, code === 0 ? "info" : "error", msg);
+	};
+	readyServer.onExit?.((info) => {
+		if (stopping) return;
+		const detail = info?.signal ? `signal ${info.signal}` : `exit code ${info?.code ?? "unknown"}`;
+		shutdown(1, "supervisor_stopped", `the ${mode} dev server exited unexpectedly (${detail}); shutting the supervisor down`);
+	});
+	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+		shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
+	});
+	return {
+		mode,
+		server,
+		shutdown,
+		startedAt
+	};
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsed = parseArgs(argv);
+	if (parsed.error) {
+		console.error(`Stim supervisor: ${parsed.error}`);
+		process.exit(2);
+		return;
+	}
+	const root = parsed.root;
+	if (!existsSync(root)) {
+		console.error(`Stim supervisor: --root ${root} does not exist.`);
+		process.exit(2);
+		return;
+	}
+	try {
+		process.chdir(root);
+	} catch {}
+	process.title = "stim-supervisor";
+	await runSupervisor({
+		root,
+		port: parsed.port,
+		tunnel: parsed.tunnel ?? false
+	});
+}
+function invokedDirectly() {
+	const entry = process.argv[1];
+	if (!entry) return false;
+	try {
+		return resolve(entry) === fileURLToPath(import.meta.url);
+	} catch {
+		return false;
+	}
+}
+if (invokedDirectly()) main().catch((err) => {
+	console.error(`Stim supervisor: ${describeError(err)}`);
+	process.exit(1);
+});
+//#endregion
+export { MODE_BARE, MODE_EXPO, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, readWorkspaceState, runSupervisor, withWorkspaceStateLock, writePidFile, writeWorkspaceState };

package/package.json

@@ -1,11 +1,64 @@
 {
   "name": "stim",
-  "version": "0.0.0",
-  "description": "Stim",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "1.0.0",
+  "description": "Stim: fast, isolated React Native environments for coding agents",
+  "keywords": [
+    "agent",
+    "emulator",
+    "expo",
+    "metro",
+    "react-native",
+    "simulator",
+    "worktree"
+  ],
+  "homepage": "https://github.com/appandflow/stim#readme",
+  "bugs": {
+    "url": "https://github.com/appandflow/stim/issues"
+  },
+  "license": "MIT",
+  "author": "Janic Duplessis",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/appandflow/stim.git",
+    "directory": "packages/stim-cli"
+  },
+  "bin": {
+    "stim": "dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "shim",
+    "skill",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": {
+    "./cache-manifest": {
+      "types": "./dist/cache-manifest.d.mts",
+      "module-sync": "./dist/cache-manifest.mjs",
+      "default": "./dist/cache-manifest.mjs"
+    }
   },
-  "author": "Jake Hamilton <jake.hamilton@hey.com>",
-  "license": "Apache-2.0"
-}
+  "dependencies": {
+    "@expo/fingerprint": "^0.20.10",
+    "@stim-cli/cache": "^1.0.0",
+    "@stim-cli/core": "^1.0.0",
+    "@stim-cli/metro": "^1.0.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "unique-pid": "0.1.1",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@stim-cli/expo-build-cache": "1.0.0",
+    "@types/ws": "^8.18.1"
+  },
+  "engines": {
+    "node": "^20.19.4 || >=22.12.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "build": "tsdown"
+  }
+}

package/shim/android-cas-pch.cmake

@@ -0,0 +1,35 @@
+function(_stim_cas_pch directory)
+  get_property(targets DIRECTORY "${directory}" PROPERTY BUILDSYSTEM_TARGETS)
+  foreach(target IN LISTS targets)
+    get_target_property(headers "${target}" PRECOMPILE_HEADERS)
+    if(NOT headers)
+      continue()
+    endif()
+    set(portable)
+    foreach(header IN LISTS headers)
+      set(mapped "${header}")
+      if(IS_ABSOLUTE "${header}")
+        foreach(root IN ITEMS "${CMAKE_BINARY_DIR}" "$ENV{STIM_ANDROID_CAS_SOURCE_ROOT}")
+          string(FIND "${header}" "${root}/" position)
+          if(position EQUAL 0)
+            string(LENGTH "${root}/" length)
+            string(SUBSTRING "${header}" ${length} -1 suffix)
+            if(root STREQUAL CMAKE_BINARY_DIR)
+              set(mapped "\"/^build/${suffix}\"")
+            else()
+              set(mapped "\"/^src/${suffix}\"")
+            endif()
+            break()
+          endif()
+        endforeach()
+      endif()
+      list(APPEND portable "${mapped}")
+    endforeach()
+    set_property(TARGET "${target}" PROPERTY PRECOMPILE_HEADERS "${portable}")
+  endforeach()
+  get_property(children DIRECTORY "${directory}" PROPERTY SUBDIRECTORIES)
+  foreach(child IN LISTS children)
+    _stim_cas_pch("${child}")
+  endforeach()
+endfunction()
+cmake_language(DEFER CALL _stim_cas_pch "${CMAKE_CURRENT_SOURCE_DIR}")