stim 1.20.2 → 1.22.0

package/dist/maintenance-run.mjs

@@ -1,236 +1,19 @@
-import { F as listMountedVolumes, N as formatBytes, P as isOnMountedVolume, _ as loadConfig$1 } from "./config-BYDxlMY3.mjs";
-import { a as unregister, n as readManifest } from "./cache-manifest-XH-fvDUj.mjs";
-import { T as canonicalPath, a as collectWorkspaceOutputs, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, r as clearWorkspaceOutputs, w as takeGcResults } from "./workspaces-C36s2jb9.mjs";
-import { N as emptyCaches, at as discoverCaches, l as resolveBudget, ot as pruneCache, r as cacheLabel, z as planCacheEmptying } from "./budget-f7516Zk0.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-B9C_zeQC.mjs";
-import { F as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-RkW4pnQf.mjs";
+import { P as formatBytes } from "./config-DlrsduwG.mjs";
+import { Tt as deviceSweepIsScoped, u as resolveBudget } from "./budget-Cvwn54qV.mjs";
+import { I as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-hcBpnEGk.mjs";
+import { v as maintenanceLogger } from "./client-OyRoEuSr.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-BwNEtIrP.mjs";
+import { A as levelFloors, C as measureDisk, D as measureSizes, M as lowestFree, O as sizeScanDeferred, T as measurePressure, j as levelStillShort, k as diskPressureLevel } from "./worktree-CHecZ4Oq.mjs";
+import { i as plannedMaintenance, m as measureOwnedDevices, n as diskRecovered, o as triggeringRoot, r as executeAction } from "./act-DsuqEkiM.mjs";
 import { r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
-import { a as maintenancePinned, c as removeWorktrees, d as cacheBlocked, f as measureDisk, h as sizeScanDeferred, i as cacheEntryProtection, m as measureSizes, o as recentUse, p as measurePressure, r as triggeringRoot, t as plannedMaintenance } from "./preview-78a9kR_-.mjs";
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, join, resolve, sep } from "node:path";
-import { MAINTENANCE_LOG_NAME, maintenanceChildLogFile, maintenanceDir, maintenanceNdjsonFile, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState, sharedCompilationCache, workspaceLogsDir } from "@stim-cli/core/state";
-import { fileURLToPath } from "node:url";
-import { LOG_ROTATE_BYTES, buildCacheRoot, metroCacheRoot, rotatedLogPath, withDirLock } from "@stim-cli/core";
 import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
-//#region src/maintenance/act.ts
-const kept = (detail) => ({
-	status: "kept",
-	bytes: 0,
-	detail
-});
-async function quietly(run) {
-	const { log, error } = {
-		log: console.log,
-		error: console.error
-	};
-	const exitCode = process.exitCode;
-	takeGcResults();
-	console.log = () => {};
-	console.error = () => {};
-	try {
-		return {
-			value: await run(),
-			results: takeGcResults()
-		};
-	} finally {
-		console.log = log;
-		console.error = error;
-		process.exitCode = exitCode;
-		takeGcResults();
-	}
-}
-function outcomeOf(results, fallbackBytes) {
-	const failed = results.find((result) => result.status === "failed");
-	if (failed) return {
-		status: "failed",
-		bytes: 0,
-		detail: failed.detail ?? `could not process ${failed.label}`
-	};
-	const done = results.filter((result) => result.status === "done");
-	if (done.length) return {
-		status: "done",
-		bytes: done.reduce((sum, result) => sum + (result.bytes ?? 0), 0) || fallbackBytes,
-		detail: done.map((result) => result.label).join(", ")
-	};
-	return kept(results.find((result) => result.detail)?.detail ?? "nothing was eligible when the action ran");
-}
-function rootCache(dir) {
-	const name = canonicalPath(dir) === canonicalPath(buildCacheRoot()) ? "Build cache" : canonicalPath(dir) === canonicalPath(metroCacheRoot()) ? "Metro transform caches" : null;
-	return name ? {
-		name,
-		dir,
-		prune: "entries",
-		entriesDepth: name === "Build cache" ? 2 : 3,
-		note: ""
-	} : null;
-}
-function cacheOf(action) {
-	const discovered = discoverCaches();
-	if (action.dir) {
-		const dir = canonicalPath(action.dir);
-		return discovered.find((cache) => canonicalPath(cache.dir) === dir) ?? rootCache(action.dir);
-	}
-	return discovered.find((cache) => cacheLabel(cache) === action.target) ?? null;
-}
-function trimCache(action, context) {
-	const cache = cacheOf(action);
-	if (!cache) return kept("it is no longer a cache Stim may trim");
-	const [planned] = planCacheEmptying([cache], false);
-	if (!planned || planned.machineGlobal) return kept(planned?.machineGlobal ?? "it is no longer a cache Stim may trim");
-	const aged = action.olderThanDays !== void 0;
-	const result = pruneCache(cache, {
-		olderThanDays: Math.max(action.olderThanDays ?? 0, context.settings.protectRecentHours / 24),
-		byMtime: true,
-		protect: context.protect ??= cacheEntryProtection(),
-		...aged ? {} : { evictBytes: action.bytes }
-	});
-	if (result.skipped) return kept(result.skipped);
-	if (result.failed) return {
-		status: "failed",
-		bytes: result.bytes,
-		detail: `${result.failed} entries could not be removed`
-	};
-	const protectedNote = result.protectedEntries ? `; ${result.protectedEntries} protected entries kept` : "";
-	if (result.removed === 0) return kept(`no unprotected entry was old enough${protectedNote}`);
-	return {
-		status: "done",
-		bytes: result.bytes,
-		detail: `${result.removed} entries${protectedNote}`,
-		...!aged && result.bytes < action.bytes ? { shortfall: `${action.target} reached ${result.bytes} of ${action.bytes} bytes${protectedNote}` } : {}
-	};
-}
-async function emptyCompilationCache(action, context) {
-	if (!measureDisk().some((disk) => disk.freeMb < context.budget.hardFloorDiskMb)) return kept("free disk is above budget.hardFloorDiskGb, and this cache can only be emptied whole");
-	const dir = sharedCompilationCache();
-	const blocked = cacheBlocked({
-		name: "Swift compilation cache",
-		dir,
-		category: "compilation-cache"
-	});
-	if (blocked) return kept(blocked);
-	const cache = discoverCaches().find((candidate) => canonicalPath(candidate.dir) === canonicalPath(dir));
-	if (cache?.prune !== "atomic") return kept("it is not a registered cache Stim empties whole");
-	const [planned] = planCacheEmptying([{
-		...cache,
-		bytes: action.bytes
-	}], true);
-	const { results } = await quietly(() => emptyCaches(planned ? [planned] : []));
-	return outcomeOf(results, action.bytes);
-}
-async function clearOutputs(action, context) {
-	const root = action.workspace;
-	if (!root) return kept("the action names no workspace");
-	if (root === context.protectedRoot) return kept("the command that started this pass runs in it");
-	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
-	const recent = recentUse(root, context.settings);
-	if (recent) return kept(recent);
-	const olderThan = action.olderThanDays ?? null;
-	const now = Date.now();
-	const report = collectWorkspaceOutputs({
-		olderThan,
-		now,
-		measure: false
-	});
-	const entry = report.workspaces.find((candidate) => candidate.projectRoot && canonicalPath(candidate.projectRoot) === root);
-	if (!entry) return kept("it has no build outputs any more");
-	const { results } = await quietly(() => clearWorkspaceOutputs({
-		...report,
-		workspaces: [entry]
-	}, {
-		olderThan,
-		now
-	}));
-	return outcomeOf(results, action.bytes);
-}
-async function removeWorktree(action, context) {
-	const sweep = context.worktreeSweep;
-	const worktree = sweep?.worktrees.find((candidate) => candidate.path === action.target);
-	if (!sweep || !worktree) return kept("it is not in this pass's worktree check");
-	const path = canonicalPath(worktree.path);
-	if (context.protectedRoot === path || context.protectedRoot.startsWith(`${path}${sep}`)) return kept("the command that started this pass runs inside it");
-	if (worktree.keys.some(maintenancePinned)) return kept("pinned by maintenance.keep");
-	const { results } = await quietly(() => removeWorktrees({
-		...sweep,
-		worktrees: [worktree]
-	}));
-	return outcomeOf(results, 0);
-}
-async function removeOrphan(action) {
-	const orphan = collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes()).orphaned.find((candidate) => candidate.dir === action.target);
-	if (!orphan) return kept("it is no longer an orphaned workspace directory");
-	const { results } = await quietly(() => deleteOrphanedWorkspaces([orphan]));
-	return outcomeOf(results, orphan.bytes ?? 0);
-}
-function unregisterCache(action) {
-	const dir = action.dir ?? action.target;
-	if (existsSync(dir) || !isOnMountedVolume(dir, listMountedVolumes()) || !readManifest().caches.some((c) => c.dir === dir)) return kept("it can no longer be shown to be a stale registration");
-	return unregister(dir) ? {
-		status: "done",
-		bytes: 0,
-		detail: dir
-	} : kept("it was already unregistered");
-}
-async function executeAction(action, context) {
-	switch (action.kind) {
-		case "would-clear-outputs": return clearOutputs(action, context);
-		case "would-trim-cache": return trimCache(action, context);
-		case "would-empty-cache": return emptyCompilationCache(action, context);
-		case "would-remove-worktree": return removeWorktree(action, context);
-		case "would-remove-orphan": return removeOrphan(action);
-		case "would-unregister-cache": return unregisterCache(action);
-		default: return kept("automatic maintenance does not stop devices or dev servers yet");
-	}
-}
-function diskRecovered(budget) {
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	return measureDisk().every((disk) => disk.freeMb >= floor);
-}
-//#endregion
-//#region src/maintenance/log.ts
-function maintenanceLogger(settings, pass, trigger) {
-	const file = maintenanceNdjsonFile();
-	const rotated = rotatedLogPath(file);
-	withDirLock(`${file}.lock`, () => {
-		try {
-			if (Date.now() - statSync(rotated).mtimeMs > settings.logRetentionDays * 864e5) unlinkSync(rotated);
-		} catch {}
-	});
-	const writer = createNdjsonWriter(file, { maxBytes: settings.logMaxMb * 1024 ** 2 });
-	return {
-		write(event, level, msg, fields = {}) {
-			if (level === "debug" && !settings.logChecks) return null;
-			const record = {
-				...fields,
-				ts: Date.now(),
-				src: "maintenance",
-				level,
-				msg,
-				event,
-				pass,
-				trigger,
-				mode: settings.mode === "on" ? "on" : "report"
-			};
-			if (!writer.write(record)) throw writer.lastError ?? /* @__PURE__ */ new Error(`Could not append ${file}`);
-			if (typeof fields.workspace === "string" && [
-				"maintenance_action",
-				"maintenance_failure",
-				"maintenance_skip"
-			].includes(event)) {
-				const workspace = createNdjsonWriter(join(workspaceLogsDir(fields.workspace), MAINTENANCE_LOG_NAME), { maxBytes: LOG_ROTATE_BYTES });
-				try {
-					if (!workspace.write(record)) throw workspace.lastError ?? /* @__PURE__ */ new Error("Could not append workspace maintenance log");
-				} finally {
-					workspace.close();
-				}
-			}
-			return record;
-		},
-		close: () => writer.close()
-	};
-}
-//#endregion
+import { randomBytes } from "node:crypto";
+import { appendFileSync, mkdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { withDirLock } from "@stim-cli/core";
+import { maintenanceChildLogFile, maintenanceDir, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
 //#region src/maintenance/run.ts
 function writeState(state) {
 	mkdirSync(maintenanceDir(), { recursive: true });
@@ -247,14 +30,65 @@ function writeState(state) {
 		}
 	});
 }
+const RESERVE_BYTES = 1048576;
+const reserveFile = () => join(maintenanceDir(), "disk-reserve");
+function releaseReserve() {
+	try {
+		const bytes = statSync(reserveFile()).size;
+		rmSync(reserveFile());
+		return bytes > 0;
+	} catch {
+		return false;
+	}
+}
+function keepReserve() {
+	try {
+		if (statSync(reserveFile()).size === RESERVE_BYTES) return;
+	} catch {}
+	try {
+		mkdirSync(maintenanceDir(), { recursive: true });
+		writeFileSync(reserveFile(), randomBytes(RESERVE_BYTES));
+	} catch {
+		try {
+			rmSync(reserveFile(), { force: true });
+		} catch {}
+	}
+}
+function claimPass(trigger) {
+	const take = () => {
+		const attempt = tryAcquireClaim({
+			root: maintenanceRunClaims(),
+			mode: "exclusive",
+			label: "maintenance",
+			details: { trigger }
+		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		return attempt.acquired;
+	};
+	try {
+		return take();
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && (error.code === "ENOSPC" || error.code === "EDQUOT")) || !releaseReserve()) throw error;
+		return take();
+	}
+}
 const EXECUTION_ORDER = {
 	"would-unregister-cache": 0,
 	"would-remove-orphan": 0,
 	"would-clear-outputs": 1,
+	"would-delete-parked-device": 2,
+	"would-delete-temp-leftovers": 2,
 	"would-trim-cache": 2,
+	"would-clear-build-dirs": 3,
 	"would-empty-cache": 3,
-	"would-remove-worktree": 4
+	"would-remove-worktree": 4,
+	"would-stop-workspace": 5,
+	"would-delete-devices": 5,
+	"would-delete-dependencies": 6,
+	"would-stop-gradle-daemons": 7,
+	"would-delete-gradle-version": 8
 };
+const executionRank = (action) => (action.level ?? 1) * 10 + (EXECUTION_ORDER[action.kind] ?? 9);
 function shrinkSizes(state, action, outcome) {
 	state.sizes = state.sizes.flatMap((size) => {
 		if (action.kind === "would-clear-outputs" && size.category === "workspace-outputs" && size.workspace === action.workspace) return [];
@@ -263,6 +97,7 @@ function shrinkSizes(state, action, outcome) {
 			bytes: Math.max(0, size.bytes - outcome.bytes)
 		}];
 		if (action.kind === "would-empty-cache" && size.dir === action.target) return [];
+		if (action.kind === "would-delete-devices" && outcome.status === "done" && size.category === "owned-devices" && size.workspace === action.workspace) return [];
 		return [size];
 	});
 }
@@ -275,6 +110,14 @@ function describeDone(action) {
 		case "would-empty-cache": return `Emptied ${action.target}`;
 		case "would-remove-worktree": return `Removed the worktree ${action.target}`;
 		case "would-remove-orphan": return `Removed the orphaned workspace directory ${action.target}`;
+		case "would-delete-parked-device": return `Deleted the parked device ${action.target}`;
+		case "would-delete-temp-leftovers": return `Deleted the recognized leftovers in ${action.target}`;
+		case "would-delete-devices": return `Deleted the owned devices of ${name}`;
+		case "would-clear-build-dirs": return `Cleared the build directory ${action.target}`;
+		case "would-delete-dependencies": return `Deleted the installed dependencies ${action.target}`;
+		case "would-stop-gradle-daemons": return "Stopped idle Gradle and Kotlin daemons";
+		case "would-delete-gradle-version": return `Deleted the unpinned Gradle ${action.target} caches and distributions`;
+		case "would-stop-workspace": return `Stopped ${name} and deleted its owned devices`;
 		default: return `Unregistered the stale cache ${action.target}`;
 	}
 }
@@ -285,14 +128,7 @@ async function runMaintenance(trigger) {
 	const startedAt = Date.now();
 	let claim;
 	try {
-		const attempt = tryAcquireClaim({
-			root: maintenanceRunClaims(),
-			mode: "exclusive",
-			label: "maintenance",
-			details: { trigger }
-		});
-		if (attempt.pending) releaseClaim(attempt.pending);
-		claim = attempt.acquired;
+		claim = claimPass(trigger);
 	} catch (error) {
 		crashLine(error);
 		return;
@@ -313,9 +149,29 @@ async function runMaintenance(trigger) {
 		};
 		const checks = due(state, settings, startedAt);
 		if (checks.length === 0) return;
-		logger = maintenanceLogger(settings, `p-${claim.claimId}`, trigger);
+		let writeError = null;
+		const noteWriteError = (error) => {
+			writeError ??= error instanceof Error ? error.message : String(error);
+		};
+		const keepState = () => {
+			try {
+				writeState(state);
+			} catch (error) {
+				noteWriteError(error);
+			}
+		};
+		try {
+			logger = maintenanceLogger(settings, `p-${claim.claimId}`, trigger);
+		} catch (error) {
+			noteWriteError(error);
+		}
 		const record = (event, level, msg, fields = {}) => {
-			const entry = logger.write(event, level, msg, fields);
+			let entry = null;
+			try {
+				entry = logger?.write(event, level, msg, fields) ?? null;
+			} catch (error) {
+				noteWriteError(error);
+			}
 			if (entry && (event === "maintenance_action" || event === "maintenance_failure" || Array.isArray(fields.blocked) && fields.blocked.length > 0)) state.recent = [...state.recent, entry].slice(-20);
 		};
 		const failures = [];
@@ -332,17 +188,18 @@ async function runMaintenance(trigger) {
 					...state.deferredAt,
 					[check]: Date.now()
 				};
-				writeState(state);
+				keepState();
 				continue;
 			}
 			state.lastAt[check] = Date.now();
 			ran.add(check);
 			delete state.deferredAt?.[check];
-			writeState(state);
+			keepState();
 			try {
 				if (check === "worktree" || check === "sweep") continue;
 				if (check === "pressure") {
 					state.pressure = measurePressure(settings, state.pressure, state.lastAt[check]);
+					state.pressure.diskLevel = diskPressureLevel(lowestFree(state.pressure.disk), budget, settings);
 					const culprits = settings.memoryPressureLevel === "off" ? null : memoryCulpritsUnder(state.pressure.memory.level);
 					if (culprits) state.pressure.memory.culprits = culprits;
 					const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
@@ -361,14 +218,15 @@ async function runMaintenance(trigger) {
 					for (const culprit of state.pressure.memory.culprits ?? []) record("maintenance_check", "info", memoryCulpritAdvice([culprit]), { culprit });
 				} else {
 					measuredSizes = true;
-					state.sizes = measureSizes(state.lastAt[check], (target, workspace) => {
+					const measureFailed = (target, workspace) => {
 						failures.push(`Could not measure ${target}`);
 						record("maintenance_failure", "error", `Could not measure ${target}`, {
 							target,
 							error: "du failed or timed out",
 							...workspace ? { workspace } : {}
 						});
-					});
+					};
+					state.sizes = [...await measureSizes(state.lastAt[check], measureFailed), ...deviceSweepIsScoped() ? [] : await measureOwnedDevices(state.lastAt[check], measureFailed)];
 					for (const size of state.sizes) record("maintenance_check", "debug", `${size.name}: ${formatBytes(size.bytes)}`, {
 						check: {
 							kind: `size:${size.category}`,
@@ -412,10 +270,11 @@ async function runMaintenance(trigger) {
 				settings,
 				budget,
 				protectedRoot: triggeringRoot(),
-				worktreeSweep: result.worktreeSweep
+				worktreeSweep: result.worktreeSweep,
+				pressureSweep: result.pressureSweep
 			};
 			const results = [];
-			const ordered = actions.toSorted((a, b) => (EXECUTION_ORDER[a.kind] ?? 9) - (EXECUTION_ORDER[b.kind] ?? 9));
+			const ordered = actions.toSorted((a, b) => executionRank(a) - executionRank(b));
 			for (const action of ordered) {
 				const began = Date.now();
 				let outcome;
@@ -424,6 +283,10 @@ async function runMaintenance(trigger) {
 						status: "kept",
 						bytes: 0,
 						detail: "free disk recovered before this action"
+					} : action.level !== void 0 && !levelStillShort(action, lowestFree(measureDisk()), budget, settings) ? {
+						status: "kept",
+						bytes: 0,
+						detail: `free disk is back above the level ${action.level} floor`
 					} : await executeAction(action, context);
 				} catch (error) {
 					outcome = {
@@ -474,8 +337,15 @@ async function runMaintenance(trigger) {
 			loggedSkips.add(skip.target);
 			record("maintenance_skip", "info", `Kept ${skip.target}: ${skip.reason}`, skip);
 		}
+		if (writeError) failures.push(`Could not write the maintenance state or log: ${writeError}`);
+		if (settings.mode !== "on" && state.pressure?.diskLevel === 3) failures.push(criticalLine(state.pressure.disk, budget, settings));
 		if (settings.mode === "on") {
 			const outcomes = await executePlan(result.actions);
+			if (state.pressure) {
+				state.pressure.disk = measureDisk();
+				state.pressure.diskLevel = diskPressureLevel(lowestFree(state.pressure.disk), budget, settings);
+				if (state.pressure.diskLevel === 3) failures.push(criticalLine(state.pressure.disk, budget, settings));
+			}
 			const blockedNow = [
 				...result.blocked,
 				...failures,
@@ -498,7 +368,7 @@ async function runMaintenance(trigger) {
 				blocked: blockedNow
 			};
 			const blockedChanged = !sameSet(new Set((previousBlocked ?? []).map(stableText)), new Set(state.lastPass.blocked.map(stableText)));
-			if (done.length || measuredSizes || blockedChanged) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Pass: ${done.length} actions, ${formatBytes(freedBytes)} freed${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
+			if (done.length || measuredSizes || blockedChanged || (state.pressure?.diskLevel ?? 0) > 0) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Pass: ${done.length} actions, ${formatBytes(freedBytes)} freed${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
 		} else {
 			const blocked = [...result.blocked, ...failures];
 			const planned = [...result.actions, ...retained];
@@ -541,9 +411,14 @@ async function runMaintenance(trigger) {
 		crashLine(error);
 	} finally {
 		logger?.close();
+		keepReserve();
 		releaseClaim(claim);
 	}
 }
+function criticalLine(disk, budget, settings) {
+	const floor = levelFloors(budget, settings)[3];
+	return `disk pressure level 3: ${disk.filter((volume) => volume.freeMb < floor).map((volume) => `${(volume.freeMb / 1024).toFixed(1)}G free on ${volume.volume}`).join(", ")} after this pass, under the ${(floor / 1024).toFixed(1)}G critical floor; builds refuse below budget.hardFloorDiskGb`;
+}
 function crashLine(error) {
 	try {
 		mkdirSync(maintenanceDir(), { recursive: true });