stim 1.17.1 → 1.18.0

package/dist/android-cas-compiler.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { createHash, randomUUID } from "node:crypto";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 import { once } from "node:events";
 //#region bin/android-cas-compiler.ts
 const context = process.env.STIM_ANDROID_CAS_CONTEXT;

package/dist/api-D0VtFhqk.mjs

@@ -0,0 +1,152 @@
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
+import { realpathSync } from "node:fs";
+import { isAbsolute } from "node:path";
+//#region src/api.ts
+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.
+* Each operation runs in a separate Stim worker. 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 context = {
+		...options,
+		projectRoot,
+		env: {
+			...process.env,
+			...options.home === void 0 ? {} : { STIM_HOME: options.home },
+			...options.buildCache === void 0 ? {} : { STIM_BUILD_CACHE: options.buildCache },
+			FORCE_COLOR: "0"
+		}
+	};
+	return {
+		projectRoot,
+		run({ signal, ...request }) {
+			return invoke(context, {
+				operation: "run",
+				options: request
+			}, signal);
+		},
+		stop({ signal, ...request } = {}) {
+			return invoke(context, {
+				operation: "stop",
+				options: request
+			}, signal);
+		},
+		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 invoke(context, {
+				operation: "diagnostics",
+				options: request
+			}, signal);
+		}
+	};
+}
+function cancelled() {
+	return new StimError({
+		code: "STIM_CANCELLED",
+		message: "The Stim operation was cancelled."
+	});
+}
+function invoke(context, request, signal) {
+	if (signal?.aborted) return Promise.reject(cancelled());
+	return new Promise((resolve, reject) => {
+		const child = getExecutor().spawn(process.execPath, [spawnEntry("api-run")], {
+			cwd: context.projectRoot,
+			env: context.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		let response;
+		let transportError;
+		let callbackError;
+		let callbackFailed = false;
+		let stderr = "";
+		const abort = () => {
+			child.send?.({ operation: "cancel" }, (error) => {
+				if (error) child.kill("SIGINT");
+			});
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
+		const progress = (stream, message) => {
+			if (stream === "stderr") stderr = (stderr + message).slice(-16384);
+			if (!context.onProgress || callbackFailed) return;
+			try {
+				context.onProgress({
+					stream,
+					message
+				});
+			} catch (error) {
+				callbackError = error;
+				callbackFailed = true;
+				abort();
+			}
+		};
+		child.stdout?.setEncoding("utf8").on("data", (chunk) => progress("stdout", chunk));
+		child.stderr?.setEncoding("utf8").on("data", (chunk) => progress("stderr", chunk));
+		child.on("message", (message) => {
+			response = message;
+		});
+		child.on("error", (error) => {
+			transportError = error;
+		});
+		child.on("close", (code, exitSignal) => {
+			signal?.removeEventListener("abort", abort);
+			if (callbackFailed) return reject(callbackError);
+			if (signal?.aborted) return reject(cancelled());
+			if (transportError) return reject(new StimError({
+				code: "STIM_WORKER_FAILED",
+				message: transportError.message,
+				details: { stderr }
+			}));
+			if (response?.ok === false) return reject(new StimError(response.error));
+			if (code === 0 && response?.ok) return resolve(response.result);
+			reject(new StimError({
+				code: "STIM_WORKER_FAILED",
+				message: `Stim worker exited without a result (${exitSignal ?? code}).`,
+				details: { stderr }
+			}));
+		});
+		child.send?.({
+			...request,
+			projectRoot: context.projectRoot
+		}, (error) => {
+			if (error) transportError = error;
+		});
+	});
+}
+//#endregion
+export { createStim as n, StimError as t };

package/dist/api-run.d.mts

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

package/dist/api-run.mjs

@@ -0,0 +1,145 @@
+import { t as StimError } from "./api-D0VtFhqk.mjs";
+import { y as refuseRelativeStimPaths } from "./config-CgYMahz7.mjs";
+import { x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { i as runAndroidOperation } from "./android-BvwuMUJ9.mjs";
+import { r as runIosOperation } from "./ios-CPdkoKaa.mjs";
+import { n as runMacos } from "./macos-DF6C7wUU.mjs";
+import { c as stopWorkspaceNow } from "./stop-BTjs3xbc.mjs";
+import { n as runWeb } from "./web-DTU0uiWj.mjs";
+import { queryJsonLogs } from "@stim-cli/core/state";
+//#region src/api-run.ts
+async function dispatch({ projectRoot: root, ...request }) {
+	let directory;
+	try {
+		refuseRelativeStimPaths();
+		directory = workspaceLogsDir$1(root);
+		if (request.operation === "diagnostics") {
+			const { tail = 200, errors = false } = request.options;
+			return {
+				ok: true,
+				result: {
+					directory,
+					records: tail === 0 ? [] : queryJsonLogs({
+						dir: directory,
+						tail,
+						errorsOnly: errors
+					})
+				}
+			};
+		}
+		if (request.operation === "stop") {
+			const result = await stopWorkspaceNow({
+				root,
+				slot: request.options.slot
+			});
+			if ("refusal" in result) throw new StimError({
+				...result.refusal,
+				details: result.remote
+			});
+			return {
+				ok: true,
+				result
+			};
+		}
+		const options = request.options;
+		switch (options.platform) {
+			case "ios": {
+				let error;
+				const result = await runIosOperation(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 {
+					ok: true,
+					result: {
+						platform: "ios",
+						facts: result.facts
+					}
+				};
+			}
+			case "android": {
+				const result = await runAndroidOperation(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 {
+					ok: true,
+					result: {
+						platform: "android",
+						facts: result.facts
+					}
+				};
+			}
+			case "macos": {
+				const record = await runMacos(root, console.error, void 0, options.remoteBuild);
+				return {
+					ok: true,
+					result: {
+						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: directory }
+						}
+					}
+				};
+			}
+			case "web": {
+				const result = await runWeb({
+					root,
+					headed: options.headed ?? false,
+					note: console.error
+				});
+				if (!result.ok) throw new StimError(result.error);
+				return {
+					ok: true,
+					result: {
+						platform: "web",
+						facts: result.facts
+					}
+				};
+			}
+			default: throw new StimError({
+				code: "STIM_BAD_ARG",
+				message: "Unknown Stim platform."
+			});
+		}
+	} catch (error) {
+		const failure = error;
+		return {
+			ok: false,
+			error: {
+				code: failure.code ?? "STIM_RUN_FAILED",
+				message: error instanceof Error ? error.message : String(error),
+				remedy: failure.remedy ?? null,
+				details: {
+					logs: directory,
+					cause: failure.details
+				}
+			}
+		};
+	}
+}
+function interrupt() {
+	if (!process.emit("SIGINT")) process.exit(130);
+}
+process.once("disconnect", interrupt);
+process.on("message", async (request) => {
+	if (request.operation === "cancel") return interrupt();
+	const response = await dispatch(request);
+	process.send?.(response, () => process.exit(response.ok ? 0 : 1));
+});
+//#endregion
+export {};

package/dist/api.d.mts

@@ -0,0 +1,212 @@
+import "./state-lKh8shBp.mjs";
+import { i as IosFacts, t as AndroidFacts } from "./build-facts-DcLv2HSd.mjs";
+import "./ndjson-Du3j0AQ9.mjs";
+import { MacosBuild, NdjsonRecord, WebBrowserState } from "@stim-cli/core/state";
+import { Command } from "commander";
+import { ChildProcess } from "node:child_process";
+//#region src/engine/device-lease.d.ts
+type LeasePlatform = "ios" | "android";
+interface ReleasedLease {
+  platform: LeasePlatform;
+  id: string;
+  deviceName: string | null;
+  expiresAt: string;
+}
+//#endregion
+//#region src/commands/stop.d.ts
+interface SupervisorOutcome {
+  status: string;
+  pid?: number;
+  reason?: string;
+  port?: number | null;
+  mode?: string | null;
+}
+interface CollectorEntry {
+  platform: string;
+  pid: number | null;
+  status: string;
+  reason?: string;
+}
+interface CollectorsOutcome {
+  status: string;
+  entries: CollectorEntry[];
+}
+interface MetroOutcome {
+  status: string;
+  port?: number | null;
+  pid?: number | null;
+  reason?: string;
+}
+interface DeviceOutcomeEntry {
+  status: string;
+  label?: string;
+  reason?: string;
+  kind?: string | null;
+  remedy?: string;
+}
+interface DeviceOutcome {
+  [key: string]: DeviceOutcomeEntry | null | undefined;
+  ios: DeviceOutcomeEntry | null;
+  android: DeviceOutcomeEntry | null;
+  remote?: DeviceOutcomeEntry | null;
+  web?: DeviceOutcomeEntry | null;
+}
+interface PortOutcome {
+  status: string;
+  port?: number | null;
+  reason?: string;
+}
+interface StopOutcomes {
+  supervisor: SupervisorOutcome;
+  collectors: CollectorsOutcome;
+  metro: MetroOutcome;
+  device: DeviceOutcome;
+  macos?: {
+    status: string;
+    reason?: string;
+  };
+  port: PortOutcome;
+  metroTunnel: TunnelOutcome;
+  releasedLeases: ReleasedLease[];
+}
+interface StopResult {
+  ok: boolean;
+  outcomes: StopOutcomes;
+  summary: string;
+}
+interface TunnelOutcome {
+  status: string;
+  provider?: string;
+  reason?: string;
+}
+//#endregion
+//#region src/web/launch.d.ts
+type WebLaunched = true | "bundling" | "unverified";
+//#endregion
+//#region src/commands/web.d.ts
+interface WebFacts extends WebBrowserState {
+  platform: "web";
+  reused: boolean;
+  launched: WebLaunched;
+  metroPort: number | null;
+  logs: {
+    dir: string;
+  };
+  durationMs: number;
+}
+//#endregion
+//#region src/api/types.d.ts
+type StimPlatform = "ios" | "android" | "macos" | "web";
+interface StimProgress {
+  stream: "stdout" | "stderr";
+  message: string;
+}
+interface StimOptions {
+  /** Absolute or relative path to the app directory, resolved once when creating the client. */
+  projectRoot: string;
+  /** Absolute Stim state directory. Omit to use the caller's STIM_HOME or the default home. */
+  home?: string;
+  /** Absolute native artifact cache directory. Its coordinating home must be shared by all writers. */
+  buildCache?: string;
+  /**
+   * Receives output chunks without writing to the importing process's terminal.
+   * An exception cancels the operation and rejects it with that exception.
+   */
+  onProgress?: (event: StimProgress) => void;
+}
+interface NativeRunOptions {
+  slot?: string;
+  metroCheck?: boolean;
+  buildCache?: boolean;
+  remoteBuild?: string;
+}
+type StimRunOptions = ((NativeRunOptions & {
+  platform: "ios";
+  configuration?: string;
+  scheme?: string;
+  deviceType?: string;
+  runtime?: string;
+}) | (NativeRunOptions & {
+  platform: "android";
+  variant?: string;
+  systemImage?: string;
+  deviceProfile?: string;
+}) | {
+  platform: "macos";
+  remoteBuild?: string;
+} | {
+  platform: "web";
+  headed?: boolean;
+}) & {
+  signal?: AbortSignal;
+};
+type StimRunResult = {
+  platform: "ios";
+  facts: IosFacts;
+} | {
+  platform: "android";
+  facts: AndroidFacts;
+} | {
+  platform: "macos";
+  facts: {
+    product: string;
+    bundle: string;
+    bundleId: string;
+    executable: string;
+    pid: number | null;
+    launched: boolean;
+    build: MacosBuild;
+    logs: {
+      dir: string;
+    };
+  };
+} | {
+  platform: "web";
+  facts: WebFacts;
+};
+interface StimStopOptions {
+  slot?: string;
+  signal?: AbortSignal;
+}
+type StimStopResult = StopResult;
+interface StimDiagnosticsOptions {
+  /** Maximum number of records, default 200. Zero returns paths without records. */
+  tail?: number;
+  errors?: boolean;
+  signal?: AbortSignal;
+}
+interface StimDiagnostics {
+  directory: string;
+  records: NdjsonRecord[];
+}
+interface StimClient {
+  readonly projectRoot: string;
+  run(options: StimRunOptions): Promise<StimRunResult>;
+  /** Stops this workspace, including resources created before a failed run. Use a fresh signal for cleanup. */
+  stop(options?: StimStopOptions): Promise<StimStopResult>;
+  /** Reads the existing local timeline; available even when run failed before creating any logs. */
+  diagnostics(options?: StimDiagnosticsOptions): Promise<StimDiagnostics>;
+}
+interface StimFailure {
+  code: string;
+  message: string;
+  remedy: string | null;
+  details?: unknown;
+}
+//#endregion
+//#region src/api.d.ts
+declare class StimError extends Error {
+  readonly code: string;
+  readonly remedy: string | null;
+  readonly details: unknown;
+  constructor({ code, message, remedy, details }: Omit<StimFailure, "remedy"> & {
+    remedy?: string | null;
+  });
+}
+/**
+ * Creates a client without starting processes or changing the caller's cwd, environment, or signal handlers.
+ * Each operation runs in a separate Stim worker. Resources remain workspace-owned until stop() is called.
+ */
+declare function createStim(options: StimOptions): StimClient;
+//#endregion
+export { type StimClient, type StimDiagnostics, type StimDiagnosticsOptions, StimError, type StimOptions, type StimPlatform, type StimProgress, type StimRunOptions, type StimRunResult, type StimStopOptions, type StimStopResult, createStim };

package/dist/api.mjs

@@ -0,0 +1,2 @@
+import { n as createStim, t as StimError } from "./api-D0VtFhqk.mjs";
+export { StimError, createStim };

package/dist/{app-install-VPkI5WEg.mjs → app-install-D-PUENug.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { D as uninstallIosApp, M as deviceHoldsApk, N as deviceHoldsBundle, l as iosSimulatorFailureAdvice, m as listUserApps } from "./ios-DSfnPfse.mjs";
-import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Ee7sDXfp.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { N as deviceHoldsApk, O as uninstallIosApp, P as deviceHoldsBundle, h as listUserApps, u as iosSimulatorFailureAdvice } from "./ios-B3SbOWdw.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Bn7jWDB1.mjs";
 import { join } from "node:path";
 //#region src/engine/app-schemes.ts
 function schemesFromInfoPlist(plist) {

package/dist/{attempt-Bk2ouQVL.mjs → attempt-DW-mQqM7.mjs}

@@ -6,10 +6,20 @@ const ATTEMPT_BACKOFF_MS = 6e4;
 function due(state, settings, now, attemptedAt) {
 	const elapsed = (stamp) => stamp === void 0 || stamp > now ? Infinity : now - stamp;
 	if (elapsed(attemptedAt) < ATTEMPT_BACKOFF_MS) return [];
-	return ["pressure", "size"].filter((check) => {
-		if (elapsed(state?.deferredAt?.[check]) < DEFERRED_RETRY_MS) return false;
-		const interval = check === "pressure" ? settings.pressureCheckMinutes : settings.sizeCheckMinutes;
-		return elapsed(state?.lastAt[check]) >= interval * 6e4;
+	const intervalMs = {
+		pressure: settings.pressureCheckMinutes * 6e4,
+		size: settings.sizeCheckMinutes * 6e4,
+		worktree: settings.removeFinishedWorktrees ? settings.worktreeCheckMinutes * 6e4 : Infinity,
+		sweep: settings.sweepHours > 0 ? settings.sweepHours * 36e5 : Infinity
+	};
+	return [
+		"pressure",
+		"size",
+		"worktree",
+		"sweep"
+	].filter((check) => {
+		if (intervalMs[check] === Infinity || elapsed(state?.deferredAt?.[check]) < DEFERRED_RETRY_MS) return false;
+		return elapsed(state?.lastAt[check]) >= intervalMs[check];
 	});
 }
 //#endregion