stim 0.0.0 → 1.0.0

package/dist/collector-run.d.mts

@@ -0,0 +1,119 @@
+import { t as NdjsonWriter } from "./ndjson-DvHSsNU9.mjs";
+import { ChildProcess, SpawnOptions } from "child_process";
+import { ChildProcess as ChildProcess$1 } from "node:child_process";
+//#region src/exec.d.ts
+interface ExecOptions {
+  timeoutMs?: number;
+  cwd?: string;
+  env?: Record<string, string>;
+  omitEnv?: readonly string[];
+}
+interface Executor {
+  run(cmd: string, opts?: ExecOptions): string;
+  runFile(file: string, args?: string[], opts?: ExecOptions): string;
+  runQuiet(cmd: string, opts?: ExecOptions): string | null;
+  runFileQuiet(file: string, args?: string[], opts?: ExecOptions): string | null;
+  spawn(cmd: string, args?: readonly string[], opts?: SpawnOptions): ChildProcess;
+}
+//#endregion
+//#region src/collector/android.d.ts
+declare function androidClockOffset(serial: string, { exec, now }?: {
+  exec?: Executor;
+  now?: () => number;
+}): number | null;
+interface PidResolution {
+  ok?: boolean;
+  pid?: number;
+  failed?: boolean;
+  reason?: string;
+}
+interface PidWatcher {
+  stop(): void;
+  probe(): number | null;
+  readonly pid: number | null;
+}
+declare function watchAppPid({ serial, packageName, pid, intervalMs, exec, onChange, resolve, setTimer, clearTimer }: {
+  serial: string;
+  packageName: string;
+  pid: number | null;
+  intervalMs?: number | null;
+  exec?: Executor | null;
+  onChange: (nextPid: number) => void | Promise<void>;
+  resolve?: (serial: string, packageName: string, opts: {
+    exec?: Executor | null;
+  }) => number | null;
+  setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+  clearTimer?: (t: ReturnType<typeof setTimeout>) => void;
+}): PidWatcher;
+//#endregion
+//#region src/collector/state.d.ts
+declare function registerCollector(root: string, platform: string, record: Record<string, unknown>): Record<string, unknown>;
+declare function unregisterCollector(root: string, platform: string, pid: number, processToken: string): Record<string, unknown>;
+declare function readCollectors(root: string): Record<string, unknown>;
+//#endregion
+//#region src/collector/run.d.ts
+declare const PLATFORMS: string[];
+interface ParsedCollectorArgs {
+  platform?: string;
+  root?: string;
+  udid?: string;
+  bundleId?: string;
+  appName?: string;
+  appExecutable?: string | null;
+  serial?: string | null;
+  packageName?: string | null;
+  physical?: boolean;
+  payloadUrl?: string | null;
+  error?: string;
+}
+declare function parseArgs(argv: string[]): ParsedCollectorArgs;
+interface RunCollectorOptions {
+  platform: string;
+  root: string;
+  udid?: string | null;
+  appName?: string | null;
+  appExecutable?: string | null;
+  bundleId?: string | null;
+  serial?: string | null;
+  packageName?: string | null;
+  physical?: boolean;
+  payloadUrl?: string | null;
+  startStream?: ((opts: {
+    platform: string;
+    udid?: string | null;
+    appName?: string | null;
+    appExecutable?: string | null;
+    bundleId?: string | null;
+    serial?: string | null;
+    physical?: boolean;
+    payloadUrl?: string | null;
+    pid?: number | null;
+  }) => ChildProcess$1) | null;
+  resolvePid?: ((opts: {
+    serial?: string | null;
+    packageName?: string | null;
+    timeoutMs: number;
+  }) => Promise<PidResolution>) | null;
+  pidTimeoutMs?: number;
+  pidOf?: ((serial: string, packageName: string, opts: {
+    exec?: Executor | null;
+  }) => number | null) | null;
+  pidWatchMs?: number | null;
+  watchPid?: typeof watchAppPid;
+  resolveClockOffset?: typeof androidClockOffset;
+  now?: () => number;
+  onExit?: (code: number) => void;
+  attachSignals?: boolean;
+  stderr?: (line: string) => void;
+}
+interface RunCollectorHandle {
+  child: ChildProcess$1 | null;
+  writer: NdjsonWriter;
+  finish: (code: number, level: string, msg: string, event: string) => void;
+  startedAt: string;
+  pid: number | null;
+}
+declare function runCollector({ platform, root, udid, appName, appExecutable, bundleId, serial, packageName, physical, payloadUrl, startStream, resolvePid, pidTimeoutMs, pidOf, pidWatchMs, watchPid, resolveClockOffset, now, onExit, attachSignals, stderr }: RunCollectorOptions): Promise<RunCollectorHandle | null>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { PLATFORMS, ParsedCollectorArgs, RunCollectorHandle, RunCollectorOptions, main, parseArgs, readCollectors, registerCollector, runCollector, unregisterCollector };

package/dist/collector-run.mjs

@@ -0,0 +1,539 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { S as captureProcessToken } from "./config-7kmtuhO2.mjs";
+import { t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { a as watchAppPid, c as parseDeviceConsoleLine, f as readCollectors, i as waitForAppPid, l as startIosDeviceConsole, m as unregisterCollector, n as parseLogcatLine, p as registerCollector, r as startAndroidLogcat, t as androidClockOffset, u as collectorProcessTitle } from "./android-jc8MnUyL.mjs";
+import { E as workspaceLogsDir } from "./state-2nush3MK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-DcAtEx_K.mjs";
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/collector/ios.ts
+const MESSAGE_TYPE_LEVEL = {
+	Debug: "debug",
+	Info: "info",
+	Default: "info",
+	Error: "error",
+	Fault: "fatal"
+};
+function levelFromMessageType(messageType) {
+	return MESSAGE_TYPE_LEVEL[messageType] ?? "info";
+}
+const NOISE_RULES = [
+	{
+		id: "network",
+		subsystem: "com.apple.network"
+	},
+	{
+		id: "network-default-subsystem",
+		messagePrefix: [
+			"nw_socket",
+			"nw_connection",
+			"nw_protocol",
+			"nw_endpoint",
+			"nw_path",
+			"nw_resolver",
+			"nw_flow",
+			"nw_read_request",
+			"nw_write_request",
+			"tcp_input"
+		]
+	},
+	{
+		id: "sectrust",
+		subsystem: "com.apple.securityd"
+	},
+	{
+		id: "sectrust-default-subsystem",
+		messagePrefix: [
+			"SecTrust",
+			"SecOSStatus",
+			"TrustResultType"
+		]
+	},
+	{
+		id: "webkit",
+		subsystem: "com.apple.WebKit"
+	},
+	{
+		id: "webkit-default-subsystem",
+		messagePrefix: [
+			"WebPrivacy",
+			"GPUProcessProxy",
+			"WebProcessProxy"
+		]
+	},
+	{
+		id: "audio-factory",
+		messageIncludes: ["AddInstanceForFactory"]
+	},
+	{
+		id: "coreui",
+		subsystem: "com.apple.coreui"
+	},
+	{
+		id: "coreui-default-subsystem",
+		messagePrefix: [
+			"CUICatalog:",
+			"CoreUI:",
+			"CoreThemeDefinition"
+		]
+	},
+	{
+		id: "uiscene-deprecation",
+		messageIncludes: [
+			"UIScene lifecycle will soon be required",
+			"`UIScene` lifecycle will soon be required",
+			"must migrate to UIScene",
+			"migrate to UIScene lifecycle"
+		]
+	},
+	{
+		id: "react-native-focus-cache",
+		exactSubsystem: "com.apple.UIKit",
+		category: "UIFocus",
+		messageEquals: "RCTScrollViewComponentView implements focusItemsInRect: - caching for linear focus movement is limited as long as this view is on screen."
+	}
+];
+function ruleMatches(rule, { subsystem, category, message }) {
+	if (rule.subsystem && subsystem !== rule.subsystem && !subsystem.startsWith(`${rule.subsystem}.`)) return false;
+	if (rule.exactSubsystem && subsystem !== rule.exactSubsystem) return false;
+	if (rule.category && category !== rule.category) return false;
+	if (rule.messageEquals && message !== rule.messageEquals) return false;
+	if (rule.messagePrefix && !rule.messagePrefix.some((p) => message.startsWith(p))) return false;
+	if (rule.messageIncludes && !rule.messageIncludes.some((p) => message.includes(p))) return false;
+	return true;
+}
+function noiseRuleId(event) {
+	const subsystem = typeof event?.subsystem === "string" ? event.subsystem : "";
+	const category = typeof event?.category === "string" ? event.category : "";
+	const message = typeof event?.eventMessage === "string" ? event.eventMessage : "";
+	for (const rule of NOISE_RULES) if (ruleMatches(rule, {
+		subsystem,
+		category,
+		message
+	})) return rule.id;
+	return null;
+}
+function levelForEvent(event) {
+	const level = levelFromMessageType(event?.messageType);
+	if (level !== "error" && level !== "fatal") return level;
+	return noiseRuleId(event) ? "info" : level;
+}
+function procFromImagePath(path) {
+	if (typeof path !== "string" || !path) return null;
+	const parts = path.split("/");
+	return parts[parts.length - 1] || null;
+}
+function tsFromEvent(event, now = Date.now) {
+	const parsed = Date.parse(event?.timestamp);
+	return Number.isFinite(parsed) ? parsed : now();
+}
+function recordFromLogEvent(event, { now = Date.now } = {}) {
+	if (!event || typeof event !== "object") return null;
+	const eventType = event.eventType;
+	if (eventType && eventType !== "logEvent") return null;
+	const msg = typeof event.eventMessage === "string" ? event.eventMessage : "";
+	if (!msg.trim()) return null;
+	const record = {
+		ts: tsFromEvent(event, now),
+		src: "device",
+		level: levelForEvent(event),
+		msg
+	};
+	const proc = procFromImagePath(event.processImagePath);
+	if (proc) record.proc = proc;
+	if (typeof event.subsystem === "string") record.subsystem = event.subsystem;
+	if (typeof event.category === "string") record.category = event.category;
+	return record;
+}
+function parseLogStreamLine(line, { now = Date.now } = {}) {
+	if (typeof line !== "string") return null;
+	const trimmed = line.trim();
+	if (!trimmed || trimmed[0] !== "{") return null;
+	let event;
+	try {
+		event = JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+	return recordFromLogEvent(event, { now });
+}
+function logStreamArgs(udid, appName, executableName) {
+	return [
+		"simctl",
+		"spawn",
+		udid,
+		"log",
+		"stream",
+		"--style",
+		"ndjson",
+		"--predicate",
+		`processImagePath ENDSWITH "/${appName}.app/${executableName && executableName.trim() !== "" ? executableName.trim() : appName}"`,
+		"--level",
+		"info"
+	];
+}
+function appNameFromBundleId(bundleId) {
+	const parts = String(bundleId || "").split(".");
+	return parts[parts.length - 1] || String(bundleId || "");
+}
+function startIosLogStream({ udid, appName, executableName = null, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("xcrun", logStreamArgs(udid, appName, executableName), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+//#endregion
+//#region src/collector/run.ts
+const PLATFORMS = ["ios", "android"];
+function parseArgs(argv) {
+	let platform;
+	let root;
+	let udid;
+	let bundleId;
+	let appName;
+	let appExecutable = null;
+	let serial = null;
+	let packageName = null;
+	let physical = false;
+	let payloadUrl = null;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--platform") {
+			platform = argv[++i];
+			continue;
+		}
+		if (arg === "--root") {
+			root = argv[++i];
+			continue;
+		}
+		if (arg === "--udid") {
+			udid = argv[++i];
+			continue;
+		}
+		if (arg === "--bundle") {
+			bundleId = argv[++i];
+			continue;
+		}
+		if (arg === "--app-name") {
+			appName = argv[++i];
+			continue;
+		}
+		if (arg === "--app-executable") {
+			appExecutable = argv[++i] ?? null;
+			continue;
+		}
+		if (arg === "--serial") {
+			serial = argv[++i] ?? null;
+			continue;
+		}
+		if (arg === "--package") {
+			packageName = argv[++i] ?? null;
+			continue;
+		}
+		if (arg === "--physical") {
+			physical = true;
+			continue;
+		}
+		if (arg === "--payload-url") {
+			payloadUrl = argv[++i] ?? null;
+			if (!payloadUrl) return { error: "--payload-url needs a URL." };
+			continue;
+		}
+		return { error: `Unknown collector argument "${arg}".` };
+	}
+	if (!platform || !PLATFORMS.includes(platform)) return { error: `--platform must be one of ${PLATFORMS.join(", ")}, got "${platform}".` };
+	if (!root) return { error: "Missing --root." };
+	if (!isAbsolute(root)) return { error: `--root must be an absolute path, got "${root}".` };
+	root = resolve(root);
+	if (platform === "ios") {
+		if (!udid) return { error: "Missing --udid (required for --platform ios)." };
+		if (!bundleId) return { error: "Missing --bundle (required for --platform ios)." };
+		if (!appName) appName = appNameFromBundleId(bundleId);
+	} else {
+		if (physical) return { error: "--physical is an iOS option; --platform android reads a serial." };
+		if (!serial) return { error: "Missing --serial (required for --platform android)." };
+		if (!packageName) return { error: "Missing --package (required for --platform android)." };
+	}
+	if (payloadUrl && !physical) return { error: "--payload-url only applies to --physical, which launches the app itself." };
+	return {
+		platform,
+		root,
+		udid,
+		bundleId,
+		appName,
+		appExecutable,
+		serial,
+		packageName,
+		physical,
+		payloadUrl
+	};
+}
+const noopFlush = () => {};
+function startMessage({ platform, physical, pid, appName, bundleId, udid, packageName, serial, appPid }) {
+	if (platform !== "ios") return `device log collector pid ${pid} streaming ${packageName} (pid ${appPid}) on ${serial}`;
+	if (!physical) return `device log collector pid ${pid} streaming ${appName} on ${udid}`;
+	return `device log collector pid ${pid} launching ${bundleId} on device ${udid} and streaming its console; subsystem, category and severity are not carried on hardware -- see \`stim guide logs\``;
+}
+async function runCollector({ platform, root, udid = null, appName = null, appExecutable = null, bundleId = null, serial = null, packageName = null, physical = false, payloadUrl = null, startStream = null, resolvePid = null, pidTimeoutMs = 3e4, pidOf = null, pidWatchMs = null, watchPid = watchAppPid, resolveClockOffset = androidClockOffset, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
+	const writer = createNdjsonWriter(join(workspaceLogsDir(root), "device.ndjson"));
+	const startedAt = new Date(now()).toISOString();
+	const processToken = captureProcessToken(process.pid);
+	if (!processToken) {
+		stderr("Stim collector: could not capture process identity; refusing to start an unmanaged collector.");
+		writer.close();
+		onExit(1);
+		return null;
+	}
+	let finished = false;
+	let captured = 0;
+	let watcher = null;
+	const finish = (code, level, msg, event, { signalled = false } = {}) => {
+		if (finished) return;
+		finished = true;
+		watcher?.stop();
+		if (physical && captured === 0 && !signalled) writer.write({
+			src: "device",
+			platform,
+			level: "warn",
+			event: "collector_empty",
+			msg: `the device console produced no output for ${bundleId}; devicectl only connects the app's streams when it starts the app, and os_log below the info level never reaches them`
+		});
+		writer.write({
+			src: "device",
+			platform,
+			level,
+			event,
+			msg
+		});
+		try {
+			unregisterCollector(root, platform, process.pid, processToken);
+		} catch {}
+		const closed = writer.close();
+		if (closed.dropped > 0) stderr(`Stim collector: dropped ${closed.dropped} record(s); last error: ${describe(closed.lastError)}`);
+		onExit(code);
+	};
+	let child = null;
+	let flushReaders = noopFlush;
+	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+		flushReaders();
+		killChild(child);
+		finish(0, "info", `device log collector received ${signal}; detaching`, "collector_stopped", { signalled: true });
+	});
+	try {
+		registerCollector(root, platform, {
+			pid: process.pid,
+			processToken,
+			startedAt
+		});
+	} catch (err) {
+		stderr(`Stim collector: could not record the collector in ${root}: ${describe(err)}`);
+		finish(1, "error", "Could not persist collector identity", "collector_failed");
+		return null;
+	}
+	let pid = null;
+	if (platform === "android") {
+		const resolved = resolvePid ? await resolvePid({
+			serial,
+			packageName,
+			timeoutMs: pidTimeoutMs
+		}) : await waitForAppPid({
+			serial,
+			packageName,
+			timeoutMs: pidTimeoutMs
+		});
+		if (!resolved.ok) {
+			finish(1, "error", `device log collector could not attach: ${resolved.reason}`, "collector_failed");
+			return null;
+		}
+		pid = resolved.pid ?? null;
+	}
+	writer.write({
+		src: "device",
+		platform,
+		level: "info",
+		event: "collector_started",
+		msg: startMessage({
+			platform,
+			physical,
+			pid: process.pid,
+			appName,
+			bundleId,
+			udid,
+			packageName,
+			serial,
+			appPid: pid
+		})
+	});
+	const parse = platform === "ios" ? physical ? parseDeviceConsoleLine : parseLogStreamLine : parseLogcatLine;
+	const attach = (streamPid) => {
+		const clockOffsetMs = platform === "android" ? resolveClockOffset(serial, { now }) : null;
+		if (platform === "android") writer.write({
+			src: "device",
+			platform,
+			level: clockOffsetMs === null ? "warn" : "debug",
+			event: "collector_clock",
+			clockOffsetMs,
+			msg: clockOffsetMs === null ? "Could not align Android device time; log timestamps retain device time and may miss launch filters." : `Android log timestamps aligned to host time (offset ${clockOffsetMs}ms).`
+		});
+		const onLine = (line) => {
+			const record = parse(line, {
+				now,
+				clockOffsetMs
+			});
+			if (!record) return;
+			captured++;
+			writer.write({
+				...record,
+				platform
+			});
+		};
+		const spawned = startStream ? startStream({
+			platform,
+			udid,
+			appName,
+			appExecutable,
+			bundleId,
+			serial,
+			physical,
+			payloadUrl,
+			pid: streamPid
+		}) : platform === "ios" ? physical ? startIosDeviceConsole({
+			udid,
+			bundleId,
+			payloadUrl
+		}) : startIosLogStream({
+			udid,
+			appName,
+			executableName: appExecutable
+		}) : startAndroidLogcat({
+			serial,
+			pid: streamPid
+		});
+		const outReader = createLineReader(onLine);
+		const errReader = createLineReader(physical ? onLine : (line) => {
+			const text = String(line).trimEnd();
+			if (text.trim()) writer.write({
+				src: "device",
+				platform,
+				level: "debug",
+				raw: true,
+				event: "collector_stderr",
+				msg: text
+			});
+		});
+		flushReaders = () => {
+			outReader.flush();
+			errReader.flush();
+		};
+		spawned.stdout?.setEncoding?.("utf-8");
+		spawned.stderr?.setEncoding?.("utf-8");
+		spawned.stdout?.on("data", (chunk) => outReader.push(chunk));
+		spawned.stderr?.on("data", (chunk) => errReader.push(chunk));
+		spawned.on("exit", (code, signal) => {
+			if (spawned !== child) return;
+			flushReaders();
+			const next = platform === "android" ? watcher?.probe() : null;
+			if (next && next !== pid) {
+				reattach(next, "the log stream ended");
+				return;
+			}
+			const how = signal ? `signal ${signal}` : `exit code ${code}`;
+			if (physical && code) {
+				finish(1, "error", `the devicectl console ended with ${how}; treat the run as failed`, "collector_failed");
+				return;
+			}
+			finish(0, "info", `device log stream ended (${how}); the app or device is gone`, "collector_stopped");
+		});
+		spawned.on("error", (err) => {
+			if (spawned !== child) return;
+			finish(1, "error", `device log stream failed: ${describe(err)}`, "collector_failed");
+		});
+		return spawned;
+	};
+	const reattach = (nextPid, why = "the app restarted") => {
+		if (finished) return;
+		const previous = pid;
+		flushReaders();
+		killChild(child);
+		child = null;
+		writer.write({
+			src: "device",
+			platform,
+			level: "info",
+			event: "collector_reattached",
+			msg: `${why}: ${packageName} is now pid ${nextPid} on ${serial} (was ${previous}); reattaching the log stream`
+		});
+		pid = nextPid;
+		try {
+			child = attach(nextPid);
+		} catch (err) {
+			finish(1, "error", `device log collector could not reattach to pid ${nextPid}: ${describe(err)}`, "collector_failed");
+		}
+	};
+	try {
+		child = attach(pid);
+	} catch (err) {
+		finish(1, "error", `device log collector could not start: ${describe(err)}`, "collector_failed");
+		return null;
+	}
+	if (platform === "android" && !finished) watcher = watchPid({
+		serial,
+		packageName,
+		pid,
+		intervalMs: pidWatchMs,
+		resolve: pidOf || void 0,
+		onChange: (nextPid) => reattach(nextPid)
+	});
+	return {
+		child,
+		writer,
+		finish,
+		startedAt,
+		pid
+	};
+}
+function killChild(child) {
+	try {
+		child?.kill?.("SIGTERM");
+	} catch {}
+}
+function describe(err) {
+	if (!err) return "unknown error";
+	return err.message || String(err);
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsed = parseArgs(argv);
+	if (parsed.error) {
+		console.error(`Stim collector: ${parsed.error}`);
+		process.exit(2);
+		return;
+	}
+	const root = parsed.root;
+	if (!existsSync(root)) {
+		console.error(`Stim collector: --root ${root} does not exist.`);
+		process.exit(2);
+		return;
+	}
+	process.title = collectorProcessTitle(parsed.platform, root);
+	await runCollector(parsed);
+}
+function invokedDirectly() {
+	const entry = process.argv[1];
+	if (!entry) return false;
+	try {
+		return resolve(entry) === fileURLToPath(import.meta.url);
+	} catch {
+		return false;
+	}
+}
+if (invokedDirectly()) main().catch((err) => {
+	console.error(`Stim collector: ${describe(err)}`);
+	process.exit(1);
+});
+//#endregion
+export { PLATFORMS, main, parseArgs, readCollectors, registerCollector, runCollector, unregisterCollector };