stim 1.25.0 → 1.27.0

package/dist/settings-payload-cm60Zhib.mjs

@@ -0,0 +1,257 @@
+import { _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-Cn94Jc0g.mjs";
+import { a as killOnAbort, i as gitPath } from "./operation-exec-Dp4FuIGR.mjs";
+import { K as removedMachineSettings, V as readCommittedSettings, st as unknownSettingKeys } from "./settings-BDVI8Ivc.mjs";
+import { r as findCommandWorkspaceAsync } from "./project-DYj-HVx6.mjs";
+import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-CbWo21kb.mjs";
+import { join } from "node:path";
+import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, replacementAdvice, settingDefinition, settingValueError } from "@stim-cli/core/state";
+//#region src/workspace/settings-payload.ts
+const MASK = "********";
+const PRECEDENCE = [
+	"workspace",
+	"repo",
+	"committed",
+	"machine"
+];
+var SettingsRefusal = class extends Error {
+	code;
+	remedy;
+	constructor(code, message, remedy) {
+		super(message);
+		this.code = code;
+		this.remedy = remedy;
+	}
+};
+/** Reads layers using exactly `env`; `signal` kills Git children. `resolvedProject` pins a mutation's readback target. */
+async function readSettingsContext(cwd, env, note = () => {}, signal, resolvedProject) {
+	const repoRootOf = (dir) => gitPath(dir, ["--show-toplevel"], env, signal);
+	const projectPath = resolvedProject === void 0 ? await findCommandWorkspaceAsync(cwd, repoRootOf, note) : resolvedProject;
+	const start = projectPath ?? cwd;
+	const [common, root] = await Promise.all([gitPath(start, ["--path-format=absolute", "--git-common-dir"], env, signal), repoRootOf(start)]);
+	signal?.throwIfAborted();
+	const repoRoot = common ? root ?? projectPath : null;
+	const app = projectPath ?? repoRoot;
+	const repository = repoRoot ?? projectPath;
+	const committed = readCommittedSettings(app);
+	let installed;
+	return {
+		projectPath,
+		gitCommonDir: common,
+		repoRoot,
+		machine: loadConfig$1(),
+		workspace: projectPath ? getProjectSettings(projectPath) : {},
+		repo: common ? getRepoSettings(common) : {},
+		committed: {
+			app: committed,
+			repository: repository === app ? committed : readCommittedSettings(repository)
+		},
+		env,
+		desktopInstalled: () => installed ??= stimDesktopInstalled(process.platform, env)
+	};
+}
+function valueAt(settings, key) {
+	let node = settings;
+	for (const segment of key.split(".")) {
+		if (!isJsonObject(node)) return void 0;
+		node = node[segment];
+	}
+	return node;
+}
+function committedDirectory(context, setting) {
+	return setting?.committedAt === "repository" ? repositoryDirectory(context) : appDirectory(context);
+}
+function repositoryDirectory(context) {
+	return context.repoRoot ?? context.projectPath;
+}
+function appDirectory(context) {
+	return context.projectPath ?? context.repoRoot;
+}
+function layerFile(context, scope, setting) {
+	const machineFile = getConfigPath$1();
+	if (scope === "machine") return machineFile;
+	if (scope === "workspace") return context.projectPath ? `${machineFile} (projects["${context.projectPath}"].settings)` : null;
+	if (scope === "repo") return context.gitCommonDir ? `${machineFile} (repos["${context.gitCommonDir}"].settings)` : null;
+	const directory = committedDirectory(context, setting);
+	return directory ? join(directory, ".stim.json") : null;
+}
+function layerSettings(context, scope, setting) {
+	if (scope === "machine") return context.machine ?? {};
+	if (scope === "workspace") return context.workspace;
+	if (scope === "repo") return context.repo;
+	return setting?.committedAt === "repository" ? context.committed.repository : context.committed.app;
+}
+function masked(setting, value) {
+	return setting.sensitive && value !== void 0 && value !== null ? MASK : value;
+}
+function settingExample(setting) {
+	switch (setting.type.kind) {
+		case "boolean": return "false";
+		case "number": return String(setting.default ?? setting.type.minimum ?? 1);
+		case "strings": return `'["node_modules"]'`;
+		case "object": return `'{"key": "value"}'`;
+		case "choice": return setting.type.choices[0];
+		default: return "<value>";
+	}
+}
+function envSettingValue(setting, raw) {
+	const value = coerceSettingText(setting, raw);
+	const error = settingValueError(setting, value);
+	if (error) throw new SettingsRefusal("STIM_BAD_ARG", `Invalid ${setting.env} value ${JSON.stringify(raw)}. Expected ${error}.`, `Fix the environment variable, or unset it and run \`stim settings set ${setting.key} ${settingExample(setting)}\`.`);
+	return value;
+}
+/** The refusal `stim settings get` gives for an invalid environment override of `key`, or null when it is unset, blank or valid. */
+function envSettingRefusal(key, env) {
+	const setting = settingDefinition(key);
+	const raw = setting?.env ? env[setting.env]?.trim() : void 0;
+	if (!setting || !raw) return null;
+	try {
+		envSettingValue(setting, raw);
+		return null;
+	} catch (error) {
+		if (error instanceof SettingsRefusal) return error;
+		throw error;
+	}
+}
+/** The refusal for an invalid configured value of a machine setting, or null when it is unset or valid. */
+function configSettingRefusal(key, value) {
+	const setting = settingDefinition(key);
+	const checked = typeof value === "string" ? value.trim() : value;
+	const error = setting && checked !== void 0 && checked !== null ? settingValueError(setting, checked) : null;
+	if (!error) return null;
+	return new SettingsRefusal("STIM_BAD_ARG", `Invalid ${key} setting ${JSON.stringify(value)}. Expected ${error}.`, `Replace it with \`stim settings set ${key} <value>\`; \`stim guide settings\` lists the values it takes.`);
+}
+/** The refusal for an invalid `remote.build` that placement would read: the environment override first, else the configured value. */
+function buildPreferenceRefusal(env, configured) {
+	const fromEnvironment = envSettingRefusal("remote.build", env);
+	if (fromEnvironment) return fromEnvironment;
+	return env.STIM_REMOTE_BUILD?.trim() ? null : configSettingRefusal("remote.build", configured);
+}
+function settingEntry(context, setting) {
+	const layers = {};
+	for (const scope of PRECEDENCE) {
+		if (!setting.scopes.includes(scope) || layerFile(context, scope, setting) === null) continue;
+		const value = valueAt(layerSettings(context, scope, setting), setting.key);
+		if (value !== void 0) layers[scope] = masked(setting, value);
+	}
+	const envValue = setting.env ? context.env[setting.env] : void 0;
+	const env = setting.env && envValue ? {
+		name: setting.env,
+		value: String(masked(setting, envValue))
+	} : void 0;
+	const scopedHome = !env && setting.scopedHomeValue !== void 0 && context.env.STIM_HOME;
+	const ci = !env && setting.ciValue !== void 0 && context.env.CI;
+	const winner = PRECEDENCE.find((scope) => scope in layers);
+	let value = null;
+	let origin = null;
+	let defaultReason = null;
+	if (env) {
+		value = masked(setting, envSettingValue(setting, envValue));
+		origin = "env";
+	} else if (scopedHome) {
+		value = setting.scopedHomeValue;
+		origin = "env";
+	} else if (ci) {
+		value = setting.ciValue;
+		origin = "env";
+	} else if (winner) {
+		value = layers[winner];
+		origin = winner;
+	} else if (setting.default !== void 0) {
+		const fallback = settingDefault(setting, context.desktopInstalled);
+		value = fallback.value;
+		origin = "default";
+		defaultReason = fallback.reason;
+	}
+	return {
+		key: setting.key,
+		value,
+		origin,
+		layers,
+		...env ? { env } : scopedHome ? { env: {
+			name: "STIM_HOME",
+			value: context.env.STIM_HOME
+		} } : ci ? { env: {
+			name: "CI",
+			value: context.env.CI
+		} } : {},
+		...setting.sensitive ? { sensitive: true } : {},
+		...defaultReason ? { defaultReason } : {}
+	};
+}
+function unknownEntries(context) {
+	const sources = [
+		{
+			scope: "machine",
+			file: layerFile(context, "machine", null),
+			settings: {
+				optimizations: context.machine?.optimizations,
+				...removedMachineSettings(context.machine)
+			}
+		},
+		{
+			scope: "workspace",
+			file: layerFile(context, "workspace", null),
+			settings: layerSettings(context, "workspace", null)
+		},
+		{
+			scope: "repo",
+			file: layerFile(context, "repo", null),
+			settings: layerSettings(context, "repo", null)
+		},
+		{
+			scope: "committed",
+			file: layerFile(context, "committed", null),
+			settings: layerSettings(context, "committed", null)
+		}
+	];
+	const repository = repositoryDirectory(context);
+	if (repository && repository !== appDirectory(context)) sources.push({
+		scope: "committed",
+		file: join(repository, ".stim.json"),
+		settings: context.committed.repository
+	});
+	return sources.flatMap(({ scope, file, settings }) => file === null ? [] : unknownSettingKeys(settings).map((key) => {
+		const value = valueAt(settings, key);
+		const command = replacementAdvice(key, value)?.command;
+		const entry = {
+			key,
+			scope,
+			file,
+			value
+		};
+		return command ? Object.assign(entry, { replacement: command }) : entry;
+	}));
+}
+function settingsPayload(context) {
+	const files = {};
+	for (const scope of SETTING_SCOPES) {
+		const file = layerFile(context, scope, null);
+		if (file) files[scope] = file;
+	}
+	return {
+		project: context.projectPath,
+		files,
+		settings: SETTINGS.map((setting) => settingEntry(context, setting)),
+		unknown: unknownEntries(context)
+	};
+}
+/** Every setting with its effective value and layers; looks Stim Desktop up asynchronously, and only when a default depends on it. */
+async function readSettingsPayload(context, signal) {
+	let asked = false;
+	const payload = settingsPayload({
+		...context,
+		desktopInstalled: () => {
+			asked = true;
+			return false;
+		}
+	});
+	if (!asked) return payload;
+	const installed = await stimDesktopInstalledAsync(process.platform, context.env, killOnAbort(signal));
+	signal?.throwIfAborted();
+	return settingsPayload({
+		...context,
+		desktopInstalled: () => installed
+	});
+}
+//#endregion
+export { envSettingRefusal as a, readSettingsPayload as c, unknownEntries as d, configSettingRefusal as i, settingEntry as l, buildPreferenceRefusal as n, layerFile as o, committedDirectory as r, readSettingsContext as s, SettingsRefusal as t, settingExample as u };

package/dist/settings-write-BdNRLlBn.mjs

@@ -0,0 +1,185 @@
+import { u as withWorkspaceProcessLock } from "./exec-aULwtNly.mjs";
+import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, f as getConfigPath$1 } from "./config-Cn94Jc0g.mjs";
+import { t as NO_PROJECT_REFUSAL } from "./project-DYj-HVx6.mjs";
+import { i as stimDesktopInstalledAsync } from "./stim-desktop-CbWo21kb.mjs";
+import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-C20iUZfp.mjs";
+import { d as unknownEntries, l as settingEntry, o as layerFile, r as committedDirectory, s as readSettingsContext, t as SettingsRefusal, u as settingExample } from "./settings-payload-cm60Zhib.mjs";
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { REPLACED_SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, replacementAdvice, settingDefinition, settingValueError } from "@stim-cli/core/state";
+//#region src/workspace/settings-write.ts
+function requireSetting(key, raw) {
+	const setting = settingDefinition(key);
+	if (setting) return setting;
+	const replaced = Object.hasOwn(REPLACED_SETTINGS, key) ? REPLACED_SETTINGS[key] : void 0;
+	if (replaced) {
+		const command = replacementAdvice(key, raw)?.command;
+		throw new SettingsRefusal("STIM_BAD_ARG", `${JSON.stringify(key)} was replaced by ${replaced.key} and is no longer read by Stim.`, `${command ? `Run \`${command}\`` : `Set ${replaced.key} (\`stim guide settings\` lists its values)`}, then run \`stim settings unset ${key}\` to remove the leftover key.`);
+	}
+	throw new SettingsRefusal("STIM_BAD_ARG", `${JSON.stringify(key)} is not a Stim setting.`, "Run `stim settings` to list every setting, or `stim guide settings` for what each one does.");
+}
+function parseScopeName(raw) {
+	if (!SETTING_SCOPES.includes(raw)) throw new SettingsRefusal("STIM_BAD_ARG", `--scope takes ${SETTING_SCOPES.join(", ")}, not ${JSON.stringify(raw)}.`, null);
+	return raw;
+}
+function readScope(raw, setting) {
+	if (raw === void 0) {
+		if (setting.scopes.length === 1) return setting.scopes[0];
+		throw new SettingsRefusal("STIM_BAD_ARG", `${setting.key} can live in more than one layer, so the command needs --scope.`, `Pass --scope ${setting.scopes.join("|")}.`);
+	}
+	const scope = parseScopeName(raw);
+	if (!setting.scopes.includes(scope)) throw new SettingsRefusal("STIM_BAD_ARG", `${setting.key} is not read from the ${scope} layer.`, `Pass --scope ${setting.scopes.join("|")}.`);
+	return scope;
+}
+function requireLayer(context, scope, setting) {
+	const file = layerFile(context, scope, setting);
+	if (file) return file;
+	if (scope === "repo") throw new SettingsRefusal("STIM_BAD_ARG", "The repo layer is keyed by a Git repository, and this directory is not inside one.", "Run this from inside the repository, or pick another --scope.");
+	throw new SettingsRefusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+}
+function parseSettingValue(setting, raw) {
+	const invalid = (expected) => new SettingsRefusal("STIM_BAD_ARG", `Invalid ${setting.key} value ${JSON.stringify(raw)}. Expected ${expected}.`, `For example: stim settings set ${setting.key} ${settingExample(setting)}${setting.scopes.length > 1 ? ` --scope ${setting.scopes[0]}` : ""}`);
+	const kind = setting.type.kind;
+	const value = coerceSettingText(setting, raw);
+	const error = settingValueError(setting, value);
+	if (error) throw invalid(kind === "strings" || kind === "object" ? `${error}, written as JSON` : error);
+	return value;
+}
+function committedTarget(context, setting) {
+	const directory = committedDirectory(context, setting);
+	if (!directory) throw new SettingsRefusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+	return join(directory, ".stim.json");
+}
+function writeCommitted(file, key, value, signal) {
+	return withConfigLockAsync$1(() => {
+		const exists = existsSync(file);
+		const text = exists ? readFileSync(file, "utf-8") : "";
+		let parsed = {};
+		if (exists && text.trim() !== "") try {
+			parsed = JSON.parse(text);
+		} catch (error) {
+			throw new SettingsRefusal("STIM_BAD_ARG", `${file} is not valid JSON: ${error.message}`, `Repair ${file}, then run the command again.`);
+		}
+		if (!isJsonObject(parsed)) throw new SettingsRefusal("STIM_BAD_ARG", `${file} is not a JSON object.`, `Repair ${file}, then run the command again.`);
+		const parts = key.split(".");
+		const chain = [parsed];
+		for (const part of parts.slice(0, -1)) {
+			const node = chain.at(-1);
+			if (!isJsonObject(node[part])) {
+				if (value === void 0) return false;
+				node[part] = {};
+			}
+			chain.push(node[part]);
+		}
+		const leaf = parts.at(-1);
+		const parent = chain.at(-1);
+		if (value === void 0) {
+			if (!(leaf in parent)) return false;
+			delete parent[leaf];
+			for (let index = chain.length - 1; index > 0; index--) {
+				if (Object.keys(chain[index]).length > 0) break;
+				delete chain[index - 1][parts[index - 1]];
+			}
+		} else parent[leaf] = value;
+		const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? 2;
+		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(parsed, null, indent)}\n`);
+		try {
+			renameSync(tmp, file);
+		} catch (error) {
+			try {
+				unlinkSync(tmp);
+			} catch {}
+			throw error;
+		}
+		return true;
+	}, signal);
+}
+function writeSetting(context, setting, scope, value, signal) {
+	if (scope === "committed") return writeCommitted(committedTarget(context, setting), setting.key, value, signal);
+	if (scope === "machine") return writeConfigSettingAsync({ scope }, setting.key, value, signal);
+	if (scope === "workspace") return writeConfigSettingAsync({
+		scope,
+		projectPath: context.projectPath
+	}, setting.key, value, signal);
+	return writeConfigSettingAsync({
+		scope,
+		gitCommonDir: context.gitCommonDir
+	}, setting.key, value, signal);
+}
+/** Shares CLI set/unset validation and side effects; after commit, recording cleanup finishes despite cancellation. */
+async function mutateSetting(request, { cwd, env, note = () => {}, signal, beforeWrite }) {
+	signal?.throwIfAborted();
+	const { key } = request;
+	const setting = requireSetting(key, request.action === "set" ? request.value : void 0);
+	const scope = readScope(request.scope, setting);
+	const value = request.action === "set" ? parseSettingValue(setting, request.value) : void 0;
+	if (setting.sensitive && scope === "committed" && value !== void 0 && !isSensitiveReference(value)) throw new SettingsRefusal("STIM_BAD_ARG", `${key} is sensitive, so a committed .stim.json takes only an env: or file: reference, never the secret.`, `Set the secret with --scope workspace or --scope repo, which store it in ${getConfigPath$1()}, readable only by you, or commit a reference such as env:MY_KEYSTORE_PASSWORD.`);
+	const context = await readSettingsContext(cwd, env, note, signal);
+	const file = requireLayer(context, scope, setting);
+	beforeWrite?.(context.projectPath);
+	const apply = async () => {
+		const recording = setting.key === "recording.enabled" ? recordingLayers() : null;
+		const changed = await writeSetting(context, setting, scope, value, signal);
+		const updated = await readSettingsContext(cwd, env, void 0, void 0, context.projectPath);
+		const recordingsDeleted = recording ? await deleteTurnedOffRecordings(recording) : void 0;
+		let entry = settingEntry({
+			...updated,
+			desktopInstalled: () => false
+		}, setting);
+		if (entry.origin === "default" && setting.desktopDefault !== void 0) {
+			const installed = await stimDesktopInstalledAsync(process.platform, env);
+			entry = settingEntry({
+				...updated,
+				desktopInstalled: () => installed
+			}, setting);
+		}
+		return {
+			key,
+			scope,
+			file,
+			changed,
+			setting: entry,
+			...recordingsDeleted ? { recordingsDeleted } : {}
+		};
+	};
+	return key === "recording.enabled" ? withWorkspaceProcessLock(configDir(), "recording-settings", apply, {
+		external: true,
+		signal
+	}) : apply();
+}
+function configTarget(context, scope) {
+	if (scope === "workspace") return context.projectPath ? {
+		scope,
+		projectPath: context.projectPath
+	} : null;
+	if (scope === "repo") return context.gitCommonDir ? {
+		scope,
+		gitCommonDir: context.gitCommonDir
+	} : null;
+	return scope === "machine" ? { scope } : null;
+}
+/** Removes a key Stim no longer reads from every layer that has it, or from one with `scope`. */
+async function unsetReplacedSetting(request, { cwd, env, note = () => {}, signal }) {
+	signal?.throwIfAborted();
+	const { key } = request;
+	const only = request.scope === void 0 ? void 0 : parseScopeName(request.scope);
+	const context = await readSettingsContext(cwd, env, note, signal);
+	const removed = [];
+	for (const entry of unknownEntries(context)) {
+		if (entry.key !== key || only && entry.scope !== only) continue;
+		const target = configTarget(context, entry.scope);
+		if (entry.scope === "committed" ? await writeCommitted(entry.file, key, void 0, signal) : target && await writeConfigSettingAsync(target, key, void 0, signal)) removed.push({
+			scope: entry.scope,
+			file: entry.file
+		});
+	}
+	return {
+		key,
+		replacedBy: REPLACED_SETTINGS[key]?.key ?? key,
+		removed
+	};
+}
+//#endregion
+export { unsetReplacedSetting as i, readScope as n, requireSetting as r, mutateSetting as t };