stim 1.11.0 → 1.12.0

package/dist/remote-cache-BRsRZru5.mjs

@@ -0,0 +1,526 @@
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { j as workspaceLogsDir } from "./metro-Dzo30hvJ.mjs";
+import { u as resolvePackageJson } from "./project-B8rbutVC.mjs";
+import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-CeT1nIIk.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { format } from "node:util";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/engine/remote-cache.ts
+const EAS_PROVIDER_PACKAGE = "eas-build-cache-provider";
+const RESOLVE_TIMEOUT_MS = 3e4;
+const UPLOAD_TIMEOUT_MS = 6e4;
+const CONFIG_TIMEOUT_MS = 3e4;
+const DYNAMIC_CONFIG_FILES = [
+	"app.config.ts",
+	"app.config.js",
+	"app.config.mjs",
+	"app.config.cjs"
+];
+const TIMED_OUT = Symbol("timed-out");
+function dynamicConfigFile(root) {
+	for (const name of DYNAMIC_CONFIG_FILES) if (existsSync(join(root, name))) return name;
+	return null;
+}
+function providerFromConfig(config) {
+	if (!config || typeof config !== "object") return null;
+	const expoField = config.expo;
+	const exp = expoField && typeof expoField === "object" ? expoField : config;
+	return exp.buildCacheProvider ?? exp.experiments?.buildCacheProvider ?? null;
+}
+function ownerFromConfig(config) {
+	if (!config || typeof config !== "object") return null;
+	const expoField = config.expo;
+	const owner = (expoField && typeof expoField === "object" ? expoField : config).owner;
+	return typeof owner === "string" && owner.trim() !== "" ? owner.trim() : null;
+}
+function normalizeProvider(raw) {
+	if (raw === null || raw === void 0 || raw === "") return null;
+	if (raw === "eas") return {
+		name: "eas",
+		reference: EAS_PROVIDER_PACKAGE,
+		options: {}
+	};
+	if (typeof raw === "object") {
+		const obj = raw;
+		if (typeof obj.plugin === "string" && obj.plugin.trim() !== "") {
+			const reference = obj.plugin.trim();
+			return {
+				name: reference,
+				reference,
+				options: obj.options && typeof obj.options === "object" ? obj.options : {}
+			};
+		}
+	}
+	return { invalid: typeof raw === "string" ? `"${raw}"` : JSON.stringify(raw) };
+}
+function runOptionsFor(platform) {
+	return platform === "android" ? { variant: "debug" } : { configuration: "Debug" };
+}
+function isProviderPlugin(plugin) {
+	if (!plugin || typeof plugin !== "object") return false;
+	const p = plugin;
+	const resolves = typeof p.resolveBuildCache === "function" || typeof p.resolveRemoteBuildCache === "function";
+	const uploads = typeof p.uploadBuildCache === "function" || typeof p.uploadRemoteBuildCache === "function";
+	return resolves && uploads;
+}
+function cacheLevel(value) {
+	return value === "local" || value === "remote" ? value : false;
+}
+function exitAfterFlush(code = 0, { exit = (c) => process.exit(c), stream = process.stdout } = {}) {
+	try {
+		stream.write("", () => exit(code));
+	} catch {
+		exit(code);
+	}
+}
+function readProjectConfig(root, { run = null, timeoutMs = CONFIG_TIMEOUT_MS } = {}) {
+	const dynamic = dynamicConfigFile(root);
+	if (!dynamic) {
+		const file = join(root, "app.json");
+		if (!existsSync(file)) return {
+			config: null,
+			source: null
+		};
+		try {
+			return {
+				config: JSON.parse(readFileSync(file, "utf-8")),
+				source: "app.json"
+			};
+		} catch (err) {
+			return { unavailable: `app.json could not be parsed: ${firstLine(err)}` };
+		}
+	}
+	const bin = expoBinPath(root);
+	if (!bin) return { unavailable: `${dynamic} is code, so it has to be evaluated to read its buildCacheProvider, and the \`expo\` package is not resolvable from this project (no expo/package.json to read a bin from, and no node_modules/.bin/expo here or in any parent)` };
+	const exec = run || ((file, args, opts) => getExecutor().runFile(file, args, opts));
+	let stdout;
+	try {
+		stdout = exec(bin, [
+			"config",
+			"--json",
+			root
+		], { timeoutMs });
+	} catch (err) {
+		return { unavailable: `\`expo config --json\` failed: ${firstLine(err)}` };
+	}
+	try {
+		return {
+			config: JSON.parse(String(stdout)),
+			source: dynamic
+		};
+	} catch (err) {
+		return { unavailable: `\`expo config --json\` did not print JSON: ${firstLine(err)}` };
+	}
+}
+async function loadPlugin(projectRoot, reference, { requireFrom = null } = {}) {
+	const localRequire = requireFrom ? requireFrom(projectRoot) : createRequire(join(projectRoot, "package.json"));
+	const file = localRequire.resolve(reference);
+	let mod;
+	try {
+		mod = localRequire(file);
+	} catch (err) {
+		if (err?.code !== "ERR_REQUIRE_ESM") throw err;
+		mod = await import(pathToFileURL(file).href);
+	}
+	const plugin = mod?.default ?? mod;
+	if (!isProviderPlugin(plugin)) throw new Error(`"${reference}" does not export resolveBuildCache and uploadBuildCache functions`);
+	return plugin;
+}
+async function loadProjectProvider(projectRoot, { isExpo = true, run = null, requireFrom = null, timeoutMs = CONFIG_TIMEOUT_MS } = {}) {
+	if (!isExpo) return { none: true };
+	const read = readProjectConfig(projectRoot, {
+		run,
+		timeoutMs
+	});
+	if (read.unavailable) return { unavailable: read.unavailable };
+	const normalized = normalizeProvider(providerFromConfig(read.config));
+	if (!normalized) return { none: true };
+	if (normalized.invalid) return { unavailable: `buildCacheProvider is ${normalized.invalid}, which is not "eas" or { plugin: <module> }` };
+	if (normalized.reference === "@stim-cli/expo-build-cache") return { none: true };
+	let plugin;
+	try {
+		plugin = await loadPlugin(projectRoot, normalized.reference, { requireFrom });
+	} catch (err) {
+		const missing = err?.code === "MODULE_NOT_FOUND";
+		return { unavailable: normalized.name === "eas" && missing ? `the EAS build cache needs the \`${EAS_PROVIDER_PACKAGE}\` package, which is not installed in this project` : `${normalized.name} could not be loaded: ${firstLine(err)}` };
+	}
+	return {
+		provider: {
+			plugin,
+			options: normalized.options ?? {}
+		},
+		name: normalized.name,
+		owner: ownerFromConfig(read.config)
+	};
+}
+const WHOAMI_TIMEOUT_MS = 15e3;
+const EAS_CLI_PACKAGE = "eas-cli";
+const EAS_CLI_BIN = "eas";
+function parseWhoami({ stdout = "", stderr = "", exitCode = 0 } = {}) {
+	const out = stripAnsi(stdout);
+	const combined = `${out}\n${stripAnsi(stderr)}`;
+	if (/^\s*Not logged in\s*$/m.test(combined)) return { loggedOut: true };
+	if (exitCode !== 0) return { unknown: firstLine(combined.trim() || `eas whoami exited ${exitCode}`) };
+	const lines = out.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+	if (lines.length === 0) return { unknown: "eas whoami printed nothing" };
+	const raw = lines[0];
+	if (raw === void 0) return { unknown: "eas whoami printed nothing" };
+	const viaToken = /\(authenticated using EXPO_TOKEN\)\s*$/.test(raw);
+	const display = raw.replace(/\s*\(authenticated using EXPO_TOKEN\)\s*$/, "").trim();
+	const accounts = [];
+	for (const line of lines) {
+		const name = /^\u2022\s*(\S+)\s*\(Role:/.exec(line)?.[1];
+		if (name !== void 0) accounts.push(name);
+	}
+	if (accounts.length === 0 && !display.endsWith("(robot)") && display !== "robot") accounts.push(display);
+	return {
+		loggedIn: true,
+		account: display,
+		accounts: accounts.length ? accounts : null,
+		viaToken
+	};
+}
+function isEasAuthFailureText(text) {
+	const t = stripAnsi(text || "");
+	if (t.trim() === "") return false;
+	return /not logged in/i.test(t) || /\beas login\b/i.test(t) || /EXPO_TOKEN/.test(t) || /unauthorized/i.test(t) || /not authorized/i.test(t) || /authentication (failed|required)/i.test(t);
+}
+function easAuthNote(status) {
+	const { code, account, owner, reason, phase = "resolve" } = status || {};
+	const because = reason ? ` (${reason})` : "";
+	if (code === "logged-out") return `eas is not authenticated${because} -- run \`eas login\` (or set EXPO_TOKEN); ` + (phase === "upload" ? "this build stayed in the local cache" : "building with the local cache only");
+	if (code === "wrong-account") return `eas is authenticated as ${account}, and this project's owner is ${owner} -- run \`eas login\` as a member of ${owner} (or set EXPO_TOKEN); consulting the EAS cache anyway`;
+	return null;
+}
+function resolveEasCliBin(projectRoot, { lookupPath = null } = {}) {
+	const fromPackage = expoBinFromPackage(resolvePackageJson(projectRoot, EAS_CLI_PACKAGE), EAS_CLI_BIN);
+	if (fromPackage) return {
+		file: fromPackage,
+		source: "project"
+	};
+	const shim = findBinUpward(projectRoot, EAS_CLI_BIN);
+	if (shim) return {
+		file: shim,
+		source: "project"
+	};
+	const onPath = lookupPath ? lookupPath() : getExecutor().findExecutable(EAS_CLI_BIN);
+	const file = (String(onPath || "").split("\n")[0] ?? "").trim();
+	return file ? {
+		file,
+		source: "path"
+	} : null;
+}
+const easAuthCache = /* @__PURE__ */ new Map();
+function checkEasAuth({ projectRoot, owner = null, run = null, resolveBin = null, timeoutMs = WHOAMI_TIMEOUT_MS, cache = easAuthCache }) {
+	const key = `${projectRoot}::${owner || ""}`;
+	if (cache?.has(key)) return cache.get(key);
+	const answer = probeEasAuth({
+		projectRoot,
+		owner,
+		run,
+		resolveBin,
+		timeoutMs
+	});
+	cache?.set(key, answer);
+	return answer;
+}
+function probeEasAuth({ projectRoot, owner, run, resolveBin, timeoutMs }) {
+	const bin = (resolveBin || resolveEasCliBin)(projectRoot);
+	if (!bin) return {
+		failed: true,
+		code: "no-cli",
+		reason: "no `eas` executable is resolvable from this project or on PATH",
+		remedy: "Install eas-cli (`npm i -g eas-cli`, or as a project devDependency), then run `eas login`."
+	};
+	const exec = run || ((file, args, opts) => getExecutor().runFile(file, args, opts));
+	let result;
+	try {
+		result = {
+			stdout: String(exec(bin.file, ["whoami"], { timeoutMs }) ?? ""),
+			exitCode: 0
+		};
+	} catch (e) {
+		const err = e;
+		if (err?.code === "ETIMEDOUT" || err?.signal === "SIGTERM" || err?.killed) return { unknown: `eas whoami timed out after ${timeoutMs}ms` };
+		result = {
+			stdout: String(err?.stdout ?? ""),
+			stderr: String(err?.stderr ?? err?.message ?? ""),
+			exitCode: typeof err?.status === "number" ? err.status : 1
+		};
+	}
+	const parsed = parseWhoami(result);
+	if (parsed.loggedOut) return {
+		failed: true,
+		code: "logged-out",
+		reason: "eas whoami says \"Not logged in\"",
+		remedy: "Run `eas login` (or set EXPO_TOKEN)."
+	};
+	if (parsed.unknown) return { unknown: parsed.unknown };
+	if (owner && Array.isArray(parsed.accounts) && !parsed.accounts.includes(owner)) return {
+		failed: true,
+		code: "wrong-account",
+		account: parsed.account,
+		accounts: parsed.accounts,
+		owner,
+		reason: `eas is authenticated as ${parsed.account} (accounts: ${parsed.accounts.join(", ")}), which does not include this project's owner ${owner}`,
+		remedy: `Run \`eas login\` as a member of ${owner}, or set EXPO_TOKEN to a token for it.`
+	};
+	return {
+		ok: true,
+		account: parsed.account,
+		accounts: parsed.accounts,
+		viaToken: parsed.viaToken,
+		source: bin.source
+	};
+}
+const capturing = [];
+const abandoned = /* @__PURE__ */ new Set();
+let patched = null;
+const PROVIDER_CONTEXT = new AsyncLocalStorage();
+function uploadDestination(lines) {
+	const text = (lines || []).map(stripAnsi);
+	for (const line of text) {
+		const url = /(https?:\/\/[^\s'"]+)/.exec(line)?.[1];
+		if (url !== void 0) return url.replace(/[.,)\]]+$/, "");
+	}
+	for (const line of text) {
+		const slug = /\bto\s+(@?[\w.-]+\/[\w.-]+)/i.exec(line)?.[1];
+		if (slug !== void 0) return slug.replace(/[.,)\]]+$/, "");
+	}
+	return null;
+}
+function providerNote(text) {
+	return `${"cache".padEnd(11)} ${text}`;
+}
+function currentFrame() {
+	const store = PROVIDER_CONTEXT.getStore();
+	return store && (capturing.includes(store) || abandoned.has(store)) ? store : null;
+}
+function install() {
+	if (patched && process.stdout.write === patched.patchedWrite) return;
+	const stdout = process.stdout;
+	const write = stdout.write.bind(stdout);
+	const log = console.log;
+	const passthrough = write;
+	const patchedWrite = ((chunk, encoding, callback) => {
+		const frame = currentFrame();
+		if (!frame) return passthrough(chunk, encoding, callback);
+		const cb = typeof encoding === "function" ? encoding : callback;
+		absorb(frame, typeof chunk === "string" ? chunk : String(chunk));
+		if (typeof cb === "function") cb();
+		return true;
+	});
+	const patchedLog = (...args) => {
+		const frame = currentFrame();
+		if (!frame) return log(...args);
+		absorb(frame, `${format(...args)}\n`);
+	};
+	stdout.write = patchedWrite;
+	console.log = patchedLog;
+	patched = {
+		stdout,
+		write,
+		log,
+		patchedWrite,
+		patchedLog
+	};
+}
+function uninstall() {
+	if (!patched || capturing.length || abandoned.size) return;
+	if (patched.stdout.write === patched.patchedWrite) patched.stdout.write = patched.write;
+	if (console.log === patched.patchedLog) console.log = patched.log;
+	patched = null;
+}
+function absorb(frame, chunk) {
+	try {
+		process.stderr.write(chunk);
+	} catch {}
+	frame.pending += chunk;
+	let index = frame.pending.indexOf("\n");
+	while (index !== -1) {
+		emitLine(frame, frame.pending.slice(0, index));
+		frame.pending = frame.pending.slice(index + 1);
+		index = frame.pending.indexOf("\n");
+	}
+}
+function emitLine(frame, raw) {
+	const line = stripAnsi(raw).trim();
+	if (line === "") return;
+	frame.lines.push(line);
+	const writer = frame.writer();
+	try {
+		writer?.write({
+			src: "build",
+			level: "debug",
+			event: "provider",
+			msg: line
+		});
+	} catch {}
+	frame.onLine?.(line);
+}
+function beginCapture({ logWriter = null, projectRoot = null, platform = null, onLine = null } = {}) {
+	let own = null;
+	const frame = {
+		lines: [],
+		pending: "",
+		onLine,
+		writer: () => {
+			if (logWriter) return logWriter;
+			if (own) return own;
+			if (!projectRoot || !platform) return null;
+			own = createNdjsonWriter(join(workspaceLogsDir(projectRoot), `build-${platform}.ndjson`));
+			return own;
+		},
+		close: () => {
+			own?.close?.();
+			own = null;
+		}
+	};
+	capturing.push(frame);
+	install();
+	return frame;
+}
+function endCapture(frame) {
+	if (!frame) return;
+	const at = capturing.lastIndexOf(frame);
+	if (at !== -1) capturing.splice(at, 1);
+	abandoned.delete(frame);
+	if (frame.pending !== "") {
+		const rest = frame.pending;
+		frame.pending = "";
+		emitLine(frame, rest);
+	}
+	frame.close();
+	uninstall();
+}
+function abandonCapture(frame, work) {
+	if (!frame) return;
+	const at = capturing.lastIndexOf(frame);
+	if (at !== -1) capturing.splice(at, 1);
+	abandoned.add(frame);
+	Promise.resolve(work).then(() => endCapture(frame), () => endCapture(frame));
+}
+async function resolveRemote({ provider, platform, projectRoot, fingerprintHash, runOptions = null, timeoutMs = RESOLVE_TIMEOUT_MS, logWriter = null } = {}) {
+	if (!provider?.plugin || !fingerprintHash) return null;
+	const opts = runOptions || runOptionsFor(platform);
+	const outcome = await withBudget(async () => {
+		const props = {
+			fingerprintHash: await providerFingerprint({
+				provider,
+				platform,
+				projectRoot,
+				runOptions: opts
+			}) ?? fingerprintHash,
+			platform,
+			runOptions: opts,
+			projectRoot
+		};
+		return typeof provider.plugin.resolveBuildCache === "function" ? provider.plugin.resolveBuildCache(props, provider.options) : provider.plugin.resolveRemoteBuildCache(props, provider.options);
+	}, timeoutMs, {
+		logWriter,
+		projectRoot,
+		platform
+	});
+	if (outcome.timedOut) return { timedOut: true };
+	if (outcome.error) return { failed: firstLine(outcome.error) };
+	const appPath = typeof outcome.value === "string" ? outcome.value.trim() : "";
+	if (!appPath) return null;
+	if (!existsSync(appPath)) return { failed: `returned ${appPath}, which does not exist` };
+	return { appPath };
+}
+async function uploadRemote({ provider, platform, projectRoot, fingerprintHash, buildPath, runOptions = null, timeoutMs = UPLOAD_TIMEOUT_MS, logWriter = null, note = (line) => console.error(line) } = {}) {
+	if (!provider?.plugin || !fingerprintHash || !buildPath) return { skipped: true };
+	const opts = runOptions || runOptionsFor(platform);
+	let announced = false;
+	const onLine = (line) => {
+		if (announced) return;
+		const dest = uploadDestination([line]);
+		if (!dest) return;
+		announced = true;
+		note(providerNote(`uploading to ${dest}`));
+	};
+	const outcome = await withBudget(async () => {
+		const props = {
+			projectRoot,
+			platform,
+			fingerprintHash: await providerFingerprint({
+				provider,
+				platform,
+				projectRoot,
+				runOptions: opts
+			}) ?? fingerprintHash,
+			buildPath,
+			runOptions: opts
+		};
+		return typeof provider.plugin.uploadBuildCache === "function" ? provider.plugin.uploadBuildCache(props, provider.options) : provider.plugin.uploadRemoteBuildCache(props, provider.options);
+	}, timeoutMs, {
+		logWriter,
+		projectRoot,
+		platform,
+		onLine
+	});
+	if (outcome.timedOut) return { timedOut: true };
+	if (outcome.error) return { failed: firstLine(outcome.error) };
+	if (typeof outcome.value !== "string" || outcome.value.trim() === "") {
+		const authLine = outcome.lines.find((line) => isEasAuthFailureText(line));
+		return { failed: authLine ? firstLine(authLine) : "the provider returned no upload destination" };
+	}
+	const destination = uploadDestination(outcome.lines);
+	return destination ? {
+		uploaded: true,
+		destination
+	} : { uploaded: true };
+}
+async function providerFingerprint({ provider, platform, projectRoot, runOptions }) {
+	if (typeof provider.plugin.calculateFingerprintHash !== "function") return null;
+	try {
+		const hash = await provider.plugin.calculateFingerprintHash({
+			projectRoot,
+			platform,
+			runOptions
+		}, provider.options);
+		return typeof hash === "string" && hash.trim() !== "" ? hash.trim() : null;
+	} catch {
+		return null;
+	}
+}
+async function withBudget(factory, ms, capture) {
+	let timer = null;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(TIMED_OUT), ms);
+		timer?.unref?.();
+	});
+	const frame = beginCapture(capture || {});
+	const work = Promise.resolve().then(() => PROVIDER_CONTEXT.run(frame, factory)).then((value) => ({ value }), (error) => ({ error }));
+	try {
+		const settled = await Promise.race([work, timeout]);
+		if (settled === TIMED_OUT) {
+			abandonCapture(frame, work);
+			return {
+				timedOut: true,
+				lines: frame.lines
+			};
+		}
+		endCapture(frame);
+		return {
+			...settled,
+			lines: frame.lines
+		};
+	} catch (err) {
+		endCapture(frame);
+		throw err;
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+function firstLine(err) {
+	const line = (String(err?.message || err || "unknown error").trim().split("\n")[0] ?? "").trim();
+	return line.length > 200 ? `${line.slice(0, 197)}...` : line;
+}
+//#endregion
+export { easAuthNote as a, loadProjectProvider as c, readProjectConfig as d, resolveEasCliBin as f, checkEasAuth as i, ownerFromConfig as l, uploadRemote as m, UPLOAD_TIMEOUT_MS as n, exitAfterFlush as o, resolveRemote as p, cacheLevel as r, isEasAuthFailureText as s, RESOLVE_TIMEOUT_MS as t, providerFromConfig as u };

package/dist/{server-bare-D_RK1RCj.mjs → server-bare-Gn3ssSdK.mjs}

@@ -1,6 +1,6 @@
 import { i as __require, t as __commonJSMin } from "./rolldown-runtime-BsOwBuO_.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { w as projectMetroSharedCache } from "./settings-B5oFZEri.mjs";
+import { w as projectMetroSharedCache } from "./settings-BlyDn2Oz.mjs";
 import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-DzeWkfqW.mjs";
 import { createRequire } from "node:module";
 import { isAbsolute, join, relative, sep } from "node:path";

package/dist/{server-expo-o6H5gcBc.mjs → server-expo-CeT1nIIk.mjs}

@@ -1,9 +1,9 @@
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { u as resolvePackageJson } from "./project-BXZzOABt.mjs";
+import { u as resolvePackageJson } from "./project-B8rbutVC.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
 import { n as stripAnsi, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { w as projectMetroSharedCache } from "./settings-B5oFZEri.mjs";
+import { w as projectMetroSharedCache } from "./settings-BlyDn2Oz.mjs";
 import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-DzeWkfqW.mjs";
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { LOG_ROTATE_BYTES } from "@stim-cli/core";

package/dist/server-expo-eWi9Coof.mjs

@@ -0,0 +1,2 @@
+import { p as startExpoServer } from "./server-expo-CeT1nIIk.mjs";
+export { startExpoServer };

package/dist/{settings-B5oFZEri.mjs → settings-BlyDn2Oz.mjs}

@@ -1,5 +1,5 @@
-import { d as getConfigPath$1, g as loadConfig$1, m as getRepoSettings, p as getProjectSettings } from "./config-BEq0Qw_a.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-BlizKDpZ.mjs";
+import { _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-0jCcMM0E.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
 import { existsSync, readFileSync, realpathSync, statSync } from "fs";
 import { isAbsolute, join, relative, resolve, sep } from "path";
 import { ANDROID_COMPILER_CACHE_CHOICES, ANDROID_PCH_CHOICES, REMOTE_DEVICE_BACKENDS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, acceptsShape, expectedShape, isLayeredSetting, settingDefinition, settingValueError } from "@stim-cli/core/state";

package/dist/{settings-C0ugALSC.mjs → settings-bE-Gu3Ti.mjs}

@@ -1,7 +1,8 @@
-import { E as writeConfigSetting, T as withConfigLock$1, d as getConfigPath$1, g as loadConfig$1, m as getRepoSettings, p as getProjectSettings } from "./config-BEq0Qw_a.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-BlizKDpZ.mjs";
-import { o as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-BXZzOABt.mjs";
-import { D as readCommittedSettings, L as unknownSettingKeys } from "./settings-B5oFZEri.mjs";
+import { D as writeConfigSetting, E as withConfigLock$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-0jCcMM0E.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
+import { i as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-B8rbutVC.mjs";
+import { n as stimDesktopInstalled, t as settingDefault } from "./stim-desktop-D0xhpZt8.mjs";
+import { D as readCommittedSettings, L as unknownSettingKeys } from "./settings-BlyDn2Oz.mjs";
 import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, settingDefinition, settingValueError } from "@stim-cli/core/state";
 import { join } from "node:path";
@@ -27,12 +28,14 @@ function readContext(env) {
 	const projectPath = findProjectRoot(process.cwd());
 	const start = projectPath ?? process.cwd();
 	const common = gitCommonDir(start);
+	let installed;
 	return {
 		projectPath,
 		gitCommonDir: common,
 		repoRoot: common ? repoRoot(start) ?? projectPath : null,
 		machine: loadConfig$1(),
-		env
+		env,
+		desktopInstalled: () => installed ??= stimDesktopInstalled()
 	};
 }
 function valueAt(settings, key) {
@@ -85,6 +88,7 @@ function settingEntry(context, setting) {
 	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";
@@ -95,8 +99,10 @@ function settingEntry(context, setting) {
 		value = layers[winner];
 		origin = winner;
 	} else if (setting.default !== void 0) {
-		value = setting.default;
+		const fallback = settingDefault(setting, context.desktopInstalled);
+		value = fallback.value;
 		origin = "default";
+		defaultReason = fallback.reason;
 	}
 	return {
 		key: setting.key,
@@ -107,7 +113,8 @@ function settingEntry(context, setting) {
 			name: "STIM_HOME",
 			value: context.env.STIM_HOME
 		} } : {},
-		...setting.sensitive ? { sensitive: true } : {}
+		...setting.sensitive ? { sensitive: true } : {},
+		...defaultReason ? { defaultReason } : {}
 	};
 }
 function unknownEntries(context) {
@@ -269,6 +276,10 @@ function writeSetting(context, setting, scope, value) {
 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)
@@ -302,9 +313,8 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 		}
 		const width = Math.max(...payload.settings.map((entry) => entry.key.length));
 		for (const entry of payload.settings) {
-			const origin = entry.origin ?? "unset";
 			const shown = entry.origin === null ? "" : formatValue(entry.value);
-			io.out(`${entry.key.padEnd(width)}  ${shown}${shown ? "  " : ""}${chalk.dim(`(${origin})`)}`);
+			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.`));
 	}));
@@ -323,7 +333,9 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 			} : entry));
 			return;
 		}
-		if (value !== null) io.out(formatValue(value));
+		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, () => {
 		const setting = requireSetting(key);
@@ -363,7 +375,7 @@ function report(io, json, write, setting, context, verb) {
 		}));
 		return;
 	}
-	const effective = entry.origin === null ? "unset" : `${formatValue(entry.value)} (${entry.origin})`;
+	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;