stim 1.20.2 → 1.22.0

package/dist/logs-jTS_lHSo.mjs

@@ -0,0 +1,248 @@
+import { m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { W as parseDeviceSlotOption, _ as loadConfig$1, g as isPathPrefix } from "./config-DlrsduwG.mjs";
+import { f as refuseNoProject, v as launchErrorPreview } from "./command-output-gwpm28fu.mjs";
+import { r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { n as findCommandWorkspace } from "./project-wM_XFTvE.mjs";
+import { n as SOURCES$1, t as LEVELS$1 } from "./ndjson-CgE_o3Dl.mjs";
+import { a as followAgentActions, i as followHostedLogs, n as openWorkspaceLogs } from "./logs-BfwwadsZ.mjs";
+import { t as errorDiagnostics } from "./error-diagnostics-DBWO2rxE.mjs";
+import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
+import { realpathSync } from "node:fs";
+import { relative, sep } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { buildCriteria, compileGrep, followLogs, logFiles, parseSince, queryLogs, recordMatches, runId, sortByTs } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/logs.ts
+const LEVEL_WIDTH = 5;
+const SRC_WIDTH = 6;
+const INDENT = "    ";
+function padTimePart(value, width = 2) {
+	return String(value).padStart(width, "0");
+}
+function formatTime(ts) {
+	if (typeof ts !== "number" || !Number.isFinite(ts)) return "--:--:--.---";
+	const d = new Date(ts);
+	return `${padTimePart(d.getHours())}:${padTimePart(d.getMinutes())}:${padTimePart(d.getSeconds())}.${padTimePart(d.getMilliseconds(), 3)}`;
+}
+function formatStackFrame(frame) {
+	if (!frame || typeof frame !== "object") return null;
+	const where = [
+		frame.file,
+		frame.line,
+		frame.column
+	].filter((p) => p !== void 0 && p !== null && p !== "").join(":");
+	if (frame.fn && where) return `at ${frame.fn} (${where})`;
+	if (frame.fn) return `at ${frame.fn}`;
+	if (where) return `at ${where}`;
+	return null;
+}
+function formatRecord(record, { paint } = {}) {
+	const colour = paint || ((t) => t);
+	const level = String(record?.level ?? "").padEnd(LEVEL_WIDTH);
+	const src = String(record?.src ?? "").padEnd(SRC_WIDTH);
+	const [first, ...rest] = (record?.msg === void 0 || record?.msg === null ? "" : String(record.msg)).split("\n");
+	const lines = [`${formatTime(record?.ts)} ${colour(level)} ${src} ${first}`];
+	for (const line of rest) lines.push(`${INDENT}${line}`);
+	for (const frame of Array.isArray(record?.stack) ? record.stack : []) {
+		const rendered = formatStackFrame(frame);
+		if (rendered) lines.push(`${INDENT}${rendered}`);
+	}
+	return lines.join("\n");
+}
+function parseTail(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return { n: value };
+	if (typeof value !== "string" || !/^\d+$/.test(value.trim())) return { error: `Invalid --tail value ${JSON.stringify(value)}. Use a non-negative whole number, e.g. --tail 50.` };
+	return { n: parseInt(value.trim(), 10) };
+}
+function validateSources(sources) {
+	if (sources === void 0 || sources === null) return { sources: void 0 };
+	const list = Array.isArray(sources) ? sources : [sources];
+	if (list.includes("all")) return { sources: [...SOURCES$1] };
+	const unknown = list.filter((s) => !SOURCES$1.includes(s));
+	if (unknown.length > 0) return { error: `Unknown --source value(s): ${unknown.join(", ")}. Use one or more of: ${SOURCES$1.join(", ")}, or all.` };
+	return { sources: list };
+}
+function validateLevel(level) {
+	if (LEVELS$1.includes(level)) return { level };
+	return { error: `Invalid --level value ${JSON.stringify(level)}. Use one of: ${LEVELS$1.join(", ")}.` };
+}
+const ERRORS_PRINT_CAP = 20;
+function nearestRegisteredLogsProject(root, candidates) {
+	return candidates.filter((candidate) => candidate !== root && isPathPrefix(root, candidate)).toSorted((a, b) => {
+		const depth = (path) => relative(root, path).split(sep).length;
+		return depth(a) - depth(b) || a.length - b.length || a.localeCompare(b);
+	})[0] ?? null;
+}
+function registeredDescendantWithLogs(root) {
+	const candidates = Object.keys(loadConfig$1()?.projects ?? {}).flatMap((path) => {
+		try {
+			const canonical = realpathSync(path);
+			return logFiles(workspaceLogsDir$1(canonical)).length > 0 ? [canonical] : [];
+		} catch {
+			return [];
+		}
+	});
+	return nearestRegisteredLogsProject(root, [...new Set(candidates)]);
+}
+function requireLogsWorkspace(root, dir) {
+	if (logFiles(dir).length > 0) return;
+	const descendant = registeredDescendantWithLogs(root);
+	fail(`STIM_NO_PROJECT: No Stim workspace has run in ${root}.${descendant ? ` The nearest registered app with logs is ${descendant}; run this command from there.` : " Run `stim start`, `stim ios`, or `stim android` in the app first."}`);
+}
+const LEVEL_COLOURS = {
+	debug: chalk.dim,
+	info: chalk.reset,
+	warn: chalk.yellow,
+	error: chalk.red,
+	fatal: chalk.bgRed
+};
+function logsCommand(program) {
+	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build, agent actions, maintenance). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only this device slot's records, plus the shared Metro and app client records once it has launched", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, agent, maintenance, placement, or all").option("--level <l>", `Minimum level: ${LEVELS$1.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 and stim web browser errors. Add --source maintenance for maintenance failures, or --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 = findCommandWorkspace(process.cwd());
+		if (!root) {
+			refuseNoProject({ json: false });
+			return;
+		}
+		const dir = workspaceLogsDir$1(root);
+		let sources;
+		if (opts.source !== void 0) {
+			const checked = validateSources(opts.source);
+			if (checked.error) fail(checked.error);
+			sources = checked.sources;
+		}
+		let minLevel;
+		if (opts.level !== void 0) {
+			const checked = validateLevel(opts.level);
+			if (checked.error) fail(checked.error);
+			minLevel = checked.level;
+		}
+		if (opts.since !== void 0) {
+			const parsed = parseSince(opts.since);
+			if (parsed.error) fail(parsed.error);
+		}
+		let tail;
+		if (opts.tail !== void 0) {
+			const parsed = parseTail(opts.tail);
+			if (parsed.error) fail(parsed.error);
+			tail = parsed.n;
+		}
+		if (opts.grep !== void 0) {
+			const compiled = compileGrep(opts.grep);
+			if (compiled.error) fail(compiled.error);
+		}
+		requireLogsWorkspace(root, dir);
+		const query = {
+			slot: opts.slot,
+			dir,
+			sources,
+			minLevel,
+			since: opts.since,
+			grep: opts.grep,
+			tail,
+			errorsOnly: Boolean(opts.errors),
+			errorContext: Boolean(opts.errors && !opts.json && !opts.follow)
+		};
+		const emit = (record) => {
+			if (opts.json) {
+				console.log(JSON.stringify(record));
+				return;
+			}
+			const rendered = {
+				...record,
+				msg: launchErrorPreview([record], root, { full: true }).join("\n"),
+				stack: void 0
+			};
+			console.log(formatRecord(rendered, { paint: record?.level ? LEVEL_COLOURS[record.level] : void 0 }));
+		};
+		const context = {
+			home: configDir(),
+			buildCache: null,
+			projectRoot: root,
+			cwd: root,
+			runId: runId(),
+			env: process.env,
+			signal: new AbortController().signal,
+			output: (stream, text) => process[stream].write(text)
+		};
+		const { view, readAgent, hostedReachable } = await openWorkspaceLogs(context, query, Boolean(opts.follow));
+		const offsets = opts.follow ? view.sizes : null;
+		let timeline = [];
+		let rawRecords;
+		try {
+			const extra = await readAgent?.(opts.json ? {
+				tail: query.tail,
+				matches: view.filter(query)
+			} : void 0) ?? [];
+			if (opts.json) rawRecords = await view.query({
+				...query,
+				extra
+			});
+			else {
+				timeline = sortByTs([...await view.query(), ...extra]);
+				rawRecords = queryLogs({
+					...query,
+					records: timeline
+				});
+			}
+		} finally {
+			await view.close();
+		}
+		const supervisorPort = readWorkspaceState$1(root)?.supervisor?.port;
+		const records = opts.json ? rawRecords : await errorDiagnostics(rawRecords, {
+			root,
+			logsDir: dir,
+			port: typeof supervisorPort === "number" ? supervisorPort : null,
+			allowRequest: true,
+			timeline
+		});
+		const errorCount = records.filter((record) => record.errorContext !== true).length;
+		let seenErrors = 0;
+		const capped = opts.errors && !opts.json && tail === void 0 && errorCount > 20 ? records.filter((record) => {
+			if (record.errorContext === true) return seenErrors <= 20;
+			seenErrors += 1;
+			return seenErrors <= 20;
+		}) : records;
+		for (const record of capped) emit(record);
+		const hidden = errorCount - capped.filter((record) => record.errorContext !== true).length;
+		if (hidden > 0) console.log(chalk.dim(`Showing 20 of ${errorCount} matching error records; ${hidden} not shown. Add --tail ${rawRecords.length} to include all captured records before grouping, or --json for raw records. Stacks are shown in full.`));
+		if (!opts.follow) {
+			if (records.length === 0 && !opts.json) console.error(chalk.dim(`No matching log records in ${dir}`));
+			return;
+		}
+		const criteria = buildCriteria({
+			slot: opts.slot,
+			sources,
+			minLevel,
+			since: opts.since,
+			grep: opts.grep,
+			errorsOnly: Boolean(opts.errors)
+		});
+		const stop = followLogs({
+			dir,
+			offsets,
+			criteria,
+			onRecord: emit,
+			errorContext: opts.errors ? opts.json ? "field" : "msg" : void 0
+		});
+		const stopAgent = readAgent ? followAgentActions(context, readAgent, (record) => {
+			if (recordMatches(record, criteria)) emit(record);
+		}) : null;
+		const stopHosted = followHostedLogs(root, !hostedReachable);
+		const finish = () => {
+			stop();
+			stopHosted?.();
+			stopReader();
+			stopAgent?.();
+			process.exit(0);
+		};
+		const stopReader = watchStdoutReader(finish);
+		process.on("SIGINT", finish);
+		process.on("SIGTERM", finish);
+	});
+}
+function fail(message) {
+	console.error(chalk.red(message));
+	process.exit(1);
+}
+//#endregion
+export { ERRORS_PRINT_CAP, logsCommand as default, formatRecord, formatStackFrame, formatTime, parseTail, validateLevel, validateSources };

package/dist/{macos-D7uDvO-z.mjs → macos-DVlSSyUg.mjs}

@@ -1,2 +1,2 @@
-import { n as runMacos, r as waitForLaunchServices, t as macosCommand } from "./macos-Ch5VJmcS.mjs";
+import { n as runMacos, r as waitForLaunchServices, t as macosCommand } from "./macos-NfV2D7dO.mjs";
 export { macosCommand as default, runMacos, waitForLaunchServices };