stim 1.8.0 → 1.10.0

package/dist/{error-diagnostics-D1Kaf-eT.mjs → error-diagnostics-xxWKNO3-.mjs}

@@ -1,17 +1,16 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { D as withDirLock, F as deviceSlotKey, I as deviceSlotPlatforms, f as getProject } from "./config-B7iyKWkL.mjs";
-import { r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { d as readWorkspaceLaunches } from "./state-DZobzxLW.mjs";
-import { n as deviceConsoleLevel } from "./ios-device-CFXA46ez.mjs";
-import { a as resolveProjectMetro } from "./metro-C7bcJ0uo.mjs";
-import { r as androidHome, s as androidToolCwd } from "./android-DWssqHQ8.mjs";
-import { n as parseLogcatLine, t as androidClockOffset } from "./android-DeYdjjBP.mjs";
-import { _ as launchErrorPreview } from "./command-output-B3ycpsYv.mjs";
-import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-Ffz_M5t0.mjs";
-import { l as readLogRecords, t as attachExpoErrorContext } from "./logs-query-BGL-Pl12.mjs";
+import { R as deviceSlotKey, f as getProject, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { P as withDirLock, m as readWorkspaceState$1, s as resolveProjectMetro } from "./metro-BWLOJ_Wr.mjs";
+import { d as readWorkspaceLaunches } from "./state-WGdIbi_d.mjs";
+import { v as launchErrorPreview } from "./command-output-D5z2_bcF.mjs";
+import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-CbEaIk7b.mjs";
+import { r as androidHome, s as androidToolCwd } from "./android-787HhP5w.mjs";
+import { r as deviceConsoleLevel } from "./ios-device-BiOsSVzd.mjs";
+import { n as parseLogcatLine, t as androidClockOffset } from "./android-DPov-fv2.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
+import { attachExpoErrorContext, readLogRecords, sortByTs } from "@stim-cli/core/state";
 import { basename, dirname, join, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 //#region src/diagnostics/diagnostic-store.ts
 /** Publishes an immutable diagnostic snapshot atomically; existing evidence wins. */
@@ -35,6 +34,7 @@ function writeDiagnosticOnce(path, content) {
 }
 //#endregion
 //#region src/diagnostics/native-crash.ts
+const CRASH_LOG_PREFIX = "native-crash-";
 const IOS_CRASH_REPORT_RETRY = "iOS crash reports can take about a minute or longer to appear. Run `stim logs --errors` again for the native stack.";
 /** Accepts only a report for this app, simulator and launch window. */
 function parseIosCrash(text, target) {
@@ -346,7 +346,7 @@ function captureNativeCrashes(target, logsDir) {
 				record.incident ?? record.deviceTs,
 				record.rawReport
 			])).digest("hex");
-			writeDiagnosticOnce(join(logsDir, `native-crash-${key}.ndjson`), `${JSON.stringify(record)}\n`);
+			writeDiagnosticOnce(join(logsDir, `${CRASH_LOG_PREFIX}${key}.ndjson`), `${JSON.stringify(record)}\n`);
 		} catch {}
 	}
 	return records;
@@ -355,8 +355,10 @@ function printNativeCrashReport(target, logsDir, emit, remote) {
 	if (remote) return;
 	for (const line of launchErrorPreview(captureNativeCrashes(target, logsDir), target.root)) emit(line);
 }
+/** Captures native crash reports for this workspace's current launches and returns the whole timeline. */
 function captureWorkspaceCrashes(root, logsDir) {
-	const attempts = readLogRecords(logsDir).filter((record) => record.event === "launch_attempt");
+	const timeline = readLogRecords(logsDir, (name) => !isCrashLog(name));
+	const attempts = timeline.filter((record) => record.event === "launch_attempt");
 	const launches = readWorkspaceLaunches(root);
 	const latest = /* @__PURE__ */ new Map();
 	for (const attempt of attempts) if (attempt.platform === "ios" || attempt.platform === "android") latest.set(deviceSlotKey(attempt.platform, String(attempt.slot ?? "default")), attempt);
@@ -402,10 +404,14 @@ function captureWorkspaceCrashes(root, logsDir) {
 				since: Number(since),
 				until,
 				physical: attempt?.physical === true,
-				appPath: attempt?.appPath ?? readWorkspaceState(root)?.lastBuild?.appPath
+				appPath: attempt?.appPath ?? readWorkspaceState$1(root)?.lastBuild?.appPath
 			}, logsDir);
 		} catch {}
 	}
+	return sortByTs([...timeline, ...readLogRecords(logsDir, isCrashLog)]);
+}
+function isCrashLog(name) {
+	return name.startsWith(CRASH_LOG_PREFIX);
 }
 //#endregion
 //#region src/diagnostics/error-symbolication.ts
@@ -583,8 +589,7 @@ function mergeErrorCopies(records, root) {
 	return result;
 }
 /** Keeps symbolicated launch evidence stable when Metro later rebuilds or stops. */
-async function errorDiagnostics(input, { root, logsDir, port, allowRequest = false }) {
-	const timeline = readLogRecords(logsDir);
+async function errorDiagnostics(input, { root, logsDir, port, allowRequest = false, timeline = readLogRecords(logsDir) }) {
 	const records = attachDeviceErrorContext(timeline, attachExpoErrorContext(timeline, input.map((record) => ({
 		...record,
 		src: typeof record.src === "string" ? record.src : void 0,

package/dist/exec-DK8KaVHK.mjs

@@ -0,0 +1,133 @@
+import { execSync } from "child_process";
+import spawn from "cross-spawn";
+import which from "which";
+//#region src/exec.ts
+const MAX_BUFFER = 67108864;
+function nameTimeout(error, command, timeoutMs) {
+	if (error?.code === "ETIMEDOUT" && error instanceof Error) error.message = `Command timed out after ${timeoutMs}ms: ${command}`;
+	return error;
+}
+let active = {
+	run(cmd, { timeoutMs, killSignal, cwd } = {}) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		if (timeoutMs) opts.timeout = timeoutMs;
+		if (killSignal) opts.killSignal = killSignal;
+		if (cwd) opts.cwd = cwd;
+		try {
+			return String(execSync(cmd, opts)).trim();
+		} catch (error) {
+			throw nameTimeout(error, cmd, timeoutMs);
+		}
+	},
+	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed } = {}) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		if (timeoutMs) opts.timeout = timeoutMs;
+		if (killSignal) opts.killSignal = killSignal;
+		if (cwd) opts.cwd = cwd;
+		if (input !== void 0) opts.input = input;
+		if (env || omitEnv?.length) {
+			const childEnv = {
+				...process.env,
+				...env
+			};
+			for (const key of omitEnv ?? []) delete childEnv[key];
+			opts.env = childEnv;
+		}
+		const result = spawn.sync(file, args, opts);
+		if (result.error) throw nameTimeout(Object.assign(result.error, result), [file, ...args].join(" "), timeoutMs);
+		if (result.status !== 0) {
+			const stderr = String(result.stderr ?? "");
+			const message = `Command failed: ${[file, ...args].join(" ")}${stderr ? `\n${stderr}` : ""}`;
+			throw Object.assign(new Error(message), result);
+		}
+		return untrimmed ? String(result.stdout) : String(result.stdout).trim();
+	},
+	runFileAsync(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv } = {}) {
+		const command = [file, ...args].join(" ");
+		return new Promise((resolve, reject) => {
+			const opts = { stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			] };
+			if (cwd) opts.cwd = cwd;
+			if (env || omitEnv?.length) {
+				const childEnv = {
+					...process.env,
+					...env
+				};
+				for (const key of omitEnv ?? []) delete childEnv[key];
+				opts.env = childEnv;
+			}
+			const child = spawn(file, args, opts);
+			const stdout = [];
+			const stderr = [];
+			let timedOut = false;
+			const timer = timeoutMs ? setTimeout(() => {
+				timedOut = true;
+				child.kill(killSignal ?? "SIGTERM");
+			}, timeoutMs) : void 0;
+			child.stdout?.on("data", (chunk) => stdout.push(chunk));
+			child.stderr?.on("data", (chunk) => stderr.push(chunk));
+			child.on("error", (error) => {
+				clearTimeout(timer);
+				reject(error);
+			});
+			child.on("close", (status, signal) => {
+				clearTimeout(timer);
+				const out = Buffer.concat(stdout).toString("utf-8");
+				const err = Buffer.concat(stderr).toString("utf-8");
+				const result = {
+					status,
+					signal,
+					stdout: out,
+					stderr: err
+				};
+				if (timedOut) reject(nameTimeout(Object.assign(new Error(command), result, { code: "ETIMEDOUT" }), command, timeoutMs));
+				else if (status !== 0) reject(Object.assign(/* @__PURE__ */ new Error(`Command failed: ${command}${err ? `\n${err}` : ""}`), result));
+				else resolve(out.trim());
+			});
+		});
+	},
+	runQuiet(cmd, opts) {
+		try {
+			return this.run(cmd, opts);
+		} catch {
+			return null;
+		}
+	},
+	runFileQuiet(file, args, opts) {
+		try {
+			return this.runFile(file, args, opts);
+		} catch {
+			return null;
+		}
+	},
+	spawn(cmd, args = [], opts = {}) {
+		return spawn(cmd, args, opts);
+	},
+	findExecutable(name) {
+		return which.sync(name, { nothrow: true });
+	}
+};
+function getExecutor() {
+	return active;
+}
+//#endregion
+export { getExecutor as t };