@mtndev/cli 1.1.0 → 2.0.1

package/esm/commands/doppler/set-secret.js

@@ -0,0 +1,370 @@
+import { prompt, promptChoice, promptYesNo } from "../aws/utils/tty.js";
+import { execDoppler } from "./utils.js";
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+//#region src/commands/doppler/set-secret.js
+/**
+* @typedef {Object} DopplerProject
+* @property {string} id
+* @property {string} name
+* @property {string} [description]
+*/
+/**
+* @typedef {Object} DopplerEnvironment
+* @property {string} id
+* @property {string} name
+*/
+/**
+* @typedef {Object} DopplerConfig
+* @property {string} name
+* @property {string} environment
+* @property {boolean} [root]
+*/
+/**
+* List Doppler projects (paginated until exhausted or cap).
+* @param {{ verbose?: boolean; limit?: number }} [params]
+* @returns {DopplerProject[]}
+*/
+function listProjects(params = {}) {
+	const { verbose = false, limit = 500 } = params;
+	/** @type {DopplerProject[]} */
+	const projects = [];
+	let page = 1;
+	while (projects.length < limit) {
+		const batch = execDoppler([
+			"projects",
+			"--json",
+			"--page",
+			String(page),
+			"--number",
+			"100"
+		], "json", true, verbose);
+		if (!Array.isArray(batch) || batch.length === 0) break;
+		for (const raw of batch) projects.push({
+			id: String(raw.id ?? raw.name ?? ""),
+			name: String(raw.name ?? raw.id ?? ""),
+			description: raw.description ? String(raw.description) : ""
+		});
+		if (batch.length < 100) break;
+		page += 1;
+	}
+	return projects.filter((project) => project.name).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* List environments for a project.
+* @param {{ project: string; verbose?: boolean }} params
+* @returns {DopplerEnvironment[]}
+*/
+function listEnvironments(params) {
+	const { project, verbose = false } = params;
+	const data = execDoppler([
+		"environments",
+		"--json",
+		"--project",
+		project
+	], "json", true, verbose);
+	if (!Array.isArray(data)) return [];
+	return data.map((raw) => ({
+		id: String(raw.id ?? ""),
+		name: String(raw.name ?? raw.id ?? "")
+	})).filter((env) => env.id).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* List configs for a project, optionally filtered by environment.
+* @param {{ project: string; environment?: string; verbose?: boolean }} params
+* @returns {DopplerConfig[]}
+*/
+function listConfigs(params) {
+	const { project, environment, verbose = false } = params;
+	/** @type {string[]} */
+	const args = [
+		"configs",
+		"--json",
+		"--project",
+		project
+	];
+	if (environment) args.push("--environment", environment);
+	const data = execDoppler(args, "json", true, verbose);
+	if (!Array.isArray(data)) return [];
+	return data.map((raw) => ({
+		name: String(raw.name ?? ""),
+		environment: String(raw.environment ?? ""),
+		root: Boolean(raw.root)
+	})).filter((config) => config.name).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Get an existing secret value (raw), or null if missing.
+* @param {{
+*   project: string;
+*   config: string;
+*   name: string;
+*   verbose?: boolean;
+* }} params
+* @returns {string | null}
+*/
+function getSecret(params) {
+	const { project, config, name, verbose = false } = params;
+	try {
+		const data = execDoppler([
+			"secrets",
+			"get",
+			name,
+			"--project",
+			project,
+			"--config",
+			config,
+			"--plain",
+			"--raw"
+		], "string", true, verbose);
+		if (typeof data !== "string") return null;
+		const value = data.replace(/\n$/, "");
+		return value.length > 0 ? value : "";
+	} catch {
+		return null;
+	}
+}
+/**
+* Set a secret via stdin so values need no shell escaping.
+* @param {{
+*   project: string;
+*   config: string;
+*   name: string;
+*   value: string;
+*   verbose?: boolean;
+* }} params
+*/
+function setSecret(params) {
+	const { project, config, name, value, verbose = false } = params;
+	const args = [
+		"secrets",
+		"set",
+		name,
+		"--project",
+		project,
+		"--config",
+		config,
+		"--no-interactive"
+	];
+	if (verbose) console.log(chalk.gray(`   Executing: doppler ${args.join(" ")}  <stdin value (${value.length} chars)>`));
+	const result = spawnSync("doppler", args, {
+		encoding: "utf-8",
+		input: value
+	});
+	if (result.error) throw new Error(result.error.message);
+	if (result.status !== 0) {
+		const stderr = (result.stderr || result.stdout || "").trim();
+		throw new Error(stderr || `doppler secrets set failed for ${name}`);
+	}
+}
+/**
+* @param {{ projects: DopplerProject[]; projectOption?: string }} params
+* @returns {Promise<string>}
+*/
+async function resolveProject(params) {
+	const { projects, projectOption } = params;
+	if (projectOption) {
+		const match = projects.find((project) => project.name === projectOption || project.id === projectOption);
+		if (!match) throw new Error(`Project "${projectOption}" not found. Available examples: ${projects.slice(0, 8).map((project) => project.name).join(", ")}`);
+		return match.name;
+	}
+	if (projects.length === 0) throw new Error("No Doppler projects found for this account.");
+	let candidates = projects;
+	if (projects.length > 30) {
+		const filter = await prompt(`  Filter projects (${projects.length} total, Enter for all): `);
+		if (filter) {
+			const lower = filter.toLowerCase();
+			candidates = projects.filter((project) => project.name.toLowerCase().includes(lower) || project.id.toLowerCase().includes(lower));
+			if (candidates.length === 0) throw new Error(`No projects matched "${filter}".`);
+		}
+	}
+	const maxShown = 50;
+	const shown = candidates.slice(0, maxShown);
+	if (candidates.length > maxShown) console.log(chalk.yellow(`  Showing first ${maxShown} of ${candidates.length} matches — refine with a filter next time.`));
+	const chosen = shown[await promptChoice({
+		message: "Choose a Doppler project:",
+		options: shown.map((project) => project.description ? `${project.name} — ${project.description}` : project.name)
+	})];
+	if (!chosen) throw new Error("No project selected");
+	return chosen.name;
+}
+/**
+* @param {{
+*   environments: DopplerEnvironment[];
+*   environmentOption?: string;
+* }} params
+* @returns {Promise<string | "all">}
+*/
+async function resolveEnvironment(params) {
+	const { environments, environmentOption } = params;
+	if (environmentOption) {
+		const normalized = environmentOption.trim().toLowerCase();
+		if (normalized === "all" || normalized === "*") return "all";
+		const match = environments.find((env) => env.id.toLowerCase() === normalized || env.name.toLowerCase() === normalized);
+		if (!match) throw new Error(`Environment "${environmentOption}" not found. Available: ${environments.map((env) => env.id).join(", ")}`);
+		return match.id;
+	}
+	if (environments.length === 0) return "all";
+	const options = [...environments.map((env) => `${env.id} (${env.name})`), "all environments"];
+	const index = await promptChoice({
+		message: "Choose an environment:",
+		options
+	});
+	if (index === options.length - 1) return "all";
+	const chosen = environments[index];
+	if (!chosen) throw new Error("No environment selected");
+	return chosen.id;
+}
+/**
+* @param {{
+*   configs: DopplerConfig[];
+*   configOption?: string;
+*   environment: string | "all";
+* }} params
+* @returns {Promise<string[]>}
+*/
+async function resolveConfigs(params) {
+	const { configs, configOption, environment } = params;
+	const scoped = environment === "all" ? configs : configs.filter((config) => config.environment === environment);
+	if (scoped.length === 0) throw new Error(environment === "all" ? "No configs found in this project." : `No configs found for environment "${environment}".`);
+	if (configOption) {
+		const normalized = configOption.trim().toLowerCase();
+		if (normalized === "all" || normalized === "*") return scoped.map((config) => config.name);
+		const requested = configOption.split(",").map((value) => value.trim());
+		const names = new Set(scoped.map((config) => config.name));
+		const missing = requested.filter((name) => !names.has(name));
+		if (missing.length > 0) throw new Error(`Config(s) not found: ${missing.join(", ")}. Available: ${[...names].join(", ")}`);
+		return requested;
+	}
+	if (scoped.length === 1) {
+		const only = scoped[0];
+		if (!only) throw new Error("No config selected");
+		console.log(`  Config: ${only.name}`);
+		return [only.name];
+	}
+	const options = [...scoped.map((config) => config.root ? `${config.name} (root, env: ${config.environment})` : `${config.name} (env: ${config.environment})`), `all configs listed (${scoped.length})`];
+	const index = await promptChoice({
+		message: "Choose a config:",
+		options
+	});
+	if (index === options.length - 1) return scoped.map((config) => config.name);
+	const chosen = scoped[index];
+	if (!chosen) throw new Error("No config selected");
+	return [chosen.name];
+}
+/**
+* @param {string | undefined} nameOption
+* @returns {Promise<string>}
+*/
+async function resolveSecretName(nameOption) {
+	if (nameOption) return nameOption;
+	const raw = await prompt("  Secret name (e.g. DATABASE_URL): ");
+	if (!raw) throw new Error("Secret name is required");
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw)) throw new Error("Secret name must be a valid env var identifier (letters, numbers, underscore)");
+	return raw;
+}
+/**
+* @param {string | undefined} valueOption
+* @returns {Promise<string>}
+*/
+async function resolveSecretValue(valueOption) {
+	if (valueOption !== void 0) return valueOption;
+	const raw = await prompt("  Secret value: ");
+	if (raw === "") {
+		if (!await promptYesNo({
+			message: "  Set an empty value?",
+			defaultYes: false
+		})) throw new Error("Secret value is required");
+	}
+	return raw;
+}
+/**
+* Interactively (or via flags) set a Doppler secret on one or more configs.
+* @param {{
+*   project?: string;
+*   environment?: string;
+*   config?: string;
+*   name?: string;
+*   value?: string;
+*   yes?: boolean;
+*   verbose?: boolean;
+* }} options
+*/
+async function setSecretInteractive(options) {
+	const { project: projectOption, environment: environmentOption, config: configOption, name: nameOption, value: valueOption, yes = false, verbose = false } = options;
+	console.log(chalk.blue("\nSet Doppler secret"));
+	console.log("");
+	const project = await resolveProject({
+		projects: listProjects({ verbose }),
+		projectOption
+	});
+	console.log(`Project: ${project}`);
+	console.log("");
+	const environment = await resolveEnvironment({
+		environments: listEnvironments({
+			project,
+			verbose
+		}),
+		environmentOption
+	});
+	console.log(environment === "all" ? "Environment: all" : `Environment: ${environment}`);
+	console.log("");
+	const targetConfigs = await resolveConfigs({
+		configs: listConfigs({
+			project,
+			environment: environment === "all" ? void 0 : environment,
+			verbose
+		}),
+		configOption,
+		environment
+	});
+	console.log(`Config(s): ${targetConfigs.join(", ")}`);
+	console.log("");
+	const name = await resolveSecretName(nameOption);
+	const value = await resolveSecretValue(valueOption);
+	/** @type {{ config: string; existing: string | null }[]} */
+	const existingByConfig = [];
+	for (const config of targetConfigs) {
+		const existing = getSecret({
+			project,
+			config,
+			name,
+			verbose
+		});
+		existingByConfig.push({
+			config,
+			existing
+		});
+	}
+	const overwrites = existingByConfig.filter((entry) => entry.existing !== null);
+	console.log("");
+	console.log("Plan:");
+	console.log(`  Project:  ${project}`);
+	console.log(`  Configs:  ${targetConfigs.join(", ")}`);
+	console.log(`  Name:     ${name}`);
+	console.log(`  Value:    ${value.length === 0 ? "(empty)" : `(${value.length} chars)`}`);
+	if (overwrites.length > 0) console.log(chalk.yellow(`  Overwrite: ${overwrites.length} config(s) already have this secret (${overwrites.map((entry) => entry.config).join(", ")})`));
+	else console.log(chalk.green("  Overwrite: none (new secret on all targets)"));
+	console.log("");
+	if (!yes) {
+		if (!await promptYesNo({
+			message: overwrites.length > 0 ? "Overwrite / set this secret?" : "Set this secret?",
+			defaultYes: false
+		})) {
+			console.log("Aborted.");
+			return;
+		}
+		console.log("");
+	}
+	for (const config of targetConfigs) {
+		setSecret({
+			project,
+			config,
+			name,
+			value,
+			verbose
+		});
+		console.log(chalk.green(`  ✓ set ${name} on ${project}/${config}`));
+	}
+}
+//#endregion
+export { getSecret, listConfigs, listEnvironments, listProjects, setSecret, setSecretInteractive };

package/esm/commands/doppler/utils/exec.js

@@ -1,12 +1,100 @@
-import {
-  exec,
-  execJson,
-  execNumber,
-  execString
-} from "../../../__chunks/SJXQJ7RS.js";
-export {
-  exec,
-  execJson,
-  execNumber,
-  execString
-};
+import chalk from "chalk";
+import { execSync } from "child_process";
+//#region src/commands/doppler/utils/exec.js
+/**
+* @typedef {'silent' | 'verbose' | 'default'} VerbosityLevel
+*/
+/**
+* @typedef {Object} ExecOptions
+* @property {'string' | 'number' | 'json'} [stdoutParser='string'] - How to parse stdout
+* @property {boolean} [throwOnError=true] - Whether to throw on error
+* @property {VerbosityLevel} [verbosity='default'] - Output verbosity level
+*/
+/**
+* Execute a command and parse the output
+* @param {string} command - Command to execute
+* @param {import('child_process').ExecSyncOptions & ExecOptions} [options={}] - Execution options (inherits all execSync options + custom options)
+* @returns {string | number | any} - Parsed output based on stdoutParser
+*/
+function exec(command, options = {}) {
+	const { stdoutParser = "string", throwOnError = true, verbosity = "default", stdio: userStdio, ...execSyncOptions } = options;
+	try {
+		if (verbosity === "verbose") console.log(chalk.gray(`   Executing: ${command}`));
+		/** @type {import('child_process').StdioOptions} */
+		let stdio;
+		if (userStdio) stdio = userStdio;
+		else if (verbosity === "verbose") stdio = "inherit";
+		else if (verbosity === "silent") stdio = "pipe";
+		else stdio = [
+			"pipe",
+			"pipe",
+			"pipe"
+		];
+		const result = execSync(command, {
+			encoding: "utf-8",
+			stdio,
+			...execSyncOptions
+		});
+		if (stdio === "inherit") return stdoutParser === "string" ? "" : void 0;
+		if (!result || typeof result === "string" && !result.trim()) return stdoutParser === "string" ? "" : void 0;
+		switch (stdoutParser) {
+			case "json": try {
+				return JSON.parse(result);
+			} catch (parseError) {
+				if (throwOnError) throw new Error(`Failed to parse JSON output: ${parseError.message}`);
+				return;
+			}
+			case "number": {
+				const num = parseFloat(result.trim());
+				if (isNaN(num)) {
+					if (throwOnError) throw new Error(`Failed to parse number from output: ${result}`);
+					return;
+				}
+				return num;
+			}
+			default: return result;
+		}
+	} catch (error) {
+		if (!throwOnError) return;
+		if (error.stderr) throw new Error(error.stderr.toString());
+		throw error;
+	}
+}
+/**
+* Execute a command with string output
+* @param {string} command - Command to execute
+* @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+* @returns {string}
+*/
+function execString(command, options = {}) {
+	return exec(command, {
+		...options,
+		stdoutParser: "string"
+	});
+}
+/**
+* Execute a command with JSON output
+* @param {string} command - Command to execute
+* @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+* @returns {any}
+*/
+function execJson(command, options = {}) {
+	return exec(command, {
+		...options,
+		stdoutParser: "json"
+	});
+}
+/**
+* Execute a command with number output
+* @param {string} command - Command to execute
+* @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+* @returns {number}
+*/
+function execNumber(command, options = {}) {
+	return exec(command, {
+		...options,
+		stdoutParser: "number"
+	});
+}
+//#endregion
+export { exec, execJson, execNumber, execString };

package/esm/commands/doppler/utils.d.ts

@@ -8,17 +8,24 @@
  */
 export function execDoppler(args: string[], parser?: "string" | "json", silent?: boolean, verbose?: boolean): string | any;
 /**
- * Check if doppler CLI is installed and configured
+ * Check if the Doppler CLI is installed and the user is logged in.
+ * Does not require a local project setup (doppler setup).
+ * @param {boolean} verbose - Show verbose output
+ */
+export function checkDopplerAuth(verbose?: boolean): void;
+/**
+ * Check if doppler CLI is installed, logged in, and a project is configured.
  * @param {boolean} verbose - Show verbose output
  */
 export function checkDependencies(verbose?: boolean): void;
 /**
- * Get list of configurations based on environment parameter
- * @param {string} environment - Environment name ('all', 'dev', 'stg', 'prd', etc.)
+ * Get list of configurations based on environments parameter
+ * @param {string} environments - Comma-separated env names ('all', 'dev', 'dev,stg', etc.)
  * @param {boolean} verbose - Show verbose output
+ * @param {string | null} project - Optional Doppler project name
  * @returns {string[]}
  */
-export function getConfigs(environment: string, verbose?: boolean): string[];
+export function getConfigs(environments: string, verbose?: boolean, project?: string | null): string[];
 /**
  * Normalize escape sequences in file content
  * @param {string} content - File content
@@ -42,22 +49,39 @@ export function promptConfirmation(message: string): Promise<boolean>;
  * Download configurations from Doppler
  * @param {{
  * verbose: boolean;
- * environment: string;
+ * environments: string;
  * }} options - Options for downloading configurations
  */
 export function downloadConfigs(options: {
     verbose: boolean;
-    environment: string;
+    environments: string;
 }): Promise<void>;
 /**
  * Upload configurations to Doppler
  * @param {{
- * environment: string;
+ * environments: string;
  * verbose: boolean;
  * }} options - Options for uploading configurations
  */
 export function uploadConfigs(options: {
-    environment: string;
+    environments: string;
+    verbose: boolean;
+}): Promise<void>;
+/**
+ * Clone secrets from one Doppler project to another
+ * @param {{
+ * from: string;
+ * to: string;
+ * environments: string;
+ * force: boolean;
+ * verbose: boolean;
+ * }} options
+ */
+export function cloneProject({ from, to, environments, force, verbose }: {
+    from: string;
+    to: string;
+    environments: string;
+    force: boolean;
     verbose: boolean;
 }): Promise<void>;
 export type VerbosityLevel = import("./utils/exec.js").VerbosityLevel;