stim 1.20.2 → 1.21.0

package/dist/api.mjs

@@ -1,2 +1,586 @@
-import { n as createStim, t as StimError } from "./api-qvOzWyfO.mjs";
+import { g as trackReportResource, h as runReport, u as operationState } from "./exec-_UbtCQcG.mjs";
+import { d as workspaceDir, m as workspaceLogsDir$1, n as ensureWorkspaceStorage } from "./paths-DQtTgsBf.mjs";
+import { E as upsertProject, p as getProject, y as refuseRelativeStimPaths } from "./config-CYcBF478.mjs";
+import { l as phaseLine } from "./command-output-B1UrjZHL.mjs";
+import { a as recordWorkspaceUseAsync, i as recordWorkspaceUse } from "./workspace-state-Cjuigeeu.mjs";
+import { $t as cancelledError, It as repoRootAsync, J as resolveProjectSettingsAsync, a as SETTING_SHAPE_REMEDY, en as throwIfCancelled, et as settingShapeErrors } from "./settings-CsJDEXgK.mjs";
+import { f as projectRegistry, r as findCommandWorkspaceAsync } from "./project-BZNjmW_8.mjs";
+import { n as macosDir } from "./state-XMziexv2.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
+import { B as recordFinishedBuild, H as tapBuildLog, V as startBuildProgress } from "./budget-Bs6SxxzO.mjs";
+import { d as runCancellationSignal, f as withNativeBuildRun } from "./native-run-DY_RLx3C.mjs";
+import { c as ensureHomeIdentity, s as workspaceShareURL } from "./stim-desktop-C12we7lz.mjs";
+import { s as resolveBuildPlacement } from "./selection-CSl9i5qU.mjs";
+import { c as stopWorkspaceNow } from "./stop-CPzlM1L-.mjs";
+import { r as runReload } from "./reload-CmTRFJaX.mjs";
+import { s as recordDoctorCheck } from "./doctor-watchman-Cv1F10Kj.mjs";
+import { a as readDoctorReport } from "./doctor-Dhqebm0q.mjs";
+import { r as readGcReport } from "./gc-_-dCXdyL.mjs";
+import { r as readWorkspaceLogs, t as followWorkspaceLogs } from "./logs-BS00Anxf.mjs";
+import { t as readProjectStats } from "./stats-report-BFfMpWWF.mjs";
+import { n as buildAndroidOperation, t as buildIosOperation } from "./build-CoPzQRNw.mjs";
+import { i as runAndroidOperation } from "./android-BLgbNqox.mjs";
+import { r as runIosOperation } from "./ios-ubFsBzwq.mjs";
+import { i as buildMacosBundle, n as runMacos } from "./macos-C-0qJ6zq.mjs";
+import { t as runWeb } from "./web-CJmIj6AI.mjs";
+import { i as SettingsRefusal, o as readSettingsContext, s as readSettingsPayload, t as mutateSetting } from "./settings-write-HyVZ8eQ8.mjs";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { stripVTControlCharacters } from "node:util";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { withAmbientContext } from "@stim-cli/core";
+import { RUN_ID_ENV, findProjectRoot, openLogDir, validRunId } from "@stim-cli/core/state";
+//#region src/commands/macos-build.ts
+async function buildMacosOperation(context, root, options) {
+	const note = (line) => context.output("stderr", `${line}\n`);
+	if (process.platform !== "darwin") throw new Error("Building a macOS app requires a Mac with Swift installed.");
+	root = realpathSync(root);
+	const selected = projectRegistry.selectMacos(root);
+	if ("problem" in selected) throw Object.assign(new Error(selected.problem.message), {
+		code: "STIM_NO_PROJECT",
+		remedy: selected.problem.remedy
+	});
+	const { settings } = await resolveProjectSettingsAsync(root, {
+		env: context.env,
+		signal: runCancellationSignal(context) ?? context.signal
+	});
+	const [shape] = settingShapeErrors(settings);
+	if (shape) throw Object.assign(/* @__PURE__ */ new Error(`${shape} ${SETTING_SHAPE_REMEDY}`), { code: "STIM_BAD_ARG" });
+	const placement = resolveBuildPlacement(options.remoteBuild);
+	if (placement.failure) throw Object.assign(new Error(placement.failure.message), placement.failure);
+	const recipe = await (await selected.load()).prepare(context, settings);
+	ensureWorkspaceStorage(root);
+	return withNativeBuildRun(context, root, {
+		command: "build",
+		platform: "macos"
+	}, async (claim) => {
+		if (!getProject(root)) upsertProject(root, {});
+		recordWorkspaceUse(root, /* @__PURE__ */ new Date(), context.env, context.cwd);
+		const started = Date.now();
+		const progress = startBuildProgress({
+			root,
+			platform: "macos",
+			slot: "default",
+			claim,
+			note
+		});
+		const logs = workspaceLogsDir$1(root);
+		const writer = tapBuildLog(createNdjsonWriter(join(logs, "build-artifact-macos.ndjson"), { truncate: true }), progress);
+		const build = {
+			state: "running",
+			startedAt: new Date(started).toISOString(),
+			buildMachine: placement.selected
+		};
+		let directory;
+		let succeeded = false;
+		try {
+			const artifacts = join(workspaceDir(root), "artifacts");
+			mkdirSync(artifacts, { recursive: true });
+			directory = mkdtempSync(join(artifacts, "macos-"));
+			const bundle = join(directory, `${recipe.product}.app`);
+			await buildMacosBundle({
+				context,
+				root,
+				recipe,
+				bundle,
+				bundleId: recipe.bundleId,
+				scratch: join(macosDir(root), "build"),
+				writer,
+				note,
+				progress,
+				record: build,
+				buildMachine: placement.selected
+			});
+			throwIfCancelled(runCancellationSignal(context), "macOS build");
+			const executable = realpathSync(join(bundle, "Contents", "MacOS", recipe.product));
+			const links = { workspace: await workspaceShareURL(root, { platform: "macos" }, runCancellationSignal(context) ?? context.signal) };
+			throwIfCancelled(runCancellationSignal(context), "macOS build");
+			build.state = "ok";
+			succeeded = true;
+			return {
+				product: recipe.product,
+				bundle,
+				bundleId: recipe.bundleId,
+				executable,
+				build,
+				logs: { dir: logs },
+				links
+			};
+		} catch (error) {
+			const failure = runCancellationSignal(context)?.aborted ? cancelledError("macOS build", error) : error;
+			build.state = "failed";
+			build.error = failure instanceof Error ? failure.message : String(failure);
+			build.errorCode = failure.code;
+			throw failure;
+		} finally {
+			build.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			build.durationMs = Date.now() - started;
+			try {
+				recordFinishedBuild(root, {
+					platform: "macos",
+					status: build.state,
+					configuration: "Debug",
+					fingerprint: null,
+					cacheKey: null,
+					cacheHit: false,
+					cacheSkipped: false,
+					durationMs: build.durationMs,
+					startedAt: build.startedAt,
+					errorCode: build.errorCode,
+					buildMachine: build.buildMachine,
+					builtOn: build.builtOn,
+					offloadedTo: build.offloadedTo,
+					offloadFallback: build.offloadFallback,
+					compileSteps: progress.steps()
+				}, { artifactOnly: true });
+			} catch (error) {
+				note(phaseLine("state", `could not record the build: ${error?.message || error}`));
+			} finally {
+				if (!succeeded && directory) rmSync(directory, {
+					recursive: true,
+					force: true
+				});
+				writer.close();
+				progress.clear();
+			}
+		}
+	}, { write: note });
+}
+//#endregion
+//#region src/api.ts
+const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+var StimError = class extends Error {
+	code;
+	remedy;
+	details;
+	constructor({ code, message, remedy = null, details }) {
+		super(message);
+		this.name = "StimError";
+		this.code = code;
+		this.remedy = remedy;
+		this.details = details;
+	}
+};
+/**
+* Creates a client without starting processes or changing the caller's cwd, environment, or signal handlers.
+* The Stim home is fixed when the client is created: `home`, else STIM_HOME from `env`, else the default home.
+* Operations run in the calling process against the client's home and project, so clients for different
+* homes can share a process.
+* Resources remain workspace-owned until stop() is called.
+*/
+function createStim(options) {
+	let projectRoot;
+	try {
+		projectRoot = realpathSync(options.projectRoot);
+	} catch (error) {
+		throw new StimError({
+			code: "STIM_NO_PROJECT",
+			message: `Could not resolve projectRoot ${options.projectRoot}: ${error instanceof Error ? error.message : String(error)}`,
+			remedy: "Pass the path to an existing, readable app directory."
+		});
+	}
+	for (const [name, path] of [["home", options.home], ["buildCache", options.buildCache]]) if (path !== void 0 && !isAbsolute(path)) throw new StimError({
+		code: "STIM_BAD_ARG",
+		message: `${name} must be an absolute path.`
+	});
+	const base = options.env ?? process.env;
+	const home = options.home ?? (base.STIM_HOME || join(base.HOME || base.USERPROFILE || homedir(), ".stim"));
+	const clientContext = {
+		...options,
+		projectRoot,
+		env: {
+			...base,
+			...options.home === void 0 ? {} : { STIM_HOME: options.home },
+			...options.buildCache === void 0 ? {} : { STIM_BUILD_CACHE: options.buildCache },
+			FORCE_COLOR: "0"
+		}
+	};
+	const begin = (signal, cancelOnProgress = false) => {
+		const controller = cancelOnProgress ? new AbortController() : void 0;
+		const abort = () => controller?.abort();
+		if (controller) {
+			signal?.addEventListener("abort", abort, { once: true });
+			if (signal?.aborted) abort();
+		}
+		const callback = {};
+		const output = (stream, message) => {
+			if ("error" in callback) return;
+			try {
+				options.onProgress?.({
+					stream,
+					message: stripVTControlCharacters(message)
+				});
+			} catch (error) {
+				callback.error = error;
+				controller?.abort();
+			}
+		};
+		const operation = operationContext(clientContext, home, output, controller?.signal ?? signal);
+		if (controller) operationState(operation).abortOperation = abort;
+		return {
+			context: operation,
+			callback,
+			dispose: () => signal?.removeEventListener("abort", abort)
+		};
+	};
+	const report = async (signal, work) => {
+		const operation = begin(signal, true);
+		operation.context.env.STIM_HOME = clientContext.env.STIM_HOME;
+		for (const name of [
+			"AGENT_DEVICE_STATE_DIR",
+			"AGENT_DEVICE_CLAIMS_DIR",
+			"AGENT_DEVICE_IOS_RUNNER_LEASE_DIR"
+		]) {
+			const directory = operation.context.env[name]?.trim();
+			if (directory) operation.context.env[name] = resolve(operation.context.cwd, directory);
+		}
+		try {
+			return await read(operation, (context) => runReport(context, (request) => withAmbientContext(request, () => work(request))));
+		} finally {
+			operation.dispose();
+		}
+	};
+	return {
+		projectRoot,
+		identity: ({ signal } = {}) => read(begin(signal), (operation) => ensureHomeIdentity(operation.signal)),
+		doctor: async ({ signal, platform, record } = {}) => {
+			if (platform !== void 0 && platform !== "ios" && platform !== "android") return Promise.reject(new StimError({
+				code: "STIM_BAD_ARG",
+				message: "platform must be ios or android."
+			}));
+			const result = await report(signal, (context) => readDoctorReport(context, platform, version));
+			if (record !== true) return result;
+			return read(begin(signal), async (context) => {
+				await recordDoctorCheck(result.project, platform, version, context.signal);
+				return result;
+			});
+		},
+		gc: ({ signal, olderThan, cache, worktrees } = {}) => {
+			if (olderThan !== void 0 && !Number.isSafeInteger(olderThan)) return Promise.reject(new StimError({
+				code: "STIM_BAD_ARG",
+				message: "olderThan must be a whole number of days."
+			}));
+			return report(signal, async (context) => {
+				const result = await readGcReport({
+					olderThan,
+					cache,
+					worktrees
+				}, {
+					operation: context,
+					easLedgerRoot: join(context.env.HOME || context.env.USERPROFILE || homedir(), ".stim", "machine", "eas")
+				});
+				if ("code" in result) throw new StimError(result);
+				return result;
+			});
+		},
+		settings: ({ signal } = {}) => read(begin(signal), async (operation) => readSettingsPayload(await readSettingsContext(operation.projectRoot, {
+			...operation.env,
+			STIM_HOME: clientContext.env.STIM_HOME
+		}, note(operation), operation.signal), operation.signal)),
+		setSetting: (key, value, { signal, scope, beforeWrite } = {}) => read(begin(signal), (operation) => mutateSetting({
+			action: "set",
+			key,
+			value,
+			scope
+		}, {
+			cwd: operation.projectRoot,
+			env: {
+				...operation.env,
+				STIM_HOME: clientContext.env.STIM_HOME
+			},
+			note: note(operation),
+			signal: operation.signal,
+			beforeWrite
+		})),
+		unsetSetting: (key, { signal, scope, beforeWrite } = {}) => read(begin(signal), (operation) => mutateSetting({
+			action: "unset",
+			key,
+			scope
+		}, {
+			cwd: operation.projectRoot,
+			env: {
+				...operation.env,
+				STIM_HOME: clientContext.env.STIM_HOME
+			},
+			note: note(operation),
+			signal: operation.signal,
+			beforeWrite
+		})),
+		stats: ({ signal } = {}) => read(begin(signal), async (operation) => (await readProjectStats(findProjectRoot(operation.projectRoot), operation.env, operation.signal)).report),
+		logs: ({ signal, ...request } = {}) => read(begin(signal), (operation) => readWorkspaceLogs(operation, request)),
+		followLogs: ({ signal, ...request }, onRecord, onBackfill) => {
+			const operation = begin(signal);
+			return read(operation, async (readContext) => {
+				const stop = await followWorkspaceLogs(readContext, request, onRecord, onBackfill);
+				if ("error" in operation.callback) stop();
+				return stop;
+			});
+		},
+		build: (({ signal, ...request }) => lifecycle(begin(signal, true), (operation) => build(operation, request))),
+		run: (({ signal, ...request }) => lifecycle(begin(signal, true), (operation) => run(operation, request))),
+		stop: ({ signal, ...request } = {}) => read(begin(signal), async (operation) => {
+			const root = operation.projectRoot;
+			const logs = workspaceLogsDir$1(root);
+			let result;
+			try {
+				result = await stopWorkspaceNow({
+					root,
+					slot: request.slot,
+					report: note(operation),
+					operation
+				});
+			} catch (error) {
+				if (operation.signal.aborted) throw error;
+				const failure = error;
+				throw new StimError({
+					code: failure.code ?? "STIM_RUN_FAILED",
+					message: error instanceof Error ? error.message : String(error),
+					remedy: failure.remedy ?? null,
+					details: {
+						logs,
+						cause: failure.details
+					}
+				});
+			}
+			if ("refusal" in result) throw new StimError({
+				...result.refusal,
+				details: {
+					logs,
+					cause: result.remote
+				}
+			});
+			return result;
+		}),
+		reload: async ({ signal, ...request } = {}) => {
+			const requestOperation = begin(signal, true);
+			try {
+				return await read(requestOperation, (context) => runReport(context, (operation) => withAmbientContext(operation, () => {
+					const result = reload(operation, request);
+					trackReportResource(operation, result.then(() => void 0, () => void 0), () => {});
+					return result;
+				})));
+			} finally {
+				requestOperation.dispose();
+			}
+		},
+		diagnostics({ signal, ...request } = {}) {
+			if (request.tail !== void 0 && (!Number.isSafeInteger(request.tail) || request.tail < 0)) return Promise.reject(new StimError({
+				code: "STIM_BAD_ARG",
+				message: "tail must be a non-negative integer."
+			}));
+			return read(begin(signal), async (operation) => {
+				const directory = workspaceLogsDir$1(operation.projectRoot);
+				if (request.tail === 0) return {
+					directory,
+					records: []
+				};
+				const view = await openLogDir(directory, { signal: operation.signal });
+				try {
+					return {
+						directory,
+						records: await view.query({
+							tail: request.tail ?? 200,
+							errorsOnly: request.errors ?? false
+						})
+					};
+				} finally {
+					await view.close();
+				}
+			});
+		}
+	};
+}
+function operationContext(client, home, output, signal) {
+	const runId = validRunId(client.env[RUN_ID_ENV]) ?? randomBytes(6).toString("hex");
+	return {
+		home,
+		buildCache: client.buildCache ?? null,
+		projectRoot: client.projectRoot,
+		cwd: client.projectRoot,
+		runId,
+		env: {
+			...client.env,
+			STIM_HOME: home,
+			[RUN_ID_ENV]: runId
+		},
+		signal: signal ?? new AbortController().signal,
+		output
+	};
+}
+async function read({ context, callback }, operation) {
+	const { signal } = context;
+	if (signal.aborted) throw cancelled();
+	let result;
+	try {
+		refuseRelativeStimPaths(context.env);
+		result = await withAmbientContext(context, () => operation(context));
+	} catch (error) {
+		if ("error" in callback) throw callback.error;
+		if (signal.aborted && !(error instanceof Error && "reportCleanup" in error)) throw cancelled();
+		if (error instanceof StimError) throw error;
+		if (error instanceof Error && "code" in error && typeof error.code === "string" && error.code.startsWith("STIM_")) {
+			const remedy = error instanceof SettingsRefusal ? error.remedy : null;
+			throw new StimError({
+				code: error.code,
+				message: error.message,
+				remedy
+			});
+		}
+		throw error;
+	}
+	if ("error" in callback) throw callback.error;
+	if (signal.aborted) throw cancelled();
+	return result;
+}
+function note(operation) {
+	return (line) => operation.output("stderr", `${line}\n`);
+}
+function cancelled() {
+	return new StimError({
+		code: "STIM_CANCELLED",
+		message: "The Stim operation was cancelled."
+	});
+}
+async function lifecycle(operation, work) {
+	try {
+		return await read(operation, async (context) => {
+			const logs = workspaceLogsDir$1(context.projectRoot);
+			try {
+				return await work(context);
+			} catch (error) {
+				const failure = error;
+				throw new StimError({
+					code: failure?.code ?? "STIM_RUN_FAILED",
+					message: error instanceof Error ? error.message : String(error),
+					remedy: failure?.remedy ?? null,
+					details: {
+						logs,
+						cause: failure?.details
+					}
+				});
+			}
+		});
+	} finally {
+		operation.dispose();
+	}
+}
+async function reload(context, options) {
+	if (options.platform !== void 0 && ![
+		"ios",
+		"android",
+		"web"
+	].includes(options.platform)) throw new StimError({
+		code: "STIM_BAD_ARG",
+		message: "platform must be ios, android or web."
+	});
+	const root = await findCommandWorkspaceAsync(context.projectRoot, (cwd) => repoRootAsync(cwd, {
+		env: context.env,
+		signal: context.signal
+	}), note(context));
+	context.signal.throwIfAborted();
+	if (!root) throw new StimError({
+		code: "STIM_NO_PROJECT",
+		message: `No Stim environment is registered for ${context.projectRoot}.`,
+		remedy: "Run stim start first."
+	});
+	options.beforeReload?.(root);
+	context.signal.throwIfAborted();
+	await recordWorkspaceUseAsync(root, /* @__PURE__ */ new Date(), context.env, context.projectRoot, context.signal);
+	const result = await runReload({
+		root,
+		platform: options.platform,
+		signal: context.signal
+	});
+	if (!result.ok) throw new StimError(result.error);
+	return result.facts;
+}
+async function build(context, options) {
+	const root = context.projectRoot;
+	switch (options.platform) {
+		case "ios": return {
+			platform: "ios",
+			facts: await buildIosOperation(context, root, options)
+		};
+		case "android": return {
+			platform: "android",
+			facts: await buildAndroidOperation(context, root, options)
+		};
+		case "macos": return {
+			platform: "macos",
+			facts: await buildMacosOperation(context, root, options)
+		};
+		default: throw new StimError({
+			code: "STIM_BAD_ARG",
+			message: "Unknown Stim build platform."
+		});
+	}
+}
+async function run(context, options) {
+	const root = context.projectRoot;
+	switch (options.platform) {
+		case "ios": {
+			let error;
+			const result = await runIosOperation(context, root, options, {}, (failure) => {
+				error = failure;
+			});
+			if (!result) throw new StimError({
+				code: error?.code ?? "STIM_RUN_FAILED",
+				message: error?.message ?? "The iOS run failed.",
+				remedy: error?.remedy,
+				details: error
+			});
+			return {
+				platform: "ios",
+				facts: result.facts
+			};
+		}
+		case "android": {
+			const result = await runAndroidOperation(context, root, options);
+			if (!result.ok || !result.facts) throw new StimError({
+				code: result.error?.code ?? "STIM_RUN_FAILED",
+				message: result.error?.message ?? "The Android run failed.",
+				remedy: result.error?.remedy
+			});
+			return {
+				platform: "android",
+				facts: result.facts
+			};
+		}
+		case "macos": {
+			const record = await runMacos(context, root, note(context), void 0, options.remoteBuild);
+			return {
+				platform: "macos",
+				facts: {
+					product: record.product,
+					bundle: record.bundle,
+					bundleId: record.bundleId,
+					executable: record.executable,
+					pid: record.app?.pid ?? null,
+					launched: record.app !== void 0,
+					build: record.build,
+					logs: { dir: workspaceLogsDir$1(root) }
+				}
+			};
+		}
+		case "web": {
+			const result = await runWeb({
+				root,
+				headed: options.headed ?? false,
+				note: note(context),
+				context
+			});
+			if (!result.ok) throw new StimError(result.error);
+			return {
+				platform: "web",
+				facts: result.facts
+			};
+		}
+		default: throw new StimError({
+			code: "STIM_BAD_ARG",
+			message: "Unknown Stim platform."
+		});
+	}
+}
+//#endregion
 export { StimError, createStim };