@mtndev/cli 1.1.0 → 2.0.1

package/esm/commands/aws/route53/add-record/utils.js

@@ -0,0 +1,389 @@
+import { runAws } from "../../utils/exec-aws.js";
+import "./schema.js";
+//#region src/commands/aws/route53/add-record/utils.js
+/**
+* @typedef {Object} HostedZone
+* @property {string} id - Bare hosted zone ID (without /hostedzone/ prefix)
+* @property {string} name - Zone name with trailing dot (e.g. mountaindev.com.)
+* @property {boolean} privateZone
+* @property {number} recordCount
+*/
+/**
+* @typedef {Object} ResourceRecordSet
+* @property {string} name
+* @property {string} type
+* @property {number | undefined} ttl
+* @property {string[]} values
+* @property {boolean} isAlias
+* @property {any} [aliasTarget] - Raw AliasTarget block (present when isAlias)
+*/
+/**
+* Strip the `/hostedzone/` prefix from a Route53 hosted zone Id.
+* @param {string} rawId
+* @returns {string}
+*/
+function bareHostedZoneId(rawId) {
+	return rawId.replace(/^\/hostedzone\//, "");
+}
+/**
+* Ensure a DNS name ends with a trailing dot (Route53 FQDN form).
+* @param {string} name
+* @returns {string}
+*/
+function withTrailingDot(name) {
+	const trimmed = name.trim();
+	if (trimmed === "") return trimmed;
+	return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+/**
+* Strip a trailing dot for display.
+* @param {string} name
+* @returns {string}
+*/
+function withoutTrailingDot(name) {
+	return name.endsWith(".") ? name.slice(0, -1) : name;
+}
+/**
+* List hosted zones for the profile.
+* @param {{ profile?: string; verbose?: boolean }} params
+* @returns {HostedZone[]}
+*/
+function listHostedZones(params) {
+	const { profile, verbose } = params;
+	const data = runAws({
+		profile,
+		args: ["route53", "list-hosted-zones"],
+		verbose
+	});
+	/** @type {HostedZone[]} */
+	const zones = [];
+	for (const zone of data.HostedZones ?? []) {
+		const id = bareHostedZoneId(String(zone.Id ?? ""));
+		const name = withTrailingDot(String(zone.Name ?? ""));
+		if (!id || !name) continue;
+		zones.push({
+			id,
+			name,
+			privateZone: Boolean(zone.Config?.PrivateZone),
+			recordCount: Number(zone.ResourceRecordSetCount ?? 0)
+		});
+	}
+	return zones.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Resolve a hosted zone from a name (mountaindev.com) or bare/prefixed ID.
+* @param {{ zones: HostedZone[]; zoneInput: string }} params
+* @returns {HostedZone | null}
+*/
+function findHostedZone(params) {
+	const { zones, zoneInput } = params;
+	const input = zoneInput.trim();
+	if (!input) return null;
+	const bareId = bareHostedZoneId(input);
+	const byId = zones.find((zone) => zone.id === bareId);
+	if (byId) return byId;
+	const normalized = withTrailingDot(input).toLowerCase();
+	const matches = zones.filter((zone) => zone.name.toLowerCase() === normalized);
+	if (matches.length === 1) return matches[0] ?? null;
+	if (matches.length > 1) return matches.find((zone) => !zone.privateZone) ?? matches[0] ?? null;
+	return null;
+}
+/**
+* Build a display label for a hosted zone in the picker.
+* @param {HostedZone} zone
+* @returns {string}
+*/
+function hostedZoneLabel(zone) {
+	const visibility = zone.privateZone ? "private" : "public";
+	return `${withoutTrailingDot(zone.name)}  (${zone.id}, ${visibility}, ${zone.recordCount} records)`;
+}
+/**
+* Turn a relative or absolute name into a Route53 FQDN under the zone.
+* Apex / "@" / empty → the zone apex.
+* @param {{ nameInput: string; zoneName: string }} params
+* @returns {string} FQDN with trailing dot
+*/
+function resolveRecordName(params) {
+	const { nameInput, zoneName } = params;
+	const zoneFqdn = withTrailingDot(zoneName);
+	const raw = nameInput.trim();
+	if (raw === "" || raw === "@") return zoneFqdn;
+	const asFqdn = withTrailingDot(raw);
+	const zoneLower = zoneFqdn.toLowerCase();
+	if (asFqdn.toLowerCase() === zoneLower) return zoneFqdn;
+	if (asFqdn.toLowerCase().endsWith(`.${zoneLower}`)) return asFqdn;
+	return withTrailingDot(`${raw.replace(/\.$/, "")}.${withoutTrailingDot(zoneFqdn)}`);
+}
+/**
+* Fetch every resource record set at an exact name, across all types.
+* Paginates when needed; Route53 list is ordered by name then type.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   verbose?: boolean;
+* }} params
+* @returns {ResourceRecordSet[]}
+*/
+function getRecordSetsAtName(params) {
+	const { profile, hostedZoneId, name, verbose } = params;
+	const targetName = withTrailingDot(name).toLowerCase();
+	let startRecordName = withTrailingDot(name);
+	/** @type {string | undefined} */
+	let startRecordType;
+	/** @type {string | undefined} */
+	let nextRecordIdentifier;
+	/** @type {ResourceRecordSet[]} */
+	const collected = [];
+	for (let page = 0; page < 20; page += 1) {
+		/** @type {string[]} */
+		const args = [
+			"route53",
+			"list-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--max-items",
+			"100"
+		];
+		if (startRecordName) args.push("--start-record-name", startRecordName);
+		if (startRecordType) args.push("--start-record-type", startRecordType);
+		if (nextRecordIdentifier) args.push("--start-record-identifier", nextRecordIdentifier);
+		const data = runAws({
+			profile,
+			args,
+			verbose
+		});
+		const sets = data.ResourceRecordSets ?? [];
+		for (const set of sets) {
+			const setName = withTrailingDot(String(set.Name ?? "")).toLowerCase();
+			if (setName === targetName) {
+				collected.push(normalizeRecordSet(set));
+				continue;
+			}
+			if (setName > targetName) return collected;
+		}
+		if (!(data.IsTruncated === true)) return collected;
+		startRecordName = data.NextRecordName ? String(data.NextRecordName) : startRecordName;
+		startRecordType = data.NextRecordType ? String(data.NextRecordType) : void 0;
+		nextRecordIdentifier = data.NextRecordIdentifier ? String(data.NextRecordIdentifier) : void 0;
+	}
+	return collected;
+}
+/**
+* Fetch a single resource record set by exact name + type, if it exists.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   type: string;
+*   verbose?: boolean;
+* }} params
+* @returns {ResourceRecordSet | null}
+*/
+function getResourceRecordSet(params) {
+	const { type, ...rest } = params;
+	const targetType = type.toUpperCase();
+	return getRecordSetsAtName(rest).find((set) => set.type === targetType) ?? null;
+}
+/**
+* Route53 forbids a CNAME from coexisting with any other record type at the
+* same name. Given the type about to be written and the record sets already at
+* that name, return the sets that would conflict (empty when there is none).
+* A same-type set is an overwrite, not a conflict.
+* @param {{ existingSets: ResourceRecordSet[]; type: string }} params
+* @returns {ResourceRecordSet[]}
+*/
+function findCnameConflicts(params) {
+	const { existingSets, type } = params;
+	const upperType = type.toUpperCase();
+	return existingSets.filter((set) => {
+		if (set.type === upperType) return false;
+		return upperType === "CNAME" || set.type === "CNAME";
+	});
+}
+/**
+* @param {any} set
+* @returns {ResourceRecordSet}
+*/
+function normalizeRecordSet(set) {
+	const values = (set.ResourceRecords ?? []).map((record) => String(record.Value ?? ""));
+	return {
+		name: withTrailingDot(String(set.Name ?? "")),
+		type: String(set.Type ?? "").toUpperCase(),
+		ttl: typeof set.TTL === "number" ? set.TTL : void 0,
+		values,
+		isAlias: Boolean(set.AliasTarget),
+		aliasTarget: set.AliasTarget ?? void 0
+	};
+}
+/**
+* Format existing values for console display.
+* @param {string[]} values
+* @returns {string}
+*/
+function formatValues(values) {
+	if (values.length === 0) return "(none)";
+	if (values.length === 1) return values[0] ?? "(none)";
+	return values.map((value) => `\n    - ${value}`).join("");
+}
+/**
+* Normalize a single record value for a given type (trailing dots, TXT quotes).
+* @param {{ type: string; value: string }} params
+* @returns {string}
+*/
+function normalizeRecordValue(params) {
+	const { type, value } = params;
+	const trimmed = value.trim();
+	if (type === "CNAME" || type === "NS" || type === "MX" || type === "SRV") {
+		if (type === "MX") {
+			const parts = trimmed.split(/\s+/);
+			if (parts.length >= 2) return `${parts[0]} ${withTrailingDot(parts.slice(1).join(" "))}`;
+		}
+		if (type === "SRV") {
+			const parts = trimmed.split(/\s+/);
+			if (parts.length >= 4) return `${parts.slice(0, 3).join(" ")} ${withTrailingDot(parts.slice(3).join(" "))}`;
+		}
+		return withTrailingDot(trimmed);
+	}
+	if (type === "TXT") {
+		if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed;
+		return `"${trimmed}"`;
+	}
+	return trimmed;
+}
+/**
+* Decide how the new value relates to an existing RRSet.
+* @param {{
+*   existing: ResourceRecordSet | null;
+*   newValue: string;
+*   mode?: "replace" | "append";
+* }} params
+* @returns {{
+*   action: "create" | "overwrite" | "append" | "noop";
+*   finalValues: string[];
+*   summary: string;
+* }}
+*/
+function planRecordChange(params) {
+	const { existing, newValue, mode = "replace" } = params;
+	if (!existing) return {
+		action: "create",
+		finalValues: [newValue],
+		summary: "Adding a new record (nothing exists at this name + type)."
+	};
+	if (existing.isAlias) return {
+		action: "overwrite",
+		finalValues: [newValue],
+		summary: "Overwriting an existing ALIAS record with a standard record set."
+	};
+	const alreadyPresent = existing.values.some((value) => value === newValue || value === `"${newValue}"`);
+	if (alreadyPresent && mode !== "replace") return {
+		action: "noop",
+		finalValues: existing.values,
+		summary: "Record already has this value. Nothing to do."
+	};
+	if (alreadyPresent && mode === "replace" && existing.values.length === 1 && existing.values[0] === newValue) return {
+		action: "noop",
+		finalValues: existing.values,
+		summary: "Record already has exactly this value. Nothing to do."
+	};
+	if (mode === "append") return {
+		action: "append",
+		finalValues: [...existing.values, newValue],
+		summary: `Adding to the existing ${existing.type} record (${existing.values.length} value(s) → ${existing.values.length + 1}).`
+	};
+	return {
+		action: "overwrite",
+		finalValues: [newValue],
+		summary: existing.values.length === 1 ? `Overwriting existing value:\n    ${existing.values[0]}\n  → ${newValue}` : `Replacing ${existing.values.length} existing values with a single new value.`
+	};
+}
+/**
+* Submit a Route53 UPSERT for a simple (non-alias) resource record set.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   type: string;
+*   ttl: number;
+*   values: string[];
+*   verbose?: boolean;
+* }} params
+* @returns {any} ChangeInfo from Route53
+*/
+function upsertResourceRecordSet(params) {
+	const { profile, hostedZoneId, name, type, ttl, values, verbose } = params;
+	const changeBatch = {
+		Comment: `mtn aws route53 add-record: ${type} ${name}`,
+		Changes: [{
+			Action: "UPSERT",
+			ResourceRecordSet: {
+				Name: withTrailingDot(name),
+				Type: type,
+				TTL: ttl ?? 300,
+				ResourceRecords: values.map((value) => ({ Value: value }))
+			}
+		}]
+	};
+	const data = runAws({
+		profile,
+		args: [
+			"route53",
+			"change-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--change-batch",
+			JSON.stringify(changeBatch)
+		],
+		verbose
+	});
+	return data.ChangeInfo ?? data;
+}
+/**
+* Submit a Route53 DELETE for an existing resource record set. Route53 requires
+* the record's exact current definition, so this is driven by the record set
+* returned from {@link getResourceRecordSet} — alias records reuse their
+* AliasTarget; standard records reuse their TTL + values.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   record: ResourceRecordSet;
+*   verbose?: boolean;
+* }} params
+* @returns {any} ChangeInfo from Route53
+*/
+function deleteResourceRecordSet(params) {
+	const { profile, hostedZoneId, record, verbose } = params;
+	/** @type {Record<string, any>} */
+	const resourceRecordSet = {
+		Name: withTrailingDot(record.name),
+		Type: record.type
+	};
+	if (record.isAlias && record.aliasTarget) resourceRecordSet.AliasTarget = record.aliasTarget;
+	else {
+		resourceRecordSet.TTL = record.ttl ?? 300;
+		resourceRecordSet.ResourceRecords = record.values.map((value) => ({ Value: value }));
+	}
+	const changeBatch = {
+		Comment: `mtn aws route53 remove-record: ${record.type} ${record.name}`,
+		Changes: [{
+			Action: "DELETE",
+			ResourceRecordSet: resourceRecordSet
+		}]
+	};
+	const data = runAws({
+		profile,
+		args: [
+			"route53",
+			"change-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--change-batch",
+			JSON.stringify(changeBatch)
+		],
+		verbose
+	});
+	return data.ChangeInfo ?? data;
+}
+//#endregion
+export { bareHostedZoneId, deleteResourceRecordSet, findCnameConflicts, findHostedZone, formatValues, getRecordSetsAtName, getResourceRecordSet, hostedZoneLabel, listHostedZones, normalizeRecordValue, planRecordChange, resolveRecordName, upsertResourceRecordSet, withTrailingDot, withoutTrailingDot };

package/esm/commands/aws/route53/remove-record/handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `aws route53 remove-record` handler: interactively (or via flags) delete a
+ * Route53 resource record set, showing the record before it is removed.
+ * @param {unknown} options
+ */
+export function removeRecordCommand(options: unknown): Promise<void>;

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

@@ -0,0 +1,111 @@
+import { promptYesNo } from "../../utils/tty.js";
+import { AwsCliError, getCallerIdentity, requireCommands } from "../../utils/exec-aws.js";
+import { resolveProfile } from "../../utils/resolve-profile.js";
+import { deleteResourceRecordSet, formatValues, getResourceRecordSet, hostedZoneLabel, withoutTrailingDot } from "../add-record/utils.js";
+import { resolveHostedZone, resolveName, resolveRecordType } from "../add-record/handler.js";
+import { removeRecordOptionsSchema } from "./schema.js";
+import chalk from "chalk";
+import { ZodError } from "zod";
+//#region src/commands/aws/route53/remove-record/handler.js
+/**
+* `aws route53 remove-record` handler: interactively (or via flags) delete a
+* Route53 resource record set, showing the record before it is removed.
+* @param {unknown} options
+*/
+async function removeRecordCommand(options) {
+	try {
+		const { profile: profileOption, zone: zoneOption, type: typeOption, name: nameOption, yes, dryRun, verbose } = removeRecordOptionsSchema.parse(options);
+		const profile = await resolveProfile({ profile: profileOption });
+		if (!profile) {
+			console.error(chalk.red("Error: pass --profile or set AWS_PROFILE."));
+			process.exit(1);
+		}
+		requireCommands(["aws"]);
+		const identity = getCallerIdentity({
+			profile,
+			verbose
+		});
+		console.log("Caller:");
+		console.log(`  Account: ${identity.Account}`);
+		console.log(`  Arn:     ${identity.Arn}`);
+		console.log("");
+		const zone = await resolveHostedZone({
+			profile,
+			zoneOption,
+			verbose
+		});
+		console.log(`Hosted zone: ${hostedZoneLabel(zone)}`);
+		console.log("");
+		const type = await resolveRecordType(typeOption);
+		const name = await resolveName({
+			nameOption,
+			zoneName: zone.name
+		});
+		const existing = getResourceRecordSet({
+			profile,
+			hostedZoneId: zone.id,
+			name,
+			type,
+			verbose
+		});
+		if (!existing) {
+			console.log(chalk.yellow(`No ${type} record at ${withoutTrailingDot(name)}. Nothing to remove.`));
+			return;
+		}
+		console.log("Record to remove:");
+		console.log(`  Name:  ${withoutTrailingDot(name)}`);
+		console.log(`  Type:  ${type}`);
+		if (existing.isAlias) console.log(`  Alias: ${withoutTrailingDot(String(existing.aliasTarget?.DNSName ?? ""))}`);
+		else {
+			if (existing.ttl !== void 0) console.log(`  TTL:   ${existing.ttl}`);
+			console.log(`  Value:${formatValues(existing.values)}`);
+		}
+		console.log("");
+		if (dryRun) {
+			console.log(chalk.cyan("Dry run — no changes made."));
+			return;
+		}
+		if (!yes) {
+			if (!await promptYesNo({
+				message: `Delete this ${type} record?`,
+				defaultYes: false
+			})) {
+				console.log("Aborted.");
+				return;
+			}
+		}
+		const changeInfo = deleteResourceRecordSet({
+			profile,
+			hostedZoneId: zone.id,
+			record: existing,
+			verbose
+		});
+		console.log("");
+		console.log(chalk.green(`Done. Deleted ${type} ${withoutTrailingDot(name)}.`));
+		if (changeInfo?.Id) {
+			console.log(`  Change ID: ${changeInfo.Id}`);
+			console.log(`  Status:    ${changeInfo.Status ?? "PENDING"}`);
+		}
+	} 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❌ remove-record failed:"));
+		if (error instanceof AwsCliError || 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💡 Use --verbose for detailed error information\n"));
+		process.exit(1);
+	}
+}
+//#endregion
+export { removeRecordCommand };

package/esm/commands/aws/route53/remove-record/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./handler.js";
+export * from "./schema.js";

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

@@ -0,0 +1,3 @@
+import { removeRecordOptionsSchema } from "./schema.js";
+import { removeRecordCommand } from "./handler.js";
+export { removeRecordCommand, removeRecordOptionsSchema };

package/esm/commands/aws/route53/remove-record/schema.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Zod schema for `aws route53 remove-record` options.
+ */
+export const removeRecordOptionsSchema: z.ZodObject<{
+    profile: z.ZodOptional<z.ZodString>;
+    zone: z.ZodOptional<z.ZodString>;
+    type: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined>;
+    name: z.ZodOptional<z.ZodString>;
+    yes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose: boolean;
+    yes: boolean;
+    dryRun: boolean;
+    profile?: string | undefined;
+    type?: string | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+}, {
+    profile?: string | undefined;
+    verbose?: boolean | undefined;
+    yes?: boolean | undefined;
+    type?: string | undefined;
+    dryRun?: boolean | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+}>;
+export type RemoveRecordOptions = z.infer<typeof removeRecordOptionsSchema>;
+import { z } from "zod";

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

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

@@ -0,0 +1,13 @@
+/**
+ * Shared Zod field for the AWS profile option.
+ */
+export const profileField: z.ZodOptional<z.ZodString>;
+/**
+ * Shared Zod field for the AWS region option.
+ */
+export const regionField: z.ZodOptional<z.ZodString>;
+/**
+ * Shared Zod field for verbose logging.
+ */
+export const verboseField: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+import { z } from "zod";

package/esm/commands/aws/schema.js

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

@@ -0,0 +1,5 @@
+/**
+ * `aws ses send-email` handler: send a single test email via the SES API or SMTP.
+ * @param {unknown} options
+ */
+export function sendEmailCommand(options: unknown): Promise<void>;

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

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

@@ -0,0 +1,3 @@
+export * from "./handler.js";
+export * from "./schema.js";
+export * from "./utils.js";

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

@@ -0,0 +1,4 @@
+import { sendEmailOptionsSchema } from "./schema.js";
+import { defaultBody, sendViaApi, sendViaSmtp } from "./utils.js";
+import { sendEmailCommand } from "./handler.js";
+export { defaultBody, sendEmailCommand, sendEmailOptionsSchema, sendViaApi, sendViaSmtp };