stim 1.14.0 → 1.16.0

package/dist/agent-device-usage-output-Dpih1Tfa.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-DnJMdEY-.mjs";
+import { a as envDir, l as processMatches, s as parseAgentDeviceRecord } from "./activity-BxwdD81S.mjs";
+import { c as listWorkspaceDirs } from "./workspaces-BV4pdHFz.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 };