@mtndev/cli 2.0.0 → 2.0.1

package/esm/commands/aws/route53/remove-record/schema.js

@@ -1,8 +1,21 @@
-import {
-  removeRecordOptionsSchema
-} from "../../../../__chunks/IZFGBYGE.js";
-import "../../../../__chunks/IEOGAQYI.js";
-import "../../../../__chunks/73BJG53F.js";
-export {
-  removeRecordOptionsSchema
-};
+import { profileField, verboseField } from "../../schema.js";
+import { RECORD_TYPES } from "../add-record/schema.js";
+import { z } from "zod";
+//#region src/commands/aws/route53/remove-record/schema.js
+/**
+* Zod schema for `aws route53 remove-record` options.
+*/
+const removeRecordOptionsSchema = z.object({
+	profile: profileField,
+	zone: z.string().optional().describe("Hosted zone name or ID (e.g. mountaindev.com or Z123…). Skips the zone picker when set."),
+	type: z.string().optional().transform((value) => value === void 0 ? void 0 : value.toUpperCase()).refine((value) => value === void 0 || typeof value === "string" && RECORD_TYPES.includes(value), { message: `Record type must be one of: ${RECORD_TYPES.join(", ")}` }).describe(`DNS record type (${RECORD_TYPES.join(", ")})`),
+	name: z.string().optional().describe("Record name relative to the zone (e.g. \"redline\") or a fully-qualified name"),
+	yes: z.boolean().optional().default(false).describe("Skip the confirmation prompt"),
+	dryRun: z.boolean().optional().default(false).describe("Preview the deletion without calling Route53"),
+	verbose: verboseField
+});
+/**
+* @typedef {z.infer<typeof removeRecordOptionsSchema>} RemoveRecordOptions
+*/
+//#endregion
+export { removeRecordOptionsSchema };

package/esm/commands/aws/schema.js

@@ -1,10 +1,16 @@
-import {
-  profileField,
-  regionField,
-  verboseField
-} from "../../__chunks/73BJG53F.js";
-export {
-  profileField,
-  regionField,
-  verboseField
-};
+import { z } from "zod";
+//#region src/commands/aws/schema.js
+/**
+* Shared Zod field for the AWS profile option.
+*/
+const profileField = z.string().optional().describe("AWS profile (defaults to the AWS_PROFILE environment variable)");
+/**
+* Shared Zod field for the AWS region option.
+*/
+const regionField = z.string().optional().describe("AWS region");
+/**
+* Shared Zod field for verbose logging.
+*/
+const verboseField = z.boolean().optional().default(false).describe("Enable verbose logging for detailed output and error traces");
+//#endregion
+export { profileField, regionField, verboseField };

package/esm/commands/aws/ses/send-email/handler.js

@@ -1,12 +1,70 @@
-import {
-  sendEmailCommand
-} from "../../../../__chunks/2FTTEFEK.js";
-import "../../../../__chunks/UXWY7BYE.js";
-import "../../../../__chunks/B2DVQ2UL.js";
-import "../../../../__chunks/5GIUAFXL.js";
-import "../../../../__chunks/3BKWTHLJ.js";
-import "../../../../__chunks/73BJG53F.js";
-import "../../../../__chunks/ZHKVJO2U.js";
-export {
-  sendEmailCommand
-};
+import { resolveProfile } from "../../utils/resolve-profile.js";
+import { sendEmailOptionsSchema } from "./schema.js";
+import { defaultBody, sendViaApi, sendViaSmtp } from "./utils.js";
+import chalk from "chalk";
+import { ZodError } from "zod";
+//#region src/commands/aws/ses/send-email/handler.js
+/**
+* `aws ses send-email` handler: send a single test email via the SES API or SMTP.
+* @param {unknown} options
+*/
+async function sendEmailCommand(options) {
+	try {
+		const parsed = sendEmailOptionsSchema.parse(options);
+		const { to, from, subject, transport, region, profile: profileOption, accessKeyId, dryRun, verbose } = parsed;
+		const body = parsed.body ?? defaultBody();
+		const profile = transport === "api" ? await resolveProfile({ profile: profileOption }) : profileOption;
+		console.log(chalk.blue("\n📧 SES send-email"));
+		console.log(chalk.gray(`   transport: ${transport}`));
+		console.log(chalk.gray(`   region:    ${region}`));
+		console.log(chalk.gray(`   from:      ${from}`));
+		console.log(chalk.gray(`   to:        ${to}`));
+		console.log(chalk.gray(`   subject:   ${subject}`));
+		if (verbose) console.log(chalk.gray(`   body:      ${body}`));
+		if (dryRun) {
+			console.log(chalk.yellow("\n[dry-run] No email sent."));
+			return;
+		}
+		const messageId = transport === "api" ? await sendViaApi({
+			to,
+			from,
+			subject,
+			body,
+			region,
+			profile
+		}) : await sendViaSmtp({
+			to,
+			from,
+			subject,
+			body,
+			region,
+			accessKeyId
+		});
+		console.log(chalk.green(`\n✅ Email sent${messageId ? ` (messageId: ${messageId})` : ""}.`));
+	} catch (error) {
+		if (error instanceof ZodError) {
+			console.error(chalk.red("\n❌ Invalid command options:"));
+			error.errors.forEach((err) => {
+				console.error(chalk.red(`   ${err.path.join(".")}: ${err.message}`));
+			});
+			process.exit(1);
+		}
+		const verbose = options?.verbose || false;
+		console.error(chalk.red("\n❌ send-email failed:"));
+		if (error instanceof Error) {
+			console.error(chalk.red(`   ${error.message}`));
+			if (verbose && error.stack) {
+				console.error(chalk.gray("\nStack trace:"));
+				console.error(chalk.gray(error.stack));
+			}
+		} else console.error(chalk.red(`   ${String(error)}`));
+		console.error(chalk.yellow("\n💡 Troubleshooting tips:"));
+		console.error(chalk.yellow("   • The sender address must be verified in SES"));
+		console.error(chalk.yellow("   • New SES accounts are sandboxed — recipients must also be verified"));
+		console.error(chalk.yellow("   • For smtp transport, set SES_SMTP_USER and SES_SMTP_PASSWORD"));
+		console.error(chalk.yellow("   • Use --verbose for detailed error information\n"));
+		process.exit(1);
+	}
+}
+//#endregion
+export { sendEmailCommand };

package/esm/commands/aws/ses/send-email/index.js

@@ -1,23 +1,4 @@
-import "../../../../__chunks/TXKMEIDQ.js";
-import {
-  sendEmailCommand
-} from "../../../../__chunks/2FTTEFEK.js";
-import {
-  defaultBody,
-  sendViaApi,
-  sendViaSmtp
-} from "../../../../__chunks/UXWY7BYE.js";
-import "../../../../__chunks/B2DVQ2UL.js";
-import "../../../../__chunks/5GIUAFXL.js";
-import {
-  sendEmailOptionsSchema
-} from "../../../../__chunks/3BKWTHLJ.js";
-import "../../../../__chunks/73BJG53F.js";
-import "../../../../__chunks/ZHKVJO2U.js";
-export {
-  defaultBody,
-  sendEmailCommand,
-  sendEmailOptionsSchema,
-  sendViaApi,
-  sendViaSmtp
-};
+import { sendEmailOptionsSchema } from "./schema.js";
+import { defaultBody, sendViaApi, sendViaSmtp } from "./utils.js";
+import { sendEmailCommand } from "./handler.js";
+export { defaultBody, sendEmailCommand, sendEmailOptionsSchema, sendViaApi, sendViaSmtp };

package/esm/commands/aws/ses/send-email/schema.js

@@ -1,7 +1,23 @@
-import {
-  sendEmailOptionsSchema
-} from "../../../../__chunks/3BKWTHLJ.js";
-import "../../../../__chunks/73BJG53F.js";
-export {
-  sendEmailOptionsSchema
-};
+import { profileField, verboseField } from "../../schema.js";
+import { z } from "zod";
+//#region src/commands/aws/ses/send-email/schema.js
+/**
+* Zod schema for `aws ses send-email` options.
+*/
+const sendEmailOptionsSchema = z.object({
+	to: z.string({ required_error: "--to <address> is required" }).describe("Recipient email address"),
+	from: z.string({ required_error: "--from <address> is required" }).describe("Verified SES sender email address"),
+	subject: z.string().optional().default("MTN CLI test email").describe("Email subject line"),
+	body: z.string().optional().describe("Email body (defaults to a timestamp and random token)"),
+	transport: z.enum(["api", "smtp"]).optional().default("api").describe("Send via the SES API (default) or SES SMTP"),
+	region: z.string().optional().default("us-east-1").describe("AWS region for the SES endpoint"),
+	profile: profileField,
+	accessKeyId: z.string().optional().describe("IAM access key ID used as the SMTP username (smtp transport only)"),
+	dryRun: z.boolean().optional().default(false).describe("Print the email payload without sending"),
+	verbose: verboseField
+});
+/**
+* @typedef {z.infer<typeof sendEmailOptionsSchema>} SendEmailOptions
+*/
+//#endregion
+export { sendEmailOptionsSchema };

package/esm/commands/aws/ses/send-email/utils.js

@@ -1,11 +1,84 @@
-import {
-  defaultBody,
-  sendViaApi,
-  sendViaSmtp
-} from "../../../../__chunks/UXWY7BYE.js";
-import "../../../../__chunks/B2DVQ2UL.js";
-export {
-  defaultBody,
-  sendViaApi,
-  sendViaSmtp
-};
+import { calculateSmtpPassword, smtpEndpoint } from "../smtp-password.js";
+import { randomBytes } from "crypto";
+//#region src/commands/aws/ses/send-email/utils.js
+/**
+* Build a default test-email body with a timestamp and random token.
+* @returns {string}
+*/
+function defaultBody() {
+	return `MTN CLI test email — random token: ${randomBytes(16).toString("hex")} — sent at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+}
+/**
+* Send an email through the SES API using the AWS SDK.
+* @param {{
+*   to: string;
+*   from: string;
+*   subject: string;
+*   body: string;
+*   region: string;
+*   profile?: string;
+* }} params
+* @returns {Promise<string | undefined>} The SES message id
+*/
+async function sendViaApi(params) {
+	const { to, from, subject, body, region, profile } = params;
+	const { SESClient, SendEmailCommand } = await import("@aws-sdk/client-ses");
+	const { fromNodeProviderChain } = await import("@aws-sdk/credential-providers");
+	const client = new SESClient({
+		region,
+		credentials: fromNodeProviderChain(profile ? { profile } : {})
+	});
+	const command = new SendEmailCommand({
+		Source: from,
+		Destination: { ToAddresses: [to] },
+		Message: {
+			Subject: { Data: subject },
+			Body: { Text: { Data: body } }
+		}
+	});
+	return (await client.send(command)).MessageId;
+}
+/**
+* Send an email through the SES SMTP endpoint using nodemailer.
+* Credentials come from SES_SMTP_USER/SES_SMTP_PASSWORD, or the password is
+* derived from AWS_SECRET_ACCESS_KEY when only that is available.
+* @param {{
+*   to: string;
+*   from: string;
+*   subject: string;
+*   body: string;
+*   region: string;
+*   accessKeyId?: string;
+* }} params
+* @returns {Promise<string | undefined>} The SMTP message id
+*/
+async function sendViaSmtp(params) {
+	const { to, from, subject, body, region, accessKeyId } = params;
+	const user = process.env.SES_SMTP_USER ?? accessKeyId;
+	let pass = process.env.SES_SMTP_PASSWORD;
+	if (!pass) {
+		const secret = process.env.AWS_SECRET_ACCESS_KEY;
+		if (secret) pass = calculateSmtpPassword({
+			secretAccessKey: secret,
+			region
+		});
+	}
+	if (!user || !pass) throw new Error("SMTP transport requires SES_SMTP_USER and SES_SMTP_PASSWORD, or AWS_SECRET_ACCESS_KEY (plus --access-key-id) to derive the SMTP password.");
+	const nodemailerModule = await import("nodemailer");
+	return (await (nodemailerModule.default ?? nodemailerModule).createTransport({
+		host: smtpEndpoint(region),
+		port: 587,
+		secure: false,
+		auth: {
+			user,
+			pass
+		}
+	}).sendMail({
+		from,
+		to,
+		subject,
+		text: body
+	})).messageId;
+}
+//#endregion
+export { defaultBody, sendViaApi, sendViaSmtp };

package/esm/commands/aws/ses/smtp-password.js

@@ -1,10 +1,69 @@
-import {
-  SMTP_REGIONS,
-  calculateSmtpPassword,
-  smtpEndpoint
-} from "../../../__chunks/B2DVQ2UL.js";
-export {
-  SMTP_REGIONS,
-  calculateSmtpPassword,
-  smtpEndpoint
-};
+import { createHmac } from "crypto";
+//#region src/commands/aws/ses/smtp-password.js
+/**
+* AWS regions that expose an SES SMTP endpoint.
+*/
+const SMTP_REGIONS = /* @__PURE__ */ new Set([
+	"us-east-2",
+	"us-east-1",
+	"us-west-1",
+	"us-west-2",
+	"ap-south-1",
+	"ap-northeast-2",
+	"ap-southeast-1",
+	"ap-southeast-2",
+	"ap-northeast-1",
+	"ca-central-1",
+	"eu-central-1",
+	"eu-west-1",
+	"eu-west-2",
+	"eu-west-3",
+	"eu-south-1",
+	"eu-north-1",
+	"sa-east-1",
+	"us-gov-west-1",
+	"us-gov-east-1",
+	"me-south-1",
+	"af-south-1",
+	"il-central-1"
+]);
+const DATE = "11111111";
+const SERVICE = "ses";
+const MESSAGE = "SendRawEmail";
+const TERMINAL = "aws4_request";
+const VERSION = 4;
+/**
+* @param {Buffer} key
+* @param {string} message
+* @returns {Buffer}
+*/
+function sign(key, message) {
+	return createHmac("sha256", key).update(message, "utf8").digest();
+}
+/**
+* Derive an SES SMTP password from an IAM secret access key, following the
+* AWS Signature V4 algorithm with SES-specific constants.
+* @see https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html#smtp-credentials-convert
+* @param {{ secretAccessKey: string; region: string }} params
+* @returns {string}
+*/
+function calculateSmtpPassword(params) {
+	const { secretAccessKey, region } = params;
+	if (!SMTP_REGIONS.has(region)) throw new Error(`calculateSmtpPassword: region "${region}" has no SES SMTP endpoint`);
+	let signature = sign(Buffer.from(`AWS4${secretAccessKey}`, "utf8"), DATE);
+	signature = sign(signature, region);
+	signature = sign(signature, SERVICE);
+	signature = sign(signature, TERMINAL);
+	signature = sign(signature, MESSAGE);
+	return Buffer.concat([Buffer.from([VERSION]), signature]).toString("base64");
+}
+/**
+* SES SMTP endpoint host for a region.
+* @param {string} region
+* @returns {string}
+*/
+function smtpEndpoint(region) {
+	return `email-smtp.${region}.amazonaws.com`;
+}
+//#endregion
+export { SMTP_REGIONS, calculateSmtpPassword, smtpEndpoint };

package/esm/commands/aws/utils/exec-aws.js

@@ -1,16 +1,137 @@
-import {
-  AwsCliError,
-  getCallerIdentity,
-  parseAwsErrorCode,
-  requireCommands,
-  runAws,
-  runAwsVault
-} from "../../../__chunks/FNXUONAV.js";
-export {
-  AwsCliError,
-  getCallerIdentity,
-  parseAwsErrorCode,
-  requireCommands,
-  runAws,
-  runAwsVault
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+//#region src/commands/aws/utils/exec-aws.js
+/**
+* Error raised when the AWS CLI (or aws-vault) exits non-zero.
+* The `code` is the AWS service error code parsed from stderr (e.g. "UnauthorizedOperation").
+*/
+var AwsCliError = class extends Error {
+	/**
+	* @param {string} message
+	* @param {string | null} [code]
+	*/
+	constructor(message, code = null) {
+		super(message);
+		this.name = "AwsCliError";
+		this.code = code;
+	}
 };
+/**
+* Extract the AWS service error code from a CLI stderr string.
+* AWS prints codes in parentheses, e.g. "...(UnauthorizedOperation) when calling...".
+* @param {string} stderr
+* @returns {string | null}
+*/
+function parseAwsErrorCode(stderr) {
+	return /\(([A-Za-z.]+)\)/.exec(stderr)?.[1] ?? null;
+}
+/**
+* Verify that the given executables are available on PATH.
+* @param {string[]} commands
+* @throws {Error} If any command is missing
+*/
+function requireCommands(commands) {
+	const missing = commands.filter((command) => {
+		return spawnSync("which", [command], { stdio: "pipe" }).status !== 0;
+	});
+	if (missing.length > 0) throw new Error(`Required command(s) not found on PATH: ${missing.join(", ")}`);
+}
+/**
+* Run an AWS CLI command using a credential profile.
+* Uses an argument array (no shell) so JSON arguments need no escaping.
+* @param {{
+*   profile?: string;
+*   region?: string;
+*   args: string[];
+*   expectJson?: boolean;
+*   verbose?: boolean;
+*   env?: Record<string, string>;
+* }} params
+* @returns {any} Parsed JSON when expectJson is true, otherwise trimmed stdout string
+*/
+function runAws(params) {
+	const { profile, region, args, expectJson = true, verbose = false, env } = params;
+	/** @type {string[]} */
+	const finalArgs = [];
+	if (profile) finalArgs.push("--profile", profile);
+	if (region) finalArgs.push("--region", region);
+	finalArgs.push("--no-cli-pager", ...args);
+	if (expectJson) finalArgs.push("--output", "json");
+	return spawnAws("aws", finalArgs, {
+		expectJson,
+		verbose,
+		env
+	});
+}
+/**
+* Run an AWS CLI command through `aws-vault exec` for profiles whose credentials
+* are stored in the OS keychain rather than ~/.aws/credentials.
+* @param {{
+*   profile: string;
+*   args: string[];
+*   duration?: string;
+*   expectJson?: boolean;
+*   verbose?: boolean;
+* }} params
+* @returns {any}
+*/
+function runAwsVault(params) {
+	const { profile, args, duration = "15m", expectJson = true, verbose = false } = params;
+	/** @type {string[]} */
+	const awsArgs = ["--no-cli-pager", ...args];
+	if (expectJson) awsArgs.push("--output", "json");
+	return spawnAws("aws-vault", [
+		"exec",
+		profile,
+		"--duration",
+		duration,
+		"--",
+		"aws",
+		...awsArgs
+	], {
+		expectJson,
+		verbose
+	});
+}
+/**
+* @param {string} command
+* @param {string[]} args
+* @param {{ expectJson: boolean; verbose: boolean; env?: Record<string, string> }} options
+* @returns {any}
+*/
+function spawnAws(command, args, options) {
+	const { expectJson, verbose, env } = options;
+	if (verbose) console.log(chalk.gray(`   Executing: ${command} ${args.join(" ")}`));
+	const result = spawnSync(command, args, {
+		encoding: "utf-8",
+		env: env ? {
+			...process.env,
+			...env
+		} : process.env
+	});
+	if (result.error) throw new AwsCliError(result.error.message);
+	if (result.status !== 0) {
+		const stderr = (result.stderr || result.stdout || "").trim();
+		throw new AwsCliError(stderr || `Command failed: ${command} ${args.join(" ")}`, parseAwsErrorCode(stderr));
+	}
+	const stdout = (result.stdout ?? "").trim();
+	if (!expectJson) return stdout;
+	if (!stdout) return {};
+	return JSON.parse(stdout);
+}
+/**
+* Fetch the caller identity for a profile (account id and ARN).
+* @param {{ profile?: string; region?: string; verbose?: boolean }} params
+* @returns {{ Account: string; Arn: string; UserId: string }}
+*/
+function getCallerIdentity(params) {
+	const { profile, region, verbose } = params;
+	return runAws({
+		profile,
+		region,
+		args: ["sts", "get-caller-identity"],
+		verbose
+	});
+}
+//#endregion
+export { AwsCliError, getCallerIdentity, parseAwsErrorCode, requireCommands, runAws, runAwsVault };

package/esm/commands/aws/utils/resolve-policy-path.js

@@ -1,6 +1,14 @@
-import {
-  resolvePolicyPath
-} from "../../../__chunks/ZO55YUSY.js";
-export {
-  resolvePolicyPath
-};
+import { fileURLToPath } from "url";
+//#region src/commands/aws/utils/resolve-policy-path.js
+/**
+* Resolve the absolute path to a bundled IAM policy document.
+* Policies live alongside the source in `iam/policies/`, and the CLI runs from
+* source, so this path is valid at runtime.
+* @param {string} fileName - Policy JSON file name (e.g. "user-admins-write-list.json")
+* @returns {string}
+*/
+function resolvePolicyPath(fileName) {
+	return fileURLToPath(new URL(`../iam/policies/${fileName}`, import.meta.url));
+}
+//#endregion
+export { resolvePolicyPath };

package/esm/commands/aws/utils/resolve-profile.js

@@ -1,11 +1,88 @@
-import {
-  listConfigProfiles,
-  pickProfileInteractive,
-  resolveProfile
-} from "../../../__chunks/5GIUAFXL.js";
-import "../../../__chunks/ZHKVJO2U.js";
-export {
-  listConfigProfiles,
-  pickProfileInteractive,
-  resolveProfile
-};
+import { prompt, promptChoice } from "./tty.js";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+//#region src/commands/aws/utils/resolve-profile.js
+/**
+* Above this many matches we ask the user to narrow the filter rather than
+* printing an unusable wall of numbered options.
+*/
+const MAX_LISTED = 30;
+/**
+* Read profile names from ~/.aws/config (honoring AWS_CONFIG_FILE).
+* Handles both `[profile NAME]` entries and a bare `[default]` section.
+* @returns {string[]}
+*/
+function listConfigProfiles() {
+	const configPath = process.env.AWS_CONFIG_FILE ?? join(homedir(), ".aws", "config");
+	let contents;
+	try {
+		contents = readFileSync(configPath, "utf-8");
+	} catch {
+		return [];
+	}
+	/** @type {string[]} */
+	const profiles = [];
+	const profileRe = /^\[profile\s+(.+?)\]$/;
+	for (const rawLine of contents.split("\n")) {
+		const line = rawLine.trim();
+		const match = profileRe.exec(line);
+		if (match?.[1]) profiles.push(match[1].trim());
+		else if (line === "[default]") profiles.push("default");
+	}
+	return profiles;
+}
+/**
+* Interactively narrow a profile list by substring, then pick one.
+* A single match auto-selects; too many matches asks the user to narrow.
+* @param {string[]} profiles
+* @returns {Promise<string>}
+*/
+async function pickProfileInteractive(profiles) {
+	for (;;) {
+		const filter = (await prompt(chalk.cyan("Filter profiles (substring, Enter for all): "))).trim().toLowerCase();
+		const matches = filter ? profiles.filter((name) => name.toLowerCase().includes(filter)) : profiles;
+		if (matches.length === 0) {
+			console.log(chalk.yellow(`  No profiles match "${filter}". Try again.`));
+			continue;
+		}
+		if (matches.length === 1) {
+			const only = matches[0] ?? "";
+			console.log(chalk.green(`  → ${only}`));
+			return only;
+		}
+		if (matches.length > MAX_LISTED) {
+			console.log(chalk.yellow(`  ${matches.length} profiles match — narrow the filter (over ${MAX_LISTED} to list).`));
+			continue;
+		}
+		return matches[await promptChoice({
+			message: chalk.cyan("Select a profile:"),
+			options: matches
+		})] ?? "";
+	}
+}
+/**
+* Resolve the AWS profile for a single-profile command.
+*
+* Precedence: explicit `--profile`, then `AWS_PROFILE`, then — only when stdin
+* is a TTY — an interactive filter-and-pick over `~/.aws/config` profiles.
+* Returns `undefined` when nothing is set and we cannot prompt (non-interactive
+* shell, or no config profiles), leaving each command's existing "no profile"
+* handling in place.
+* @param {{ profile?: string; interactive?: boolean }} params
+* @returns {Promise<string | undefined>}
+*/
+async function resolveProfile(params) {
+	const explicit = params.profile ?? process.env.AWS_PROFILE;
+	if (explicit) return explicit;
+	if (!(params.interactive ?? Boolean(process.stdin.isTTY))) return;
+	const profiles = listConfigProfiles();
+	if (profiles.length === 0) return;
+	console.log(chalk.yellow("\nNo AWS profile selected (--profile and AWS_PROFILE are unset)."));
+	const chosen = await pickProfileInteractive(profiles);
+	console.log(chalk.gray(`Using profile "${chosen}" for this command.\n`));
+	return chosen;
+}
+//#endregion
+export { listConfigProfiles, pickProfileInteractive, resolveProfile };