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

package/cjs/__chunks/B5ENMOCD.cjs

@@ -0,0 +1,288 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _G5K4PVILcjs = require('./G5K4PVIL.cjs');
+
+
+var _R3GUC7O7cjs = require('./R3GUC7O7.cjs');
+
+// src/commands/aws/ec2/allow-ip/utils.js
+async function getCurrentPublicIp() {
+  const urls = ["https://checkip.amazonaws.com", "https://api.ipify.org"];
+  for (const url of urls) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 8e3);
+      const response = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (!response.ok) continue;
+      const ip = (await response.text()).trim();
+      if (ip && ip.includes(".")) {
+        return ip;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  throw new Error("Could not determine your current public IP address");
+}
+function listEnabledRegions(params) {
+  const { profile, region, verbose } = params;
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: [
+      "ec2",
+      "describe-regions",
+      "--query",
+      "Regions[?OptInStatus!=`not-opted-in`].RegionName"
+    ],
+    verbose
+  });
+  const regions = Array.isArray(data) ? data : [];
+  return regions.map((value) => String(value)).sort();
+}
+function listInstances(params) {
+  const { profile, region, verbose } = params;
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: ["ec2", "describe-instances"],
+    verbose
+  });
+  const instances = [];
+  for (const reservation of _nullishCoalesce(data.Reservations, () => ( []))) {
+    for (const raw of _nullishCoalesce(reservation.Instances, () => ( []))) {
+      const state = _nullishCoalesce(_optionalChain([raw, 'access', _ => _.State, 'optionalAccess', _2 => _2.Name]), () => ( "unknown"));
+      if (state === "terminated" || state === "shutting-down") {
+        continue;
+      }
+      let name = "";
+      for (const tag of _nullishCoalesce(raw.Tags, () => ( []))) {
+        if (tag.Key === "Name") {
+          name = _nullishCoalesce(tag.Value, () => ( ""));
+          break;
+        }
+      }
+      const securityGroupIds = (_nullishCoalesce(raw.SecurityGroups, () => ( []))).map((group) => group.GroupId).filter((id) => Boolean(id));
+      instances.push({
+        instanceId: raw.InstanceId,
+        name,
+        state,
+        instanceType: _nullishCoalesce(raw.InstanceType, () => ( "unknown")),
+        publicIp: _nullishCoalesce(raw.PublicIpAddress, () => ( null)),
+        securityGroupIds
+      });
+    }
+  }
+  instances.sort(
+    (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) || a.instanceId.localeCompare(b.instanceId)
+  );
+  return instances;
+}
+function describeSecurityGroups(params) {
+  const { profile, region, groupIds, verbose } = params;
+  if (groupIds.length === 0) {
+    return [];
+  }
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: ["ec2", "describe-security-groups", "--group-ids", ...groupIds],
+    verbose
+  });
+  const groups = (_nullishCoalesce(data.SecurityGroups, () => ( []))).map((raw) => ({
+    groupId: raw.GroupId,
+    groupName: _nullishCoalesce(raw.GroupName, () => ( "")),
+    description: _nullishCoalesce(raw.Description, () => ( ""))
+  }));
+  groups.sort((a, b) => a.groupName.localeCompare(b.groupName));
+  return groups;
+}
+function getSecurityGroupDetails(params) {
+  const { profile, region, groupId, verbose } = params;
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: ["ec2", "describe-security-groups", "--group-ids", groupId],
+    verbose
+  });
+  const securityGroups = _nullishCoalesce(data.SecurityGroups, () => ( []));
+  if (securityGroups.length === 0) {
+    return null;
+  }
+  return securityGroups[0];
+}
+function isSingleHostCidr(cidrIp) {
+  return cidrIp.endsWith("/32") && cidrIp !== "0.0.0.0/0";
+}
+function portAllowsSsh(permission) {
+  const protocol = permission.IpProtocol;
+  if (protocol !== "tcp" && protocol !== "6") {
+    return false;
+  }
+  const fromPort = permission.FromPort;
+  const toPort = permission.ToPort;
+  if (fromPort === void 0 && toPort === void 0) {
+    return true;
+  }
+  if (fromPort === void 0 || toPort === void 0) {
+    return false;
+  }
+  return fromPort <= _G5K4PVILcjs.SSH_PORT && _G5K4PVILcjs.SSH_PORT <= toPort;
+}
+function listSshIngressRules(securityGroup) {
+  const rules = [];
+  for (const permission of _nullishCoalesce(securityGroup.IpPermissions, () => ( []))) {
+    if (!portAllowsSsh(permission)) {
+      continue;
+    }
+    const fromPort = _nullishCoalesce(permission.FromPort, () => ( _G5K4PVILcjs.SSH_PORT));
+    const toPort = _nullishCoalesce(permission.ToPort, () => ( _G5K4PVILcjs.SSH_PORT));
+    const ipProtocol = _nullishCoalesce(permission.IpProtocol, () => ( "tcp"));
+    for (const ipRange of _nullishCoalesce(permission.IpRanges, () => ( []))) {
+      const cidrIp = ipRange.CidrIp;
+      if (!cidrIp || !isSingleHostCidr(cidrIp)) {
+        continue;
+      }
+      rules.push({
+        cidrIp,
+        description: _nullishCoalesce(ipRange.Description, () => ( "")),
+        fromPort,
+        toPort,
+        ipProtocol
+      });
+    }
+  }
+  return rules;
+}
+function extractRoamingFirstName(params) {
+  const { profile, identity } = params;
+  const arn = _nullishCoalesce(identity.Arn, () => ( ""));
+  const username = arn.includes("/") ? _nullishCoalesce(arn.split("/").pop(), () => ( "")) : "";
+  for (const candidate of [username, _nullishCoalesce(profile, () => ( ""))]) {
+    if (!candidate) continue;
+    const match = /^md-([^-]+)-/.exec(candidate);
+    if (match && match[1]) {
+      return match[1].charAt(0).toUpperCase() + match[1].slice(1).toLowerCase();
+    }
+  }
+  return _G5K4PVILcjs.DEFAULT_ROAMING_NAME;
+}
+function roamingRuleDescription(firstName) {
+  return `${firstName} Roaming`;
+}
+function resolveRoamingRule(sshRules, ruleDescription) {
+  const target = ruleDescription.toLowerCase();
+  for (const rule of sshRules) {
+    if (rule.description.trim().toLowerCase() === target) {
+      return rule;
+    }
+  }
+  return null;
+}
+function ruleAlreadyAllowsIp(sshRules, newCidr) {
+  for (const rule of sshRules) {
+    if (rule.cidrIp === newCidr) {
+      return rule;
+    }
+  }
+  return null;
+}
+function buildIpPermissions(params) {
+  const {
+    cidrIp,
+    description,
+    fromPort = _G5K4PVILcjs.SSH_PORT,
+    toPort = _G5K4PVILcjs.SSH_PORT,
+    ipProtocol = "tcp"
+  } = params;
+  return JSON.stringify([
+    {
+      IpProtocol: ipProtocol,
+      FromPort: fromPort,
+      ToPort: toPort,
+      IpRanges: [{ CidrIp: cidrIp, Description: description }]
+    }
+  ]);
+}
+function authorizeRule(params) {
+  const { profile, region, groupId, verbose, ...rule } = params;
+  _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: [
+      "ec2",
+      "authorize-security-group-ingress",
+      "--group-id",
+      groupId,
+      "--ip-permissions",
+      buildIpPermissions(rule)
+    ],
+    expectJson: false,
+    verbose
+  });
+}
+function revokeRule(params) {
+  const { profile, region, groupId, rule, verbose } = params;
+  _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    region,
+    args: [
+      "ec2",
+      "revoke-security-group-ingress",
+      "--group-id",
+      groupId,
+      "--ip-permissions",
+      buildIpPermissions({
+        cidrIp: rule.cidrIp,
+        description: rule.description,
+        fromPort: rule.fromPort,
+        toPort: rule.toPort,
+        ipProtocol: rule.ipProtocol
+      })
+    ],
+    expectJson: false,
+    verbose
+  });
+}
+function instanceLabel(instance) {
+  const publicIp = instance.publicIp || "no public IP";
+  const name = instance.name || "(no name)";
+  return `${instance.instanceId}  ${name}  ${instance.state}  ${instance.instanceType}  ${publicIp}`;
+}
+function securityGroupLabel(group) {
+  return `${group.groupId}  ${group.groupName}  ${group.description}`;
+}
+function sshRuleLabel(rule) {
+  const description = rule.description || "(no description)";
+  return `${rule.cidrIp}  ${description}`;
+}
+function printSshRules(sshRules, log = console.log) {
+  if (sshRules.length === 0) {
+    log("  (no single-host SSH rules on port 22)");
+    return;
+  }
+  for (const rule of sshRules) {
+    log(`  - ${sshRuleLabel(rule)}`);
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getCurrentPublicIp = getCurrentPublicIp; exports.listEnabledRegions = listEnabledRegions; exports.listInstances = listInstances; exports.describeSecurityGroups = describeSecurityGroups; exports.getSecurityGroupDetails = getSecurityGroupDetails; exports.listSshIngressRules = listSshIngressRules; exports.extractRoamingFirstName = extractRoamingFirstName; exports.roamingRuleDescription = roamingRuleDescription; exports.resolveRoamingRule = resolveRoamingRule; exports.ruleAlreadyAllowsIp = ruleAlreadyAllowsIp; exports.authorizeRule = authorizeRule; exports.revokeRule = revokeRule; exports.instanceLabel = instanceLabel; exports.securityGroupLabel = securityGroupLabel; exports.sshRuleLabel = sshRuleLabel; exports.printSshRules = printSshRules;

package/cjs/__chunks/B6XM5KSF.cjs

@@ -0,0 +1,338 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _BLMSMR5Ecjs = require('./BLMSMR5E.cjs');
+
+
+var _R3GUC7O7cjs = require('./R3GUC7O7.cjs');
+
+// src/commands/aws/route53/add-record/utils.js
+function bareHostedZoneId(rawId) {
+  return rawId.replace(/^\/hostedzone\//, "");
+}
+function withTrailingDot(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") {
+    return trimmed;
+  }
+  return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+function withoutTrailingDot(name) {
+  return name.endsWith(".") ? name.slice(0, -1) : name;
+}
+function listHostedZones(params) {
+  const { profile, verbose } = params;
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    args: ["route53", "list-hosted-zones"],
+    verbose
+  });
+  const zones = [];
+  for (const zone of _nullishCoalesce(data.HostedZones, () => ( []))) {
+    const id = bareHostedZoneId(String(_nullishCoalesce(zone.Id, () => ( ""))));
+    const name = withTrailingDot(String(_nullishCoalesce(zone.Name, () => ( ""))));
+    if (!id || !name) {
+      continue;
+    }
+    zones.push({
+      id,
+      name,
+      privateZone: Boolean(_optionalChain([zone, 'access', _ => _.Config, 'optionalAccess', _2 => _2.PrivateZone])),
+      recordCount: Number(_nullishCoalesce(zone.ResourceRecordSetCount, () => ( 0)))
+    });
+  }
+  return zones.sort((a, b) => a.name.localeCompare(b.name));
+}
+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 _nullishCoalesce(matches[0], () => ( null));
+  }
+  if (matches.length > 1) {
+    return _nullishCoalesce(_nullishCoalesce(matches.find((zone) => !zone.privateZone), () => ( matches[0])), () => ( null));
+  }
+  return null;
+}
+function hostedZoneLabel(zone) {
+  const visibility = zone.privateZone ? "private" : "public";
+  return `${withoutTrailingDot(zone.name)}  (${zone.id}, ${visibility}, ${zone.recordCount} records)`;
+}
+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;
+  }
+  const relative = raw.replace(/\.$/, "");
+  return withTrailingDot(`${relative}.${withoutTrailingDot(zoneFqdn)}`);
+}
+function getRecordSetsAtName(params) {
+  const { profile, hostedZoneId, name, verbose } = params;
+  const targetName = withTrailingDot(name).toLowerCase();
+  let startRecordName = withTrailingDot(name);
+  let startRecordType;
+  let nextRecordIdentifier;
+  const collected = [];
+  for (let page = 0; page < 20; page += 1) {
+    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 = _R3GUC7O7cjs.runAws.call(void 0, { profile, args, verbose });
+    const sets = _nullishCoalesce(data.ResourceRecordSets, () => ( []));
+    for (const set of sets) {
+      const setName = withTrailingDot(String(_nullishCoalesce(set.Name, () => ( "")))).toLowerCase();
+      if (setName === targetName) {
+        collected.push(normalizeRecordSet(set));
+        continue;
+      }
+      if (setName > targetName) {
+        return collected;
+      }
+    }
+    const truncated = data.IsTruncated === true;
+    if (!truncated) {
+      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;
+}
+function getResourceRecordSet(params) {
+  const { type, ...rest } = params;
+  const targetType = type.toUpperCase();
+  const sets = getRecordSetsAtName(rest);
+  return _nullishCoalesce(sets.find((set) => set.type === targetType), () => ( null));
+}
+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";
+  });
+}
+function normalizeRecordSet(set) {
+  const values = (_nullishCoalesce(set.ResourceRecords, () => ( []))).map(
+    (record) => String(_nullishCoalesce(record.Value, () => ( "")))
+  );
+  return {
+    name: withTrailingDot(String(_nullishCoalesce(set.Name, () => ( "")))),
+    type: String(_nullishCoalesce(set.Type, () => ( ""))).toUpperCase(),
+    ttl: typeof set.TTL === "number" ? set.TTL : void 0,
+    values,
+    isAlias: Boolean(set.AliasTarget),
+    aliasTarget: _nullishCoalesce(set.AliasTarget, () => ( void 0))
+  };
+}
+function formatValues(values) {
+  if (values.length === 0) {
+    return "(none)";
+  }
+  if (values.length === 1) {
+    return _nullishCoalesce(values[0], () => ( "(none)"));
+  }
+  return values.map((value) => `
+    - ${value}`).join("");
+}
+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) {
+        const priority = parts[0];
+        const exchange = parts.slice(1).join(" ");
+        return `${priority} ${withTrailingDot(exchange)}`;
+      }
+    }
+    if (type === "SRV") {
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 4) {
+        const prefix = parts.slice(0, 3).join(" ");
+        const target = parts.slice(3).join(" ");
+        return `${prefix} ${withTrailingDot(target)}`;
+      }
+    }
+    return withTrailingDot(trimmed);
+  }
+  if (type === "TXT") {
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed;
+    }
+    return `"${trimmed}"`;
+  }
+  return trimmed;
+}
+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) \u2192 ${existing.values.length + 1}).`
+    };
+  }
+  return {
+    action: "overwrite",
+    finalValues: [newValue],
+    summary: existing.values.length === 1 ? `Overwriting existing value:
+    ${existing.values[0]}
+  \u2192 ${newValue}` : `Replacing ${existing.values.length} existing values with a single new value.`
+  };
+}
+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: _nullishCoalesce(ttl, () => ( _BLMSMR5Ecjs.DEFAULT_TTL)),
+          ResourceRecords: values.map((value) => ({ Value: value }))
+        }
+      }
+    ]
+  };
+  const data = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    args: [
+      "route53",
+      "change-resource-record-sets",
+      "--hosted-zone-id",
+      hostedZoneId,
+      "--change-batch",
+      JSON.stringify(changeBatch)
+    ],
+    verbose
+  });
+  return _nullishCoalesce(data.ChangeInfo, () => ( data));
+}
+function deleteResourceRecordSet(params) {
+  const { profile, hostedZoneId, record, verbose } = params;
+  const resourceRecordSet = {
+    Name: withTrailingDot(record.name),
+    Type: record.type
+  };
+  if (record.isAlias && record.aliasTarget) {
+    resourceRecordSet.AliasTarget = record.aliasTarget;
+  } else {
+    resourceRecordSet.TTL = _nullishCoalesce(record.ttl, () => ( _BLMSMR5Ecjs.DEFAULT_TTL));
+    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 = _R3GUC7O7cjs.runAws.call(void 0, {
+    profile,
+    args: [
+      "route53",
+      "change-resource-record-sets",
+      "--hosted-zone-id",
+      hostedZoneId,
+      "--change-batch",
+      JSON.stringify(changeBatch)
+    ],
+    verbose
+  });
+  return _nullishCoalesce(data.ChangeInfo, () => ( data));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.bareHostedZoneId = bareHostedZoneId; exports.withTrailingDot = withTrailingDot; exports.withoutTrailingDot = withoutTrailingDot; exports.listHostedZones = listHostedZones; exports.findHostedZone = findHostedZone; exports.hostedZoneLabel = hostedZoneLabel; exports.resolveRecordName = resolveRecordName; exports.getRecordSetsAtName = getRecordSetsAtName; exports.getResourceRecordSet = getResourceRecordSet; exports.findCnameConflicts = findCnameConflicts; exports.formatValues = formatValues; exports.normalizeRecordValue = normalizeRecordValue; exports.planRecordChange = planRecordChange; exports.upsertResourceRecordSet = upsertResourceRecordSet; exports.deleteResourceRecordSet = deleteResourceRecordSet;

package/cjs/__chunks/BDU2UCE5.cjs

@@ -0,0 +1 @@
+"use strict";

package/cjs/__chunks/BLMSMR5E.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _WOYF2L6Tcjs = require('./WOYF2L6T.cjs');
+
+// src/commands/aws/route53/add-record/schema.js
+var _zod = require('zod');
+var RECORD_TYPES = [
+  "A",
+  "AAAA",
+  "CNAME",
+  "TXT",
+  "MX",
+  "NS",
+  "SRV",
+  "CAA"
+];
+var DEFAULT_TTL = 300;
+var addRecordOptionsSchema = _zod.z.object({
+  profile: _WOYF2L6Tcjs.profileField,
+  zone: _zod.z.string().optional().describe(
+    "Hosted zone name or ID (e.g. mountaindev.com or Z123\u2026). Skips the zone picker when set."
+  ),
+  type: _zod.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: _zod.z.string().optional().describe(
+    'Record name relative to the zone (e.g. "redline") or a fully-qualified name'
+  ),
+  value: _zod.z.string().optional().describe("Record value (e.g. a CNAME target or A address)"),
+  ttl: _zod.z.number().int().positive().optional().describe(`TTL in seconds (default: ${DEFAULT_TTL})`),
+  yes: _zod.z.boolean().optional().default(false).describe("Skip the confirmation prompt"),
+  dryRun: _zod.z.boolean().optional().default(false).describe("Preview the change without calling Route53"),
+  verbose: _WOYF2L6Tcjs.verboseField
+});
+
+
+
+
+
+exports.RECORD_TYPES = RECORD_TYPES; exports.DEFAULT_TTL = DEFAULT_TTL; exports.addRecordOptionsSchema = addRecordOptionsSchema;