stim 1.15.0 → 1.16.0

package/dist/{worktree-qXKzADSC.mjs → worktree-K-xj9Db0.mjs}

@@ -2,37 +2,466 @@ import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { E as upsertProject, H as projectDeviceSlots, S as removeProject, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, k as acquireAvdClaim, p as getProject } from "./config-D0DbpZtM.mjs";
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { a as pullRequestLookup, r as endedPullRequest } from "./pull-request-pxnDCQzn.mjs";
-import { b as workspaceDir, i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
-import { C as sourceCheckoutOf, S as restoreFile, T as warmWorktreePaths, _ as readWorktreeExclude, b as resolveFullRef, d as hasUncommittedWork, f as isPodInstallChurn, g as podsOutOfSync, h as locallyKnownUpstream, i as depsOutOfSync, l as hasPopulatedSubmodules, m as listWorktrees, n as cloneIgnoredEntries, o as dirtyPaths, r as deleteBranch, s as gitCommonDir, t as branchExists, u as hasRemote, v as removeWorktree, w as unpushedCommits } from "./worktree-C0c5Udwa.mjs";
-import { a as findProjectRoot$1, n as appProjectProblem } from "./project-CV3tDFHl.mjs";
-import { a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, u as readRemoteSession } from "./state-CaeaHbDA.mjs";
-import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-CliHHn7a.mjs";
-import { u as releaseWorkspaceLeases } from "./device-lease-W5Pi1q38.mjs";
+import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-DnJMdEY-.mjs";
+import { $ as cloneIgnoredEntries, A as readCommittedSettings, H as unknownSettingKeys, P as resolveSettings, Q as branchExists, R as settingShapeErrors, St as warmWorktreePaths, _t as resolveFullRef, a as SETTING_SHAPE_REMEDY, at as gitCommonDirOnDisk, bt as sourceCheckoutOf, ct as hasUncommittedWork, dt as listWorktrees, et as deleteBranch, ft as locallyKnownUpstream, ht as removeWorktree, it as gitCommonDir, lt as isPodInstallChurn, mt as readWorktreeExclude, ot as hasPopulatedSubmodules, pt as podsOutOfSync, rt as dirtyPaths, st as hasRemote, tt as depsOutOfSync, xt as unpushedCommits, yt as restoreFile } from "./settings-oTSkkNrM.mjs";
+import { n as appProjectProblem, o as findProjectRoot$1 } from "./project-Du91Ilvc.mjs";
+import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-BeK1ZPz1.mjs";
+import { g as workspaceAgentDeviceDir, i as recordWorkspaceUse, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { o as readWebRecord } from "./state-C1jB7Q8q.mjs";
+import { a as machineNumber } from "./budget-DjrURfQn.mjs";
+import { n as withIdleWorkspace, t as emptyWorkspaceDir } from "./in-use-DvBw0Kxo.mjs";
+import { t as agentDeviceDaemon } from "./activity-BxwdD81S.mjs";
+import { u as releaseWorkspaceLeases } from "./device-lease-D-hLqx1b.mjs";
+import { a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, u as readRemoteSession } from "./state-DcW6vOd_.mjs";
+import { ft as parkedMaxSetting, ot as POOL_SETTING_REMEDY } from "./android-B_NumVyQ.mjs";
 import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Cnz8CPnl.mjs";
-import { at as POOL_SETTING_REMEDY, dt as parkedMaxSetting } from "./android-Db2eEMaf.mjs";
-import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
-import { B as unknownSettingKeys, L as settingShapeErrors, N as resolveSettings, a as SETTING_SHAPE_REMEDY } from "./settings-CduVcoxj.mjs";
-import { a as teardownOwnedBrowser, i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-BYuQafiA.mjs";
-import { t as clearNamedPorts } from "./named-ports-Dj_XBNaL.mjs";
-import { o as readWebRecord } from "./state-DFm77wRn.mjs";
-import { n as withIdleWorkspace, t as emptyWorkspaceDir } from "./in-use-CndPMilN.mjs";
-import { g as withManagedRemoteWorktreeRemovalLock, l as withdrawDevServerStopRequest, p as stopTunnel, s as requestDevServerStop, u as resolveSupervisorTarget, v as withManagedTunnelRemovalLock } from "./stop-cause-CZ_Mr-v9.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-BkYxUtuj.mjs";
-import { C as podInstallCommand, u as HEARTBEAT_INTERVAL_MS } from "./toolchain-DmeYjXD9.mjs";
-import { t as stopMacosApp } from "./stop-Bvf1MflS.mjs";
-import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-BFlKbOIp.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-CO2elm_b.mjs";
-import { i as endRecordedSession } from "./device-remote-9ulPsdhY.mjs";
-import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-BmsjKZ2H.mjs";
-import { a as forgetStatusMeasures, t as startWarmProgress } from "./warm-progress-DVHLN4uC.mjs";
+import { a as teardownOwnedBrowser, i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-CL6vDs2Y.mjs";
+import { t as clearNamedPorts } from "./named-ports-Bk_YXEmE.mjs";
+import { i as stopTunnel, l as withManagedTunnelRemovalLock, s as withManagedRemoteWorktreeRemovalLock, t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-CidxIqup.mjs";
+import { C as podInstallCommand, u as HEARTBEAT_INTERVAL_MS } from "./toolchain-DkUflduf.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-DiA16AsN.mjs";
+import { t as stopMacosApp } from "./stop-B0Yxtmiy.mjs";
+import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-urbmfXig.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-C8-V13XN.mjs";
+import { i as endRecordedSession } from "./device-remote-D5WVWqOq.mjs";
+import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-B6cMXZab.mjs";
+import { a as forgetStatusMeasures, s as mergeState, t as startWarmProgress } from "./warm-progress-CpGv3Wb6.mjs";
+import { r as workspaceRecordingEnabled } from "./recordings-BIXOzVnr.mjs";
+import { r as stopHostedIos } from "./hosted-ios-CIWelIqf.mjs";
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
 import { existsSync as existsSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1 } from "fs";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { workspaceName } from "@stim-cli/core";
-import { LAST_BUILD_KEYS, readMacosRecord } from "@stim-cli/core/state";
+import { withDirLock, workspaceName } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, countErrorEntries, endedAgentSessionOf, listRecordedDevices, loadConfig, queryLogs, readArchives, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sortByTs } from "@stim-cli/core/state";
+import { claimRemoveCommand, clearFreeClaimSet, readClaimSet, releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import chalk from "chalk";
+//#region src/archive.ts
+const DAY = 864e5;
+const KINDS = [
+	"logs",
+	"recordings",
+	"agentActions"
+];
+const KIND_PATH = {
+	logs: "logs",
+	recordings: "recordings",
+	agentActions: "agent-device/sessions"
+};
+function archiveSettings() {
+	const config = loadConfig();
+	return Object.fromEntries([
+		"maxAgeDays",
+		"maxCount",
+		"maxTotalGb",
+		"logs.maxAgeDays",
+		"logs.maxMbPerWorkspace",
+		"recordings.maxAgeDays",
+		"recordings.maxTotalGb",
+		"agentActions.maxAgeDays"
+	].map((key) => {
+		const result = machineNumber(`archive.${key}`, config, process.env);
+		if (result.error) throw new Error(result.error);
+		return [key, result.value];
+	}));
+}
+function enabled(root) {
+	const config = loadConfig();
+	const project = config?.projects?.[root];
+	const present = existsSync(root);
+	const common = present ? gitCommonDirOnDisk(root) : null;
+	if (!present && Object.values(config?.repos ?? {}).some((repo) => repo.settings?.archive?.enabled === false)) return false;
+	return archiveEnabled(process.env, [
+		project?.settings,
+		common ? config?.repos?.[common]?.settings : void 0,
+		present ? readCommittedSettings(root) : void 0,
+		config
+	]);
+}
+function files(dir) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).flatMap((name) => {
+		const path = join(dir, name);
+		const stat = lstatSync(path);
+		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		return stat.isDirectory() ? files(path) : [{
+			path,
+			bytes: stat.size,
+			at: stat.mtimeMs
+		}];
+	});
+}
+function secureTree(dir) {
+	if (lstatSync(dir).isSymbolicLink()) throw new Error(`refusing symlink ${dir}`);
+	chmodSync(dir, 448);
+	for (const name of readdirSync(dir)) {
+		const path = join(dir, name);
+		const stat = lstatSync(path);
+		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		if (stat.isDirectory()) secureTree(path);
+		else chmodSync(path, 384);
+	}
+}
+function writeRecord(dir, record) {
+	const small = [
+		"state.json",
+		"ended-agents.json",
+		"log-error-index.json"
+	].reduce((sum, name) => {
+		const path = join(dir, name);
+		return sum + (existsSync(path) ? statSync(path).size : 0);
+	}, 0);
+	for (let pass = 0; pass < 8; pass++) {
+		record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
+		const bytes = small + Buffer.byteLength(`${JSON.stringify(record)}\n`);
+		if (bytes === record.bytes.record) break;
+		record.bytes.record = bytes;
+	}
+	record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
+	const tmp = join(dir, `.archive-${randomUUID()}.tmp`);
+	try {
+		writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 384 });
+		renameSync(tmp, join(dir, "archive.json"));
+	} finally {
+		rmSync(tmp, { force: true });
+	}
+	const now = /* @__PURE__ */ new Date();
+	utimesSync(archiveRoot(), now, now);
+}
+function removeRecord(id) {
+	const dir = archiveDir(id);
+	if (!existsSync(dir)) return;
+	const removing = join(archiveRoot(), `.removing-${id}`);
+	renameSync(dir, removing);
+	rmSync(removing, {
+		recursive: true,
+		force: true
+	});
+}
+function sweepArchiveStaging(remove, waitMs = 0) {
+	if (!existsSync(archiveRoot())) return [];
+	return withDirLock(archiveLock(), () => readdirSync(archiveRoot()).filter((name) => name.startsWith(".incoming-") && (!name.endsWith(".claims") || !existsSync(join(archiveRoot(), name.slice(0, -7)))) || name.startsWith(".removing-")).flatMap((name) => {
+		const path = join(archiveRoot(), name.endsWith(".claims") ? name.slice(0, -7) : name);
+		const root = `${path}.claims`;
+		const survey = name.startsWith(".incoming-") ? readClaimSet(root) : null;
+		const unresolved = survey?.unresolved[0];
+		const kept = Boolean(survey && (survey.live.length || survey.unresolved.length));
+		const entry = {
+			path,
+			kept,
+			reason: unresolved?.reason ?? (kept ? "live archive writer" : null),
+			removeCommand: unresolved ? claimRemoveCommand(root) : null
+		};
+		if (remove && !kept) {
+			if (!survey || clearFreeClaimSet({
+				root,
+				label: "archive staging"
+			}).status === "cleared") {
+				rmSync(path, {
+					recursive: true,
+					force: true
+				});
+				return [];
+			}
+		}
+		return [entry];
+	}), { waitMs });
+}
+function stripPids(value) {
+	if (Array.isArray(value)) return value.map(stripPids);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([key]) => !/pids?$/i.test(key)).map(([key, child]) => [key, stripPids(child)]));
+	return value;
+}
+function gitFacts(root) {
+	const empty = {
+		repository: null,
+		branch: null,
+		head: null,
+		subject: null,
+		merged: null,
+		pullRequest: null
+	};
+	if (!existsSync(root)) return empty;
+	const exec = getExecutor();
+	const run = (args) => exec.runFileQuiet("git", [
+		"-C",
+		root,
+		...args
+	], { timeoutMs: 1e3 });
+	const common = gitCommonDirOnDisk(root);
+	const summary = run([
+		"show",
+		"-s",
+		"--format=%H%n%s",
+		"HEAD"
+	])?.split("\n");
+	const location = run([
+		"rev-parse",
+		"--show-toplevel",
+		"--abbrev-ref",
+		"HEAD"
+	])?.split("\n");
+	const branch = location?.[1] && location[1] !== "HEAD" ? location[1] : null;
+	const defaultRef = run([
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	]);
+	let merged = null;
+	if (defaultRef?.startsWith("refs/remotes/")) {
+		const state = mergeState(root, {
+			ref: defaultRef,
+			name: defaultRef.slice(13)
+		}, { timeoutMs: 2e3 });
+		merged = state.merged ? true : state.unknown ? null : false;
+	}
+	let prPath = root;
+	try {
+		if (location?.[0]) prPath = realpathSync(location[0]);
+	} catch {}
+	const pr = readPullRequestCache(prPath)?.pullRequest;
+	if (pr?.state === "merged") merged = true;
+	return {
+		repository: common ? basename(common) === ".git" ? dirname(common) : common : null,
+		branch,
+		head: summary?.[0] ?? null,
+		subject: summary?.[1] ?? null,
+		merged,
+		pullRequest: pr ? {
+			number: pr.number,
+			state: pr.state,
+			title: pr.title,
+			url: pr.url
+		} : null
+	};
+}
+function archiveWorkspace(root, removedBy, state = readWorkspaceState(root)) {
+	writeArchive(root, removedBy, state);
+	try {
+		enforceArchiveRetention();
+	} catch (error) {
+		console.error(`could not enforce archive retention: ${String(error?.message ?? error).split("\n")[0]}`);
+	}
+}
+function writeArchive(root, removedBy, state) {
+	let staging = null;
+	let claim;
+	try {
+		const dir = workspaceDir(root);
+		if (!existsSync(dir) || lstatSync(dir).isSymbolicLink()) return;
+		if (existsSync(root)) root = realpathSync(root);
+		try {
+			sweepArchiveStaging(true, 5e3);
+		} catch {}
+		if (!enabled(root)) return;
+		const limits = archiveSettings();
+		if (!limits.maxAgeDays || !limits.maxCount) return;
+		const logs = join(dir, "logs");
+		if (!existsSync(join(dir, "state.json")) && !Object.values(readBuildHistory(state)).some((entries) => entries?.length) && (!existsSync(logs) || readdirSync(logs).length === 0)) return;
+		const worktree = gitFacts(root);
+		mkdirSync(archiveRoot(), {
+			recursive: true,
+			mode: 448
+		});
+		chmodSync(archiveRoot(), 448);
+		const token = randomUUID();
+		staging = join(archiveRoot(), `.incoming-${token}`);
+		const attempt = tryAcquireClaim({
+			root: `${staging}.claims`,
+			mode: "exclusive",
+			label: "archive staging"
+		});
+		claim = attempt.acquired;
+		if (!claim) {
+			releaseClaim(attempt.pending);
+			throw new Error("archive staging claim is held");
+		}
+		withDirLock(archiveLock(), () => {
+			mkdirSync(staging, { mode: 448 });
+			let at = Date.now();
+			const workspace = workspaceName(root);
+			while (existsSync(archiveDir(`${workspace}--${at}`))) at++;
+			const id = `${workspace}--${at}`;
+			if (state) {
+				const { supervisor: _supervisor, collectors: _collectors, warm: _warm, ...stable } = state;
+				writeFileSync(join(staging, "state.json"), `${JSON.stringify(stripPids(stable))}\n`, { mode: 384 });
+			}
+			for (const name of ["ended-agents.json", "log-error-index.json"]) {
+				const data = readJsonObject(join(dir, name));
+				if (data) writeFileSync(join(staging, name), `${JSON.stringify(stripPids(data))}\n`, { mode: 384 });
+			}
+			const move = (kind) => {
+				const from = join(dir, KIND_PATH[kind]);
+				if (!limits[`${kind}.maxAgeDays`] || !existsSync(from)) return;
+				const to = join(staging, KIND_PATH[kind]);
+				mkdirSync(join(to, ".."), {
+					recursive: true,
+					mode: 448
+				});
+				renameSync(from, to);
+				secureTree(to);
+			};
+			move("logs");
+			move("agentActions");
+			const config = loadConfig();
+			if (limits["recordings.maxAgeDays"] && workspaceRecordingEnabled(root, config?.projects?.[root] ?? {}, config, process.env)) {
+				const recordingDir = join(dir, "recordings");
+				if (existsSync(recordingDir) && lstatSync(recordingDir).isSymbolicLink()) throw new Error(`refusing symlink ${recordingDir}`);
+				for (const device of listRecordedDevices(recordingDir)) {
+					if (lstatSync(device.dir).isSymbolicLink()) throw new Error(`refusing symlink ${device.dir}`);
+					const to = join(staging, "recordings", `${device.platform}-${device.slot}`);
+					for (const segment of device.segments.filter((entry) => !entry.open)) {
+						mkdirSync(to, {
+							recursive: true,
+							mode: 448
+						});
+						try {
+							if (lstatSync(segment.file).isSymbolicLink()) throw new Error(`refusing symlink ${segment.file}`);
+							renameSync(segment.file, join(to, basename(segment.file)));
+							chmodSync(join(to, basename(segment.file)), 384);
+						} catch (error) {
+							if (error.code !== "ENOENT") throw error;
+						}
+					}
+				}
+			}
+			const index = readJsonObject(join(staging, "log-error-index.json"));
+			const indexed = Object.values(index?.files ?? {}).flatMap((file) => Object.values(file.markers ?? {}).concat(file.errors ?? []));
+			const lastErrorCount = countErrorEntries(sortByTs(queryLogs({
+				records: indexed,
+				errorsOnly: true
+			})));
+			const history = Object.values(readBuildHistory(state)).flat();
+			const last = Object.values(readLastBuilds(state)).toSorted((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))[0] ?? null;
+			const bytes = {
+				logs: 0,
+				recordings: 0,
+				agentActions: 0,
+				record: 0,
+				total: 0
+			};
+			const expires = {
+				logs: null,
+				recordings: null,
+				agentActions: null,
+				record: new Date(at + limits.maxAgeDays * DAY).toISOString()
+			};
+			for (const kind of KINDS) {
+				bytes[kind] = files(join(staging, KIND_PATH[kind])).reduce((sum, file) => sum + file.bytes, 0);
+				if (bytes[kind]) expires[kind] = new Date(at + limits[`${kind}.maxAgeDays`] * DAY).toISOString();
+			}
+			const record = {
+				id,
+				projectRoot: root,
+				project: basename(root),
+				workspace,
+				worktree,
+				removedAt: new Date(at).toISOString(),
+				removedBy,
+				lastUsedAt: typeof state?.lastUsedAt === "string" ? state.lastUsedAt : null,
+				builds: {
+					count: history.length,
+					last,
+					lastErrorCount
+				},
+				agents: (readJsonObject(join(dir, "ended-agents.json"))?.sessions ?? []).map(endedAgentSessionOf).filter((session) => session !== null),
+				bytes,
+				expires,
+				version: 1
+			};
+			writeRecord(staging, record);
+			renameSync(staging, archiveDir(id));
+		}, { waitMs: 3e4 });
+		releaseClaim(claim);
+		claim = void 0;
+		staging = null;
+	} catch (error) {
+		if (staging) try {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		console.error(`could not archive: ${String(error?.message ?? error).split("\n")[0]}`);
+	} finally {
+		releaseClaim(claim);
+	}
+}
+function removeKind(record, kind) {
+	rmSync(join(archiveDir(record.id), KIND_PATH[kind]), {
+		recursive: true,
+		force: true
+	});
+	record.bytes[kind] = 0;
+	record.expires[kind] = null;
+	writeRecord(archiveDir(record.id), record);
+}
+function logRemovalOrder(path) {
+	return /\.ndjson\.\d+$/.test(path) ? 0 : /^build-.*\.ndjson$/.test(basename(path)) ? 1 : 2;
+}
+function enforceArchiveRetention(now = Date.now()) {
+	if (!existsSync(archiveRoot())) return;
+	let limits;
+	try {
+		limits = archiveSettings();
+	} catch (error) {
+		console.error(`could not enforce archive retention: ${String(error.message).split("\n")[0]}`);
+		return;
+	}
+	withDirLock(archiveLock(), () => {
+		const listed = readArchives().toReversed();
+		const records = listed.filter((record, index) => limits.maxAgeDays > 0 && now - Date.parse(record.removedAt) < limits.maxAgeDays * DAY && index >= listed.length - limits.maxCount);
+		for (const record of listed) if (!records.includes(record)) removeRecord(record.id);
+		const recordings = recordingEnabled(process.env, [loadConfig()]);
+		for (const record of records) {
+			for (const kind of [
+				"recordings",
+				"agentActions",
+				"logs"
+			]) {
+				const age = limits[`${kind}.maxAgeDays`];
+				if (record.bytes[kind] && (!age || now - Date.parse(record.removedAt) >= age * DAY || kind === "recordings" && !recordings)) removeKind(record, kind);
+			}
+			const cap = limits["logs.maxMbPerWorkspace"] * 1024 ** 2;
+			if (record.bytes.logs > cap) {
+				const entries = files(join(archiveDir(record.id), "logs")).toSorted((a, b) => logRemovalOrder(a.path) - logRemovalOrder(b.path) || (logRemovalOrder(a.path) === 0 ? Number(b.path.split(".").at(-1)) - Number(a.path.split(".").at(-1)) : 0) || a.at - b.at);
+				for (const file of entries) {
+					if (record.bytes.logs <= cap) break;
+					rmSync(file.path);
+					record.bytes.logs = Math.max(0, record.bytes.logs - file.bytes);
+				}
+				if (!record.bytes.logs) record.expires.logs = null;
+				writeRecord(archiveDir(record.id), record);
+			}
+		}
+		const totalCap = limits.maxTotalGb * 1024 ** 3;
+		const recordingCap = limits["recordings.maxTotalGb"] * 1024 ** 3;
+		for (const record of records) for (;;) {
+			const usage = archivedUsage(records);
+			const totalOver = usage.bytes > totalCap;
+			const recordingsOver = usage.byKind.recordings > recordingCap;
+			if (!totalOver && !recordingsOver) break;
+			const candidates = KINDS.filter((kind) => record.bytes[kind] > 0 && (totalOver || kind === "recordings")).toSorted((a, b) => record.bytes[b] - record.bytes[a]);
+			if (!candidates.length) break;
+			removeKind(record, candidates[0]);
+		}
+		for (const record of records) {
+			const before = JSON.stringify(record.expires);
+			for (const kind of KINDS) record.expires[kind] = record.bytes[kind] ? new Date(Date.parse(record.removedAt) + limits[`${kind}.maxAgeDays`] * DAY).toISOString() : null;
+			record.expires.record = new Date(Date.parse(record.removedAt) + limits.maxAgeDays * DAY).toISOString();
+			if (JSON.stringify(record.expires) !== before) writeRecord(archiveDir(record.id), record);
+		}
+	}, { waitMs: 3e4 });
+}
+function deleteSelectedArchives(ids, kind) {
+	withDirLock(archiveLock(), () => {
+		for (const record of readArchives().filter((entry) => ids.includes(entry.id))) if (kind) removeKind(record, kind);
+		else removeRecord(record.id);
+	}, { waitMs: 3e4 });
+}
+//#endregion
 //#region src/devices/reclaim.ts
 async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
 	const skippedDevices = [];
@@ -288,6 +717,7 @@ async function reclaimProject(path, options = {}) {
 	const existed = existsSync(dir);
 	const run = await withIdleWorkspace(path, () => reclaimIdleProject(path, existed, options), {
 		purpose: "workspace removal",
+		hosted: false,
 		supervisor: false,
 		managedLocks: false
 	});
@@ -316,7 +746,7 @@ async function reclaimProject(path, options = {}) {
 		failedWorkspaceDirs: []
 	};
 }
-async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" } }) {
+async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" } }) {
 	await clearNamedPorts(path, { stop: true });
 	const project = getProject(path);
 	for (const { platforms } of projectDeviceSlots(project)) if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
@@ -395,6 +825,17 @@ async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices =
 	};
 	skippedDevices.push(...skippedCollectors);
 	failedDevices.push(...failedCollectors);
+	try {
+		await stopHostedIos(path);
+	} catch (error) {
+		const failed = {
+			platform: "ios",
+			name: "hosted iOS simulator",
+			reason: error.message
+		};
+		failedDevices.push(failed);
+		skippedDevices.push(failed);
+	}
 	const remote = reclaimRemoteSession(path, { stopSession });
 	if (remote.failed) {
 		skippedDevices.push(remote.failed);
@@ -428,6 +869,28 @@ async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices =
 	if (failedDevices.length === 0 && !supervisorHeld) {
 		const dir = workspaceDir(path);
 		if (existsSync(dir)) try {
+			const stateDir = workspaceAgentDeviceDir(path);
+			if (!["none", "dead"].includes(agentDeviceDaemon(stateDir))) {
+				const exec = getExecutor();
+				try {
+					if (!exec.findExecutable("agent-device")) throw new Error("agent-device is not on PATH");
+					exec.runFile("agent-device", [
+						"daemon",
+						"stop",
+						"--state-dir",
+						stateDir,
+						"--clean"
+					], {
+						timeoutMs: 2e4,
+						killSignal: "SIGKILL",
+						env: { AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1" }
+					});
+				} catch (error) {
+					process.stderr.write(`${phaseLine("agent-device", `daemon could not be stopped: ${error.message}; run agent-device daemon stop --state-dir "${stateDir}" --clean`)}\n`);
+					throw error;
+				}
+			}
+			if (archive) archiveWorkspace(path, archive.removedBy, initialState);
 			emptyWorkspaceDir(dir);
 			if (workspaceExisted) removedWorkspaceDirs.push(dir);
 		} catch {
@@ -1492,7 +1955,7 @@ async function withReclaimLocks(rootPath, fn) {
 	const acquire = (index) => index === keys.length ? fn(keys) : withManagedTunnelRemovalLock(keys[index], () => acquire(index + 1));
 	return acquire(0);
 }
-async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false } = {}) {
+async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false, removedBy } = {}) {
 	const dereferenced = [];
 	const killedPids = [];
 	const deletedDevices = [];
@@ -1511,6 +1974,7 @@ async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRoot
 		let r;
 		try {
 			r = await reclaimProject(key, {
+				archive: removedBy ? { removedBy } : void 0,
 				deleteOwnedDevices: true,
 				parkOwnedDevices: true,
 				preserveProjectRecord: preserveRootProject && key === rootPath,
@@ -1835,7 +2299,10 @@ async function runRemove(target, opts, onRemoved) {
 			printRemovalRefusal(path, current);
 			return;
 		}
-		const result = await reclaimAll(path, lockedKeys, { preserveRootProject: true });
+		const result = await reclaimAll(path, lockedKeys, {
+			preserveRootProject: true,
+			removedBy: opts.removedBy ?? "worktree-remove"
+		});
 		if (result.keptEntries.length) {
 			reportRetainedResources(path, result);
 			return;
@@ -1914,4 +2381,4 @@ function worktreeCommand(program) {
 	registerRemove(worktree);
 }
 //#endregion
-export { porcelainPath as a, registerWarm as c, removalRemedy as d, removeWorktreeTarget as f, reclaimProject as g, describeDereferenced as h, matchWorktreeEntry as i, removalBlockers as l, worktreeCommand as m, excludePodChurn as n, reclaimKeys as o, warmedWorkspace as p, excludeWatchmanCookies as r, registerRemove as s, dependencyInstallCommand as t, removalPath as u };
+export { deleteSelectedArchives as _, porcelainPath as a, registerWarm as c, removalRemedy as d, removeWorktreeTarget as f, reclaimProject as g, describeDereferenced as h, matchWorktreeEntry as i, removalBlockers as l, worktreeCommand as m, excludePodChurn as n, reclaimKeys as o, warmedWorkspace as p, excludeWatchmanCookies as r, registerRemove as s, dependencyInstallCommand as t, removalPath as u, sweepArchiveStaging as v };

package/dist/{worktree-BT_uULFx.mjs → worktree-jnG8Iph5.mjs}

@@ -1,2 +1,2 @@
-import { a as porcelainPath, c as registerWarm, d as removalRemedy, f as removeWorktreeTarget, i as matchWorktreeEntry, l as removalBlockers, m as worktreeCommand, n as excludePodChurn, o as reclaimKeys, p as warmedWorkspace, r as excludeWatchmanCookies, s as registerRemove, t as dependencyInstallCommand, u as removalPath } from "./worktree-qXKzADSC.mjs";
+import { a as porcelainPath, c as registerWarm, d as removalRemedy, f as removeWorktreeTarget, i as matchWorktreeEntry, l as removalBlockers, m as worktreeCommand, n as excludePodChurn, o as reclaimKeys, p as warmedWorkspace, r as excludeWatchmanCookies, s as registerRemove, t as dependencyInstallCommand, u as removalPath } from "./worktree-K-xj9Db0.mjs";
 export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, excludeWatchmanCookies, matchWorktreeEntry, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget, warmedWorkspace };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stim",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Stim: fast, isolated React Native environments for coding agents",
   "keywords": [
     "agent",
@@ -48,9 +48,9 @@
   },
   "dependencies": {
     "@expo/fingerprint": "^0.20.10",
-    "@stim-cli/cache": "^1.15.0",
-    "@stim-cli/core": "^1.15.0",
-    "@stim-cli/metro": "^1.15.0",
+    "@stim-cli/cache": "^1.16.0",
+    "@stim-cli/core": "^1.16.0",
+    "@stim-cli/metro": "^1.16.0",
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",
@@ -58,7 +58,7 @@
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@stim-cli/expo-build-cache": "1.15.0",
+    "@stim-cli/expo-build-cache": "1.16.0",
     "@types/cross-spawn": "^6.0.6",
     "@types/which": "^3.0.4",
     "@types/ws": "^8.18.1",