@mtndev/cli 1.1.0 → 2.0.1

package/esm/commands/aws/ses/send-email/schema.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Zod schema for `aws ses send-email` options.
+ */
+export const sendEmailOptionsSchema: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodString;
+    subject: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+    transport: z.ZodDefault<z.ZodOptional<z.ZodEnum<["api", "smtp"]>>>;
+    region: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    accessKeyId: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    region: string;
+    verbose: boolean;
+    dryRun: boolean;
+    to: string;
+    from: string;
+    subject: string;
+    transport: "api" | "smtp";
+    profile?: string | undefined;
+    accessKeyId?: string | undefined;
+    body?: string | undefined;
+}, {
+    to: string;
+    from: string;
+    profile?: string | undefined;
+    region?: string | undefined;
+    verbose?: boolean | undefined;
+    dryRun?: boolean | undefined;
+    accessKeyId?: string | undefined;
+    subject?: string | undefined;
+    body?: string | undefined;
+    transport?: "api" | "smtp" | undefined;
+}>;
+export type SendEmailOptions = z.infer<typeof sendEmailOptionsSchema>;
+import { z } from "zod";

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

@@ -0,0 +1,23 @@
+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.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Build a default test-email body with a timestamp and random token.
+ * @returns {string}
+ */
+export function defaultBody(): string;
+/**
+ * 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
+ */
+export function sendViaApi(params: {
+    to: string;
+    from: string;
+    subject: string;
+    body: string;
+    region: string;
+    profile?: string;
+}): Promise<string | undefined>;
+/**
+ * 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
+ */
+export function sendViaSmtp(params: {
+    to: string;
+    from: string;
+    subject: string;
+    body: string;
+    region: string;
+    accessKeyId?: string;
+}): Promise<string | undefined>;

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

@@ -0,0 +1,84 @@
+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.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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}
+ */
+export function calculateSmtpPassword(params: {
+    secretAccessKey: string;
+    region: string;
+}): string;
+/**
+ * SES SMTP endpoint host for a region.
+ * @param {string} region
+ * @returns {string}
+ */
+export function smtpEndpoint(region: string): string;
+/**
+ * AWS regions that expose an SES SMTP endpoint.
+ */
+export const SMTP_REGIONS: Set<string>;

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

@@ -0,0 +1,69 @@
+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.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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}
+ */
+export function parseAwsErrorCode(stderr: string): string | null;
+/**
+ * Verify that the given executables are available on PATH.
+ * @param {string[]} commands
+ * @throws {Error} If any command is missing
+ */
+export function requireCommands(commands: string[]): void;
+/**
+ * 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
+ */
+export function runAws(params: {
+    profile?: string;
+    region?: string;
+    args: string[];
+    expectJson?: boolean;
+    verbose?: boolean;
+    env?: Record<string, string>;
+}): any;
+/**
+ * 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}
+ */
+export function runAwsVault(params: {
+    profile: string;
+    args: string[];
+    duration?: string;
+    expectJson?: boolean;
+    verbose?: boolean;
+}): any;
+/**
+ * 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 }}
+ */
+export function getCallerIdentity(params: {
+    profile?: string;
+    region?: string;
+    verbose?: boolean;
+}): {
+    Account: string;
+    Arn: string;
+    UserId: string;
+};
+/**
+ * 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").
+ */
+export class AwsCliError extends Error {
+    /**
+     * @param {string} message
+     * @param {string | null} [code]
+     */
+    constructor(message: string, code?: string | null);
+    code: string | null;
+}

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

@@ -0,0 +1,137 @@
+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.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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}
+ */
+export function resolvePolicyPath(fileName: string): string;

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

@@ -0,0 +1,14 @@
+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.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Read profile names from ~/.aws/config (honoring AWS_CONFIG_FILE).
+ * Handles both `[profile NAME]` entries and a bare `[default]` section.
+ * @returns {string[]}
+ */
+export function listConfigProfiles(): string[];
+/**
+ * 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>}
+ */
+export function pickProfileInteractive(profiles: string[]): Promise<string>;
+/**
+ * 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>}
+ */
+export function resolveProfile(params: {
+    profile?: string;
+    interactive?: boolean;
+}): Promise<string | undefined>;

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

@@ -0,0 +1,88 @@
+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 };

package/esm/commands/aws/utils/tty.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Prompt for a single line of input.
+ * @param {string} message - Prompt text shown to the user
+ * @returns {Promise<string>}
+ */
+export function prompt(message: string): Promise<string>;
+/**
+ * Prompt the user to pick one option from a numbered list.
+ * @param {{ message: string; options: string[] }} params
+ * @returns {Promise<number>} Zero-based index of the chosen option
+ */
+export function promptChoice(params: {
+    message: string;
+    options: string[];
+}): Promise<number>;
+/**
+ * Prompt a yes/no question.
+ * @param {{ message: string; defaultYes?: boolean }} params
+ * @returns {Promise<boolean>}
+ */
+export function promptYesNo(params: {
+    message: string;
+    defaultYes?: boolean;
+}): Promise<boolean>;