stim 1.15.0 → 1.17.0

package/dist/{activity-B2-kb7k0.mjs → activity-IRvJY_ru.mjs}

@@ -1,10 +1,10 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { C as workspaceLogsDir, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
-import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-W5Pi1q38.mjs";
+import { r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-DpoS36_u.mjs";
 import { closeSync, fstatSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
-import { readViewedDevices } from "@stim-cli/core/state";
+import { agentDeviceStateDirs, readViewedDevices } from "@stim-cli/core/state";
 import { homedir } from "node:os";
 //#region src/devices/automation-tools.ts
 const AUTOMATION_TOOLS = [
@@ -182,12 +182,14 @@ function parseAgentDeviceRecord(kind, path, raw) {
 		deviceId,
 		session: kind === "claim" && typeof entry?.session === "string" && entry.session ? entry.session : null,
 		workspace: kind === "claim" && typeof entry?.workspace === "string" && entry.workspace ? entry.workspace : null,
+		stateDir: kind === "claim" && typeof entry?.stateDir === "string" && entry.stateDir ? entry.stateDir : null,
 		deviceName: kind === "claim" && typeof device?.name === "string" ? device.name : null,
 		readable: Boolean(entry && deviceId),
 		owner: entry ? field(entry, "ownerPid", "ownerStartTime") : null,
 		runner: entry && kind === "runner-lease" ? field(entry, "runnerPid", "runnerStartTime") : null,
 		claimProtocol: kind === "runner-lease" && entry?.deviceClaimProtocol === 1,
-		createdAtMs
+		createdAtMs,
+		xctestrunPath: typeof entry?.xctestrunPath === "string" ? entry.xctestrunPath : null
 	};
 }
 function processMatches(entry, startOf) {
@@ -198,6 +200,17 @@ function processMatches(entry, startOf) {
 	if (!Number.isFinite(recorded)) return "unknown";
 	return Math.floor(start.startedAtMs / 1e3) === Math.floor(recorded / 1e3) ? "live" : "dead";
 }
+function agentDeviceDaemon(stateDir, startOf = process_identity_exports.inspectProcessStart) {
+	let raw;
+	try {
+		raw = readFileSync(join(stateDir, "daemon.json"), "utf8");
+	} catch (error) {
+		return error.code === "ENOENT" ? "none" : "unknown";
+	}
+	const entry = parseObject(raw);
+	const owner = entry && field(entry, "pid", "processStartTime");
+	return owner ? processMatches(owner, startOf) : "unknown";
+}
 function agentDeviceLiveness(record, startOf) {
 	const results = (record.kind === "claim" ? [record.owner] : [record.owner, record.runner]).map((entry) => entry ? processMatches(entry, startOf) : "unknown");
 	if (results.includes("dead")) return "dead";
@@ -291,13 +304,13 @@ function agentDeviceDirs(home) {
 * When an agent-device session last recorded an event: its events file's modification time. agent-device names a
 * session's directory after the session with every character outside `[a-zA-Z0-9._-]` replaced by `_`.
 */
-function agentSessionActedAt(home, session) {
-	const root = envDir("AGENT_DEVICE_STATE_DIR") ?? join(home, ".agent-device");
-	try {
-		return statSync(join(root, "sessions", session.replaceAll(/[^a-zA-Z0-9._-]/g, "_"), "events.ndjson")).mtimeMs;
-	} catch {
-		return null;
-	}
+function agentSessionActedAt(home, session, stateDir) {
+	let latest = null;
+	for (const root of stateDir ? [stateDir] : agentDeviceStateDirs(home)) try {
+		const at = statSync(join(root, "sessions", session.replaceAll(/[^a-zA-Z0-9._-]/g, "_"), "events.ndjson")).mtimeMs;
+		latest = latest === null ? at : Math.max(latest, at);
+	} catch {}
+	return latest;
 }
 function readAgentDeviceRecords(home) {
 	return agentDeviceDirs(home).flatMap(({ kind, dir }) => {
@@ -377,6 +390,26 @@ function createDeviceProcessTables() {
 		}
 	};
 }
+function workspaceDeviceRecency(root) {
+	const recency = [];
+	const usedAt = Date.parse(String(readWorkspaceState$1(root)?.lastUsedAt ?? ""));
+	if (Number.isFinite(usedAt)) recency.push({
+		basis: "workspace-use",
+		at: usedAt
+	});
+	for (const file of ["client.ndjson", "device.ndjson"]) try {
+		recency.push({
+			basis: "device-log",
+			at: statSync(join(workspaceLogsDir$1(root), file)).mtimeMs
+		});
+	} catch {}
+	return recency;
+}
+/** The newest workspace use or change to its in-app or native device logs. */
+function workspaceDeviceLastUseAt(root) {
+	const times = workspaceDeviceRecency(root).map(({ at }) => at).filter(Number.isFinite);
+	return times.length ? Math.max(...times) : NaN;
+}
 function createActivityReader({ now = Date.now(), home = homedir(), startOf = process_identity_exports.inspectProcessStart, leaseFiles = listLeaseFiles, tables = createDeviceProcessTables(), viewers = readViewedDevices } = {}) {
 	let agentDevice;
 	let stimLeases;
@@ -407,7 +440,7 @@ function createActivityReader({ now = Date.now(), home = homedir(), startOf = pr
 					pid: record.owner?.pid ?? null,
 					since: record.createdAtMs !== null ? new Date(record.createdAtMs).toISOString() : null
 				});
-				const actedAt = record.session ? agentSessionActedAt(home, record.session) : null;
+				const actedAt = record.session ? agentSessionActedAt(home, record.session, record.stateDir) : null;
 				if (actedAt !== null) evidence.recency.push({
 					basis: "agent-action",
 					at: actedAt
@@ -458,7 +491,7 @@ function createActivityReader({ now = Date.now(), home = homedir(), startOf = pr
 			});
 		}
 		if (target.workspace) {
-			const dir = workspaceLogsDir(target.workspace);
+			const dir = workspaceLogsDir$1(target.workspace);
 			const deviceAt = latestDeviceLogAt(log(join(dir, "device.ndjson")) ?? [], target);
 			if (deviceAt !== null) evidence.recency.push({
 				basis: "device-log",
@@ -479,7 +512,7 @@ function createActivityReader({ now = Date.now(), home = homedir(), startOf = pr
 	};
 }
 function workspaceActivity(workspace, now = Date.now()) {
-	const dir = workspaceLogsDir(workspace);
+	const dir = workspaceLogsDir$1(workspace);
 	const state = readWorkspaceState$1(workspace);
 	const recency = [];
 	const deviceAt = latestRecordAt(tailLines(join(dir, "device.ndjson")) ?? [], (record) => record.src === "device" && isDeviceRecord(record));
@@ -579,7 +612,7 @@ function readWebActivity(target, tables, now = Date.now()) {
 		...driver,
 		basis: "cdp-client"
 	});
-	const lines = tailLines(join(workspaceLogsDir(target.workspace), "web.ndjson")) ?? [];
+	const lines = tailLines(join(workspaceLogsDir$1(target.workspace), "web.ndjson")) ?? [];
 	const actionAt = latestRecordAt(lines, (record) => record.src === "agent");
 	if (actionAt !== null) evidence.recency.push({
 		basis: "agent-action",
@@ -593,4 +626,4 @@ function readWebActivity(target, tables, now = Date.now()) {
 	return classifyActivity(evidence, now);
 }
 //#endregion
-export { probeWebDrivers as a, tailLines as c, idleForMs as i, workspaceActivity as l, createActivityReader as n, readAgentDeviceRecords as o, createDeviceProcessTables as r, readWebActivity as s, agentDeviceLiveness as t };
+export { envDir as a, probeWebDrivers as c, readWebActivity as d, tailLines as f, createDeviceProcessTables as i, processMatches as l, workspaceDeviceLastUseAt as m, agentDeviceLiveness as n, idleForMs as o, workspaceActivity as p, createActivityReader as r, parseAgentDeviceRecord as s, agentDeviceDaemon as t, readAgentDeviceRecords as u };

package/dist/agent-device-usage-output-BK41vnzN.mjs

@@ -0,0 +1,411 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { j as formatBytes } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { o as formatLongDuration } from "./command-output-CDAIFD-8.mjs";
+import { a as envDir, l as processMatches, s as parseAgentDeviceRecord } from "./activity-IRvJY_ru.mjs";
+import { c as listWorkspaceDirs } from "./workspaces-Bcib97-6.mjs";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { agentDeviceUsageFile, readAgentDeviceUsageCache, readSwiftpmCacheUsage, swiftpmCacheUsageFile } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+import chalk from "chalk";
+//#region src/devices/report-only-usage.ts
+function canonical(path) {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve(path);
+	}
+}
+function parseDu(output) {
+	const sizes = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const match = /^(\d+)\t(.+?)\r?$/.exec(line);
+		if (match) sizes.set(resolve(match[2]), Number(match[1]) * 1024);
+	}
+	return sizes;
+}
+async function measureDu(args) {
+	let output = "";
+	let complete = true;
+	try {
+		output = await getExecutor().runFileAsync("du", args, { timeoutMs: 2e4 });
+	} catch (error) {
+		complete = false;
+		const failure = error;
+		if (failure.status === 1 && !failure.code && typeof failure.stdout === "string") output = failure.stdout;
+	}
+	return {
+		sizes: parseDu(output),
+		complete
+	};
+}
+function writeUsageCache(file, value) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, JSON.stringify(value));
+		renameSync(temporary, file);
+	} catch {
+		try {
+			rmSync(temporary, { force: true });
+		} catch {}
+	}
+}
+//#endregion
+//#region src/devices/swiftpm-cache-usage.ts
+async function getSwiftpmCacheUsage({ maxAgeMs = 6e5 } = {}) {
+	const dir = canonical(process.platform === "darwin" ? join(homedir(), "Library", "Caches", "org.swift.swiftpm") : join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "org.swift.swiftpm"));
+	const cached = readSwiftpmCacheUsage();
+	const age = cached ? Date.now() - Date.parse(cached.measuredAt) : Infinity;
+	if (cached && cached.dir === dir && age >= 0 && age < maxAgeMs) return cached;
+	const present = existsSync(dir);
+	const result = present ? await measureDu(["-sk", dir]) : null;
+	const bytes = present ? result?.complete ? result.sizes.get(dir) ?? null : null : 0;
+	const usage = {
+		version: 1,
+		measuredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		dir,
+		present,
+		bytes,
+		complete: bytes !== null
+	};
+	writeUsageCache(swiftpmCacheUsageFile(), usage);
+	return usage;
+}
+//#endregion
+//#region src/devices/agent-device-usage.ts
+const MAX_AGE_MS = 6e5;
+function contains(parent, path) {
+	const rel = relative(parent, path);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function parseRunnerMetadata(raw) {
+	let value = null;
+	try {
+		value = raw === null ? null : JSON.parse(raw);
+	} catch {}
+	return {
+		packageVersion: typeof value?.packageVersion === "string" ? value.packageVersion : null,
+		xcodeBuildVersion: typeof value?.xcodeBuildVersion === "string" ? value.xcodeBuildVersion : null
+	};
+}
+function runnerLastUsedAt(plist, mtimeMs) {
+	const match = plist?.match(/<key>LastAccessedDate<\/key>\s*<date>([^<]+)<\/date>/);
+	const date = match ? Date.parse(match[1]) : NaN;
+	const at = Number.isFinite(date) ? date : mtimeMs;
+	return at !== null && Number.isFinite(at) ? new Date(at).toISOString() : null;
+}
+function runnerInUse(dir, leases, unreadable, lock, startOf) {
+	if (unreadable || leases.some((lease) => !lease.readable)) return {
+		inUse: true,
+		inUseReason: "unreadable"
+	};
+	for (const lease of leases) {
+		if (!lease.xctestrunPath || !contains(dir, lease.xctestrunPath)) continue;
+		const liveness = [lease.owner, lease.runner].flatMap((process) => process ? [processMatches(process, startOf)] : []);
+		if (liveness.includes("live")) return {
+			inUse: true,
+			inUseReason: "lease"
+		};
+		if (liveness.includes("unknown")) return {
+			inUse: true,
+			inUseReason: "unreadable"
+		};
+	}
+	if (lock === "unreadable") return {
+		inUse: true,
+		inUseReason: "unreadable"
+	};
+	if (lock && processMatches(lock, startOf) !== "dead") return {
+		inUse: true,
+		inUseReason: "lock"
+	};
+	return {
+		inUse: false,
+		inUseReason: null
+	};
+}
+function subtract(total, parts) {
+	return total === null || parts.some((part) => part === null) ? null : Math.max(0, total - parts.reduce((sum, part) => sum + part, 0));
+}
+function largest(entries) {
+	return entries.toSorted((a, b) => (b.bytes ?? -1) - (a.bytes ?? -1));
+}
+function assembleAgentDeviceUsage(tree, sizes, complete, measuredAt) {
+	const size = (dir) => tree.absent.has(dir) ? 0 : sizes.get(dir) ?? null;
+	const { stateDir, runnerRoot } = tree.roots;
+	const sessions = join(stateDir, "sessions");
+	const logs = join(stateDir, "logs");
+	const runnerBytes = tree.runnerPresent ? size(runnerRoot) : 0;
+	const platforms = largest(tree.platforms.map((platform) => ({
+		...platform,
+		bytes: size(platform.dir),
+		entries: largest(platform.entries.map((entry) => ({
+			...entry,
+			bytes: size(entry.dir)
+		})))
+	})));
+	const stateBytes = tree.statePresent ? size(stateDir) : 0;
+	const sessionsBytes = tree.statePresent ? size(sessions) : 0;
+	const logsBytes = tree.statePresent ? size(logs) : 0;
+	const workspaces = largest(tree.workspaces.map((entry) => ({
+		...entry,
+		bytes: size(entry.dir)
+	})));
+	const hosted = tree.hosted ? {
+		...tree.hosted,
+		bytes: size(tree.hosted.dir)
+	} : null;
+	return {
+		version: 1,
+		measuredAt,
+		complete,
+		bytes: (stateBytes ?? 0) + (contains(stateDir, runnerRoot) ? 0 : runnerBytes ?? 0) + workspaces.reduce((sum, entry) => sum + (entry.bytes ?? 0), 0) + (hosted?.bytes ?? 0),
+		stateDir: {
+			dir: stateDir,
+			present: tree.statePresent,
+			bytes: stateBytes,
+			sessions: {
+				dir: sessions,
+				bytes: sessionsBytes,
+				count: tree.sessionsCount
+			},
+			logs: {
+				dir: logs,
+				bytes: logsBytes
+			},
+			other: {
+				bytes: subtract(stateBytes, [
+					sessionsBytes,
+					logsBytes,
+					...contains(stateDir, runnerRoot) ? [runnerBytes] : []
+				]),
+				largest: largest(tree.otherChildren.map((entry) => ({
+					...entry,
+					bytes: sizes.get(join(stateDir, entry.name)) ?? entry.bytes
+				}))).slice(0, 5)
+			}
+		},
+		runnerBuilds: {
+			dir: runnerRoot,
+			present: tree.runnerPresent,
+			bytes: runnerBytes,
+			sharedBytes: tree.runnerPresent ? subtract(size(join(runnerRoot, "derived")), platforms.map((entry) => entry.bytes)) : 0,
+			platforms
+		},
+		workspaces,
+		hosted
+	};
+}
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+function children(dir) {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+function directories(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+}
+function workspaceAgentDeviceDir(dir) {
+	return join(dir, "agent-device");
+}
+function readRunnerLock(dir) {
+	if (!existsSync(dir)) return null;
+	try {
+		const owner = JSON.parse(readFileSync(join(dir, "owner.json"), "utf8"));
+		if (owner && typeof owner === "object" && !Array.isArray(owner) && "pid" in owner && typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0 && "startTime" in owner && typeof owner.startTime === "string" && Number.isFinite(Date.parse(owner.startTime))) return {
+			pid: owner.pid,
+			startTime: owner.startTime
+		};
+	} catch {}
+	return "unreadable";
+}
+function discover() {
+	const runnerRoot = canonical(join(homedir(), ".agent-device", "apple-runner"));
+	const hostedDir = canonical(join(configDir(), "server", "agent-device"));
+	const workspaceDirs = listWorkspaceDirs().map(({ dir, projectRoot }) => ({
+		dir: canonical(workspaceAgentDeviceDir(dir)),
+		projectRoot,
+		bytes: null
+	}));
+	const override = envDir("AGENT_DEVICE_STATE_DIR");
+	const candidate = override ? canonical(override) : null;
+	const overlaps = candidate && [...workspaceDirs.map(({ dir }) => dir), hostedDir].some((dir) => contains(dir, candidate) || contains(candidate, dir));
+	const stateDir = candidate && !overlaps ? candidate : canonical(join(homedir(), ".agent-device"));
+	const workspaces = workspaceDirs.filter(({ dir }) => existsSync(dir));
+	const roots = {
+		stateDir,
+		runnerRoot,
+		hostedDir,
+		workspaceDirs: workspaces.map(({ dir }) => dir).toSorted()
+	};
+	const leaseDir = envDir("AGENT_DEVICE_IOS_RUNNER_LEASE_DIR") ?? join(runnerRoot, "leases");
+	let leases = [];
+	let unreadable = false;
+	try {
+		leases = readdirSync(leaseDir).filter((name) => name.endsWith(".json")).map((name) => {
+			const path = join(leaseDir, name);
+			const record = parseAgentDeviceRecord("runner-lease", path, readText(path));
+			if (record.xctestrunPath) record.xctestrunPath = canonical(record.xctestrunPath);
+			return record;
+		});
+	} catch (error) {
+		unreadable = error.code !== "ENOENT";
+	}
+	const starts = /* @__PURE__ */ new Map();
+	const startOf = (pid) => {
+		if (!starts.has(pid)) starts.set(pid, (0, process_identity_exports.inspectProcessStart)(pid));
+		return starts.get(pid);
+	};
+	const derived = join(runnerRoot, "derived");
+	const platforms = directories(derived).flatMap((platform) => {
+		const dir = join(derived, platform);
+		const entries = directories(dir).filter((name) => name.startsWith("cache-") && !name.endsWith(".lock")).map((name) => {
+			const entryDir = join(dir, name);
+			let mtime = null;
+			try {
+				mtime = statSync(entryDir).mtimeMs;
+			} catch {}
+			return Object.assign({
+				name,
+				dir: entryDir,
+				bytes: null,
+				lastUsedAt: runnerLastUsedAt(readText(join(entryDir, "info.plist")), mtime)
+			}, parseRunnerMetadata(readText(join(entryDir, ".agent-device-runner-cache.json"))), runnerInUse(canonical(entryDir), leases, unreadable, readRunnerLock(`${entryDir}.lock`), startOf));
+		});
+		return entries.length ? [{
+			platform,
+			dir,
+			bytes: null,
+			entries
+		}] : [];
+	});
+	const statePresent = existsSync(stateDir);
+	const runnerPresent = existsSync(runnerRoot);
+	const absent = new Set([
+		join(stateDir, "sessions"),
+		join(stateDir, "logs"),
+		derived
+	].filter((dir) => !existsSync(dir)));
+	const otherChildren = children(stateDir).filter((name) => ![
+		"sessions",
+		"logs",
+		"apple-runner"
+	].includes(name)).map((name) => {
+		let bytes = null;
+		try {
+			const stat = statSync(join(stateDir, name));
+			if (stat.isFile() && typeof stat.blocks === "number") bytes = stat.blocks * 512;
+		} catch {}
+		return {
+			name,
+			bytes
+		};
+	});
+	return {
+		roots,
+		statePresent,
+		runnerPresent,
+		sessionsCount: directories(join(stateDir, "sessions")).length,
+		otherChildren,
+		platforms,
+		workspaces,
+		hosted: existsSync(hostedDir) ? {
+			dir: hostedDir,
+			bytes: null,
+			sessions: directories(hostedDir).length
+		} : null,
+		absent
+	};
+}
+async function getAgentDeviceUsage({ maxAgeMs = MAX_AGE_MS } = {}) {
+	const tree = discover();
+	const cached = readAgentDeviceUsageCache();
+	const age = cached ? Date.now() - Date.parse(cached.usage.measuredAt) : Infinity;
+	if (cached && age >= 0 && age < maxAgeMs && JSON.stringify(cached.roots) === JSON.stringify(tree.roots)) return cached.usage;
+	const sizes = /* @__PURE__ */ new Map();
+	let complete = true;
+	const measure = async (args) => {
+		const result = await measureDu(args);
+		complete &&= result.complete;
+		for (const [dir, bytes] of result.sizes) sizes.set(dir, bytes);
+	};
+	if (tree.statePresent) await measure([
+		"-k",
+		"-d",
+		"4",
+		tree.roots.stateDir
+	]);
+	if (tree.runnerPresent && !contains(tree.roots.stateDir, tree.roots.runnerRoot)) await measure([
+		"-k",
+		"-d",
+		"4",
+		tree.roots.runnerRoot
+	]);
+	const extra = [...tree.roots.workspaceDirs, ...tree.hosted ? [tree.hosted.dir] : []];
+	if (extra.length) await measure(["-sk", ...extra]);
+	const usage = assembleAgentDeviceUsage(tree, sizes, complete, (/* @__PURE__ */ new Date()).toISOString());
+	writeUsageCache(agentDeviceUsageFile(), {
+		...usage,
+		roots: tree.roots
+	});
+	return usage;
+}
+//#endregion
+//#region src/devices/swiftpm-cache-usage-output.ts
+function swiftpmCacheLines(usage, now = Date.now()) {
+	if (!usage?.present) return [];
+	return [
+		`SwiftPM cache (${usage.bytes === null ? "unknown" : formatBytes(usage.bytes).replace(/([KMG])$/, " $1B")}${usage.complete ? "" : ", incomplete"}) - measured ${formatLongDuration(Math.max(0, now - Date.parse(usage.measuredAt)))} ago`,
+		`  ${usage.dir}`,
+		chalk.dim("  shared by every SwiftPM build on this machine; Stim reports it and never deletes it")
+	];
+}
+//#endregion
+//#region src/devices/agent-device-usage-output.ts
+const size = (bytes) => bytes === null ? "unknown" : formatBytes(bytes);
+function agentDeviceLines(usage, detailed = false, now = Date.now()) {
+	if (!usage || !usage.stateDir.present && !usage.runnerBuilds.present && !usage.workspaces.length && !usage.hosted) return [];
+	const lines = [`agent-device (${formatBytes(usage.bytes)}${usage.complete ? "" : ", incomplete"}) - measured ${formatLongDuration(Math.max(0, now - Date.parse(usage.measuredAt)))} ago`];
+	lines.push(`  runner builds: ${size(usage.runnerBuilds.bytes)}`);
+	for (const platform of usage.runnerBuilds.platforms) {
+		lines.push(`    ${platform.platform}: ${size(platform.bytes)}, ${platform.entries.length} entries, ${platform.entries.filter((entry) => entry.inUse).length} in use`);
+		if (detailed) for (const entry of platform.entries) {
+			const details = [
+				entry.lastUsedAt ? `last use ${entry.lastUsedAt.slice(0, 10)}` : "last use unknown",
+				entry.packageVersion ? `agent-device ${entry.packageVersion}` : null,
+				entry.xcodeBuildVersion ? `Xcode ${entry.xcodeBuildVersion}` : null,
+				entry.inUse ? `in use (${entry.inUseReason})` : null
+			].filter(Boolean);
+			lines.push(`      ${entry.name}: ${size(entry.bytes)}, ${details.join(", ")}`, `        ${entry.dir}`);
+		}
+	}
+	const { sessions, logs, other } = usage.stateDir;
+	lines.push(`  sessions: ${size(sessions.bytes)}, ${sessions.count} entries`, `  logs: ${size(logs.bytes)}`, `  other: ${size(other.bytes)}`);
+	if (detailed) for (const entry of other.largest) lines.push(`    ${entry.name}: ${size(entry.bytes)}`);
+	const knownWorkspaceBytes = usage.workspaces.reduce((sum, entry) => sum + (entry.bytes ?? 0), 0);
+	if (usage.workspaces.length) {
+		lines.push(`  workspaces: ${usage.workspaces.length}, ${usage.workspaces.some((entry) => entry.bytes === null) ? "at least " : ""}${formatBytes(knownWorkspaceBytes)}`);
+		if (detailed) for (const entry of usage.workspaces) lines.push(`    ${entry.dir}: ${size(entry.bytes)}`);
+	}
+	if (usage.hosted) lines.push(`  stim-server hosted: ${size(usage.hosted.bytes)}${detailed ? `, ${usage.hosted.sessions} entries, ${usage.hosted.dir}` : ""}`);
+	if (detailed) lines.push("  Stim never trims or deletes the shared runner builds, sessions, logs and other state or the hosted driver dir; a workspace's own agent-device dir goes only with its workspace.", "  A lease flag identifies a live owner or runner; a lock flag identifies a live or unverified lock owner, and unreadable flags conservatively keep entries in use.", "  Clear the rest with agent-device's own tooling or by removing the directories yourself.");
+	return lines;
+}
+//#endregion
+export { getSwiftpmCacheUsage as i, swiftpmCacheLines as n, getAgentDeviceUsage as r, agentDeviceLines as t };