@mtndev/cli 0.0.0-dev-20260626045346 → 0.0.0-pr-20-20261020022402

package/esm/__chunks/G4NJHFFU.js

@@ -0,0 +1,320 @@
+import {
+  findCnameConflicts,
+  findHostedZone,
+  formatValues,
+  getRecordSetsAtName,
+  hostedZoneLabel,
+  listHostedZones,
+  normalizeRecordValue,
+  planRecordChange,
+  resolveRecordName,
+  upsertResourceRecordSet,
+  withoutTrailingDot
+} from "./33UYMUQD.js";
+import {
+  DEFAULT_TTL,
+  RECORD_TYPES,
+  addRecordOptionsSchema
+} from "./IEOGAQYI.js";
+import {
+  AwsCliError,
+  getCallerIdentity,
+  requireCommands
+} from "./FNXUONAV.js";
+import {
+  resolveProfile
+} from "./5GIUAFXL.js";
+import {
+  prompt,
+  promptChoice,
+  promptYesNo
+} from "./ZHKVJO2U.js";
+
+// src/commands/aws/route53/add-record/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+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 index = await promptChoice({
+    message: "Choose a hosted zone:",
+    options: zones.map((zone) => hostedZoneLabel(zone))
+  });
+  const chosen = zones[index];
+  if (!chosen) {
+    throw new Error("No hosted zone selected");
+  }
+  return chosen;
+}
+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;
+}
+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 });
+}
+async function resolveValue(params) {
+  const { valueOption, type } = params;
+  let input = valueOption;
+  if (!input) {
+    const hint = type === "CNAME" ? " (e.g. target.example.com.)" : type === "TXT" ? " (quotes added if omitted)" : "";
+    input = await prompt(`Record value${hint}: `);
+  }
+  if (!input) {
+    throw new Error("Record value is required");
+  }
+  return normalizeRecordValue({ type, value: input });
+}
+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)}`
+    )
+  );
+  const append = await promptYesNo({
+    message: "Add to the existing values instead of replacing them?",
+    defaultYes: false
+  });
+  return append ? "append" : "replace";
+}
+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 ?? DEFAULT_TTL;
+    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(
+          `\u274C 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 === DEFAULT_TTL ? "" : ` --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("");
+    }
+    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 \u2014 no changes made."));
+      return;
+    }
+    if (!yes) {
+      const confirmed = 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
+      });
+      if (!confirmed) {
+        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\u274C Invalid command options:"));
+      error.errors.forEach((err) => {
+        console.error(chalk.red(`   ${err.path.join(".")}: ${err.message}`));
+      });
+      process.exit(1);
+    }
+    const verbose = (
+      /** @type {any} */
+      options?.verbose || false
+    );
+    console.error(chalk.red("\n\u274C 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\u{1F4A1} Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  resolveHostedZone,
+  resolveRecordType,
+  resolveName,
+  addRecordCommand
+};

package/esm/__chunks/IEOGAQYI.js

@@ -0,0 +1,46 @@
+import {
+  profileField,
+  verboseField
+} from "./73BJG53F.js";
+
+// src/commands/aws/route53/add-record/schema.js
+import { z } from "zod";
+var RECORD_TYPES = [
+  "A",
+  "AAAA",
+  "CNAME",
+  "TXT",
+  "MX",
+  "NS",
+  "SRV",
+  "CAA"
+];
+var DEFAULT_TTL = 300;
+var addRecordOptionsSchema = z.object({
+  profile: profileField,
+  zone: z.string().optional().describe(
+    "Hosted zone name or ID (e.g. mountaindev.com or Z123\u2026). 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: ${DEFAULT_TTL})`),
+  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
+});
+
+export {
+  RECORD_TYPES,
+  DEFAULT_TTL,
+  addRecordOptionsSchema
+};

package/esm/__chunks/IZFGBYGE.js

@@ -0,0 +1,34 @@
+import {
+  RECORD_TYPES
+} from "./IEOGAQYI.js";
+import {
+  profileField,
+  verboseField
+} from "./73BJG53F.js";
+
+// src/commands/aws/route53/remove-record/schema.js
+import { z } from "zod";
+var removeRecordOptionsSchema = z.object({
+  profile: profileField,
+  zone: z.string().optional().describe(
+    "Hosted zone name or ID (e.g. mountaindev.com or Z123\u2026). 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
+});
+
+export {
+  removeRecordOptionsSchema
+};

package/esm/__chunks/J34UVKLA.js

@@ -0,0 +1,26 @@
+import {
+  profileField,
+  regionField,
+  verboseField
+} from "./73BJG53F.js";
+
+// src/commands/aws/ec2/allow-ip/schema.js
+import { z } from "zod";
+var DEFAULT_REGION = "us-east-1";
+var SSH_PORT = 22;
+var DEFAULT_ROAMING_NAME = "Declan";
+var allowIpOptionsSchema = z.object({
+  profile: profileField,
+  region: regionField,
+  ruleName: z.string().optional().describe(
+    'SSH rule description to update or create (default: "{FirstName} Roaming" derived from the profile/IAM user)'
+  ),
+  verbose: verboseField
+});
+
+export {
+  DEFAULT_REGION,
+  SSH_PORT,
+  DEFAULT_ROAMING_NAME,
+  allowIpOptionsSchema
+};

package/esm/__chunks/JZPBBBIG.js

@@ -0,0 +1,74 @@
+import {
+  usersOptionsSchema
+} from "./XXK32TIM.js";
+import {
+  createUsersInteractive
+} from "./3QLI5BDL.js";
+import {
+  getCallerIdentity,
+  requireCommands
+} from "./FNXUONAV.js";
+import {
+  resolveProfile
+} from "./5GIUAFXL.js";
+
+// src/commands/aws/iam/users/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+async function usersCommand(options) {
+  try {
+    const {
+      accountName,
+      profile: profileOption,
+      verbose
+    } = usersOptionsSchema.parse(options);
+    requireCommands(["aws"]);
+    const profile = await resolveProfile({ profile: profileOption });
+    console.log(chalk.blue("\nAWS IAM user management"));
+    console.log("");
+    console.log("Caller:");
+    const identity = getCallerIdentity({ profile, verbose });
+    console.log(`  Account: ${identity.Account}`);
+    console.log(`  Arn:     ${identity.Arn}`);
+    console.log("");
+    await createUsersInteractive({
+      accountName,
+      profile,
+      identity,
+      verbose
+    });
+    console.log("Done.");
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.error(chalk.red("\n\u274C Invalid command options:"));
+      error.errors.forEach((err) => {
+        console.error(chalk.red(`   ${err.path.join(".")}: ${err.message}`));
+      });
+      process.exit(1);
+    }
+    const verbose = (
+      /** @type {any} */
+      options?.verbose || false
+    );
+    console.error(chalk.red("\n\u274C iam users 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\u{1F4A1} Requires the AWS CLI and a profile with IAM write access.\n"
+      )
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  usersCommand
+};

package/esm/__chunks/KWUJP5MG.js

@@ -0,0 +1,135 @@
+// src/commands/doppler/schema.js
+import { z } from "zod";
+var environmentsBase = z.string().optional().describe(
+  'Environments to process, comma-separated (e.g., dev,stg,prd or "all")'
+);
+var commonFields = {
+  verbose: z.boolean().optional().default(false).describe("Enable verbose logging for detailed error information"),
+  help: z.boolean().optional().default(false).describe("Display help for command")
+};
+var dopplerDownloadSchema = z.object({
+  action: z.literal("download"),
+  environments: environmentsBase.default("dev"),
+  ...commonFields
+});
+var dopplerUploadSchema = z.object({
+  action: z.literal("upload"),
+  environments: environmentsBase.default("all"),
+  ...commonFields
+});
+var dopplerCloneSchema = z.object({
+  action: z.literal("clone"),
+  from: z.string({ required_error: "--from <project> is required for clone" }).describe("Source Doppler project name"),
+  to: z.string({ required_error: "--to <project> is required for clone" }).describe("Target Doppler project name"),
+  force: z.boolean().optional().default(false).describe("Skip confirmation prompts when overwriting existing secrets"),
+  environments: environmentsBase.default("all"),
+  ...commonFields
+});
+var dopplerSetSchema = z.object({
+  action: z.literal("set"),
+  project: z.string().optional().describe("Doppler project name (prompts when omitted)"),
+  environment: z.string().optional().describe(
+    'Doppler environment id (e.g. dev, stg, prd) or "all" (prompts when omitted)'
+  ),
+  config: z.string().optional().describe(
+    'Config name, comma-separated list, or "all" within the chosen environment (prompts when omitted)'
+  ),
+  name: z.string().optional().describe("Secret name / env var key (e.g. DATABASE_URL)"),
+  value: z.string().optional().describe("Secret value (prompts when omitted)"),
+  yes: z.boolean().optional().default(false).describe("Skip the confirmation prompt"),
+  ...commonFields
+});
+var dopplerCommandOptionsSchema = z.discriminatedUnion("action", [
+  dopplerDownloadSchema,
+  dopplerUploadSchema,
+  dopplerCloneSchema,
+  dopplerSetSchema
+]);
+var dopplerCommandMetadata = {
+  name: "doppler",
+  description: `Manage Doppler configurations
+
+Subcommands:
+  download  Download configurations from Doppler to local .env files
+  upload    Upload local .env files to Doppler (with confirmation prompt)
+  clone     Clone all secrets from one Doppler project to another
+  set       Add or update a secret (interactive project/env/config picker)
+
+Examples:
+  $ @mtndev/cli doppler download                                          # Download dev config
+  $ @mtndev/cli doppler download -e all                                   # Download all configs
+  $ @mtndev/cli doppler download -e dev,stg                               # Download dev and stg
+  $ @mtndev/cli doppler upload                                            # Upload .env.dev
+  $ @mtndev/cli doppler upload -e prd                                     # Upload production config
+  $ @mtndev/cli doppler clone --from my-app --to my-app-copy             # Clone all configs
+  $ @mtndev/cli doppler clone --from my-app --to my-app-copy -e dev,stg  # Clone specific envs
+  $ @mtndev/cli doppler clone --from my-app --to my-app-copy --force     # Clone without prompts
+  $ @mtndev/cli doppler set                                               # Interactive set
+  $ @mtndev/cli doppler set -p core --environment dev -c dev --name API_KEY --value secret --yes`,
+  options: {
+    environments: {
+      description: dopplerDownloadSchema.shape.environments.description,
+      default: "dev",
+      alias: "e"
+    },
+    from: {
+      description: dopplerCloneSchema.shape.from.description,
+      default: void 0
+    },
+    to: {
+      description: dopplerCloneSchema.shape.to.description,
+      default: void 0
+    },
+    force: {
+      description: dopplerCloneSchema.shape.force.description,
+      default: false,
+      alias: "f"
+    },
+    project: {
+      description: dopplerSetSchema.shape.project.description,
+      default: void 0,
+      alias: "p"
+    },
+    environment: {
+      description: dopplerSetSchema.shape.environment.description,
+      default: void 0
+    },
+    config: {
+      description: dopplerSetSchema.shape.config.description,
+      default: void 0,
+      alias: "c"
+    },
+    name: {
+      description: dopplerSetSchema.shape.name.description,
+      default: void 0
+    },
+    value: {
+      description: dopplerSetSchema.shape.value.description,
+      default: void 0
+    },
+    yes: {
+      description: dopplerSetSchema.shape.yes.description,
+      default: false,
+      alias: "y"
+    },
+    verbose: {
+      description: dopplerDownloadSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: dopplerDownloadSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+export {
+  dopplerDownloadSchema,
+  dopplerUploadSchema,
+  dopplerCloneSchema,
+  dopplerSetSchema,
+  dopplerCommandOptionsSchema,
+  dopplerCommandMetadata
+};