stim 1.20.2 → 1.22.0

package/dist/api-qvOzWyfO.mjs

@@ -1,154 +0,0 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.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,
-		build: (({ signal, ...request }) => invoke(context, {
-			operation: "build",
-			options: request
-		}, signal)),
-		run: (({ signal, ...request }) => 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.mjs

@@ -1,294 +0,0 @@
-import { E as upsertProject, p as getProject, y as refuseRelativeStimPaths } from "./config-BYDxlMY3.mjs";
-import { t as StimError } from "./api-qvOzWyfO.mjs";
-import { K as resolveProjectSettings, Q as settingShapeErrors, a as SETTING_SHAPE_REMEDY } from "./settings-B717odTD.mjs";
-import { i as recordWorkspaceUse, p as ensureWorkspaceStorage, w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { d as projectRegistry } from "./project-_phNIJfs.mjs";
-import { Dt as recordFinishedBuild, Ot as startBuildProgress, kt as tapBuildLog } from "./budget-f7516Zk0.mjs";
-import { S as withNativeBuildRun, x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { n as cancelledError, r as throwIfCancelled } from "./cancellation-C_22VQTH.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { y as resolveBuildPlacement } from "./client-qQAaXSUs.mjs";
-import { n as macosDir } from "./state-CG_OFoaA.mjs";
-import { n as buildAndroidOperation, t as buildIosOperation } from "./build-DYDbfkk5.mjs";
-import { i as runAndroidOperation } from "./android-DCKZrNvV.mjs";
-import { r as runIosOperation } from "./ios-Ce7bc7br.mjs";
-import { i as buildMacosBundle, n as runMacos } from "./macos-Ch5VJmcS.mjs";
-import { c as stopWorkspaceNow } from "./stop-BNmBMi1F.mjs";
-import { t as runWeb } from "./web-BDBMxDpx.mjs";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { queryJsonLogs } from "@stim-cli/core/state";
-//#region src/commands/macos-build.ts
-const note = (line) => console.error(line);
-async function buildMacosOperation(root, options) {
-	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 } = resolveProjectSettings(root);
-	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 selected.load()).prepare(settings);
-	ensureWorkspaceStorage(root);
-	return withNativeBuildRun(root, {
-		command: "build",
-		platform: "macos"
-	}, async (claim) => {
-		if (!getProject(root)) upsertProject(root, {});
-		recordWorkspaceUse(root);
-		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({
-				root,
-				recipe,
-				bundle,
-				bundleId: recipe.bundleId,
-				scratch: join(macosDir(root), "build"),
-				writer,
-				note,
-				progress,
-				record: build,
-				buildMachine: placement.selected
-			});
-			throwIfCancelled(runCancellationSignal(), "macOS build");
-			const executable = realpathSync(join(bundle, "Contents", "MacOS", recipe.product));
-			build.state = "ok";
-			succeeded = true;
-			return {
-				product: recipe.product,
-				bundle,
-				bundleId: recipe.bundleId,
-				executable,
-				build,
-				logs: { dir: logs }
-			};
-		} catch (error) {
-			const failure = runCancellationSignal()?.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-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
-			};
-		}
-		if (request.operation === "build") switch (request.options.platform) {
-			case "ios": return {
-				ok: true,
-				result: {
-					platform: "ios",
-					facts: await buildIosOperation(root, request.options)
-				}
-			};
-			case "android": return {
-				ok: true,
-				result: {
-					platform: "android",
-					facts: await buildAndroidOperation(root, request.options)
-				}
-			};
-			case "macos": return {
-				ok: true,
-				result: {
-					platform: "macos",
-					facts: await buildMacosOperation(root, request.options)
-				}
-			};
-			default: throw new StimError({
-				code: "STIM_BAD_ARG",
-				message: "Unknown Stim build platform."
-			});
-		}
-		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 {};