stim 1.8.0 → 1.9.0

package/dist/launch-verify-Q_OtW1Rf.mjs

@@ -0,0 +1,365 @@
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { o as readNdjsonGenerations } from "./ndjson-9uFNRwfe.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-DPsSm0v_.mjs";
+import { s as isAppLaunchError } from "./command-output-gByVmIjy.mjs";
+import { d as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, o as androidAppProcess } from "./app-install-Uf3a83Tv.mjs";
+import { join } from "node:path";
+//#region src/engine/app-readiness.ts
+const APP_READINESS_TIMEOUT_MS = 3e4;
+function appReadinessSignal(record, platform) {
+	if (record.src !== "device" || !platform || record.platform !== platform) return null;
+	if (record.level !== "info" && record.level !== "debug") return null;
+	if (typeof record.msg !== "string") return null;
+	const text = record.msg.trim();
+	const message = /^(?:'[^']*'|"[^"]*")$/.test(text) ? text.slice(1, -1) : text;
+	return /^\[stim:readiness\] (pending|ready)$/.exec(message)?.[1] ?? null;
+}
+//#endregion
+//#region src/engine/launch-verify.ts
+const RELEASE_VERIFY_WAIT_MS = 3e3;
+async function verifyReleaseLaunch({ pid, waitMs = RELEASE_VERIFY_WAIT_MS, alive = isProcessAlive, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+	const startedAt = now();
+	if (!pid) return {
+		verified: false,
+		reason: "no-pid",
+		waitedMs: 0
+	};
+	await sleep(Math.max(0, waitMs));
+	const waitedMs = now() - startedAt;
+	return alive(pid) ? {
+		verified: true,
+		waitedMs
+	} : {
+		verified: false,
+		reason: "exited",
+		waitedMs
+	};
+}
+async function verifyAndroidReleaseLaunch({ serial, packageName, waitMs = RELEASE_VERIFY_WAIT_MS, exec = null, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+	const e = exec || getExecutor();
+	const startedAt = now();
+	await sleep(Math.max(0, waitMs));
+	const pid = androidAppProcess(serial, packageName, { exec: e });
+	const waitedMs = now() - startedAt;
+	if (pid === void 0) return {
+		verified: false,
+		reason: "probe-failed",
+		waitedMs
+	};
+	return pid === null ? {
+		verified: false,
+		reason: "exited",
+		waitedMs,
+		pid: null
+	} : {
+		verified: true,
+		waitedMs,
+		pid
+	};
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err?.code === "EPERM";
+	}
+}
+const LAUNCH_UNVERIFIED = "unverified";
+const LAUNCH_BUNDLING = "bundling";
+const LAUNCH_FATAL = "fatal";
+const VERIFY_TIMEOUT_MS = 2e4;
+const STABILITY_WINDOW_MS = 3e3;
+const VERIFY_POLL_MS = 500;
+const BUNDLE_EVENTS = /* @__PURE__ */ new Set([
+	"bundle_build_started",
+	"bundle_build_done",
+	"bundle_build_failed",
+	"bundling_error",
+	"transformer_error",
+	"bundle_response_started",
+	"bundle_response_finished",
+	"bundle_response_failed"
+]);
+function isBundleProof(record, since = 0, platform = null) {
+	if (!record || typeof record !== "object") return false;
+	const rec = record;
+	const ts = Number(rec.ts);
+	if (!Number.isFinite(ts) || ts < Number(since || 0)) return false;
+	if (platform && recordPlatform(rec) !== platform) return false;
+	if (typeof rec.event === "string" && BUNDLE_EVENTS.has(rec.event)) return true;
+	if (rec.src === "metro" && typeof rec.msg === "string" && expoBundleLine(rec.msg)) return true;
+	return false;
+}
+const BUNDLE_URL_PATH = /\.bundle\b|\/_expo\/|expo-development-client/i;
+function isBundleRequestProof(record, since = 0, port = null, platform = null) {
+	if (!record || typeof record !== "object" || !port) return false;
+	const rec = record;
+	const ts = Number(rec.ts);
+	if (!Number.isFinite(ts) || ts < Number(since || 0)) return false;
+	if (typeof rec.msg !== "string") return false;
+	if (rec.level === "error" || rec.level === "fatal") return false;
+	const sourcePlatform = recordPlatform(rec);
+	if (platform && sourcePlatform && sourcePlatform !== platform) return false;
+	const digits = String(port).replace(/[^0-9]/g, "");
+	if (!digits) return false;
+	if (!new RegExp(`:${digits}\\b`).test(rec.msg)) return false;
+	return BUNDLE_URL_PATH.test(rec.msg);
+}
+function expoBundleLine(msg) {
+	return /\bBundl(?:ing|ed)\b/.test(msg);
+}
+function nativeLaunchFailure({ readCrashes, since, platform, processAlive, mode, waitedMs }) {
+	if (!readCrashes) return null;
+	const crashes = readCrashes().filter((record) => record.event === "native_crash" && after(record, since) && recordCouldBelongToPlatform(record, platform));
+	return crashes.length ? {
+		verified: false,
+		fatal: true,
+		errors: crashes,
+		processAlive: processAlive?.() ?? null,
+		mode,
+		waitedMs
+	} : null;
+}
+async function verifyLaunch({ slot, logsDir, since, metroPort = null, platform = null, mode = null, requireBundleResponse, timeoutMs = VERIFY_TIMEOUT_MS, stabilityMs = STABILITY_WINDOW_MS, pollMs = VERIFY_POLL_MS, readRecords = null, readDeviceRecords = null, readClientRecords = null, readNativeCrashes = null, processAlive = null, onReadinessPending = null, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+	const read = readRecords || (() => readMetroRecords(logsDir));
+	const readDevice = readDeviceRecords || (() => readNdjson(logsDir, "device.ndjson"));
+	const readClient = readClientRecords || (() => readNdjson(logsDir, "client.ndjson"));
+	const startedAt = now();
+	const bundleDeadline = startedAt + Math.max(0, timeoutMs);
+	let proof = null;
+	let activity = null;
+	let stabilityDeadline = null;
+	let pendingAt = null;
+	let deliveryId = null;
+	let runtimeLoadingAt = null;
+	let runtimeStartedAt = null;
+	let nextCrashCheck = startedAt + 1e3;
+	while (true) {
+		const metroRecords = read().filter((record) => after(record, since) && (slot === void 0 || record.slot === slot));
+		const bundleRecords = metroRecords.filter((record) => !requireBundleResponse || String(record.event).startsWith("bundle_response_"));
+		const deviceRecords = readDevice().filter((record) => after(record, since) && (slot === void 0 || (record.slot ?? "default") === slot));
+		const clientRecords = readClient().filter((record) => after(record, since) && (slot === void 0 || record.slot === slot));
+		if (now() >= nextCrashCheck) {
+			nextCrashCheck = now() + 2e3;
+			const crash = nativeLaunchFailure({
+				readCrashes: readNativeCrashes,
+				since,
+				platform,
+				processAlive,
+				mode,
+				waitedMs: now() - startedAt
+			});
+			if (crash) return crash;
+		}
+		if (deliveryId === null) {
+			const request = bundleRecords.find((record) => record.event === "bundle_response_started" && typeof record.requestId === "string" && isBundleProof(record, since, platform));
+			if (request) {
+				deliveryId = request.requestId;
+				proof = null;
+				stabilityDeadline = null;
+			}
+		}
+		for (const record of bundleRecords) {
+			if (isBundleProof(record, since, platform)) activity = record;
+			const completed = deliveryId === null ? isBundleReadyProof(record, since, platform) : record.event === "bundle_response_finished" && record.requestId === deliveryId && isBundleProof(record, since, platform);
+			if (!proof && completed) {
+				proof = record;
+				stabilityDeadline = Number(record.ts) + Math.max(0, stabilityMs);
+			}
+		}
+		const signals = deviceRecords.filter((record) => Number(record.ts) <= now()).toSorted((a, b) => Number(a.ts) - Number(b.ts));
+		if (platform === "android" && runtimeLoadingAt === null) {
+			const loading = signals.find((record) => record.src === "device" && record.platform === "android" && /^(?:unknown:)?BridgelessReact\(\d+\)$/.test(String(record.proc)) && /^ReactHost\{\d+\}\.getOrCreateReactInstanceTask\(\): Loading JS Bundle$/.test(String(record.msg)) && (stabilityDeadline === null || Number(record.ts) <= stabilityDeadline));
+			if (loading) runtimeLoadingAt = Number(loading.ts);
+		}
+		if (runtimeLoadingAt !== null && runtimeStartedAt === null) {
+			const executing = signals.find((record) => record.src === "device" && record.platform === "android" && Number(record.ts) >= runtimeLoadingAt && (/^ReactNativeJS\(\d+\)$/.test(String(record.proc)) || appReadinessSignal(record, platform) !== null));
+			if (executing) runtimeStartedAt = Number(executing.ts);
+		}
+		const runtimeWaiting = runtimeLoadingAt !== null && runtimeStartedAt === null;
+		const completedAt = proof ? Math.max(Number(proof.ts), runtimeStartedAt ?? 0) : null;
+		if (completedAt !== null) stabilityDeadline = completedAt + Math.max(0, stabilityMs);
+		const readinessDeadline = completedAt !== null ? completedAt + APP_READINESS_TIMEOUT_MS : bundleDeadline;
+		if (pendingAt === null) {
+			const pending = signals.find((record) => appReadinessSignal(record, platform) === "pending" && (runtimeWaiting || stabilityDeadline === null || Number(record.ts) <= stabilityDeadline));
+			if (pending) {
+				pendingAt = Number(pending.ts);
+				onReadinessPending?.();
+			}
+		}
+		const ready = pendingAt !== null && signals.some((record) => Number(record.ts) >= pendingAt && Number(record.ts) <= readinessDeadline && appReadinessSignal(record, platform) === "ready");
+		const bundleErrors = bundleRecords.filter((record) => isFatalLaunchError(record, platform) || deliveryId !== null && record.event === "bundle_response_failed" && record.requestId === deliveryId && isBundleProof(record, since, platform));
+		if (bundleErrors.length) {
+			const alive = processAlive ? processAlive() : null;
+			const fatalRecord = bundleErrors[bundleErrors.length - 1];
+			const fatalAt = Number(fatalRecord?.ts ?? since ?? 0);
+			return {
+				verified: false,
+				fatal: true,
+				errors: metroRecords.filter((record) => after(record, fatalAt) && recordCouldBelongToPlatform(record, platform) && isLaunchError(record, platform)),
+				processAlive: alive,
+				record: fatalRecord,
+				mode,
+				waitedMs: now() - startedAt,
+				...pendingAt !== null ? { readiness: "error" } : {}
+			};
+		}
+		if (proof && stabilityDeadline !== null && (pendingAt !== null || now() >= stabilityDeadline)) {
+			const errorSince = pendingAt === null ? Number(proof.ts ?? since ?? 0) : Number(since ?? 0);
+			const errors = [
+				...metroRecords.filter((record) => after(record, errorSince) && recordCouldBelongToPlatform(record, platform)),
+				...deviceRecords.filter((record) => after(record, errorSince) && recordCouldBelongToPlatform(record, platform)),
+				...clientRecords.filter((record) => after(record, errorSince) && recordCouldBelongToPlatform(record, platform))
+			].filter((record) => isLaunchError(record, platform));
+			const alive = processAlive ? processAlive() : null;
+			const waitedMs = now() - startedAt;
+			if (alive === false) return {
+				verified: false,
+				fatal: true,
+				errors,
+				processAlive: alive,
+				record: proof,
+				mode,
+				waitedMs,
+				...pendingAt !== null ? { readiness: "error" } : {}
+			};
+			const actionableErrors = errors.filter((record) => !isIosConnectionRefusal(record, platform));
+			const appErrors = actionableErrors.some(isAppLaunchError);
+			if (!runtimeWaiting && pendingAt === null || appErrors || ready || now() >= readinessDeadline) return {
+				verified: true,
+				record: proof,
+				errors: actionableErrors,
+				processAlive: alive,
+				mode,
+				waitedMs,
+				...pendingAt !== null ? { readiness: appErrors ? "error" : ready ? "ready" : "timed-out" } : {}
+			};
+		}
+		if ((!proof || runtimeWaiting) && now() >= bundleDeadline) {
+			const requested = findBundleRequest(deviceRecords, since, metroPort, platform) ?? activity;
+			const waitedMs = now() - startedAt;
+			if (requested) return {
+				verified: false,
+				timedOut: true,
+				requested: true,
+				record: requested,
+				mode,
+				waitedMs
+			};
+			return {
+				verified: false,
+				timedOut: true,
+				mode,
+				waitedMs
+			};
+		}
+		await sleep(Math.min(pollMs, Math.max(0, (runtimeWaiting ? bundleDeadline : proof && pendingAt !== null ? readinessDeadline : stabilityDeadline ?? bundleDeadline) - now())));
+	}
+}
+function after(record, since) {
+	const ts = Number(record.ts);
+	return Number.isFinite(ts) && ts >= Number(since ?? 0);
+}
+function isLaunchError(record, platform) {
+	return record.level === "error" || record.level === "fatal" || isFatalLaunchError(record, platform);
+}
+const TCP_REFUSAL = /^TCP Conn 0x[0-9a-f]+ Failed : error 0:61 \[61\]$/i;
+function isIosConnectionRefusal(record, platform) {
+	return platform === "ios" && record.src === "device" && record.level === "error" && typeof record.msg === "string" && TCP_REFUSAL.test(record.msg);
+}
+function isFatalLaunchError(record, platform) {
+	if (platform && recordPlatform(record) !== platform) return false;
+	return record.event === "bundle_build_failed" || record.event === "bundling_error" || record.event === "transformer_error" || (record.event === "expo_stdout" || record.event === "expo_stderr") && typeof record.msg === "string" && /\bBundling failed\b/.test(record.msg);
+}
+function isBundleReadyProof(record, since = 0, platform = null) {
+	if (!isBundleProof(record, since, platform)) return false;
+	const rec = record;
+	if (rec.event === "bundle_build_done") return true;
+	return rec.src === "metro" && typeof rec.msg === "string" && /\bBundled\b/.test(rec.msg);
+}
+function findBundleRequest(records, since, port, platform) {
+	for (const record of records) if (isBundleRequestProof(record, since ?? 0, port, platform)) return record;
+	return null;
+}
+function recordCouldBelongToPlatform(record, platform) {
+	if (!platform) return true;
+	const sourcePlatform = recordPlatform(record);
+	return sourcePlatform === null || sourcePlatform === platform;
+}
+function recordPlatform(record) {
+	if (record.platform === "ios" || record.platform === "android") return record.platform;
+	if (typeof record.msg !== "string") return null;
+	const match = record.msg.match(/\b(iOS|Android)\s+Bundl(?:ed|ing)\b/i);
+	if (!match) return null;
+	return match[1].toLowerCase() === "ios" ? "ios" : "android";
+}
+function readMetroRecords(logsDir) {
+	return readNdjson(logsDir, "metro.ndjson");
+}
+function readCollectorRecords(logsDir) {
+	return readNdjson(logsDir, "device.ndjson");
+}
+function readNdjson(logsDir, name) {
+	return logsDir ? readNdjsonGenerations(join(logsDir, name)) : [];
+}
+function unverifiedLaunchLines({ platform, metroPort, waitedMs = VERIFY_TIMEOUT_MS, bundleId = null, udid = null, serial = null, devClientUrl: url = null, mode = null, remote = false, physical = false, devClient = false, lanOrigin = null, metroOrigin = null, localNetworkPending = false, component = null }) {
+	const seconds = Math.round(Number(waitedMs || 0) / 1e3);
+	const localNetwork = localNetworkPending && platform === "ios" && physical;
+	const lines = [`The app was started, but nothing fetched a bundle from this workspace's Metro (port ${metroPort}) within ${seconds}s.`];
+	const origin = metroOrigin || `http://localhost:${metroPort}`;
+	const picker = `If expo-dev-launcher's DEVELOPMENT SERVERS picker is showing, tap the entry for ${origin} -- NOT another workspace's, which would load a different project's bundle onto this device.`;
+	let step = 0;
+	const push = (text) => lines.push(`  ${++step}. ${text}`);
+	lines.push(localNetwork ? `THE PHONE'S LOCAL NETWORK PERMISSION IS NOT GRANTED: the LAN connections this launch made failed with NSURLErrorDomain -1009 and the path reason "unsatisfied (Local network prohibited)", which is what iOS returns while the "would like to find and connect to devices on your local network" prompt is unanswered OR was answered Don't Allow earlier -- the log reads the same either way. Nothing the app sends reaches ${lanOrigin || origin} until it is granted. Do this, in order:` : "The app is launched; what is unproven is that it is talking to THIS dev server. Do this, in order:");
+	if (remote) {
+		push(`Check that ${origin} is reachable FROM THE DEVICE's network, not just from this machine. That is the usual cause: a tunnel that stopped, or one this machine can reach and the device cannot.`);
+		push("If an \"Open in <app>?\" alert or the expo-dev-launcher picker is showing on the remote device, confirm it with your device tool (`agent-device snapshot -i`, then `agent-device press`).");
+		lines.push(`Then check \`stim logs --source metro\`${mode ? ` (${mode})` : ""} for a bundle request.`);
+		return lines;
+	}
+	if (platform === "ios" && physical) {
+		const target = lanOrigin || origin;
+		const relaunch = `xcrun devicectl device process launch --device ${udid} --terminate-existing ` + (url ? `--payload-url '${url}' ` : "") + bundleId + (url ? ` -- ${DEV_MENU_LAUNCH_ARGS.join(" ")}` : "");
+		if (localNetwork) {
+			push(`See the prompt: agent-device alert get --platform ios --udid ${udid}. It reads the alert without opening anything, so it works while the app sits behind it.`);
+			push(`Tap Allow: agent-device alert accept --platform ios --udid ${udid}. A second \`alert get\` then finds none.`);
+			push("If the FIRST `alert get` already finds no alert, this permission was denied on an earlier run -- a Don't Allow persists across upgrade installs. Turn the app on by hand under Settings > Privacy & Security > Local Network; there is no API for that switch.");
+			if (devClient) {
+				push(`The app does NOT retry after the grant -- it stays on "Failed to load app ... The Internet connection appears to be offline." with a Reload button. Press it: agent-device snapshot -i --platform ios --udid ${udid}, then agent-device press 'label="Reload"' --platform ios --udid ${udid}. This launch carried -EXDevMenuShowsAtLaunch 0, so the Expo dev menu is not over the app; if the app was started another way and the menu is on screen, agent-device press 'label="Close"' --platform ios --udid ${udid} dismisses it.`);
+				push(`Without agent-device, relaunching also recovers: ${relaunch}. It costs the device log -- it replaces the process the collector follows, so \`stim logs --source device\` stops for the rest of this run. Pressing Reload keeps the collector alive.`);
+				push("By hand: tap Allow on the phone, then tap Reload on the app.");
+			} else {
+				push(`The app does NOT retry after the grant. A bare app is expected to show React Native's "Could not connect to development server" RedBox -- NOT VERIFIED ON HARDWARE, so read the screen rather than trusting that: agent-device snapshot -i --platform ios --udid ${udid}, then press its Reload button by the ref or label that snapshot reports.`);
+				push(`Cleanest for a bare app: relaunch, which re-reads ip.txt: ${relaunch}. It costs the device log -- it replaces the process the collector follows, so \`stim logs --source device\` stops for the rest of this run.`);
+				push("By hand: tap Allow on the phone, then tap Reload on the RedBox.");
+			}
+			lines.push("`agent-device metro reload` does NOT recover either screen: it only reaches an app already connected to Metro's websocket, and this app never connected.");
+			lines.push(`Then check \`stim logs --source metro\`${mode ? ` (${mode})` : ""} for a bundle request.`);
+			return lines;
+		}
+		push(`Tap Allow on the phone's "would like to find and connect to devices on your local network" prompt if it is showing, or turn the app on under Settings > Privacy & Security > Local Network. iOS gates every LAN connection behind that permission, it cannot be PRE-granted from this machine -- but once the prompt is up a device tool can accept it (agent-device alert get, then agent-device alert accept, both --platform ios --udid ${udid}) -- and until it is granted nothing the app sends reaches ${target}.`);
+		push("Check the phone is on the same network as this Mac -- the same Wi-Fi SSID, not cellular, not a VPN -- and that the network does not isolate clients from each other.");
+		push("Check macOS is not blocking inbound connections: System Settings > Network > Firewall, or `/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate`. The gate on this machine passes either way, because macOS routes a host connection to its own address over loopback.");
+		push(`If this Mac has several network interfaces, ${target} may not be the one the phone shares: set ios.lanHost in .stim.json to the address it can reach.`);
+		if (devClient) {
+			push(picker);
+			if (url && udid) push(`Retry the deep link: xcrun devicectl device process launch --device ${udid} --terminate-existing --payload-url '${url}' ${bundleId} -- ${DEV_MENU_LAUNCH_ARGS.join(" ")}`);
+		} else lines.push("AND READ THIS: a Debug device build with no dev client carries the JS bundle baked in when the artifact was built, so an unreachable Metro is silent. The app on screen is not broken -- it is running THAT bundle, which on a cache hit is another workspace's JS, not this workspace's.");
+		lines.push(`Then check \`stim logs --source metro\`${mode ? ` (${mode})` : ""} for a bundle request.`);
+		return lines;
+	}
+	if (platform === "ios") {
+		if (devClient) push(picker);
+		if (url && udid) push(`Retry the deep link: xcrun simctl openurl ${udid} '${url}'`);
+		else if (udid && bundleId) push(`Re-launch: xcrun simctl launch --terminate-running-process ${udid} ${bundleId}`);
+	} else {
+		if (url && serial) push(`Re-send the dev-client deep link -- this is the command that points the app at THIS workspace's Metro: adb -s ${serial} shell am start -a android.intent.action.VIEW -d ${deviceShellArg(deviceShellArg(url))} --ez ${ANDROID_DISABLE_AUTO_LAUNCH_EXTRA} true`);
+		if (devClient) push(picker);
+		if (serial && bundleId) push(`If the app is stuck, restart its process: ${component ? `adb -s ${serial} shell am force-stop ${bundleId} && adb -s ${serial} shell am start -n ${component}` : url ? `adb -s ${serial} shell am force-stop ${bundleId} && adb -s ${serial} shell am start -a android.intent.action.VIEW -d ${deviceShellArg(deviceShellArg(url))} --ez ${ANDROID_DISABLE_AUTO_LAUNCH_EXTRA} true` : `adb -s ${serial} shell am force-stop ${bundleId} && adb -s ${serial} shell monkey -p ${bundleId} 1`}`);
+	}
+	lines.push(`Then check \`stim logs --source metro\`${mode ? ` (${mode})` : ""} for a bundle request.`);
+	return lines;
+}
+//#endregion
+export { VERIFY_TIMEOUT_MS as a, readMetroRecords as c, verifyLaunch as d, verifyReleaseLaunch as f, RELEASE_VERIFY_WAIT_MS as i, unverifiedLaunchLines as l, LAUNCH_FATAL as n, isBundleProof as o, APP_READINESS_TIMEOUT_MS as p, LAUNCH_UNVERIFIED as r, readCollectorRecords as s, LAUNCH_BUNDLING as t, verifyAndroidReleaseLaunch as u };

package/dist/{logs-CakdBTtm.mjs → logs-CI9NQSK7.mjs}

@@ -1,10 +1,10 @@
-import { B as validateDeviceSlot, g as loadConfig, h as isPathPrefix } from "./config-B7iyKWkL.mjs";
-import { n as SOURCES, t as LEVELS } from "./ndjson-BZwI1NBv.mjs";
-import { _ as workspaceLogsDir, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { _ as launchErrorPreview } from "./command-output-B3ycpsYv.mjs";
-import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-D1Kaf-eT.mjs";
-import { a as followLogs, c as queryLogs, i as fileSizes, n as buildCriteria, o as logFiles, r as compileGrep, s as parseSince } from "./logs-query-BGL-Pl12.mjs";
+import { G as parseDeviceSlotOption, g as loadConfig, h as isPathPrefix } from "./config-Cp9lM3wX.mjs";
+import { n as SOURCES, t as LEVELS } from "./ndjson-9uFNRwfe.mjs";
+import { b as workspaceLogsDir, r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { f as refuseNoProject, v as launchErrorPreview } from "./command-output-gByVmIjy.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-Vfz83GCF.mjs";
+import { a as fileSizes, c as parseSince, i as compileGrep, l as queryLogs, o as followLogs, r as buildCriteria, s as logFiles, u as readLogRecords } from "./logs-query-Cqma3WIu.mjs";
 import { realpathSync } from "node:fs";
 import { relative, sep } from "node:path";
 import chalk from "chalk";
@@ -93,11 +93,11 @@ const LEVEL_COLOURS = {
 	fatal: chalk.bgRed
 };
 function logsCommand(program) {
-	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only records attributed to this device slot", validateDeviceSlot).option("--source <s...>", "Only these sources: metro, client, device, build, or all").option("--level <l>", `Minimum level: ${LEVELS.join(", ")}`).option("--since <d>", "Only records newer than this, e.g. 30s, 5m, 2h").option("--grep <re>", "Only records whose message matches this regular expression").option("--tail <n>", "Only the last n matching records").option("--errors", "Errors and fatals since the last marker, from metro, client and build, plus confirmed native app-crash reports. Add --source device or --source all for general device errors.").option("--follow", "Keep streaming new records until interrupted").option("--json", "Emit the raw records, one per line (valid NDJSON; zero matches is zero bytes, exit 0)").action(async (opts) => {
+	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only records attributed to this device slot", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, or all").option("--level <l>", `Minimum level: ${LEVELS.join(", ")}`).option("--since <d>", "Only records newer than this, e.g. 30s, 5m, 2h").option("--grep <re>", "Only records whose message matches this regular expression").option("--tail <n>", "Only the last n matching records").option("--errors", "Errors and fatals since the last marker, from metro, client and build, plus confirmed native app-crash reports. Add --source device or --source all for general device errors.").option("--follow", "Keep streaming new records until interrupted").option("--json", "Emit the raw records, one per line (valid NDJSON; zero matches is zero bytes, exit 0)").action(async (opts) => {
 		const root = findProjectRoot(process.cwd());
 		if (!root) {
-			console.error(chalk.red("Not in a React Native project (no package.json found)."));
-			process.exit(1);
+			refuseNoProject({ json: false });
+			return;
 		}
 		const dir = workspaceLogsDir(root);
 		let sources;
@@ -150,15 +150,20 @@ function logsCommand(program) {
 			};
 			console.log(formatRecord(rendered, { paint: record?.level ? LEVEL_COLOURS[record.level] : void 0 }));
 		};
+		const captured = captureWorkspaceCrashes(root, dir);
 		const offsets = opts.follow ? fileSizes(dir) : null;
-		captureWorkspaceCrashes(root, dir);
-		const rawRecords = queryLogs(query);
+		const timeline = opts.follow ? readLogRecords(dir) : captured;
+		const rawRecords = queryLogs({
+			...query,
+			records: timeline
+		});
 		const supervisorPort = readWorkspaceState(root)?.supervisor?.port;
 		const records = opts.json ? rawRecords : await errorDiagnostics(rawRecords, {
 			root,
 			logsDir: dir,
 			port: typeof supervisorPort === "number" ? supervisorPort : null,
-			allowRequest: true
+			allowRequest: true,
+			timeline
 		});
 		const errorCount = records.filter((record) => record.errorContext !== true).length;
 		let seenErrors = 0;

package/dist/{logs-query-BGL-Pl12.mjs → logs-query-Cqma3WIu.mjs}

@@ -1,6 +1,7 @@
-import { a as parseNdjsonLine, i as levelRank, o as parseNdjsonText } from "./ndjson-BZwI1NBv.mjs";
-import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from "fs";
+import { a as parseNdjsonLine, i as levelRank, o as readNdjsonGenerations } from "./ndjson-9uFNRwfe.mjs";
+import { closeSync, openSync, readSync, readdirSync, statSync } from "fs";
 import { join } from "path";
+import { rotatedLogPath } from "@stim-cli/core";
 import { StringDecoder } from "string_decoder";
 //#region src/diagnostics/logs-query.ts
 const SINCE_UNITS = {
@@ -111,17 +112,9 @@ function fileSizes(dir) {
 	} catch {}
 	return sizes;
 }
-function readLogRecords(dir) {
+function readLogRecords(dir, include = () => true) {
 	const all = [];
-	for (const name of logFiles(dir)) {
-		let text;
-		try {
-			text = readFileSync(join(dir, name), "utf-8");
-		} catch {
-			continue;
-		}
-		for (const record of parseNdjsonText(text)) all.push(record);
-	}
+	for (const name of logFiles(dir).filter(include)) for (const record of readNdjsonGenerations(join(dir, name))) all.push(record);
 	return sortByTs(all);
 }
 function isExpoErrorContext(record, event) {
@@ -172,8 +165,8 @@ function launchMarkersBySlot(records) {
 	}
 	return markers;
 }
-function queryLogs({ slot, dir, sources, minLevel, since, grep, tail, errorsOnly, errorContext, now } = {}) {
-	const all = readLogRecords(dir).filter((record) => slot === void 0 || (record.slot ?? "default") === slot);
+function queryLogs({ slot, dir, records, sources, minLevel, since, grep, tail, errorsOnly, errorContext, now } = {}) {
+	const all = (records ?? readLogRecords(dir)).filter((record) => slot === void 0 || (record.slot ?? "default") === slot);
 	if (all.length === 0) return [];
 	const { launchTs, bundleTs } = errorsOnly ? markerWindow(all) : {
 		launchTs: null,
@@ -241,27 +234,31 @@ function followLogs({ dir, onRecord, criteria = {}, intervalMs = 500, offsets =
 		});
 		decoders.set(name, new StringDecoder("utf8"));
 	}
+	function emit(records) {
+		for (const record of records) if (recordMatches(record, criteria)) onRecord(record);
+	}
+	function drainRotated(name, entry) {
+		const path = rotatedLogPath(join(dir, name));
+		let size;
+		try {
+			size = statSync(path).size;
+		} catch {
+			return;
+		}
+		const decoder = decoders.get(name) ?? new StringDecoder("utf8");
+		emit(advanceTail(entry, readChunk(path, decoder, entry.offset, size) + decoder.end(), size).records);
+	}
 	function pollFile(name) {
 		const path = join(dir, name);
 		const size = statSync(path).size;
 		const entry = state.get(name);
+		if (entry && size < entry.offset) drainRotated(name, entry);
 		const { start, prev } = tailRead(entry, size);
 		if (prev !== entry) decoders.set(name, new StringDecoder("utf8"));
 		if (!decoders.has(name)) decoders.set(name, new StringDecoder("utf8"));
-		let chunk = "";
-		if (size > start) {
-			const fd = openSync(path, "r");
-			try {
-				const buf = Buffer.allocUnsafe(size - start);
-				const read = readSync(fd, buf, 0, size - start, start);
-				chunk = decoders.get(name).write(buf.subarray(0, read));
-			} finally {
-				closeSync(fd);
-			}
-		}
-		const next = advanceTail(prev, chunk, size);
+		const next = advanceTail(prev, readChunk(path, decoders.get(name), start, size), size);
 		state.set(name, next.state);
-		for (const record of next.records) if (recordMatches(record, criteria)) onRecord(record);
+		emit(next.records);
 	}
 	function poll() {
 		for (const name of logFiles(dir)) try {
@@ -273,6 +270,17 @@ function followLogs({ dir, onRecord, criteria = {}, intervalMs = 500, offsets =
 		clearInterval(timer);
 	};
 }
+function readChunk(path, decoder, start, size) {
+	if (size <= start) return "";
+	const fd = openSync(path, "r");
+	try {
+		const buf = Buffer.allocUnsafe(size - start);
+		const read = readSync(fd, buf, 0, size - start, start);
+		return decoder.write(buf.subarray(0, read));
+	} finally {
+		closeSync(fd);
+	}
+}
 function tsOf(record) {
 	return typeof record?.ts === "number" && Number.isFinite(record.ts) ? record.ts : null;
 }
@@ -287,4 +295,4 @@ function sortByTs(records) {
 	});
 }
 //#endregion
-export { followLogs as a, queryLogs as c, fileSizes as i, readLogRecords as l, buildCriteria as n, logFiles as o, compileGrep as r, parseSince as s, attachExpoErrorContext as t };
+export { fileSizes as a, parseSince as c, recordMatches as d, sortByTs as f, compileGrep as i, queryLogs as l, attachExpoErrorContext as n, followLogs as o, buildCriteria as r, logFiles as s, ERROR_SOURCES as t, readLogRecords as u };

package/dist/{metro-C7bcJ0uo.mjs → metro-DrLHaMn2.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { A as isOnMountedVolume, g as loadConfig, j as listMountedVolumes, n as allMetroPorts, r as claimMetroPort, v as removeProject, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
+import { D as process_identity_exports, I as isOnMountedVolume, L as listMountedVolumes, g as loadConfig, n as allMetroPorts, r as claimMetroPort, y as releaseMetroPort } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
 import { existsSync, readlinkSync, realpathSync } from "fs";
 import { sep } from "path";
 import { request } from "http";
@@ -75,7 +75,7 @@ async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, {
 async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
 	const reclaim = await findReclaimablePort(projectPath, probe);
 	if (reclaim && await isFree(reclaim.port)) {
-		removeProject(reclaim.ownerPath);
+		releaseMetroPort(reclaim.ownerPath, reclaim.port);
 		return reclaim.port;
 	}
 	return computeNextPort(isFree);
@@ -139,6 +139,76 @@ function parseLsofCwd(out) {
 	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
 	return nLine ? nLine.slice(1) : null;
 }
+function lsofOutput(args) {
+	return getExecutor().runFileAsync("lsof", args).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
+}
+function parseLsofListeners(out) {
+	const byPort = /* @__PURE__ */ new Map();
+	let pid = null;
+	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) pid = parseInt(line.slice(1), 10);
+	else if (line.startsWith("n") && pid !== null && Number.isFinite(pid)) {
+		const port = addressPort(line.slice(1));
+		const pids = byPort.get(port) ?? [];
+		if (!pids.includes(pid)) pids.push(pid);
+		byPort.set(port, pids);
+	}
+	return byPort;
+}
+/**
+* `listeningPids` for several ports with one lsof call. A port lsof could not be asked about is
+* missing from the map.
+*/
+async function listeningPidsByPort(ports) {
+	const result = /* @__PURE__ */ new Map();
+	if (ports.length === 0) return result;
+	const out = await lsofOutput([
+		"-nP",
+		`-iTCP:${ports.join(",")}`,
+		"-sTCP:LISTEN",
+		"-Fpn"
+	]);
+	if (out === null) return result;
+	const found = parseLsofListeners(out);
+	for (const port of ports) result.set(port, found.get(port) ?? []);
+	return result;
+}
+function parseLsofCwds(out) {
+	const cwds = /* @__PURE__ */ new Map();
+	let pid = null;
+	let inCwd = false;
+	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) {
+		pid = parseInt(line.slice(1), 10);
+		inCwd = false;
+	} else if (line.startsWith("f")) inCwd = line === "fcwd";
+	else if (inCwd && line.startsWith("n") && pid !== null && !cwds.has(pid)) cwds.set(pid, line.slice(1));
+	return cwds;
+}
+/** `processCwd` for several pids with at most one lsof call. A pid lsof could not be asked about is missing from the map. */
+async function processCwds(pids) {
+	const cwds = /* @__PURE__ */ new Map();
+	const viaLsof = [];
+	for (const pid of new Set(pids)) {
+		let cwd = null;
+		if (process.platform === "linux") try {
+			cwd = readlinkSync(`/proc/${pid}/cwd`);
+		} catch {}
+		if (cwd) cwds.set(pid, cwd);
+		else viaLsof.push(pid);
+	}
+	if (viaLsof.length === 0) return cwds;
+	const out = await lsofOutput([
+		"-a",
+		"-p",
+		viaLsof.join(","),
+		"-d",
+		"cwd",
+		"-Fn"
+	]);
+	if (out === null) return cwds;
+	const found = parseLsofCwds(out);
+	for (const pid of viaLsof) cwds.set(pid, found.get(pid) ?? null);
+	return cwds;
+}
 function processCwd(pid) {
 	if (process.platform === "linux") try {
 		return readlinkSync(`/proc/${pid}/cwd`);
@@ -166,15 +236,15 @@ function ownedSupervisor(projectPath, port) {
 	if (supervisor?.port !== port || (0, process_identity_exports.inspectProcessIdentity)(supervisor) !== "same") return null;
 	return supervisor;
 }
-async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning, cwdOf = processCwd } = {}) {
-	const pid = listeningPids(port)[0];
+async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning, pidsOf = listeningPids, cwdOf = processCwd } = {}) {
+	const pid = (await pidsOf(port))[0];
 	if (pid === void 0) return { missing: true };
 	if (!await probe(port)) return {
 		notOurs: `pid ${pid} on port ${port} does not answer Metro's /status`,
 		kind: NOT_OURS_UNRESPONSIVE,
 		pid
 	};
-	const cwd = cwdOf(pid);
+	const cwd = await cwdOf(pid);
 	if (!cwd) {
 		const owner = ownedSupervisor(projectPath, port);
 		if (owner && (pid === owner.pid || pid === owner.serverPid)) return { metro: {
@@ -230,4 +300,4 @@ function killMetroTree(leader, processToken) {
 	}
 }
 //#endregion
-export { resolveProjectMetro as a, isPortFree as c, pidExists as i, reserveMetroPort as l, killMetroTree as n, signalProcessTree as o, listeningPids as r, isMetroRunning as s, NOT_OURS_FOREIGN_CWD as t };
+export { pidExists as a, resolveProjectMetro as c, isPortFree as d, reserveMetroPort as f, listeningPidsByPort as i, signalProcessTree as l, killMetroTree as n, processCwd as o, listeningPids as r, processCwds as s, NOT_OURS_FOREIGN_CWD as t, isMetroRunning as u };