stim 1.20.2 → 1.22.0

package/dist/settings-DpR-1Wnn.mjs

@@ -0,0 +1,114 @@
+import { a as layerFile, c as settingEntry, i as SettingsRefusal, n as readScope, o as readSettingsContext, r as requireSetting, s as readSettingsPayload, t as mutateSetting } from "./settings-write-CzD60rOD.mjs";
+import { SETTING_SCOPES } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/settings.ts
+function formatValue(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function formatOrigin(entry) {
+	if (entry.origin === null) return "unset";
+	return entry.defaultReason ? `${entry.origin}: ${entry.defaultReason}` : entry.origin;
+}
+const CONSOLE = {
+	out: (line) => console.log(line),
+	note: (line) => console.error(line)
+};
+async function run(json, io, action) {
+	try {
+		await action();
+	} catch (error) {
+		const code = error.code;
+		if (!(error instanceof SettingsRefusal) && !(typeof code === "string" && code.startsWith("STIM_"))) throw error;
+		const failure = {
+			code,
+			message: error.message,
+			remedy: error instanceof SettingsRefusal ? error.remedy : null
+		};
+		io.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) io.note(chalk.dim(failure.remedy));
+		if (json) io.out(JSON.stringify(failure));
+		process.exitCode = 1;
+	}
+}
+function wantsJson(opts, command) {
+	return Boolean(opts.json ?? command.parent?.opts().json);
+}
+function registerSettings(program, io = CONSOLE, env = process.env) {
+	const settings = program.command("settings").description("Show every Stim setting with its effective value and layer, or change one").option("--json", "print every setting, its origin, and each layer value as JSON").action((opts) => run(Boolean(opts.json), io, async () => {
+		const payload = await readSettingsPayload(await readSettingsContext(process.cwd(), env, io.note));
+		if (opts.json) {
+			io.out(JSON.stringify(payload));
+			return;
+		}
+		const width = Math.max(...payload.settings.map((entry) => entry.key.length));
+		for (const entry of payload.settings) {
+			const shown = entry.origin === null ? "" : formatValue(entry.value);
+			io.out(`${entry.key.padEnd(width)}  ${shown}${shown ? "  " : ""}${chalk.dim(`(${formatOrigin(entry)})`)}`);
+		}
+		for (const entry of payload.unknown) io.note(chalk.yellow(`Warning: ${entry.key} in ${entry.file} is not read by Stim.`));
+	}));
+	settings.command("get <key>").description("Print the effective value of a setting, or its value in one layer").option("--scope <scope>", `read one layer: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the setting entry as JSON").action((key, opts, command) => run(wantsJson(opts, command), io, async () => {
+		const setting = requireSetting(key);
+		const scope = opts.scope === void 0 ? null : readScope(opts.scope, setting);
+		const context = await readSettingsContext(process.cwd(), env, io.note);
+		const entry = settingEntry(context, setting);
+		const value = scope ? entry.layers[scope] ?? null : entry.value;
+		if (wantsJson(opts, command)) {
+			io.out(JSON.stringify(scope ? {
+				key,
+				scope,
+				file: layerFile(context, scope, setting),
+				value
+			} : entry));
+			return;
+		}
+		if (value === null) return;
+		io.out(formatValue(value));
+		if (!scope && entry.defaultReason) io.note(chalk.dim(`(${formatOrigin(entry)})`));
+	}));
+	settings.command("set <key> <value>").description("Write a setting to one layer").option("--scope <scope>", `the layer to write: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the written setting as JSON").action((key, raw, opts, command) => run(wantsJson(opts, command), io, async () => {
+		const result = await mutateSetting({
+			action: "set",
+			key,
+			value: raw,
+			scope: opts.scope
+		}, {
+			cwd: process.cwd(),
+			env,
+			note: io.note
+		});
+		report(io, wantsJson(opts, command), result, "set");
+	}));
+	settings.command("unset <key>").description("Remove a setting from one layer").option("--scope <scope>", `the layer to clear: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the setting after removal as JSON").action((key, opts, command) => run(wantsJson(opts, command), io, async () => {
+		const result = await mutateSetting({
+			action: "unset",
+			key,
+			scope: opts.scope
+		}, {
+			cwd: process.cwd(),
+			env,
+			note: io.note
+		});
+		report(io, wantsJson(opts, command), result, "unset");
+	}));
+}
+function report(io, json, result, verb) {
+	const { setting: entry, recordingsDeleted, ...write } = result;
+	if (json) {
+		io.out(JSON.stringify(result));
+		return;
+	}
+	for (const workspace of recordingsDeleted ?? []) io.note(`Deleted the device recordings of ${workspace}.`);
+	const effective = entry.origin === null ? "unset" : `${formatValue(entry.value)} (${formatOrigin(entry)})`;
+	if (!write.changed) {
+		io.out(`${write.key} was not set in ${write.file}; effective value: ${effective}`);
+		return;
+	}
+	const shown = verb === "set" ? ` = ${formatValue(entry.layers[write.scope])}` : "";
+	io.out(`${verb} ${write.key}${shown} in ${write.file}; effective value: ${effective}`);
+}
+function settingsCommand(program) {
+	registerSettings(program);
+}
+//#endregion
+export { settingsCommand as default, registerSettings };

package/dist/settings-write-CzD60rOD.mjs

@@ -0,0 +1,360 @@
+import { i as withWorkspaceProcessLock } from "./exec-DEoAhcze.mjs";
+import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-DlrsduwG.mjs";
+import { a as killOnAbort, i as gitPath } from "./operation-exec-BW0em61G.mjs";
+import { it as unknownSettingKeys, z as readCommittedSettings } from "./settings-C7O8A6ZI.mjs";
+import { r as findCommandWorkspaceAsync, t as NO_PROJECT_REFUSAL } from "./project-wM_XFTvE.mjs";
+import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-D5OGpYZM.mjs";
+import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-CQmfzAh7.mjs";
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, 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;
+}
+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 }
+		},
+		{
+			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) => ({
+		key,
+		scope,
+		file,
+		value: valueAt(settings, key)
+	})));
+}
+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
+//#region src/workspace/settings-write.ts
+function requireSetting(key) {
+	const setting = settingDefinition(key);
+	if (setting) return setting;
+	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 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("|")}.`);
+	}
+	if (!SETTING_SCOPES.includes(raw)) throw new SettingsRefusal("STIM_BAD_ARG", `--scope takes ${SETTING_SCOPES.join(", ")}, not ${JSON.stringify(raw)}.`, null);
+	const scope = 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);
+	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();
+}
+//#endregion
+export { layerFile as a, settingEntry as c, SettingsRefusal as i, readScope as n, readSettingsContext as o, requireSetting as r, readSettingsPayload as s, mutateSetting as t };