stim 1.14.0 → 1.16.0

package/dist/workspace-state-B8-aJ1_5.mjs

@@ -0,0 +1,371 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { join as join$1, resolve as resolve$1 } from "path";
+import { buildCacheRoot as sharedBuildCache, withDirLock as withDirLock$1, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+import { WORKSPACE_AGENT_KEY, emulatorLogFile, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache as sharedCcache$1, sharedCompilationCache as sharedCompilationCache$1, supervisorLogFile, supervisorPidFile, workspaceAgentDeviceDir, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir as workspaceLogsDir$1, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/agent-sessions.ts
+const TITLE_MAX_LENGTH = 120;
+const SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const CODEX_ACTIVE_MS = 18e5;
+const CODEX_QUERY_TIMEOUT_MS = 5e3;
+const COMMAND_ATTRIBUTION_MS = 18e5;
+/**
+* Claude desktop opens a Claude Code session with `claude://code/continue?session=<id>`, and accepts only its own
+* `local_` session ids there, which a session file carries as `hostSessionId` when the desktop app hosts the session.
+*/
+const CLAUDE_DESKTOP_SESSION = /^local_[A-Za-z0-9-]{1,64}$/;
+/**
+* Claude Code writes a Remote Control session's claude.ai id to its session file as `bridgeSessionId`, and prints
+* `https://claude.ai/code/<id>` as the session URL, which the Claude mobile app also opens as a universal link.
+*/
+const CLAUDE_REMOTE_SESSION = /^session_[A-Za-z0-9]{1,64}$/;
+function shortTitle(value) {
+	if (typeof value !== "string") return void 0;
+	const title = value.replace(/\p{Cc}+/gu, " ").replace(/\s+/g, " ").trim();
+	if (!title) return void 0;
+	return title.length > TITLE_MAX_LENGTH ? `${title.slice(0, 117)}...` : title;
+}
+function isoFromMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? new Date(value).toISOString() : void 0;
+}
+function withOptional(session, fields) {
+	for (const [key, value] of Object.entries(fields)) if (value !== void 0) Object.assign(session, { [key]: value });
+	return session;
+}
+/** The agent session a shell's environment names, from `CLAUDE_CODE_SESSION_ID` or `CODEX_THREAD_ID`. */
+function agentFromEnv(env) {
+	const claude = env.CLAUDE_CODE_SESSION_ID?.trim();
+	if (claude && SESSION_ID.test(claude)) return {
+		tool: "claude-code",
+		sessionId: claude
+	};
+	const codex = env.CODEX_THREAD_ID?.trim();
+	if (codex && SESSION_ID.test(codex)) return {
+		tool: "codex",
+		sessionId: codex
+	};
+	return null;
+}
+/**
+* A Claude Code session from one `~/.claude/sessions/<pid>.json` file, or null when the entry lacks a pid, session id
+* or absolute cwd. The format is Claude Code's own and undocumented, so every other field is optional.
+*/
+function parseClaudeSession(entry, apps) {
+	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+	const raw = entry;
+	if (!Number.isSafeInteger(raw.pid) || raw.pid <= 0) return null;
+	if (typeof raw.sessionId !== "string" || !SESSION_ID.test(raw.sessionId)) return null;
+	if (typeof raw.cwd !== "string" || !isAbsolute(raw.cwd)) return null;
+	const host = raw.hostSessionId;
+	const bridge = raw.bridgeSessionId;
+	return withOptional({
+		tool: "claude-code",
+		sessionId: raw.sessionId,
+		cwd: raw.cwd
+	}, {
+		title: shortTitle(raw.name),
+		startedAt: isoFromMs(raw.startedAt),
+		lastActiveAt: isoFromMs(raw.updatedAt),
+		pid: raw.pid,
+		openUrl: apps.claude && typeof host === "string" && CLAUDE_DESKTOP_SESSION.test(host) ? `claude://code/continue?session=${host}` : void 0,
+		webUrl: typeof bridge === "string" && CLAUDE_REMOTE_SESSION.test(bridge) ? `https://claude.ai/code/${bridge}` : void 0
+	});
+}
+function isSubagentSource(source) {
+	if (typeof source !== "string" || !source.startsWith("{")) return false;
+	try {
+		const parsed = JSON.parse(source);
+		return Boolean(parsed && typeof parsed === "object" && "subagent" in parsed);
+	} catch {
+		return false;
+	}
+}
+/**
+* Codex threads from rows of its `threads` table. `name` is the thread's short name; `title` there is the first
+* prompt, so it is never read. Subagent threads, which Codex spawns inside a thread, are left out.
+*/
+function parseCodexThreads(rows, apps) {
+	if (!Array.isArray(rows)) return [];
+	return rows.flatMap((row) => {
+		if (!row || typeof row !== "object") return [];
+		const raw = row;
+		if (typeof raw.id !== "string" || !SESSION_ID.test(raw.id)) return [];
+		if (typeof raw.cwd !== "string" || !isAbsolute(raw.cwd) || isSubagentSource(raw.source)) return [];
+		return [withOptional({
+			tool: "codex",
+			sessionId: raw.id,
+			cwd: raw.cwd
+		}, {
+			title: shortTitle(raw.name),
+			startedAt: isoFromMs(raw.created_at_ms),
+			lastActiveAt: isoFromMs(raw.updated_at_ms),
+			openUrl: apps.codex ? `codex://threads/${raw.id}` : void 0
+		})];
+	});
+}
+function codexStateDatabase(names) {
+	let best = null;
+	for (const name of names) {
+		const version = Number(/^state_(\d+)\.sqlite$/.exec(name)?.[1]);
+		if (Number.isFinite(version) && (!best || version > best.version)) best = {
+			name,
+			version
+		};
+	}
+	return best?.name ?? null;
+}
+const APP_BUNDLES = {
+	claude: {
+		names: ["Claude"],
+		bundleId: "com.anthropic.claudefordesktop"
+	},
+	codex: {
+		names: ["ChatGPT", "Codex"],
+		bundleId: "com.openai.codex"
+	}
+};
+function bundleInstalled(home, { names, bundleId }) {
+	for (const folder of ["/Applications", join(home, "Applications")]) for (const name of names) try {
+		if (readFileSync(join(folder, `${name}.app`, "Contents", "Info.plist"), "latin1").includes(bundleId)) return true;
+	} catch {}
+	return false;
+}
+function installedAgentApps(home = homedir()) {
+	if (process.platform !== "darwin") return {
+		claude: false,
+		codex: false
+	};
+	return {
+		claude: bundleInstalled(home, APP_BUNDLES.claude),
+		codex: bundleInstalled(home, APP_BUNDLES.codex)
+	};
+}
+function canonical(session) {
+	try {
+		return {
+			...session,
+			cwd: realpathSync(session.cwd)
+		};
+	} catch {
+		return null;
+	}
+}
+function sessionProcessRuns(session) {
+	const start = (0, process_identity_exports.inspectProcessStart)(session.pid);
+	if (start.status === "gone") return false;
+	if (start.status === "unknown" || !session.startedAt) return true;
+	return start.startedAtMs <= Date.parse(session.startedAt) + 2e3;
+}
+async function claudeSessions(home, apps) {
+	const directory = join(home, ".claude", "sessions");
+	let names;
+	try {
+		names = (await readdir(directory)).filter((name) => name.endsWith(".json"));
+	} catch {
+		return [];
+	}
+	return (await Promise.all(names.map(async (name) => {
+		try {
+			const session = parseClaudeSession(JSON.parse(await readFile(join(directory, name), "utf8")), apps);
+			return session && sessionProcessRuns(session) ? canonical(session) : null;
+		} catch {
+			return null;
+		}
+	}))).filter((session) => session !== null);
+}
+const CODEX_QUERY = `const { DatabaseSync } = require('node:sqlite');
+const db = new DatabaseSync(process.argv[1], { readOnly: true });
+const rows = db.prepare('SELECT id, cwd, name, source, created_at_ms, updated_at_ms FROM threads WHERE archived = 0 AND updated_at_ms >= ? AND source NOT LIKE ? ORDER BY updated_at_ms DESC LIMIT 50').all(Number(process.argv[2]), '%"subagent"%');
+db.close();
+process.stdout.write(JSON.stringify(rows));`;
+async function codexSessions(codexHome, apps, now) {
+	let database;
+	try {
+		database = codexStateDatabase(await readdir(codexHome));
+	} catch {
+		return [];
+	}
+	if (!database) return [];
+	try {
+		const out = await getExecutor().runFileAsync(process.execPath, [
+			"--no-warnings",
+			"--experimental-sqlite",
+			"-e",
+			CODEX_QUERY,
+			join(codexHome, database),
+			String(now - CODEX_ACTIVE_MS)
+		], { timeoutMs: CODEX_QUERY_TIMEOUT_MS });
+		return parseCodexThreads(JSON.parse(out), apps).map(canonical).filter((session) => session !== null);
+	} catch {
+		return [];
+	}
+}
+/**
+* The Claude Code sessions whose process runs and the Codex threads updated in the last 30 minutes, with canonical
+* working directories. Every source is optional: a missing, unreadable or changed format yields no sessions from it.
+*/
+async function discoverAgentSessions({ home = homedir(), codexHome = process.env.CODEX_HOME || join(home, ".codex"), apps = installedAgentApps(home), now = Date.now() } = {}) {
+	const [claude, codex] = await Promise.all([claudeSessions(home, apps), codexSessions(codexHome, apps, now)]);
+	return [...claude, ...codex];
+}
+function within(directory, candidate) {
+	const path = relative(directory, candidate);
+	return path === "" || !path.startsWith("..") && !isAbsolute(path);
+}
+function agentKey(session) {
+	return `${session.tool}:${session.sessionId}`;
+}
+function activeAt(session) {
+	const at = Date.parse(session.lastActiveAt ?? "");
+	return Number.isFinite(at) ? at : -Infinity;
+}
+/**
+* The sessions working in each workspace, most recently active first. A session belongs to the deepest workspace
+* whose path holds its cwd, and to every workspace whose git worktree root is its cwd. A workspace's recorded session
+* is added with the discovered session's details when it is running, or on its own for `COMMAND_ATTRIBUTION_MS`
+* after the command.
+*/
+function attributeAgentSessions(workspaces, sessions, now) {
+	const found = workspaces.map(() => /* @__PURE__ */ new Map());
+	for (const session of sessions) {
+		const holders = workspaces.flatMap((workspace, i) => within(workspace.path, session.cwd) ? [i] : []);
+		const deepest = Math.max(-1, ...holders.map((i) => workspaces[i].path.length));
+		workspaces.forEach((workspace, i) => {
+			if (holders.includes(i) && workspace.path.length === deepest || workspace.root === session.cwd) found[i].set(agentKey(session), session);
+		});
+	}
+	workspaces.forEach(({ recorded }, i) => {
+		if (!recorded) return;
+		const running = found[i].get(agentKey(recorded)) ?? sessions.find((session) => agentKey(session) === agentKey(recorded));
+		if (running) {
+			const newer = activeAt(recorded) > activeAt(running);
+			found[i].set(agentKey(recorded), newer ? {
+				...running,
+				lastActiveAt: recorded.lastActiveAt
+			} : running);
+		} else if (now - activeAt(recorded) <= COMMAND_ATTRIBUTION_MS) found[i].set(agentKey(recorded), recorded);
+	});
+	return found.map((map) => [...map.values()].toSorted((a, b) => activeAt(b) - activeAt(a)));
+}
+//#endregion
+//#region src/workspace/paths.ts
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve$1(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	mkdirSync(dir, { recursive: true });
+	return withDirLock$1(join$1(dir, "metadata.lock"), () => {
+		if (!existsSync(file)) {
+			const metadata = {
+				projectRoot: canonicalRoot,
+				workspace: workspaceName$1(canonicalRoot),
+				version: 1
+			};
+			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
+			try {
+				renameSync(tmp, file);
+			} catch (error) {
+				rmSync(tmp, { force: true });
+				throw error;
+			}
+			return dir;
+		}
+		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
+		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
+		error.code = "STIM_WORKSPACE_COLLISION";
+		throw error;
+	});
+}
+//#endregion
+//#region src/workspace/workspace-state.ts
+function withWorkspaceStateLock(root, fn) {
+	const file = workspaceStateFile(root);
+	return withDirLock$1(workspaceStateLock(root), fn, { ensureParent: () => {
+		ensureWorkspaceStorage(root);
+		mkdirSync(dirname(file), { recursive: true });
+	} });
+}
+function writeWorkspaceState(root, patch) {
+	return updateWorkspaceState(root, (state) => ({
+		...state,
+		...patch
+	}));
+}
+function updateWorkspaceState(root, update) {
+	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
+}
+function replaceWorkspaceState(root, state) {
+	const file = workspaceStateFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, { mode: 384 });
+	renameSync(tmp, file);
+	return state;
+}
+function clearWorkspaceStateKeys(root, keys) {
+	if (!existsSync(workspaceStateFile(root))) return;
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		const file = workspaceStateFile(root);
+		if (!state) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return;
+		}
+		let changed = false;
+		for (const key of keys) {
+			if (!(key in state)) continue;
+			delete state[key];
+			changed = true;
+		}
+		if (!changed) return;
+		if (Object.keys(state).length === 0) {
+			rmSync(file, { force: true });
+			return;
+		}
+		replaceWorkspaceState(root, state);
+	});
+}
+function clearWorkspaceStateKey(root, key, shouldClear) {
+	return withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		if (!state || !(key in state)) return true;
+		if (!shouldClear(state[key])) return false;
+		delete state[key];
+		const file = workspaceStateFile(root);
+		if (Object.keys(state).length === 0) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return true;
+		}
+		replaceWorkspaceState(root, state);
+		return true;
+	});
+}
+/** Records a command's use of the workspace, and the agent session whose shell ran it when there is one. */
+function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date(), env = process.env) {
+	const agent = agentFromEnv(env);
+	let cwd = process.cwd();
+	try {
+		cwd = realpathSync(cwd);
+	} catch {}
+	try {
+		writeWorkspaceState(root, {
+			lastUsedAt: now.toISOString(),
+			...agent ? { [WORKSPACE_AGENT_KEY]: {
+				...agent,
+				cwd,
+				lastActiveAt: now.toISOString()
+			} } : {}
+		});
+	} catch {}
+}
+//#endregion
+export { workspaceStateFile as C, discoverAgentSessions as D, attributeAgentSessions as E, workspaceName$1 as S, agentKey as T, workspaceDerivedData as _, updateWorkspaceState as a, workspaceLogErrorIndex as b, writeWorkspaceState as c, sharedBuildCache as d, sharedCcache$1 as f, workspaceAgentDeviceDir as g, supervisorPidFile as h, recordWorkspaceUse as i, emulatorLogFile as l, supervisorLogFile as m, clearWorkspaceStateKeys as n, withWorkspaceStateLock as o, sharedCompilationCache$1 as p, readWorkspaceState$1 as r, workspaceLastUsed as s, clearWorkspaceStateKey as t, ensureWorkspaceStorage as u, workspaceDir as v, withDirLock$1 as w, workspaceLogsDir$1 as x, workspaceId as y };

package/dist/workspaces-BV4pdHFz.mjs

@@ -0,0 +1,306 @@
+import { M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix, j as formatBytes } from "./config-D0DbpZtM.mjs";
+import { S as workspaceName, s as workspaceLastUsed } from "./workspace-state-B8-aJ1_5.mjs";
+import { i as recordGcResult, n as withIdleWorkspace, o as canonicalPath, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-DvBw0Kxo.mjs";
+import { a as teardownOwnedBrowser } from "./teardown-CL6vDs2Y.mjs";
+import { existsSync, lstatSync, readdirSync, rmSync, statSync } from "fs";
+import { basename, isAbsolute, join, relative } from "path";
+import { isJsonObject, readJsonFile } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/gc/workspaces.ts
+function workspacesRoot() {
+	return join(getConfigDir(), "workspaces");
+}
+function isInsideWorkspaces(dir) {
+	const rel = relative(canonicalPath(workspacesRoot()), canonicalPath(dir));
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function readRecordedRoot(dir, name) {
+	let parsed;
+	try {
+		parsed = readJsonFile(join(dir, "workspace.json"));
+	} catch (error) {
+		return {
+			projectRoot: null,
+			problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
+		};
+	}
+	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
+	if (typeof projectRoot !== "string" || !isAbsolute(projectRoot)) return {
+		projectRoot: null,
+		problem: "its workspace.json records no absolute project root"
+	};
+	if (workspaceName(projectRoot) !== name) return {
+		projectRoot: null,
+		problem: `its workspace.json records ${projectRoot}, whose workspace directory has another name`
+	};
+	return {
+		projectRoot,
+		problem: null
+	};
+}
+function listWorkspaceDirs() {
+	const root = workspacesRoot();
+	let names;
+	try {
+		names = readdirSync(root).toSorted();
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const name of names) {
+		const dir = join(root, name);
+		try {
+			if (!statSync(dir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		entries.push({
+			dir,
+			...readRecordedRoot(dir, name)
+		});
+	}
+	return entries;
+}
+function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse }) {
+	const orphaned = [];
+	const skipped = [];
+	for (const { dir, projectRoot, problem } of entries) {
+		if (projectRoot === null) {
+			skipped.push({
+				dir,
+				reason: `workspace directory not resolved: ${problem ?? "unknown project root"}`
+			});
+			continue;
+		}
+		const present = exists(projectRoot);
+		if (present === null) {
+			skipped.push({
+				dir,
+				reason: `cannot tell whether its project root ${projectRoot} still exists`
+			});
+			continue;
+		}
+		if (present) continue;
+		if (registryKeys.some((key) => isPathPrefix(projectRoot, key))) continue;
+		if (!isMounted(projectRoot)) {
+			skipped.push({
+				dir,
+				reason: `the volume of its project root ${projectRoot} is not mounted`
+			});
+			continue;
+		}
+		const reasons = inUse(projectRoot);
+		if (reasons.length) {
+			skipped.push({
+				dir,
+				reason: `its project root ${projectRoot} is gone, but ${reasons.join("; ")}`
+			});
+			continue;
+		}
+		orphaned.push({
+			dir,
+			projectRoot
+		});
+	}
+	return {
+		orphaned,
+		skipped
+	};
+}
+function rootPresence(path) {
+	try {
+		lstatSync(path);
+		return true;
+	} catch (error) {
+		const code = error?.code;
+		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
+	}
+}
+function collectOrphanedWorkspaces(registryKeys, mountedVolumes, { measure = true } = {}) {
+	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
+		registryKeys,
+		exists: rootPresence,
+		isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
+		inUse: (root) => workspaceInUse(root)
+	});
+	return {
+		orphaned: measure ? classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })) : classified.orphaned,
+		skipped: classified.skipped
+	};
+}
+const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift. The next stim macos in a cleared workspace is a full Swift build.";
+const WORKSPACE_OUTPUT_DIRS = [
+	"derived-data",
+	"gradle-build",
+	"android-cas",
+	"cache-provider"
+];
+const DAY_MS = 864e5;
+function planWorkspaceOutputs(entries, { olderThan, now }) {
+	return entries.map(({ dir, projectRoot, problem, bytes, lastUsed, inUse }) => {
+		const idleDays = Number.isFinite(lastUsed) ? Math.max(0, Math.floor((now - lastUsed) / DAY_MS)) : null;
+		const [keptCode, keptReason] = projectRoot === null ? ["unresolved", `workspace directory not resolved: ${problem ?? "unknown project root"}`] : inUse.length ? ["in-use", `in use: ${inUse.join("; ")}`] : olderThan === null ? [null, null] : idleDays === null ? ["last-use-unknown", "its last use is unknown"] : idleDays < olderThan ? ["recently-used", `used ${idleDays}d ago, within --older-than ${olderThan}`] : [null, null];
+		return {
+			dir,
+			projectRoot,
+			bytes,
+			idleDays,
+			willClear: keptCode === null,
+			keptCode,
+			keptReason
+		};
+	});
+}
+const SIZE_TIMEOUT_MS = 6e4;
+function sizeOf(dir, timeoutMs = SIZE_TIMEOUT_MS) {
+	return measuredDirectorySize(dir, { timeoutMs });
+}
+function outputPaths(dir) {
+	const paths = WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync(path));
+	const macos = join(dir, "macos");
+	try {
+		if (!lstatSync(macos).isDirectory()) return paths;
+		for (const entry of readdirSync(macos, { withFileTypes: true })) if (entry.name === "build" || entry.name.endsWith(".app") || entry.name.startsWith("staging-") && entry.isDirectory()) paths.push(join(macos, entry.name));
+	} catch {}
+	return paths;
+}
+function outputBytes(paths, timeoutMs) {
+	let total = 0;
+	for (const path of paths) {
+		const size = sizeOf(path, timeoutMs);
+		if (size === null) return null;
+		total += size;
+	}
+	return total;
+}
+function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS }) {
+	const mountedVolumes = listMountedVolumes();
+	const entries = listWorkspaceDirs().filter((entry) => !exclude.includes(entry.dir)).filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => Object.assign({}, entry, { paths: outputPaths(entry.dir) })).filter((entry) => entry.paths.length > 0).map(({ paths, ...entry }) => Object.assign({}, entry, { bytes: measure ? outputBytes(paths, sizeTimeoutMs) : null })).map((entry) => Object.assign({}, entry, {
+		lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
+		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
+	}));
+	return {
+		root: workspacesRoot(),
+		workspaces: planWorkspaceOutputs(entries, {
+			olderThan,
+			now
+		})
+	};
+}
+async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
+	let failures = 0;
+	let cleared = 0;
+	const clearedRoots = [];
+	for (const entry of report.workspaces) {
+		const root = entry.projectRoot;
+		if (!entry.willClear || root === null) {
+			if (entry.keptReason) {
+				console.log(chalk.dim(`Kept the build outputs of ${root ?? entry.dir}: ${entry.keptReason}`));
+				recordGcResult("workspaceOutputs", "kept", root ?? entry.dir, {
+					bytes: entry.bytes,
+					detail: entry.keptReason
+				});
+			}
+			continue;
+		}
+		let run;
+		try {
+			run = await withIdleWorkspace(root, () => {
+				const [again] = planWorkspaceOutputs([{
+					...entry,
+					problem: null,
+					lastUsed: workspaceLastUsed(root),
+					inUse: []
+				}], {
+					olderThan,
+					now
+				});
+				if (again?.keptReason) return again.keptReason;
+				for (const path of outputPaths(entry.dir)) rmSync(path, {
+					recursive: true,
+					force: true
+				});
+				return null;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not clear the build outputs of ${root}: ${error?.message || String(error)}`));
+			recordGcResult("workspaceOutputs", "failed", root, {
+				bytes: entry.bytes,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		const kept = run.ran ? run.value : `in use: ${run.reasons.join("; ")}`;
+		if (kept) {
+			console.log(chalk.yellow(`Kept the build outputs of ${root}: ${kept}`));
+			recordGcResult("workspaceOutputs", "kept", root, {
+				bytes: entry.bytes,
+				detail: kept
+			});
+			continue;
+		}
+		cleared += entry.bytes ?? 0;
+		clearedRoots.push(root);
+		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+		recordGcResult("workspaceOutputs", "done", root, { bytes: entry.bytes });
+	}
+	if (cleared) console.log(chalk.dim(`Cleared ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
+	return {
+		failures,
+		cleared: clearedRoots
+	};
+}
+function stillOrphaned({ dir, projectRoot }) {
+	if (readRecordedRoot(dir, basename(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
+	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
+}
+async function deleteOrphanedWorkspaces(orphaned) {
+	let failures = 0;
+	for (const entry of orphaned) {
+		if (!existsSync(entry.dir)) continue;
+		let run;
+		try {
+			run = await withIdleWorkspace(entry.projectRoot, async () => {
+				if (!stillOrphaned(entry)) return false;
+				const browser = await teardownOwnedBrowser(entry.projectRoot, { deleteProfile: true });
+				if (browser.status === "failed" || browser.status === "skipped") throw new Error(`its owned Chrome profile was kept: ${browser.reason}`);
+				emptyWorkspaceDir(entry.dir);
+				return true;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
+			recordGcResult("workspaceDirectory", "failed", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		if (!run.ran) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: run.reasons.join("; ")
+			});
+			continue;
+		}
+		if (!run.value) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: "it can no longer be confirmed orphaned"
+			});
+			continue;
+		}
+		const size = entry.bytes === void 0 ? "" : ` (${sizeText(entry.bytes)})`;
+		console.log(chalk.green(`Removed the orphaned workspace directory ${entry.dir}${size}`));
+		recordGcResult("workspaceDirectory", "done", entry.dir, { bytes: entry.bytes ?? null });
+	}
+	return failures;
+}
+function sizeText(bytes) {
+	return bytes === null ? "size unknown" : formatBytes(bytes);
+}
+//#endregion
+export { collectWorkspaceOutputs as a, listWorkspaceDirs as c, collectOrphanedWorkspaces as i, rootPresence as l, WORKSPACE_OUTPUT_DIRS as n, deleteOrphanedWorkspaces as o, clearWorkspaceOutputs as r, isInsideWorkspaces as s, REBUILD_COST as t, sizeText as u };