stim 1.20.2 → 1.21.0

package/dist/eas-session-ledger-Cm0Gwq2F.mjs

@@ -1,207 +0,0 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { D as withDirLock } from "./workspace-state-DJt_MMvf.mjs";
-import { accessSync, constants, existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { delimiter, dirname, join, resolve } from "node:path";
-import { easMachineStateRoot, easMachineStateRoot as easMachineStateRoot$1, easSessionLedgerFile, easSessionLedgerLock, readEasSessionLedger, readEasSessionLedger as readEasSessionLedger$1, validEasSessionClaim } from "@stim-cli/core/state";
-//#region src/diagnostics/stim-installations.ts
-const VERSION_OUTPUT_LIMIT = 4096;
-function parsedVersion(version) {
-	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
-	if (!match) return null;
-	const core = [
-		match[1],
-		match[2],
-		match[3]
-	];
-	if (core.some((part) => part.length > 1 && part.startsWith("0"))) return null;
-	const prereleaseParts = match[4]?.split(".");
-	if (prereleaseParts?.some((part) => !part || /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null;
-	const prerelease = prereleaseParts?.map((part) => /^\d+$/.test(part) ? Number(part) : part);
-	return {
-		core: core.map(Number),
-		prerelease: prerelease ?? null
-	};
-}
-function compareStimVersions(left, right) {
-	const a = parsedVersion(left);
-	const b = parsedVersion(right);
-	if (!a || !b) return null;
-	for (let index = 0; index < a.core.length; index += 1) {
-		const difference = (a.core[index] ?? 0) - (b.core[index] ?? 0);
-		if (difference !== 0) return difference;
-	}
-	if (!a.prerelease && !b.prerelease) return 0;
-	if (!a.prerelease) return 1;
-	if (!b.prerelease) return -1;
-	for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
-		const x = a.prerelease[index];
-		const y = b.prerelease[index];
-		if (x === void 0) return -1;
-		if (y === void 0) return 1;
-		if (x === y) continue;
-		if (typeof x === "number" && typeof y === "number") return x - y;
-		if (typeof x === "number") return -1;
-		if (typeof y === "number") return 1;
-		return x < y ? -1 : 1;
-	}
-	return 0;
-}
-function parseStimVersionOutput(output) {
-	const version = output?.split("\n")[0]?.trim() ?? "";
-	return parsedVersion(version) ? version.replace(/^v/, "") : null;
-}
-function executableNames(platform) {
-	return platform === "win32" ? [
-		"stim.cmd",
-		"stim.exe",
-		"stim"
-	] : ["stim"];
-}
-function stimExecutablePaths(pathValue, { platform = process.platform, cwd = process.cwd() } = {}) {
-	const found = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const entry of pathValue.split(delimiter)) {
-		const directory = resolve(cwd, entry || ".");
-		for (const name of executableNames(platform)) {
-			const path = join(directory, name);
-			try {
-				accessSync(path, platform === "win32" ? constants.F_OK : constants.X_OK);
-				if (!statSync(path).isFile()) continue;
-				const realPath = realpathSync(path);
-				if (seen.has(realPath)) continue;
-				seen.add(realPath);
-				found.push({
-					path,
-					realPath
-				});
-			} catch {}
-		}
-	}
-	return found;
-}
-function canonicalPath(path) {
-	if (!path) return null;
-	try {
-		return realpathSync(resolve(path));
-	} catch {
-		return resolve(path);
-	}
-}
-function analyzeStimVersions(runningVersion, runningPath, installations) {
-	const candidates = [runningVersion, ...installations.map((entry) => entry.version)];
-	const versions = [...new Set(candidates)].filter((version) => version !== null && compareStimVersions(version, version) !== null).toSorted((left, right) => -(compareStimVersions(left, right) ?? 0));
-	const highestVersion = versions[0] ?? null;
-	const resolved = installations[0] ?? null;
-	return {
-		runningVersion,
-		runningPath,
-		resolved,
-		installations,
-		versions,
-		highestVersion,
-		resolvedIsOlder: Boolean(resolved?.version && highestVersion && (compareStimVersions(resolved.version, highestVersion) ?? 0) < 0)
-	};
-}
-function probeStimVersion(path, timeoutMs) {
-	return new Promise((resolveProbe) => {
-		let settled = false;
-		let output = "";
-		const finish = (version) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			resolveProbe(version);
-		};
-		let child;
-		try {
-			child = getExecutor().spawn(path, ["--version"], {
-				stdio: [
-					"ignore",
-					"pipe",
-					"ignore"
-				],
-				detached: process.platform !== "win32"
-			});
-		} catch {
-			resolveProbe(null);
-			return;
-		}
-		const timer = setTimeout(() => {
-			try {
-				if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
-				else child.kill("SIGKILL");
-			} catch {}
-			finish(null);
-		}, timeoutMs);
-		child.stdout?.on("data", (chunk) => {
-			if (output.length < VERSION_OUTPUT_LIMIT) output += String(chunk).slice(0, VERSION_OUTPUT_LIMIT - output.length);
-		});
-		child.on("error", () => finish(null));
-		child.on("close", (code) => finish(code === 0 ? parseStimVersionOutput(output) : null));
-	});
-}
-async function inspectStimVersions(runningVersion, { pathValue = process.env.PATH ?? "", runningPath = process.argv[1], probeTimeoutMs = 5e3 } = {}) {
-	const paths = stimExecutablePaths(pathValue);
-	const versions = await Promise.all(paths.map((entry) => probeStimVersion(entry.path, probeTimeoutMs)));
-	const installations = paths.map((entry, index) => ({
-		path: entry.path,
-		realPath: entry.realPath,
-		version: versions[index] ?? null
-	}));
-	return analyzeStimVersions(runningVersion, canonicalPath(runningPath), installations);
-}
-//#endregion
-//#region src/engine/eas-machine-root-guard-env.ts
-const EAS_TEST_GUARD_ROOT_ENV = "STIM_TEST_GUARD_REAL_EAS_ROOT";
-//#endregion
-//#region src/engine/eas-session-ledger.ts
-function assertEasMachineRootWritable(root) {
-	const guardedRoot = process.env[EAS_TEST_GUARD_ROOT_ENV];
-	if (!guardedRoot || resolve(root) !== resolve(guardedRoot)) return;
-	throw new Error(`Refusing to write the real EAS machine root ${root} from a test process. Pass a temporary ledgerRoot, machineRoot, or easLedgerRoot, or point HOME (and USERPROFILE on Windows) at a temporary directory.`);
-}
-function writeLedger(root, ledger) {
-	mkdirSync(root, { recursive: true });
-	const file = easSessionLedgerFile(root);
-	const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-	writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`);
-	try {
-		renameSync(tmp, file);
-	} catch (error) {
-		rmSync(tmp, { force: true });
-		throw error;
-	}
-}
-function recordEasSessionClaim(claim, root = easMachineStateRoot()) {
-	assertEasMachineRootWritable(root);
-	const normalized = validEasSessionClaim(claim.sessionId, claim);
-	if (!normalized) throw new Error(`Invalid EAS session claim for ${claim.sessionId}.`);
-	withDirLock(easSessionLedgerLock(root), () => {
-		const current = readEasSessionLedger(root);
-		if (!current.safe) throw new Error(current.notice ?? "EAS ownership ledger is unreadable.");
-		current.claims.set(normalized.sessionId, normalized);
-		writeLedger(root, {
-			version: 1,
-			claims: Object.fromEntries(current.claims)
-		});
-	}, { ensureParent: () => mkdirSync(dirname(easSessionLedgerLock(root)), { recursive: true }) });
-}
-function removeEasSessionClaim(sessionId, root = easMachineStateRoot(), when = () => true) {
-	const file = easSessionLedgerFile(root);
-	if (!existsSync(file)) return false;
-	assertEasMachineRootWritable(root);
-	return withDirLock(easSessionLedgerLock(root), () => {
-		const current = readEasSessionLedger(root);
-		if (!current.safe) return false;
-		const claim = current.claims.get(sessionId);
-		if (!claim || !when(claim)) return false;
-		current.claims.delete(sessionId);
-		writeLedger(root, {
-			version: 1,
-			claims: Object.fromEntries(current.claims)
-		});
-		return true;
-	});
-}
-//#endregion
-export { removeEasSessionClaim as a, recordEasSessionClaim as i, easMachineStateRoot$1 as n, compareStimVersions as o, readEasSessionLedger$1 as r, inspectStimVersions as s, assertEasMachineRootWritable as t };

package/dist/exec-DqKo9GKJ.mjs

@@ -1,268 +0,0 @@
-import { execSync } from "child_process";
-import spawn from "cross-spawn";
-import which from "which";
-import { basename } from "path";
-import { createDebugLog, runId } from "@stim-cli/core/state";
-//#region src/debug-log.ts
-const debugLog = createDebugLog("cli", { base: () => ({ runId: runId() }) });
-//#endregion
-//#region src/exec.ts
-const MAX_BUFFER = 67108864;
-function budgetMs(timeoutMs) {
-	if (timeoutMs === "unbounded") return void 0;
-	if (!(timeoutMs > 0)) throw new RangeError(`timeoutMs must be a positive number of milliseconds or 'unbounded', got ${timeoutMs}`);
-	return timeoutMs;
-}
-/** Whether an exec error is a child killed for exceeding its `timeoutMs`. */
-function isTimeoutError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ETIMEDOUT";
-}
-function nameTimeout(error, command, timeoutMs) {
-	if (error?.code === "ETIMEDOUT" && error instanceof Error) error.message = `Command timed out after ${timeoutMs}ms: ${command}`;
-	return error;
-}
-const WINDOWS_BATCH_FILE = /\.(?:bat|cmd)$/i;
-const BATCH_UNSAFE_ARGUMENT = /["\r\n]/;
-function isUnsafeBatchSpawn(target, args, platform = process.platform) {
-	return platform === "win32" && WINDOWS_BATCH_FILE.test(target) && args.some((arg) => BATCH_UNSAFE_ARGUMENT.test(arg));
-}
-function refuseUnsafeBatchArguments(file, args) {
-	if (process.platform !== "win32") return;
-	const target = which.sync(file, { nothrow: true }) ?? file;
-	if (isUnsafeBatchSpawn(target, args)) throw new Error(`Refusing to run ${basename(target)}: an argument contains a character cmd.exe could misinterpret (a double quote or a line break).`);
-}
-function redactError(error, values) {
-	const secrets = values?.filter(Boolean) ?? [];
-	if (secrets.length === 0 || !error || typeof error !== "object") return error;
-	const scrub = (text) => secrets.reduce((acc, secret) => acc.split(secret).join("***"), text);
-	const fields = error;
-	for (const key of Object.getOwnPropertyNames(error)) {
-		const value = fields[key];
-		if (typeof value === "string") fields[key] = scrub(value);
-		else if (Array.isArray(value)) fields[key] = value.map((item) => typeof item === "string" ? scrub(item) : item);
-	}
-	return error;
-}
-const defaultExecutor = {
-	run(cmd, { timeoutMs, killSignal, cwd, env }) {
-		const opts = {
-			encoding: "utf-8",
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			maxBuffer: MAX_BUFFER
-		};
-		const timeout = budgetMs(timeoutMs);
-		if (timeout !== void 0) opts.timeout = timeout;
-		if (killSignal) opts.killSignal = killSignal;
-		if (cwd) opts.cwd = cwd;
-		if (env) opts.env = {
-			...process.env,
-			...env
-		};
-		try {
-			return String(execSync(cmd, opts)).trim();
-		} catch (error) {
-			throw nameTimeout(error, cmd, timeoutMs);
-		}
-	},
-	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed, rejectStderr, detachedSilent, redact }) {
-		const opts = {
-			encoding: "utf-8",
-			stdio: detachedSilent ? "ignore" : [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			maxBuffer: MAX_BUFFER
-		};
-		if (detachedSilent) opts.detached = true;
-		const timeout = budgetMs(timeoutMs);
-		if (timeout !== void 0) opts.timeout = timeout;
-		if (killSignal) opts.killSignal = killSignal;
-		if (cwd) opts.cwd = cwd;
-		if (input !== void 0) opts.input = input;
-		if (env || omitEnv?.length) {
-			const childEnv = {
-				...process.env,
-				...env
-			};
-			for (const key of omitEnv ?? []) delete childEnv[key];
-			opts.env = childEnv;
-		}
-		refuseUnsafeBatchArguments(file, args);
-		const result = spawn.sync(file, args, opts);
-		if (result.error) throw redactError(nameTimeout(Object.assign(result.error, result), [file, ...args].join(" "), timeoutMs), redact);
-		if (result.status !== 0 || rejectStderr && String(result.stderr ?? "").trim()) {
-			const stderr = String(result.stderr ?? "");
-			const message = `Command failed: ${[file, ...args].join(" ")}${stderr ? `\n${stderr}` : ""}`;
-			throw redactError(Object.assign(new Error(message), result), redact);
-		}
-		if (detachedSilent) return "";
-		return untrimmed ? String(result.stdout) : String(result.stdout).trim();
-	},
-	runFileAsync(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, rejectStderr, onSpawn, detachedSilent, redact }) {
-		const command = [file, ...args].join(" ");
-		return new Promise((resolve, reject) => {
-			refuseUnsafeBatchArguments(file, args);
-			const timeout = budgetMs(timeoutMs);
-			const opts = detachedSilent ? {
-				stdio: "ignore",
-				detached: true
-			} : { stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			] };
-			if (cwd) opts.cwd = cwd;
-			if (env || omitEnv?.length) {
-				const childEnv = {
-					...process.env,
-					...env
-				};
-				for (const key of omitEnv ?? []) delete childEnv[key];
-				opts.env = childEnv;
-			}
-			const child = spawn(file, args, opts);
-			try {
-				onSpawn?.(child);
-			} catch (error) {
-				child.kill("SIGKILL");
-				reject(error);
-				return;
-			}
-			const stdout = [];
-			const stderr = [];
-			let timedOut = false;
-			const timer = timeout === void 0 ? void 0 : setTimeout(() => {
-				timedOut = true;
-				child.kill(killSignal ?? "SIGTERM");
-			}, timeout);
-			child.stdout?.on("data", (chunk) => stdout.push(chunk));
-			child.stderr?.on("data", (chunk) => stderr.push(chunk));
-			child.on("error", (error) => {
-				clearTimeout(timer);
-				reject(redactError(error, redact));
-			});
-			child.on("close", (status, signal) => {
-				clearTimeout(timer);
-				const out = Buffer.concat(stdout).toString("utf-8");
-				const err = Buffer.concat(stderr).toString("utf-8");
-				const result = {
-					status,
-					signal,
-					stdout: out,
-					stderr: err
-				};
-				if (timedOut) reject(redactError(nameTimeout(Object.assign(new Error(command), result, { code: "ETIMEDOUT" }), command, timeoutMs), redact));
-				else if (status !== 0 || rejectStderr && err.trim()) reject(redactError(Object.assign(/* @__PURE__ */ new Error(`Command failed: ${command}${err ? `\n${err}` : ""}`), result), redact));
-				else resolve(detachedSilent ? "" : out.trim());
-			});
-		});
-	},
-	runQuiet(cmd, opts) {
-		budgetMs(opts.timeoutMs);
-		try {
-			return this.run(cmd, opts);
-		} catch {
-			return null;
-		}
-	},
-	runFileQuiet(file, args, opts) {
-		budgetMs(opts.timeoutMs);
-		try {
-			return this.runFile(file, args, opts);
-		} catch {
-			return null;
-		}
-	},
-	spawn(cmd, args = [], opts = {}) {
-		refuseUnsafeBatchArguments(cmd, args);
-		return spawn(cmd, args, opts);
-	},
-	findExecutable(name) {
-		return which.sync(name, { nothrow: true });
-	}
-};
-/** The program a call runs, without its arguments: those can carry tokens. */
-const programOf = (command) => basename(command.trim().split(/\s+/)[0] ?? "");
-function outcomeOf(error) {
-	const { status, signal, code } = error ?? {};
-	return {
-		ok: false,
-		...typeof status === "number" ? { exit: status } : {},
-		...signal ? { signal } : {},
-		...code ? { code } : {}
-	};
-}
-let executionId = 0;
-function timedSync(fn, program) {
-	return (...args) => {
-		if (!debugLog.enabled()) return fn(...args);
-		const id = ++executionId;
-		const name = program(...args);
-		const started = performance.now();
-		debugLog.log("exec.start", {
-			program: name,
-			executionId: id
-		});
-		try {
-			const out = fn(...args);
-			debugLog.log("exec", {
-				program: name,
-				executionId: id,
-				ms: Math.round(performance.now() - started),
-				ok: true
-			});
-			return out;
-		} catch (error) {
-			debugLog.log("exec", {
-				program: name,
-				executionId: id,
-				ms: Math.round(performance.now() - started),
-				...outcomeOf(error)
-			});
-			throw error;
-		}
-	};
-}
-let active = {
-	...defaultExecutor,
-	run: timedSync((cmd, opts) => defaultExecutor.run(cmd, opts), programOf),
-	runFile: timedSync((file, args, opts) => defaultExecutor.runFile(file, args, opts), (file) => basename(file)),
-	async runFileAsync(file, args, opts) {
-		if (!debugLog.enabled()) return defaultExecutor.runFileAsync(file, args, opts);
-		const id = ++executionId;
-		const name = basename(file);
-		const started = performance.now();
-		debugLog.log("exec.start", {
-			program: name,
-			executionId: id
-		});
-		try {
-			const out = await defaultExecutor.runFileAsync(file, args, opts);
-			debugLog.log("exec", {
-				program: name,
-				executionId: id,
-				ms: Math.round(performance.now() - started),
-				ok: true
-			});
-			return out;
-		} catch (error) {
-			debugLog.log("exec", {
-				program: name,
-				executionId: id,
-				ms: Math.round(performance.now() - started),
-				...outcomeOf(error)
-			});
-			throw error;
-		}
-	}
-};
-function getExecutor() {
-	return active;
-}
-//#endregion
-export { isTimeoutError as n, debugLog as r, getExecutor as t };

package/dist/git-DDfFzkMm.mjs

@@ -1,45 +0,0 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-//#region src/workspace/git.ts
-const GIT_TIMEOUT_MS = 1e4;
-const GIT_CONCURRENCY = 6;
-function gitCall(cwd, args, { write, timeoutMs = GIT_TIMEOUT_MS, ...opts }) {
-	return {
-		args: [
-			...write ? [] : ["--no-optional-locks"],
-			"-C",
-			cwd,
-			...args
-		],
-		opts: {
-			...opts,
-			timeoutMs
-		}
-	};
-}
-/** Runs git in `cwd`, bounded by `timeoutMs` (10 s by default); throws like `runFile`. */
-function git(cwd, args, opts = {}) {
-	const call = gitCall(cwd, args, opts);
-	return getExecutor().runFile("git", call.args, call.opts);
-}
-/** `git`, returning null instead of throwing. */
-function gitQuiet(cwd, args, opts = {}) {
-	const call = gitCall(cwd, args, opts);
-	return getExecutor().runFileQuiet("git", call.args, call.opts);
-}
-const queue = [];
-let running = 0;
-/** `git` without blocking the event loop, at most six at a time; the budget starts when the call leaves the queue. */
-async function gitAsync(cwd, args, opts = {}) {
-	if (running < GIT_CONCURRENCY) running++;
-	else await new Promise((proceed) => queue.push(proceed));
-	try {
-		const call = gitCall(cwd, args, opts);
-		return await getExecutor().runFileAsync("git", call.args, call.opts);
-	} finally {
-		const next = queue.shift();
-		if (next) next();
-		else running--;
-	}
-}
-//#endregion
-export { gitAsync as n, gitQuiet as r, git as t };