@stim-cli/ci 1.19.0 → 1.20.0

package/README.md

@@ -10,6 +10,39 @@ its own checkout. The run stops that checkout's workspace, including resources
 started before a build failure; an explicit API `run.slot` limits cleanup to
 that slot. Do not point CI at a developer's active checkout.
 
+## Build only
+
+```sh
+npx --yes --package @stim-cli/ci stim-ci build --platform ios --project ./app --artifacts ./build-results
+```
+
+This compiles or restores an artifact without starting a simulator, emulator,
+Metro server, or app. It does not stop an existing workspace session. iOS builds
+target the simulator; archives, device distribution and web compilation are
+not supported. By default, iOS and Android builds use the same native artifact
+cache as `run`. A later `run` in the same job validates that cache normally; its
+`run.json` reports `cacheKey` and `cacheHit`, which show whether it reused the
+build. Android reuse requires the run's emulator system image to have the host's
+ABI; a configured `android.systemImage` with another ABI, or a physical device,
+misses. An iOS Debug build with `--arch all` is keyed without an architecture,
+so a later Debug `run` misses. macOS builds are not cached, so a later macOS
+`run` builds again.
+
+The result has `stage: "build"`, `build`, `buildPath`, and `artifactPath`.
+The results directory contains `build.json`, `result.json`, `diagnostics.json`,
+and `app.apk` for Android or `app.tar.gz` for iOS/macOS. iOS and macOS also
+keep the archive command's output in `artifact.stdout.log` and
+`artifact.stderr.log`. The archive preserves app
+executable permissions and symlinks when uploaded through an artifact service.
+Extract it with `tar -xzf app.tar.gz`. Importing a downloaded artifact into a
+Stim run is not part of this command.
+
+The library exports `buildCI({ projectRoot, build: { platform: "ios" }, ... })`.
+It accepts the same home/cache, timeout, cancellation and progress options as
+`runCI`. Build cancellation waits for the owned build operation to finish
+cleanup and retains diagnostics; it never calls workspace `stop()`. A cancel or timeout after the artifact is exported does not fail the build
+stage.
+
 ## Command line
 
 Without installing:
@@ -27,8 +60,22 @@ stim-ci run --platform android --project ./app --artifacts ./test-results --time
 `--platform` accepts `ios`, `android`, `macos`, or `web`. `--project` defaults
 to the current directory. `--home` and `--build-cache` explicitly select the
 Stim home and native artifact cache; leaving them unset preserves normal Stim
-configuration. The CLI uses each project's normal build settings. The library
-also accepts the public API's platform-specific run options.
+configuration.
+
+Without selectors, the CLI uses each project's normal build settings. `build`
+and `run` accept the same selectors as the public API, so a run can match a
+build:
+
+| Option                   | Platform | Stage      | Selects                                                 |
+| ------------------------ | -------- | ---------- | ------------------------------------------------------- |
+| `--scheme <name>`        | iOS      | build, run | Xcode scheme                                            |
+| `--configuration <name>` | iOS      | build, run | Xcode configuration                                     |
+| `--variant <name>`       | Android  | build, run | Gradle variant                                          |
+| `--arch <name>`          | iOS      | build      | Architecture: `arm64`, `x86_64`, `all`                  |
+| `--abi <name>`           | Android  | build      | ABI: `arm64-v8a`, `armeabi-v7a`, `x86`, `x86_64`, `all` |
+
+The library also accepts the public API's other platform-specific build and run
+options.
 
 Everything after `--` is an argument vector. No shell is inferred. To use shell
 syntax, pass a shell explicitly: `-- bash -e -o pipefail -c 'pnpm test:e2e'`.

package/dist/cli-oSziKUiL.mjs

@@ -0,0 +1,155 @@
+import { n as buildCI, t as runCI } from "./src-q52NuL5J.mjs";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+const HELP = `Usage: stim-ci build --platform <ios|android|macos> [options]
+       stim-ci run --platform <ios|android|macos|web> [options] -- <command> [args...]
+
+Build exports an artifact without starting or stopping an app.
+Run builds and launches an app, runs a test command, collects diagnostics, and stops it.
+The final result is JSON on stdout; progress and test output go to stderr.
+
+Options:
+  --project <path>       Project directory (default: current directory)
+  --artifacts <path>     Results directory (default: a fresh temporary directory)
+  --home <path>          Explicit Stim home (default: job-local on GitHub-hosted runners)
+  --build-cache <path>   Native artifact cache directory
+  --timeout <seconds>    Setup and test timeout (cleanup has its own deadline)
+  --help                 Show this help
+  --version              Show the package version
+
+Build selectors (build and run):
+  --scheme <name>        iOS scheme
+  --configuration <name> iOS configuration
+  --variant <name>       Android variant
+
+Build-only selectors:
+  --arch <name>          iOS architecture: arm64, x86_64, all
+  --abi <name>           Android ABI: arm64-v8a, armeabi-v7a, x86, x86_64, all
+`;
+function parse(argv) {
+	const separator = argv.indexOf("--");
+	const command = separator < 0 ? [] : argv.slice(separator + 1);
+	const { values, positionals } = parseArgs({
+		args: separator < 0 ? argv : argv.slice(0, separator),
+		allowPositionals: true,
+		options: {
+			platform: { type: "string" },
+			project: { type: "string" },
+			artifacts: { type: "string" },
+			home: { type: "string" },
+			"build-cache": { type: "string" },
+			timeout: { type: "string" },
+			scheme: { type: "string" },
+			configuration: { type: "string" },
+			variant: { type: "string" },
+			arch: { type: "string" },
+			abi: { type: "string" }
+		}
+	});
+	const stage = positionals[0];
+	if (positionals.length !== 1 || stage !== "run" && stage !== "build") throw new Error("Expected stim-ci build or run.");
+	const platform = values.platform;
+	if (platform !== "ios" && platform !== "android" && platform !== "macos" && platform !== "web") throw new Error("--platform must be ios, android, macos or web.");
+	const timeoutMs = values.timeout === void 0 ? void 0 : Number(values.timeout) * 1e3;
+	const common = {
+		projectRoot: values.project ?? process.cwd(),
+		artifactsDir: values.artifacts,
+		home: values.home,
+		buildCache: values["build-cache"],
+		timeoutMs
+	};
+	if (stage === "run" && (values.arch !== void 0 || values.abi !== void 0)) throw new Error("--arch and --abi only apply to build-only.");
+	if (platform !== "ios" && (values.scheme !== void 0 || values.configuration !== void 0 || values.arch !== void 0)) throw new Error("--scheme, --configuration and --arch only apply to iOS.");
+	if (platform !== "android" && (values.variant !== void 0 || values.abi !== void 0)) throw new Error("--variant and --abi only apply to Android.");
+	if (stage === "build") {
+		if (separator >= 0) throw new Error("Build-only does not take a test command. Use stim-ci run to launch and test.");
+		if (platform === "web") throw new Error("Web projects have no native build artifact. Use stim-ci run --platform web.");
+		if (values.arch !== void 0 && ![
+			"arm64",
+			"x86_64",
+			"all"
+		].includes(values.arch)) throw new Error("--arch must be arm64, x86_64 or all.");
+		if (values.abi !== void 0 && ![
+			"arm64-v8a",
+			"armeabi-v7a",
+			"x86",
+			"x86_64",
+			"all"
+		].includes(values.abi)) throw new Error("--abi must be arm64-v8a, armeabi-v7a, x86, x86_64 or all.");
+		const build = platform === "ios" ? {
+			platform,
+			scheme: values.scheme,
+			configuration: values.configuration,
+			arch: values.arch
+		} : platform === "android" ? {
+			platform,
+			variant: values.variant,
+			abi: values.abi
+		} : { platform };
+		return {
+			stage,
+			options: {
+				...common,
+				build
+			}
+		};
+	}
+	if (separator < 0) throw new Error("Separate the test command with --.");
+	if (!command[0]) throw new Error("A test command is required after --.");
+	const run = platform === "ios" ? {
+		platform,
+		scheme: values.scheme,
+		configuration: values.configuration
+	} : platform === "android" ? {
+		platform,
+		variant: values.variant
+	} : { platform };
+	return {
+		stage,
+		options: {
+			...common,
+			run,
+			command
+		}
+	};
+}
+async function main(argv = process.argv.slice(2)) {
+	if (argv.length === 1 && argv[0] === "--version") {
+		process.stdout.write(`1.20.0\n`);
+		return;
+	}
+	if (argv.length === 0 || argv[0] === "--help" || (argv[0] === "run" || argv[0] === "build") && argv[1] === "--help") {
+		process.stdout.write(HELP);
+		return;
+	}
+	const controller = new AbortController();
+	const interrupt = () => controller.abort();
+	try {
+		const invocation = parse(argv);
+		process.on("SIGINT", interrupt);
+		process.on("SIGTERM", interrupt);
+		const callbacks = {
+			signal: controller.signal,
+			onProgress: ({ message }) => {
+				process.stderr.write(message);
+			}
+		};
+		const result = invocation.stage === "build" ? await buildCI({
+			...invocation.options,
+			...callbacks
+		}) : await runCI({
+			...invocation.options,
+			...callbacks
+		});
+		process.stdout.write(`${JSON.stringify(result)}\n`);
+		process.exitCode = result.exitCode;
+	} catch (error) {
+		process.stderr.write(`stim-ci: ${error.message}\n`);
+		process.exitCode = 1;
+	} finally {
+		process.off("SIGINT", interrupt);
+		process.off("SIGTERM", interrupt);
+	}
+}
+//#endregion
+export { main };

package/dist/index.d.mts

@@ -1,4 +1,15 @@
-import { StimOptions, StimRunOptions, StimRunResult, StimStopResult } from "stim";
+import { StimBuildOptions, StimBuildResult, StimOptions, StimRunOptions, StimRunResult, StimStopResult } from "stim";
+//#region src/context.d.ts
+interface CIContextOptions {
+  projectRoot: string;
+  artifactsDir?: string;
+  home?: string;
+  buildCache?: string;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  onProgress?: StimOptions["onProgress"];
+}
+//#endregion
 //#region src/command.d.ts
 interface CommandResult {
   exitCode: number | null;
@@ -9,18 +20,40 @@ interface CommandResult {
   error?: string;
 }
 //#endregion
+//#region src/build.d.ts
+type WithoutSignal$1<T> = T extends unknown ? Omit<T, "signal"> : never;
+interface CIBuildOptions extends CIContextOptions {
+  build: WithoutSignal$1<StimBuildOptions>;
+}
+interface CIBuildResult {
+  version: 1;
+  stage: "build";
+  projectRoot: string;
+  platform: StimBuildOptions["platform"];
+  artifactsDir: string;
+  resultPath: string;
+  buildPath: string;
+  /** Portable APK or tar.gz bundle preserving executable permissions and symlinks. */
+  artifactPath: string | null;
+  startedAt: string;
+  durationMs: number;
+  exitCode: number;
+  build: StimBuildResult | null;
+  failure?: CIFailure;
+  reportingError?: CIFailure;
+  diagnostics: {
+    path: string | null;
+    error?: CIFailure;
+  };
+}
+/** Builds and exports an artifact without starting or stopping a workspace runtime. */
+declare function buildCI(input: CIBuildOptions): Promise<CIBuildResult>;
+//#endregion
 //#region src/index.d.ts
 type WithoutSignal<T> = T extends unknown ? Omit<T, "signal"> : never;
-interface CIOptions {
-  projectRoot: string;
+interface CIOptions extends CIContextOptions {
   run: WithoutSignal<StimRunOptions>;
   command: readonly [string, ...string[]];
-  artifactsDir?: string;
-  home?: string;
-  buildCache?: string;
-  timeoutMs?: number;
-  signal?: AbortSignal;
-  onProgress?: StimOptions["onProgress"];
 }
 interface CIFailure {
   code: string;
@@ -54,4 +87,4 @@ interface CIResult {
 /** Runs an app and argv-based test command, stops its workspace or explicit slot, and retains diagnostics. */
 declare function runCI(options: CIOptions): Promise<CIResult>;
 //#endregion
-export { CIFailure, CIOptions, CIResult, type CommandResult, runCI };
+export { type CIBuildOptions, type CIBuildResult, CIFailure, CIOptions, CIResult, type CommandResult, buildCI, runCI };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as runCI } from "./src-BdobdbxB.mjs";
-export { runCI };
+import { n as buildCI, t as runCI } from "./src-q52NuL5J.mjs";
+export { buildCI, runCI };

package/dist/{src-BdobdbxB.mjs → src-q52NuL5J.mjs}

@@ -1,16 +1,56 @@
 import { copyDiagnosticLogs } from "./artifacts.mjs";
-import { closeSync, mkdirSync, mkdtempSync, openSync, readdirSync, realpathSync, renameSync, writeFileSync, writeSync } from "node:fs";
+import { closeSync, copyFileSync, mkdirSync, mkdtempSync, openSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, writeSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { createStim } from "stim";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import spawn from "cross-spawn";
+//#region src/context.ts
+function failure(error, code) {
+	const caught = error;
+	return {
+		code: typeof caught?.code === "string" ? caught.code : code,
+		message: typeof caught?.message === "string" ? caught.message : String(error),
+		...typeof caught?.remedy === "string" ? { remedy: caught.remedy } : {}
+	};
+}
+function writeJson(path, value) {
+	const pending = `${path}.tmp`;
+	writeFileSync(pending, `${JSON.stringify(value, null, 2)}\n`);
+	renameSync(pending, path);
+}
+function prepareCI(options) {
+	if (options.timeoutMs !== void 0 && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0)) throw new Error("timeoutMs must be a positive integer.");
+	if (process.env.GITHUB_ACTIONS === "true" && process.env.RUNNER_ENVIRONMENT === "github-hosted" && process.env.RUNNER_TEMP && !options.home && !process.env.STIM_HOME) {
+		const directory = join(resolve(process.env.RUNNER_TEMP), "stim-ci");
+		options = {
+			...options,
+			home: join(directory, "home"),
+			buildCache: options.buildCache || (process.env.STIM_BUILD_CACHE ? void 0 : join(directory, "build-cache"))
+		};
+	}
+	const projectRoot = realpathSync(options.projectRoot);
+	const artifactsDir = options.artifactsDir ? resolve(options.artifactsDir) : mkdtempSync(join(tmpdir(), "stim-ci-"));
+	mkdirSync(artifactsDir, { recursive: true });
+	if (readdirSync(artifactsDir).length > 0) throw new Error(`Artifacts directory must be empty: ${artifactsDir}. Choose a new directory for this run.`);
+	const timeout = options.timeoutMs === void 0 ? void 0 : AbortSignal.timeout(options.timeoutMs);
+	const signals = [options.signal, timeout].filter((value) => value !== void 0);
+	const signal = signals.length ? AbortSignal.any(signals) : void 0;
+	return {
+		options,
+		projectRoot,
+		artifactsDir,
+		timeout,
+		signal
+	};
+}
+//#endregion
 //#region src/command.ts
-async function runCommand({ command, cwd, env, artifactsDir, signal, onOutput }) {
+async function runCommand({ command, cwd, env, artifactsDir, logName = "test", signal, onOutput }) {
 	signal?.throwIfAborted();
 	const started = Date.now();
-	const stdout = join(artifactsDir, "test.stdout.log");
-	const stderr = join(artifactsDir, "test.stderr.log");
+	const stdout = join(artifactsDir, `${logName}.stdout.log`);
+	const stderr = join(artifactsDir, `${logName}.stderr.log`);
 	const out = openSync(stdout, "w");
 	let err;
 	try {
@@ -95,7 +135,7 @@ async function runCommand({ command, cwd, env, artifactsDir, signal, onOutput })
 						groupError ??= String(caught);
 					}
 					if (Date.now() >= deadline) {
-						error ??= groupError ?? `Test process group ${child.pid} did not exit after termination`;
+						error ??= groupError ?? `${logName === "artifact" ? "Artifact export" : "Test"} process group ${child.pid} did not exit after termination`;
 						break;
 					}
 					await setTimeout$1(20);
@@ -118,20 +158,130 @@ async function runCommand({ command, cwd, env, artifactsDir, signal, onOutput })
 	}
 }
 //#endregion
-//#region src/index.ts
-function failure(error, code) {
-	const caught = error;
-	return {
-		code: typeof caught?.code === "string" ? caught.code : code,
-		message: typeof caught?.message === "string" ? caught.message : String(error),
-		...typeof caught?.remedy === "string" ? { remedy: caught.remedy } : {}
+//#region src/build.ts
+/** Builds and exports an artifact without starting or stopping a workspace runtime. */
+async function buildCI(input) {
+	const { options, projectRoot, artifactsDir, timeout, signal } = prepareCI(input);
+	const started = Date.now();
+	const result = {
+		version: 1,
+		stage: "build",
+		projectRoot,
+		platform: options.build.platform,
+		artifactsDir,
+		resultPath: join(artifactsDir, "result.json"),
+		buildPath: join(artifactsDir, "build.json"),
+		artifactPath: null,
+		startedAt: new Date(started).toISOString(),
+		durationMs: 0,
+		exitCode: 1,
+		build: null,
+		diagnostics: { path: null }
 	};
+	let reporting = false;
+	const onProgress = options.onProgress ? (event) => {
+		try {
+			options.onProgress(event);
+		} catch (error) {
+			result.reportingError ??= failure(error, "STIM_CI_REPORT_FAILED");
+			if (!reporting) throw error;
+		}
+	} : void 0;
+	const stim = createStim({
+		projectRoot,
+		home: options.home ? resolve(options.home) : void 0,
+		buildCache: options.buildCache ? resolve(options.buildCache) : void 0,
+		onProgress
+	});
+	let attempted = false;
+	let exporting;
+	try {
+		signal?.throwIfAborted();
+		attempted = true;
+		result.build = await stim.build({
+			...options.build,
+			signal
+		});
+		signal?.throwIfAborted();
+		writeJson(result.buildPath, result.build);
+		if (result.build.platform === "android") {
+			exporting = join(artifactsDir, "app.apk");
+			copyFileSync(result.build.facts.apkPath, exporting);
+		} else {
+			const bundle = result.build.platform === "ios" ? result.build.facts.appPath : result.build.facts.bundle;
+			exporting = join(artifactsDir, "app.tar.gz");
+			const packed = await runCommand({
+				command: [
+					"tar",
+					"-czf",
+					exporting,
+					"-C",
+					dirname(bundle),
+					"--",
+					basename(bundle)
+				],
+				cwd: projectRoot,
+				env: {
+					...process.env,
+					COPYFILE_DISABLE: "1"
+				},
+				artifactsDir,
+				logName: "artifact",
+				signal,
+				onOutput: onProgress
+			});
+			if (packed.exitCode !== 0 || packed.error) throw Object.assign(new Error(packed.error ?? `Artifact export exited with ${packed.exitCode}.`), { code: "STIM_CI_ARTIFACT_FAILED" });
+		}
+		signal?.throwIfAborted();
+		result.artifactPath = exporting;
+		result.exitCode = 0;
+	} catch (error) {
+		result.failure = failure(error, result.build ? "STIM_CI_ARTIFACT_FAILED" : "STIM_CI_BUILD_FAILED");
+		if (result.build && !result.failure.code.startsWith("STIM_")) result.failure.code = "STIM_CI_ARTIFACT_FAILED";
+	} finally {
+		reporting = true;
+		if (signal?.aborted) {
+			const timedOut = timeout?.aborted && !options.signal?.aborted;
+			result.exitCode = timedOut ? 124 : 130;
+			result.failure = {
+				code: timedOut ? "STIM_CI_TIMEOUT" : "STIM_CI_CANCELLED",
+				message: timedOut ? `CI build exceeded ${options.timeoutMs}ms.` : "CI build was cancelled."
+			};
+		}
+		if (exporting && !result.artifactPath) try {
+			rmSync(exporting, { force: true });
+		} catch (error) {
+			result.reportingError ??= failure(error, "STIM_CI_REPORT_FAILED");
+		}
+		if (attempted) try {
+			const diagnostics = await stim.diagnostics({
+				tail: 1e3,
+				signal: AbortSignal.timeout(1e4)
+			});
+			result.diagnostics.path = join(artifactsDir, "diagnostics.json");
+			writeJson(result.diagnostics.path, diagnostics);
+		} catch (error) {
+			result.diagnostics.error = failure(error, "STIM_CI_DIAGNOSTICS_FAILED");
+		}
+		if (result.reportingError && result.exitCode === 0) {
+			result.exitCode = 1;
+			result.failure = result.reportingError;
+		}
+		result.durationMs = Date.now() - started;
+		try {
+			writeJson(result.resultPath, result);
+		} catch (error) {
+			result.reportingError = failure(error, "STIM_CI_REPORT_FAILED");
+			if (result.exitCode === 0) {
+				result.exitCode = 1;
+				result.failure = result.reportingError;
+			}
+		}
+	}
+	return result;
 }
-function writeJson(path, value) {
-	const pending = `${path}.tmp`;
-	writeFileSync(pending, `${JSON.stringify(value, null, 2)}\n`);
-	renameSync(pending, path);
-}
+//#endregion
+//#region src/index.ts
 function commandEnvironment(result, options) {
 	const facts = result.run.facts;
 	return {
@@ -150,22 +300,9 @@ function commandEnvironment(result, options) {
 async function runCI(options) {
 	if (!options.command[0]) throw new Error("A non-empty test command is required.");
 	for (const argument of options.command) if (typeof argument !== "string" || argument.includes("\0")) throw new Error("Test command arguments must be strings without null bytes.");
-	if (options.timeoutMs !== void 0 && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0)) throw new Error("timeoutMs must be a positive integer.");
-	if (process.env.GITHUB_ACTIONS === "true" && process.env.RUNNER_ENVIRONMENT === "github-hosted" && process.env.RUNNER_TEMP && !options.home && !process.env.STIM_HOME) {
-		const directory = join(resolve(process.env.RUNNER_TEMP), "stim-ci");
-		options = {
-			...options,
-			home: join(directory, "home"),
-			buildCache: options.buildCache || (process.env.STIM_BUILD_CACHE ? void 0 : join(directory, "build-cache"))
-		};
-	}
-	const projectRoot = realpathSync(options.projectRoot);
-	const artifactsDir = options.artifactsDir ? resolve(options.artifactsDir) : mkdtempSync(join(tmpdir(), "stim-ci-"));
-	mkdirSync(artifactsDir, { recursive: true });
-	if (readdirSync(artifactsDir).length > 0) throw new Error(`Artifacts directory must be empty: ${artifactsDir}. Choose a new directory for this run.`);
-	const timeout = options.timeoutMs === void 0 ? void 0 : AbortSignal.timeout(options.timeoutMs);
-	const signals = [options.signal, timeout].filter((value) => value !== void 0);
-	const signal = signals.length ? AbortSignal.any(signals) : void 0;
+	const prepared = prepareCI(options);
+	options = prepared.options;
+	const { projectRoot, artifactsDir, timeout, signal } = prepared;
 	const started = Date.now();
 	const result = {
 		version: 1,
@@ -288,4 +425,4 @@ async function runCI(options) {
 	return result;
 }
 //#endregion
-export { runCI as t };
+export { buildCI as n, runCI as t };

package/dist/stim-ci.mjs

@@ -6,6 +6,6 @@ const minor = parts[1] ?? 0;
 if (major < 22 || major === 22 && minor < 12) {
 	process.stderr.write(`stim-ci requires Node.js 22.12.0 or later; this is ${process.versions.node}.\n`);
 	process.exitCode = 1;
-} else import("./cli-RvPAkat7.mjs").then(({ main }) => main());
+} else import("./cli-oSziKUiL.mjs").then(({ main }) => main());
 //#endregion
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stim-cli/ci",
-  "version": "1.19.0",
-  "description": "Run Stim apps and test commands in CI with diagnostics and scoped cleanup.",
+  "version": "1.20.0",
+  "description": "Build Stim app artifacts or run Stim apps and test commands in CI with diagnostics and scoped cleanup.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "cross-spawn": "^7.0.6",
-    "stim": "^1.19.0"
+    "stim": "^1.20.0"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6"

package/dist/cli-RvPAkat7.mjs

@@ -1,80 +0,0 @@
-import { t as runCI } from "./src-BdobdbxB.mjs";
-import { parseArgs } from "node:util";
-//#region src/cli.ts
-const HELP = `Usage: stim-ci run --platform <ios|android|macos|web> [options] -- <command> [args...]
-
-Build and launch an app, run a test command, collect diagnostics, and stop it.
-The final result is JSON on stdout; progress and test output go to stderr.
-
-Options:
-  --project <path>       Project directory (default: current directory)
-  --artifacts <path>     Results directory (default: a fresh temporary directory)
-  --home <path>          Explicit Stim home (default: job-local on GitHub-hosted runners)
-  --build-cache <path>   Native artifact cache directory
-  --timeout <seconds>   Setup and test timeout (cleanup has its own deadline)
-  --help                Show this help
-  --version             Show the package version
-`;
-function parse(argv) {
-	const separator = argv.indexOf("--");
-	if (separator < 0) throw new Error("Separate the test command with --.");
-	const command = argv.slice(separator + 1);
-	if (!command[0]) throw new Error("A test command is required after --.");
-	const { values, positionals } = parseArgs({
-		args: argv.slice(0, separator),
-		allowPositionals: true,
-		options: {
-			platform: { type: "string" },
-			project: { type: "string" },
-			artifacts: { type: "string" },
-			home: { type: "string" },
-			"build-cache": { type: "string" },
-			timeout: { type: "string" }
-		}
-	});
-	if (positionals.length !== 1 || positionals[0] !== "run") throw new Error("Expected stim-ci run.");
-	const platform = values.platform;
-	if (platform !== "ios" && platform !== "android" && platform !== "macos" && platform !== "web") throw new Error("--platform must be ios, android, macos or web.");
-	const timeoutMs = values.timeout === void 0 ? void 0 : Number(values.timeout) * 1e3;
-	return {
-		projectRoot: values.project ?? process.cwd(),
-		run: { platform },
-		command,
-		artifactsDir: values.artifacts,
-		home: values.home,
-		buildCache: values["build-cache"],
-		timeoutMs
-	};
-}
-async function main(argv = process.argv.slice(2)) {
-	if (argv.length === 1 && argv[0] === "--version") {
-		process.stdout.write(`1.19.0\n`);
-		return;
-	}
-	if (argv.length === 0 || argv[0] === "--help" || argv[0] === "run" && argv[1] === "--help") {
-		process.stdout.write(HELP);
-		return;
-	}
-	const controller = new AbortController();
-	const interrupt = () => controller.abort();
-	try {
-		const options = parse(argv);
-		process.on("SIGINT", interrupt);
-		process.on("SIGTERM", interrupt);
-		const result = await runCI({
-			...options,
-			signal: controller.signal,
-			onProgress: ({ message }) => process.stderr.write(message)
-		});
-		process.stdout.write(`${JSON.stringify(result)}\n`);
-		process.exitCode = result.exitCode;
-	} catch (error) {
-		process.stderr.write(`stim-ci: ${error.message}\n`);
-		process.exitCode = 1;
-	} finally {
-		process.off("SIGINT", interrupt);
-		process.off("SIGTERM", interrupt);
-	}
-}
-//#endregion
-export { main };