@mtndev/cli 1.1.0 → 2.0.1

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

@@ -0,0 +1,258 @@
+import { prompt, promptChoice, promptYesNo } from "../../utils/tty.js";
+import { AwsCliError, getCallerIdentity, requireCommands } from "../../utils/exec-aws.js";
+import { resolveProfile } from "../../utils/resolve-profile.js";
+import { RECORD_TYPES, addRecordOptionsSchema } from "./schema.js";
+import { findCnameConflicts, findHostedZone, formatValues, getRecordSetsAtName, hostedZoneLabel, listHostedZones, normalizeRecordValue, planRecordChange, resolveRecordName, upsertResourceRecordSet, withoutTrailingDot } from "./utils.js";
+import chalk from "chalk";
+import { ZodError } from "zod";
+//#region src/commands/aws/route53/add-record/handler.js
+/**
+* Resolve the hosted zone: from --zone, or interactive picker.
+* @param {{
+*   profile?: string;
+*   zoneOption?: string;
+*   verbose: boolean;
+* }} params
+* @returns {Promise<import("./utils.js").HostedZone>}
+*/
+async function resolveHostedZone(params) {
+	const { profile, zoneOption, verbose } = params;
+	const zones = listHostedZones({
+		profile,
+		verbose
+	});
+	if (zones.length === 0) throw new Error("No Route53 hosted zones found for this profile.");
+	if (zoneOption) {
+		const match = findHostedZone({
+			zones,
+			zoneInput: zoneOption
+		});
+		if (!match) throw new Error(`No hosted zone matching "${zoneOption}". Available: ${zones.map((z) => withoutTrailingDot(z.name)).join(", ")}`);
+		return match;
+	}
+	const chosen = zones[await promptChoice({
+		message: "Choose a hosted zone:",
+		options: zones.map((zone) => hostedZoneLabel(zone))
+	})];
+	if (!chosen) throw new Error("No hosted zone selected");
+	return chosen;
+}
+/**
+* Resolve record type from --type or interactive picker.
+* @param {string | undefined} typeOption
+* @returns {Promise<string>}
+*/
+async function resolveRecordType(typeOption) {
+	if (typeOption) return typeOption.toUpperCase();
+	const index = await promptChoice({
+		message: "Choose a record type:",
+		options: RECORD_TYPES
+	});
+	const chosen = RECORD_TYPES[index];
+	if (!chosen) throw new Error("No record type selected");
+	return chosen;
+}
+/**
+* Resolve record name from --name or prompt.
+* @param {{ nameOption?: string; zoneName: string }} params
+* @returns {Promise<string>} FQDN with trailing dot
+*/
+async function resolveName(params) {
+	const { nameOption, zoneName } = params;
+	let input = nameOption;
+	if (!input) input = await prompt(`Record name (relative to ${withoutTrailingDot(zoneName)}, or FQDN; @ for apex): `);
+	if (!input) throw new Error("Record name is required");
+	return resolveRecordName({
+		nameInput: input,
+		zoneName
+	});
+}
+/**
+* Resolve record value from --value or prompt.
+* @param {{ valueOption?: string; type: string }} params
+* @returns {Promise<string>}
+*/
+async function resolveValue(params) {
+	const { valueOption, type } = params;
+	let input = valueOption;
+	if (!input) input = await prompt(`Record value${type === "CNAME" ? " (e.g. target.example.com.)" : type === "TXT" ? " (quotes added if omitted)" : ""}: `);
+	if (!input) throw new Error("Record value is required");
+	return normalizeRecordValue({
+		type,
+		value: input
+	});
+}
+/**
+* When an existing multi-value set is present, ask replace vs append
+* (single-value types default to replace).
+* @param {{
+*   existing: import("./utils.js").ResourceRecordSet;
+*   type: string;
+* }} params
+* @returns {Promise<"replace" | "append">}
+*/
+async function resolveChangeMode(params) {
+	const { existing, type } = params;
+	if (type === "CNAME" || existing.values.length <= 1) return "replace";
+	console.log("");
+	console.log(chalk.yellow(`Existing ${type} record has ${existing.values.length} values:${formatValues(existing.values)}`));
+	return await promptYesNo({
+		message: "Add to the existing values instead of replacing them?",
+		defaultYes: false
+	}) ? "append" : "replace";
+}
+/**
+* `aws route53 add-record` handler: interactively (or via flags) create or
+* update a Route53 resource record set, showing whether the change adds or
+* overwrites.
+* @param {unknown} options
+*/
+async function addRecordCommand(options) {
+	try {
+		const { profile: profileOption, zone: zoneOption, type: typeOption, name: nameOption, value: valueOption, ttl: ttlOption, yes, dryRun, verbose } = addRecordOptionsSchema.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 value = await resolveValue({
+			valueOption,
+			type
+		});
+		const ttl = ttlOption ?? 300;
+		console.log("");
+		console.log("Proposed record:");
+		console.log(`  Name:  ${withoutTrailingDot(name)}`);
+		console.log(`  Type:  ${type}`);
+		console.log(`  TTL:   ${ttl}`);
+		console.log(`  Value: ${value}`);
+		console.log("");
+		const existingSets = getRecordSetsAtName({
+			profile,
+			hostedZoneId: zone.id,
+			name,
+			verbose
+		});
+		const existing = existingSets.find((set) => set.type === type) ?? null;
+		const conflicts = findCnameConflicts({
+			existingSets,
+			type
+		});
+		if (conflicts.length > 0) {
+			console.error(chalk.red(`❌ Conflict: cannot add a ${type} record at ${withoutTrailingDot(name)}.`));
+			console.error("");
+			console.error(chalk.yellow("Route53 does not allow a CNAME and any other record type to coexist at the same name. Conflicting record(s) already exist:"));
+			for (const conflict of conflicts) console.error(`  ${conflict.type}  ${withoutTrailingDot(conflict.name)}${formatValues(conflict.isAlias ? ["(alias)"] : conflict.values)}`);
+			console.error("");
+			console.error(chalk.yellow("Remove the conflicting record, then re-create the one you wanted:"));
+			const zoneName = withoutTrailingDot(zone.name);
+			const displayName = withoutTrailingDot(name);
+			const quotedValue = /^[A-Za-z0-9._:@/-]+$/.test(value) ? value : `"${value}"`;
+			const ttlFlag = ttl === 300 ? "" : ` --ttl ${ttl}`;
+			let step = 1;
+			for (const conflict of conflicts) console.error(chalk.cyan(`  ${step++}. mtn aws route53 remove-record -z ${zoneName} -t ${conflict.type} -n ${displayName}`));
+			console.error(chalk.cyan(`  ${step}. mtn aws route53 add-record -z ${zoneName} -t ${type} -n ${displayName} --value ${quotedValue}${ttlFlag}`));
+			process.exit(1);
+		}
+		if (existing?.isAlias) {
+			console.log(chalk.yellow("An ALIAS record already exists at this name + type. Continuing will replace it with a standard record set."));
+			console.log("");
+		} else if (existing) {
+			console.log(chalk.yellow(`Existing ${type} record at ${withoutTrailingDot(name)}:${formatValues(existing.values)}`));
+			if (existing.ttl !== void 0) console.log(`  TTL: ${existing.ttl}`);
+			console.log("");
+		} else {
+			console.log(chalk.green(`No existing ${type} record at ${withoutTrailingDot(name)}.`));
+			console.log("");
+		}
+		/** @type {"replace" | "append"} */
+		let mode = "replace";
+		if (existing && !existing.isAlias && existing.values.length > 0) mode = await resolveChangeMode({
+			existing,
+			type
+		});
+		const plan = planRecordChange({
+			existing,
+			newValue: value,
+			mode
+		});
+		console.log(plan.summary);
+		console.log("");
+		if (plan.action === "noop") return;
+		if (plan.action === "overwrite" || plan.action === "append") {
+			console.log("Final values that will be written:");
+			for (const finalValue of plan.finalValues) console.log(`  - ${finalValue}`);
+			console.log("");
+		}
+		if (dryRun) {
+			console.log(chalk.cyan("Dry run — no changes made."));
+			return;
+		}
+		if (!yes) {
+			if (!await promptYesNo({
+				message: plan.action === "create" ? "Create this record?" : plan.action === "append" ? "Add this value to the existing record?" : "Overwrite the existing record?",
+				defaultYes: false
+			})) {
+				console.log("Aborted.");
+				return;
+			}
+		}
+		const changeInfo = upsertResourceRecordSet({
+			profile,
+			hostedZoneId: zone.id,
+			name,
+			type,
+			ttl: existing?.ttl ?? ttl,
+			values: plan.finalValues,
+			verbose
+		});
+		console.log("");
+		console.log(chalk.green(`Done. ${plan.action === "create" ? "Created" : plan.action === "append" ? "Updated (appended)" : "Updated (overwrote)"} ${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❌ add-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 { addRecordCommand, resolveHostedZone, resolveName, resolveRecordType };

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

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

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

@@ -0,0 +1,4 @@
+import { DEFAULT_TTL, RECORD_TYPES, addRecordOptionsSchema } from "./schema.js";
+import { bareHostedZoneId, deleteResourceRecordSet, findCnameConflicts, findHostedZone, formatValues, getRecordSetsAtName, getResourceRecordSet, hostedZoneLabel, listHostedZones, normalizeRecordValue, planRecordChange, resolveRecordName, upsertResourceRecordSet, withTrailingDot, withoutTrailingDot } from "./utils.js";
+import { addRecordCommand, resolveHostedZone, resolveName, resolveRecordType } from "./handler.js";
+export { DEFAULT_TTL, RECORD_TYPES, addRecordCommand, addRecordOptionsSchema, bareHostedZoneId, deleteResourceRecordSet, findCnameConflicts, findHostedZone, formatValues, getRecordSetsAtName, getResourceRecordSet, hostedZoneLabel, listHostedZones, normalizeRecordValue, planRecordChange, resolveHostedZone, resolveName, resolveRecordName, resolveRecordType, upsertResourceRecordSet, withTrailingDot, withoutTrailingDot };

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

@@ -0,0 +1,45 @@
+/**
+ * Common Route53 record types offered in the interactive picker.
+ * Alias records are not supported by this command.
+ */
+export const RECORD_TYPES: string[];
+/**
+ * Default TTL (seconds) when creating or replacing a record set.
+ */
+export const DEFAULT_TTL: 300;
+/**
+ * Zod schema for `aws route53 add-record` options.
+ */
+export const addRecordOptionsSchema: 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>;
+    value: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    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;
+    value?: string | undefined;
+    type?: string | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+    ttl?: number | undefined;
+}, {
+    profile?: string | undefined;
+    verbose?: boolean | undefined;
+    yes?: boolean | undefined;
+    value?: string | undefined;
+    type?: string | undefined;
+    dryRun?: boolean | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+    ttl?: number | undefined;
+}>;
+export type AddRecordOptions = z.infer<typeof addRecordOptionsSchema>;
+import { z } from "zod";

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

@@ -0,0 +1,40 @@
+import { profileField, verboseField } from "../../schema.js";
+import { z } from "zod";
+//#region src/commands/aws/route53/add-record/schema.js
+/**
+* Common Route53 record types offered in the interactive picker.
+* Alias records are not supported by this command.
+*/
+const RECORD_TYPES = [
+	"A",
+	"AAAA",
+	"CNAME",
+	"TXT",
+	"MX",
+	"NS",
+	"SRV",
+	"CAA"
+];
+/**
+* Default TTL (seconds) when creating or replacing a record set.
+*/
+const DEFAULT_TTL = 300;
+/**
+* Zod schema for `aws route53 add-record` options.
+*/
+const addRecordOptionsSchema = 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"),
+	value: z.string().optional().describe("Record value (e.g. a CNAME target or A address)"),
+	ttl: z.number().int().positive().optional().describe(`TTL in seconds (default: 300)`),
+	yes: z.boolean().optional().default(false).describe("Skip the confirmation prompt"),
+	dryRun: z.boolean().optional().default(false).describe("Preview the change without calling Route53"),
+	verbose: verboseField
+});
+/**
+* @typedef {z.infer<typeof addRecordOptionsSchema>} AddRecordOptions
+*/
+//#endregion
+export { DEFAULT_TTL, RECORD_TYPES, addRecordOptionsSchema };

package/esm/commands/aws/route53/add-record/utils.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @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}
+ */
+export function bareHostedZoneId(rawId: string): string;
+/**
+ * Ensure a DNS name ends with a trailing dot (Route53 FQDN form).
+ * @param {string} name
+ * @returns {string}
+ */
+export function withTrailingDot(name: string): string;
+/**
+ * Strip a trailing dot for display.
+ * @param {string} name
+ * @returns {string}
+ */
+export function withoutTrailingDot(name: string): string;
+/**
+ * List hosted zones for the profile.
+ * @param {{ profile?: string; verbose?: boolean }} params
+ * @returns {HostedZone[]}
+ */
+export function listHostedZones(params: {
+    profile?: string;
+    verbose?: boolean;
+}): HostedZone[];
+/**
+ * Resolve a hosted zone from a name (mountaindev.com) or bare/prefixed ID.
+ * @param {{ zones: HostedZone[]; zoneInput: string }} params
+ * @returns {HostedZone | null}
+ */
+export function findHostedZone(params: {
+    zones: HostedZone[];
+    zoneInput: string;
+}): HostedZone | null;
+/**
+ * Build a display label for a hosted zone in the picker.
+ * @param {HostedZone} zone
+ * @returns {string}
+ */
+export function hostedZoneLabel(zone: HostedZone): string;
+/**
+ * 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
+ */
+export function resolveRecordName(params: {
+    nameInput: string;
+    zoneName: string;
+}): string;
+/**
+ * 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[]}
+ */
+export function getRecordSetsAtName(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    verbose?: boolean;
+}): ResourceRecordSet[];
+/**
+ * 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}
+ */
+export function getResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    type: string;
+    verbose?: boolean;
+}): ResourceRecordSet | 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[]}
+ */
+export function findCnameConflicts(params: {
+    existingSets: ResourceRecordSet[];
+    type: string;
+}): ResourceRecordSet[];
+/**
+ * Format existing values for console display.
+ * @param {string[]} values
+ * @returns {string}
+ */
+export function formatValues(values: string[]): string;
+/**
+ * Normalize a single record value for a given type (trailing dots, TXT quotes).
+ * @param {{ type: string; value: string }} params
+ * @returns {string}
+ */
+export function normalizeRecordValue(params: {
+    type: string;
+    value: string;
+}): string;
+/**
+ * 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;
+ * }}
+ */
+export function planRecordChange(params: {
+    existing: ResourceRecordSet | null;
+    newValue: string;
+    mode?: "replace" | "append";
+}): {
+    action: "create" | "overwrite" | "append" | "noop";
+    finalValues: string[];
+    summary: string;
+};
+/**
+ * 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
+ */
+export function upsertResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    type: string;
+    ttl: number;
+    values: string[];
+    verbose?: boolean;
+}): any;
+/**
+ * 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
+ */
+export function deleteResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    record: ResourceRecordSet;
+    verbose?: boolean;
+}): any;
+export type HostedZone = {
+    /**
+     * - Bare hosted zone ID (without /hostedzone/ prefix)
+     */
+    id: string;
+    /**
+     * - Zone name with trailing dot (e.g. mountaindev.com.)
+     */
+    name: string;
+    privateZone: boolean;
+    recordCount: number;
+};
+export type ResourceRecordSet = {
+    name: string;
+    type: string;
+    ttl: number | undefined;
+    values: string[];
+    isAlias: boolean;
+    /**
+     * - Raw AliasTarget block (present when isAlias)
+     */
+    aliasTarget?: any;
+};