glimmervoid 0.35.0 → 0.36.0

package/dist/chunks/{session-routes-BYy3am9m.js → session-routes-DB5aDKsx.js}

@@ -1,4 +1,4 @@
-import { g as SESSION_COMMANDS } from "./session-D6xXN0UU.js";
+import { h as SESSION_COMMANDS } from "./session-B8RhqQJe.js";
 //#region session/core/session-routes.ts
 var SUPERVISION_LINE = "Glimmervoid supervises this session. Run glimmervoid --help for the commands it gives you and this session's limits.";
 var GUARDRAILS_LINE = "Its guardrails are OS-enforced, so a read, write or connection they refuse will not succeed on retry.";

package/dist/chunks/settings-cli-C2TY6hl-.js

@@ -0,0 +1,484 @@
+import { r as errorMessage, t as errorCode } from "./text-DoirglWV.js";
+import "./session-B8RhqQJe.js";
+import { t as renderTable } from "./ascii-figure-core-pDAwtlKO.js";
+import { n as glimmervoidHomeDir, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import { r as BrowserConfig } from "./config-CuZ16F9W.js";
+import { $ as withEnvSecrets, A as settingsOf, C as deleteValueAtPath, D as scoreSettingsSearch, E as parsePosthogProjectSelection, M as FILE_ONLY_GROUPS, N as SETTINGS_REGISTRY, O as setValueAtPath, S as cloneValue, T as hasScaledUnit, X as ENV_SECRET_BINDINGS, Z as readEnvSecrets, j as valueAtPath, k as settingsGroupOf, l as saveConfigFileOnce, s as loadConfigFile, u as validateConfig, w as displayText, x as SETTINGS_INDEX } from "./config-store-LqQ7MuyV.js";
+import fs from "node:fs";
+import os from "node:os";
+import { parseArgs } from "node:util";
+//#region server/settings-cli.ts
+var usage = `glimmervoid settings: read and change config.json from the command line
+
+  glimmervoid settings list                  every config.json setting with its value and where the value comes from
+  glimmervoid settings get <path>            one setting; a secret shows as configured or not configured, never its value
+  glimmervoid settings set <path> <value>    validate the whole file and write it; a running Glimmervoid reloads it
+  glimmervoid settings unset <path>          remove the key from config.json so the default applies
+  glimmervoid settings search <text>         find settings by title, keyword, key path or section
+  glimmervoid settings schema                every setting: id, path, type, default, unit, effect and section (needs no config file)
+
+  <path> is a config.json key path such as posthog.trafficSpikeEnabled, or a setting id such as posthog-traffic-enabled.
+  <value> is true or false for a toggle, a number, text, a comma-separated or JSON list, or JSON for a structured value.
+  A number is in the unit config.json stores, as schema's Stored unit column names: set visions.dispatch.quietMs 45000 means 45000 ms.
+  Where the dashboard shows another unit, get, list and set add it in parentheses, such as 30000 (30 seconds).
+  A secret (a bot token or API key) is never set or unset here, since a value on the command line lands in shell history;
+  change it in the dashboard settings or through its environment variable.
+  --json           machine-readable output`;
+var VALUE_COLUMN_WIDTH = 40;
+var EFFECT_NOTES = Object.freeze({
+	now: "A running Glimmervoid applies it without a restart.",
+	"new-sessions": "Sessions started after this change use it.",
+	restart: "Restart Glimmervoid to apply it."
+});
+var HAND_EDITED_SETTING_REASONS = /* @__PURE__ */ new Map([["port", "a listener port that clashes with remote.port stops Glimmervoid from starting"]]);
+var SECTION_BY_SETTING_ID = new Map([...SETTINGS_REGISTRY.sections.flatMap((section) => section.settings.map((setting) => [setting.id, {
+	id: section.id,
+	title: section.title
+}])), ...SETTINGS_REGISTRY.fileOnly.map((setting) => {
+	const groupId = setting.group ?? "";
+	return [setting.id, {
+		id: groupId,
+		title: settingsGroupOf(groupId)?.title ?? groupId
+	}];
+})]);
+var ALL_SETTINGS = [...settingsOf(SETTINGS_REGISTRY.sections), ...SETTINGS_REGISTRY.fileOnly];
+var SECTION_ORDER = [...SETTINGS_REGISTRY.sections.map((section) => ({
+	id: section.id,
+	title: section.title
+})), ...Object.entries(FILE_ONLY_GROUPS).map(([id, group]) => ({
+	id,
+	title: group.title
+}))];
+function fail(message) {
+	return {
+		ok: false,
+		message
+	};
+}
+function succeed(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function isConfigFileSetting(setting) {
+	return setting.scope === "machine" && setting.control !== "readonly";
+}
+function sectionOf(setting) {
+	return SECTION_BY_SETTING_ID.get(setting.id) ?? {
+		id: "",
+		title: ""
+	};
+}
+function describeSetting(setting) {
+	const descriptor = {
+		id: setting.id,
+		path: setting.path,
+		title: setting.title,
+		description: setting.description,
+		type: setting.control,
+		scope: setting.scope,
+		access: setting.access,
+		effect: setting.takesEffect,
+		default: cloneValue(setting.defaultValue) ?? null,
+		unit: setting.unit?.storedLabel ?? setting.unit?.label ?? null,
+		displayUnit: setting.unit?.label ?? null,
+		storedPerDisplay: setting.unit?.storedPerDisplay ?? 1,
+		section: sectionOf(setting)
+	};
+	if (setting.options) descriptor.options = setting.options.map((option) => option.value);
+	if (setting.range) descriptor.range = setting.range;
+	if (setting.fileOnlyReason) descriptor.fileOnlyReason = setting.fileOnlyReason;
+	return descriptor;
+}
+function isStoredSecret(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function readSetting(setting, view) {
+	const stored = valueAtPath(view.config, setting.path);
+	const source = view.secretSources[setting.path] ?? (stored !== void 0 ? "config.json" : "default");
+	const readout = {
+		...describeSetting(setting),
+		secret: setting.control === "password",
+		source
+	};
+	if (readout.secret) {
+		readout.configured = isStoredSecret(stored);
+		return readout;
+	}
+	readout.value = stored !== void 0 ? cloneValue(stored) : readout.default;
+	return readout;
+}
+function fitColumn(text) {
+	if (text.length <= VALUE_COLUMN_WIDTH) return text;
+	return `${text.slice(0, 37)}...`;
+}
+function storedValueText(setting, value) {
+	if (setting.valueKind) return displayText(setting, value);
+	const stored = JSON.stringify(value ?? null);
+	if (typeof value !== "number" || !hasScaledUnit(setting)) return stored;
+	return `${stored} (${displayText(setting, value)})`;
+}
+function valueText(readout, setting) {
+	if (readout.secret) return readout.configured ? "configured" : "not configured";
+	return storedValueText(setting, readout.value);
+}
+function defaultText(setting) {
+	return storedValueText(setting, setting.defaultValue);
+}
+function settingsBySection(settings) {
+	return SECTION_ORDER.map((section) => ({
+		section,
+		settings: settings.filter((setting) => sectionOf(setting).id === section.id)
+	})).filter((group) => group.settings.length > 0);
+}
+function renderSectionTables(settings, headers, rowOf) {
+	return settingsBySection(settings).map(({ section, settings: grouped }) => renderTable({
+		title: section.title,
+		headers,
+		rows: grouped.map(rowOf),
+		align: headers.map(() => "left")
+	})).join("\n\n");
+}
+function resolveSetting(argument) {
+	return SETTINGS_INDEX.byPath.get(argument) ?? SETTINGS_INDEX.byId.get(argument) ?? null;
+}
+function requireConfigFileSetting(argument, configPath) {
+	const setting = resolveSetting(argument);
+	if (!setting) return fail(`${argument} is not a setting in the registry, so this command cannot read or change it; edit config.json at ${configPath} by hand`);
+	if (setting.scope === "browser") return fail(`${setting.id} is a browser preference saved in each browser, not in config.json; change it in the dashboard under Settings > ${sectionOf(setting).title}`);
+	if (setting.control === "readonly") return fail(`${setting.id} is a read-only status row under Settings > ${sectionOf(setting).title}; it has no config.json key`);
+	return succeed(setting);
+}
+function requirePositional(positionals, index, name) {
+	const value = positionals[index];
+	if (value === void 0) throw new Error(`missing <${name}>\n\n${usage}`);
+	return value;
+}
+function parseListValue(path, raw) {
+	const listError = `${path} must be a comma-separated list or a JSON array of strings`;
+	if (!raw.trim().startsWith("[")) return succeed(raw.split(",").map((entry) => entry.trim()).filter((entry) => entry !== ""));
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) return succeed(parsed);
+	} catch {
+		return fail(listError);
+	}
+	return fail(listError);
+}
+function parseNumberValue(setting, raw) {
+	if (setting.nullable && raw.trim() === "") return succeed(null);
+	const number = Number(raw);
+	if (raw.trim() === "" || !Number.isFinite(number)) return fail(`${setting.path} must be a number`);
+	if (setting.integer !== false && !Number.isInteger(number)) return fail(`${setting.path} must be a whole number`);
+	if (setting.zeroIsNull && number <= 0) return succeed(null);
+	return succeed(number);
+}
+function parseSettingValue(setting, raw) {
+	if (setting.valueKind === "posthog-projects") {
+		const selection = parsePosthogProjectSelection(raw);
+		if (selection === null) return fail(`${setting.path} must be all, none or a comma-separated list of positive integer project ids`);
+		return succeed(selection);
+	}
+	if (setting.control === "toggle") {
+		if (/^(true|on|yes|1)$/i.test(raw.trim())) return succeed(true);
+		if (/^(false|off|no|0)$/i.test(raw.trim())) return succeed(false);
+		return fail(`${setting.path} must be a boolean: true or false`);
+	}
+	if (setting.control === "number") return parseNumberValue(setting, raw);
+	if (setting.control === "list" || setting.control === "projects") return parseListValue(setting.path, raw);
+	if (setting.control === "json") try {
+		return succeed(JSON.parse(raw));
+	} catch (error) {
+		return fail(`${setting.path} must be JSON: ${errorMessage(error)}`);
+	}
+	const text = raw.trim();
+	if (setting.nullable && text === "") return succeed(null);
+	return succeed(text);
+}
+function rangeLabel(range) {
+	if (range.label) return range.label;
+	if (range.max !== void 0) return `between ${range.min} and ${range.max}`;
+	return range.exclusiveMin ? `greater than ${range.min}` : `at least ${range.min}`;
+}
+function registryValueError(setting, value) {
+	if (value === null) return null;
+	if (setting.control === "number" && typeof value === "number" && setting.range) {
+		const belowMin = setting.range.exclusiveMin ? value <= setting.range.min : value < setting.range.min;
+		const aboveMax = setting.range.max !== void 0 && value > setting.range.max;
+		if (belowMin || aboveMax) return `${setting.path} must be ${rangeLabel(setting.range)}`;
+	}
+	if (setting.options && typeof value === "string" && !setting.options.some((option) => option.value === value)) return `${setting.path} must be one of ${setting.options.map((option) => option.value).join(", ")}`;
+	return null;
+}
+function isBrowserConfigKey(key) {
+	return Object.hasOwn(BrowserConfig.shape, key);
+}
+function dashboardSchemaCheck(setting) {
+	const [topLevelKey, ...nestedParts] = setting.path.split(".");
+	return (candidate) => {
+		if (!isBrowserConfigKey(topLevelKey)) return null;
+		const parsed = BrowserConfig.shape[topLevelKey].safeParse(candidate[topLevelKey]);
+		if (parsed.success) return null;
+		const issue = parsed.error.issues.find((candidateIssue) => nestedParts.every((part, index) => String(candidateIssue.path[index]) === part)) ?? parsed.error.issues.at(0);
+		if (!issue) return null;
+		const issueKeyPath = [topLevelKey, ...issue.path.map(String)].join(".");
+		return issue.message.includes(issueKeyPath) ? issue.message : `${issueKeyPath}: ${issue.message}`;
+	};
+}
+function validationErrorOf(view, mutate, settingPath, checks) {
+	const candidate = cloneValue(view.config);
+	if (!isRecord(candidate)) return "config must be a plain object";
+	mutate(candidate);
+	const validation = validateConfig(withEnvSecrets(candidate, readEnvSecrets(process.env)));
+	if (!validation.ok) {
+		const schemaMessage = validation.errors.join("; ");
+		return schemaMessage.includes(settingPath) ? schemaMessage : `${settingPath}: ${schemaMessage}`;
+	}
+	for (const check of checks) {
+		const error = check(candidate);
+		if (error) return error;
+	}
+	return null;
+}
+function applyValidatedMutation(view, setting, mutate, checks = []) {
+	const validationError = validationErrorOf(view, mutate, setting.path, checks);
+	if (validationError) throw new Error(validationError);
+	const saved = saveConfigFileOnce(view.configPath, mutate);
+	if (!saved.ok) throw new Error(saved.message);
+	return saved.config;
+}
+function unreadableHomeMessage(homeDir, error) {
+	return `cannot read the Glimmervoid home at ${homeDir} (${errorCode(error) ?? errorMessage(error)}). A session with guardrails cannot read it; run this command from a shell outside the session`;
+}
+function homeReadError(homeDir) {
+	try {
+		fs.accessSync(homeDir, fs.constants.R_OK);
+		return null;
+	} catch (error) {
+		if (errorCode(error) === "ENOENT" && !process.env["GLIMMERVOID_AGENT_URL"]) return null;
+		return unreadableHomeMessage(homeDir, error);
+	}
+}
+function readConfigFile(configPath, homeDir) {
+	try {
+		const loaded = loadConfigFile(configPath, { exitOnError: false });
+		if (!loaded.config) return fail(loaded.message);
+		return succeed(loaded.config);
+	} catch (error) {
+		if (errorCode(error) === "EACCES" || errorCode(error) === "EPERM") return fail(unreadableHomeMessage(homeDir, error));
+		return fail(`could not read ${configPath}: ${errorMessage(error)}`);
+	}
+}
+function openConfigFile() {
+	const env = process.env;
+	const homeDir = glimmervoidHomeDir(os.homedir(), env);
+	const homeError = homeReadError(homeDir);
+	if (homeError) return fail(homeError);
+	const decided = decideConfigPath({
+		env,
+		homeDir
+	}, (candidate) => fs.existsSync(candidate));
+	if (!decided.path && decided.source === "env") return fail(`config file not found: ${decided.envPath}`);
+	if (!decided.path) return fail(`no config.json at ${decided.homePath}. Start Glimmervoid once to create it; glimmervoid settings schema needs no config file`);
+	const loaded = readConfigFile(decided.path, homeDir);
+	if (!loaded.ok) return fail(loaded.message);
+	const secretSources = Object.fromEntries(readEnvSecrets(env).map((secret) => [`${secret.blockName}.${secret.secretKey}`, secret.environmentVariable]));
+	return succeed({
+		configPath: decided.path,
+		config: loaded.value,
+		secretSources
+	});
+}
+function print(context, jsonValue, text) {
+	context.writeOutput(`${context.isJson ? JSON.stringify(jsonValue, null, 2) : text}\n`);
+	return 0;
+}
+function requireView() {
+	const opened = openConfigFile();
+	if (!opened.ok) throw new Error(opened.message);
+	return opened.value;
+}
+function requireSetting(context, view) {
+	const resolved = requireConfigFileSetting(requirePositional(context.positionals, 1, "path"), view.configPath);
+	if (!resolved.ok) throw new Error(resolved.message);
+	return resolved.value;
+}
+function secretRefusal(setting) {
+	const binding = ENV_SECRET_BINDINGS.find((candidate) => `${candidate.blockName}.${candidate.secretKey}` === setting.path);
+	const environmentWay = binding ? `, or set ${binding.environmentVariable} in the environment Glimmervoid starts with` : "";
+	return `${setting.path} is a secret, so this command never takes or removes it, since a value on the command line lands in shell history; change it in the dashboard under Settings > ${sectionOf(setting).title}${environmentWay}`;
+}
+function writeRefusal(setting, configPath) {
+	if (setting.control === "password") return secretRefusal(setting);
+	const handEditedReason = HAND_EDITED_SETTING_REASONS.get(setting.path);
+	if (handEditedReason) return `${setting.path} cannot be changed from this command, because ${handEditedReason}; edit config.json at ${configPath} by hand`;
+	return null;
+}
+function requireWritableSetting(context, view) {
+	const setting = requireSetting(context, view);
+	const refusal = writeRefusal(setting, view.configPath);
+	if (refusal) throw new Error(refusal);
+	return setting;
+}
+var commands = {
+	list: (context) => {
+		const view = requireView();
+		const settings = ALL_SETTINGS.filter(isConfigFileSetting);
+		const readouts = settings.map((setting) => readSetting(setting, view));
+		const readoutById = new Map(readouts.map((readout) => [readout.id, readout]));
+		const rowOf = (setting) => {
+			const readout = readoutById.get(setting.id);
+			if (!readout) return [
+				setting.path,
+				"",
+				""
+			];
+			return [
+				setting.path,
+				fitColumn(valueText(readout, setting)),
+				readout.source
+			];
+		};
+		return print(context, readouts, renderSectionTables(settings, [
+			"Setting",
+			"Value",
+			"Source"
+		], rowOf));
+	},
+	get: (context) => {
+		const view = requireView();
+		const setting = requireSetting(context, view);
+		const readout = readSetting(setting, view);
+		const sourceNote = readout.secret && !readout.configured ? "" : ` (${readout.source})`;
+		return print(context, readout, `${setting.path} = ${valueText(readout, setting)}${sourceNote}`);
+	},
+	set: (context) => {
+		const view = requireView();
+		const setting = requireWritableSetting(context, view);
+		const parsed = parseSettingValue(setting, requirePositional(context.positionals, 2, "value"));
+		if (!parsed.ok) throw new Error(parsed.message);
+		const previous = cloneValue(valueAtPath(view.config, setting.path)) ?? null;
+		const written = applyValidatedMutation(view, setting, (config) => setValueAtPath(config, setting.path, parsed.value), [() => registryValueError(setting, parsed.value), dashboardSchemaCheck(setting)]);
+		const readout = readSetting(setting, {
+			...view,
+			config: written
+		});
+		return print(context, {
+			...readout,
+			previous,
+			configPath: view.configPath
+		}, `${setting.path} = ${valueText(readout, setting)}\n${EFFECT_NOTES[setting.takesEffect]}`);
+	},
+	unset: (context) => {
+		const view = requireView();
+		const setting = requireWritableSetting(context, view);
+		if (valueAtPath(view.config, setting.path) === void 0) return print(context, {
+			...readSetting(setting, view),
+			configPath: view.configPath,
+			changed: false
+		}, `${setting.path} is not set in config.json; the default ${defaultText(setting)} already applies`);
+		const written = applyValidatedMutation(view, setting, (config) => deleteValueAtPath(config, setting.path), [dashboardSchemaCheck(setting)]);
+		return print(context, {
+			...readSetting(setting, {
+				...view,
+				config: written
+			}),
+			configPath: view.configPath,
+			changed: true
+		}, `${setting.path} unset; the default ${defaultText(setting)} applies\n${EFFECT_NOTES[setting.takesEffect]}`);
+	},
+	search: (context) => {
+		const query = context.positionals.slice(1).join(" ");
+		if (query.trim() === "") throw new Error(`missing <text>\n\n${usage}`);
+		const results = scoreSettingsSearch(SETTINGS_REGISTRY.sections, query, SETTINGS_REGISTRY.fileOnly);
+		const rows = results.map((result) => [
+			result.setting.scope === "browser" ? `${result.setting.id} (browser preference)` : result.setting.path,
+			result.setting.title,
+			sectionOf(result.setting).title
+		]);
+		const text = results.length === 0 ? "(no matches)" : renderTable({
+			title: `Settings matching ${query}`,
+			headers: [
+				"Setting",
+				"Title",
+				"Section"
+			],
+			rows,
+			align: [
+				"left",
+				"left",
+				"left"
+			]
+		});
+		return print(context, results.map((result) => ({
+			...describeSetting(result.setting),
+			score: result.score
+		})), text);
+	},
+	schema: (context) => {
+		const rowOf = (setting) => [
+			setting.id,
+			setting.scope === "browser" ? `${setting.path} (browser)` : setting.path,
+			setting.control,
+			fitColumn(JSON.stringify(setting.defaultValue ?? null)),
+			setting.unit?.storedLabel ?? setting.unit?.label ?? "",
+			setting.unit?.label ?? "",
+			setting.takesEffect
+		];
+		return print(context, ALL_SETTINGS.map(describeSetting), renderSectionTables(ALL_SETTINGS, [
+			"Id",
+			"Path",
+			"Type",
+			"Default",
+			"Stored unit",
+			"Display unit",
+			"Effect"
+		], rowOf));
+	}
+};
+function runCommandLine(commandArguments, io) {
+	const { values, positionals } = parseArgs({
+		args: commandArguments,
+		allowPositionals: true,
+		options: {
+			json: {
+				type: "boolean",
+				default: false
+			},
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
+	});
+	const commandName = positionals[0];
+	const command = commandName === void 0 ? void 0 : commands[commandName];
+	if (values.help || commandName === void 0 || command === void 0) {
+		io.writeOutput(`${usage}\n`);
+		return values.help ? 0 : 1;
+	}
+	return command({
+		positionals,
+		isJson: values.json,
+		writeOutput: io.writeOutput
+	});
+}
+function processIo() {
+	return {
+		writeOutput: (text) => process.stdout.write(text),
+		writeError: (text) => process.stderr.write(text)
+	};
+}
+function runSettingsCommand(commandArguments, io = processIo()) {
+	try {
+		return runCommandLine(commandArguments, io);
+	} catch (error) {
+		io.writeError(`settings: ${errorMessage(error)}\n`);
+		return 1;
+	}
+}
+//#endregion
+export { runSettingsCommand };

package/dist/chunks/{ssh-sign-cli-DPHpT22B.js → ssh-sign-cli-C2nUwJC-.js}

@@ -1,8 +1,8 @@
 import { r as errorMessage } from "./text-DoirglWV.js";
-import { w as SshSignReply, y as SIGN_URL_ENV } from "./session-D6xXN0UU.js";
+import { C as SshSignReply, v as SIGN_URL_ENV } from "./session-B8RhqQJe.js";
 import { n as execFileAsync, o as spawn } from "./child-process-safe-CbQnyh7D.js";
 import { a as isLoopbackHostname } from "./hook-relay-core-DA_bz2KA.js";
-import { t as postToAgentIngress } from "./agent-api-cli-vGwstJ1j.js";
+import { t as postToAgentIngress } from "./agent-api-cli-d-Bgsshx.js";
 import { l as parseSshPublicKey } from "./ssh-signing-core-CRhVVWNW.js";
 import path from "node:path";
 import fsp from "node:fs/promises";