stim 1.14.0 → 1.16.0

package/dist/{ios-device-BiOsSVzd.mjs → ios-device-Ee7sDXfp.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 //#region src/collector/ios-device.ts
 const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
 const DEV_MENU_LAUNCH_ARGS = [

package/dist/{ios-device-DGglU3E_.mjs → ios-device-FfCN_C8p.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { n as TOOL_ERROR_PREFIX } from "./ios-device-BiOsSVzd.mjs";
-import { i as INSTALL_ERROR } from "./app-install-BpgSgkJj.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as TOOL_ERROR_PREFIX } from "./ios-device-Ee7sDXfp.mjs";
+import { i as INSTALL_ERROR } from "./app-install-CKWdbXIX.mjs";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -38,12 +38,17 @@ function parseDevicectlDevices(payload) {
 			transportType: text(connection.transportType),
 			platform: text(hardware.platform),
 			reality: text(hardware.reality),
-			tunnelState: text(connection.tunnelState)
+			tunnelState: text(connection.tunnelState),
+			model: text(hardware.marketingName)
 		});
 	}
 	return out;
 }
 function listIosDevices({ exec = null } = {}) {
+	return readIosDevices({ exec }) ?? [];
+}
+/** devicectl's device list, or null when devicectl failed or did not answer within `timeoutMs`. */
+function readIosDevices({ exec = null, timeoutMs = DEVICECTL_TIMEOUT_MS } = {}) {
 	const executor = exec || getExecutor();
 	const dir = mkdtempSync(join(tmpdir(), "stim-devicectl-"));
 	const out = join(dir, "devices.json");
@@ -54,10 +59,10 @@ function listIosDevices({ exec = null } = {}) {
 			"devices",
 			"-j",
 			out
-		], { timeoutMs: DEVICECTL_TIMEOUT_MS });
+		], { timeoutMs });
 		return parseDevicectlDevices(readFileSync(out, "utf-8"));
 	} catch {
-		return [];
+		return null;
 	} finally {
 		rmSync(dir, {
 			recursive: true,
@@ -507,4 +512,4 @@ function localNetworkPending(records, { since = 0, pid = null, lanOrigin }) {
 	return false;
 }
 //#endregion
-export { iosPoolCandidates as a, listIosDevices as c, verifyIosDeviceReleaseLaunch as d, iosDeviceProcess as i, localNetworkPending as l, installIosDeviceApp as n, iosPoolNoCandidatesRefusal as o, iosDeviceBounds as r, isWirelessIosDevice as s, awaitIosDeviceLaunch as t, resolveIosPhysicalDevice as u };
+export { iosPoolCandidates as a, isWirelessIosDevice as c, readIosDevices as d, resolveIosPhysicalDevice as f, iosDeviceProcess as i, listIosDevices as l, installIosDeviceApp as n, iosPoolNoCandidatesRefusal as o, verifyIosDeviceReleaseLaunch as p, iosDeviceBounds as r, isReachable as s, awaitIosDeviceLaunch as t, localNetworkPending as u };

package/dist/ios-state-DS5UpYTH.mjs

@@ -0,0 +1,48 @@
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { HOSTED_METRO_REQUESTS_KEY, hostedIosPlacements, hostedIosRecords, hostedMetroRequests, isJsonObject, parseHostedIosPlacement, unreadableHostedIos } from "@stim-cli/core/state";
+//#region src/device-host/ios-state.ts
+function readHostedIos(root, slot) {
+	const state = readWorkspaceState$1(root);
+	if (slot !== void 0) {
+		const record = hostedIosRecords(state)[slot];
+		if (record !== void 0 && !parseHostedIosPlacement(record)) throw Object.assign(new Error(unreadableHostedIos(slot)), {
+			code: "STIM_HOSTING_REFUSED",
+			remedy: `Restore that slot's recorded machine and session from the host, then run stim stop${slot === "default" ? "" : ` --slot ${slot}`} to reconcile it.`
+		});
+	}
+	const placements = hostedIosPlacements(state);
+	return slot === void 0 ? placements : placements[slot] ? { [slot]: placements[slot] } : {};
+}
+function writeHostedIos(root, slot, host) {
+	updateWorkspaceState(root, (state) => {
+		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
+		const current = slot === "default" ? state.ios : isJsonObject(slots[slot]) ? slots[slot].ios : void 0;
+		const record = isJsonObject(current) ? { ...current } : {};
+		const previous = parseHostedIosPlacement(record.host);
+		if (previous && previous.session !== host?.session) {
+			const requests = { ...hostedMetroRequests(state) };
+			delete requests[previous.session];
+			state = {
+				...state,
+				[HOSTED_METRO_REQUESTS_KEY]: requests
+			};
+		}
+		if (host) record.host = host;
+		else delete record.host;
+		return slot === "default" ? {
+			...state,
+			ios: record
+		} : {
+			...state,
+			deviceSlots: {
+				...slots,
+				[slot]: {
+					...isJsonObject(slots[slot]) ? slots[slot] : {},
+					ios: record
+				}
+			}
+		};
+	});
+}
+//#endregion
+export { writeHostedIos as n, readHostedIos as t };

package/dist/{launch-verify-Deg4tB3Z.mjs → launch-verify-2DBRizjo.mjs}

@@ -1,8 +1,8 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { o as readNdjsonGenerations } from "./ndjson-CDY9IkVC.mjs";
-import { s as isAppLaunchError } from "./command-output-DVcpw6eE.mjs";
-import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-BiOsSVzd.mjs";
-import { d as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, o as androidAppProcess } from "./app-install-BpgSgkJj.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { s as isAppLaunchError } from "./command-output-DnJMdEY-.mjs";
+import { o as readNdjsonGenerations } from "./ndjson-PclOIwVY.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Ee7sDXfp.mjs";
+import { f as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, s as androidAppProcess } from "./app-install-CKWdbXIX.mjs";
 import { join } from "node:path";
 //#region src/engine/app-readiness.ts
 const APP_READINESS_TIMEOUT_MS = 3e4;

package/dist/logs-CHEVK8zD.mjs

@@ -0,0 +1,371 @@
+import { H as projectDeviceSlots, V as parseDeviceSlotOption, _ as loadConfig$1, g as isPathPrefix } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { f as refuseNoProject, l as phaseLine, v as launchErrorPreview } from "./command-output-DnJMdEY-.mjs";
+import { a as findCommandWorkspace } from "./project-Du91Ilvc.mjs";
+import { r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { n as agentDeviceLiveness, u as readAgentDeviceRecords } from "./activity-BxwdD81S.mjs";
+import { n as SOURCES, t as LEVELS } from "./ndjson-PclOIwVY.mjs";
+import { o as connectHost } from "./hosted-client-a-WmqE2L.mjs";
+import { n as pullHostedMacosLogs, t as pullHostedIosLogs } from "./hosted-logs-D5g041Q3.mjs";
+import "./hosted-macos-BSZyIb3y.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-B9L4Ae0x.mjs";
+import { t as readHostedIos } from "./ios-state-DS5UpYTH.mjs";
+import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
+import { realpathSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { agentDeviceStateDirs, buildCriteria, compileGrep, createAgentActionReader, fileSizes, followLogs, logFiles, parseSince, queryJsonLogs, queryLogs, readLogRecords, readMacosRecord, recordMatches, sortByTs } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+import chalk from "chalk";
+//#region src/devices/agent-actions.ts
+function workspaceAgentTargets(project) {
+	const targets = [];
+	let slots;
+	try {
+		slots = projectDeviceSlots(project);
+	} catch {
+		return [];
+	}
+	for (const { slot, platforms } of slots) {
+		const { ios, android } = platforms;
+		if (ios?.owned && typeof ios.deviceUdid === "string") targets.push({
+			platform: "ios",
+			id: ios.deviceUdid,
+			slot
+		});
+		if (android?.owned && typeof android.consolePort === "number" && typeof android.avdName === "string") targets.push({
+			platform: "android",
+			id: `emulator-${android.consolePort}`,
+			slot,
+			name: android.avdName
+		});
+	}
+	return targets;
+}
+function canonicalDir(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
+function createAgentActionReader$1({ targets, sinceTs, home = homedir(), now, startOf = process_identity_exports.inspectProcessStart }) {
+	const byId = new Map(targets.map((target) => [target.id, target]));
+	let claimed;
+	const read = createAgentActionReader({
+		sessionsDirs: () => agentDeviceStateDirs(home).map((root) => join(root, "sessions")),
+		targets,
+		sinceTs,
+		now,
+		claimedDevice: (session, sessionsDir) => {
+			claimed ??= new Map(readAgentDeviceRecords(home).filter((record) => record.kind === "claim" && record.session && record.deviceId).filter((record) => {
+				const target = byId.get(record.deviceId);
+				return target?.name === void 0 || target.name === record.deviceName;
+			}).filter((record) => agentDeviceLiveness(record, startOf) === "live").map((record) => [`${record.stateDir ? canonicalDir(record.stateDir) : ""}\0${record.session}`, record.deviceId]));
+			return claimed.get(`${canonicalDir(dirname(sessionsDir))}\0${session}`) ?? claimed.get(`\0${session}`) ?? null;
+		}
+	});
+	return () => {
+		claimed = void 0;
+		return read();
+	};
+}
+//#endregion
+//#region src/device-host/hosted-logs-sync.ts
+function warning(machine, error) {
+	const message = error.message.replace(/\.$/, "");
+	const hint = message.includes("refused device-host.logs.query") ? ` If ${machine} runs an older stim-server, update it.` : "";
+	return phaseLine("device", `Could not read the app's logs from ${machine}: ${message}. Showing the logs already copied here.${hint}`);
+}
+async function syncHostedMacosLogs(root, placement, slot, warnings) {
+	let host;
+	try {
+		host = await connectHost(placement.machine);
+		if (slot !== void 0) await pullHostedIosLogs(root, slot, placement, host);
+		else await pullHostedMacosLogs(root, placement, host);
+		return true;
+	} catch (error) {
+		if (!warnings?.has(placement.machine)) {
+			process.stderr.write(`${warning(placement.machine, error)}\n`);
+			warnings?.add(placement.machine);
+		}
+		return false;
+	} finally {
+		host?.connection.close();
+	}
+}
+function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3, slot } = {}) {
+	let host;
+	let retryAt = 0;
+	let stopped = false;
+	let running = false;
+	const tick = async () => {
+		if (running || stopped || Date.now() < retryAt) return;
+		running = true;
+		try {
+			const placement = slot !== void 0 ? readHostedIos(root)[slot] : readMacosRecord(root)?.host;
+			if (!placement) {
+				host?.connection.close();
+				host = void 0;
+				return;
+			}
+			host ??= await connectHost(placement.machine);
+			if (slot !== void 0) await pullHostedIosLogs(root, slot, placement, host);
+			else await pullHostedMacosLogs(root, placement, host);
+			failing = false;
+		} catch (error) {
+			host?.connection.close();
+			host = void 0;
+			if (!failing) process.stderr.write(`${warning((slot !== void 0 ? readHostedIos(root)[slot] : readMacosRecord(root)?.host)?.machine ?? "the host", error)}\n`);
+			failing = true;
+			retryAt = Date.now() + retryMs;
+		} finally {
+			running = false;
+		}
+	};
+	const timer = setInterval(() => void tick(), intervalMs);
+	return () => {
+		stopped = true;
+		clearInterval(timer);
+		host?.connection.close();
+	};
+}
+async function syncHostedLogs(root) {
+	const macos = readMacosRecord(root)?.host;
+	const warnings = /* @__PURE__ */ new Set();
+	return (await Promise.all([...macos ? [syncHostedMacosLogs(root, macos)] : [], ...Object.entries(readHostedIos(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings))])).every(Boolean);
+}
+function followHostedLogs(root, failing) {
+	const stops = /* @__PURE__ */ new Map();
+	const refresh = () => {
+		if (readMacosRecord(root)?.host && !stops.has("macos")) stops.set("macos", followHostedMacosLogs(root, { failing }));
+		for (const slot of Object.keys(readHostedIos(root))) {
+			const key = `ios:${slot}`;
+			if (!stops.has(key)) stops.set(key, followHostedMacosLogs(root, {
+				failing,
+				slot
+			}));
+		}
+	};
+	refresh();
+	const timer = setInterval(refresh, 500);
+	return () => {
+		clearInterval(timer);
+		for (const stop of stops.values()) stop();
+	};
+}
+//#endregion
+//#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] };
+	const unknown = list.filter((s) => !SOURCES.includes(s));
+	if (unknown.length > 0) return { error: `Unknown --source value(s): ${unknown.join(", ")}. Use one or more of: ${SOURCES.join(", ")}, or all.` };
+	return { sources: list };
+}
+function validateLevel(level) {
+	if (LEVELS.includes(level)) return { level };
+	return { error: `Invalid --level value ${JSON.stringify(level)}. Use one of: ${LEVELS.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, 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 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 hostedReachable = await syncHostedLogs(root);
+		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 captured = captureWorkspaceCrashes(root, dir);
+		const offsets = opts.follow ? fileSizes(dir) : null;
+		const workspaceTimeline = opts.follow ? readLogRecords(dir) : captured;
+		const agentSince = workspaceTimeline[0]?.ts ?? (opts.follow ? Date.now() : void 0);
+		const readAgent = (sources ? sources.includes("agent") : !opts.errors) && agentSince !== void 0 ? createAgentActionReader$1({
+			targets: workspaceAgentTargets(loadConfig$1()?.projects?.[root]),
+			sinceTs: agentSince
+		}) : null;
+		const timeline = readAgent ? sortByTs([...workspaceTimeline, ...readAgent()]) : workspaceTimeline;
+		const rawRecords = (opts.json ? queryJsonLogs : queryLogs)({
+			...query,
+			records: timeline
+		});
+		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 agentTimer = readAgent ? setInterval(() => {
+			for (const record of readAgent()) if (recordMatches(record, criteria)) emit(record);
+		}, 500) : null;
+		const stopHosted = followHostedLogs(root, !hostedReachable);
+		const finish = () => {
+			stop();
+			stopHosted?.();
+			stopReader();
+			if (agentTimer) clearInterval(agentTimer);
+			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 };