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

package/esm/__chunks/QFXN4EHM.js

@@ -0,0 +1,393 @@
+import {
+  execDoppler
+} from "./YGWTVPZE.js";
+import {
+  prompt,
+  promptChoice,
+  promptYesNo
+} from "./ZHKVJO2U.js";
+
+// src/commands/doppler/set-secret.js
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+function listProjects(params = {}) {
+  const { verbose = false, limit = 500 } = params;
+  const projects = [];
+  let page = 1;
+  while (projects.length < limit) {
+    const batch = execDoppler(
+      ["projects", "--json", "--page", String(page), "--number", "100"],
+      "json",
+      true,
+      verbose
+    );
+    if (!Array.isArray(batch) || batch.length === 0) {
+      break;
+    }
+    for (const raw of batch) {
+      projects.push({
+        id: String(raw.id ?? raw.name ?? ""),
+        name: String(raw.name ?? raw.id ?? ""),
+        description: raw.description ? String(raw.description) : ""
+      });
+    }
+    if (batch.length < 100) {
+      break;
+    }
+    page += 1;
+  }
+  return projects.filter((project) => project.name).sort((a, b) => a.name.localeCompare(b.name));
+}
+function listEnvironments(params) {
+  const { project, verbose = false } = params;
+  const data = execDoppler(
+    ["environments", "--json", "--project", project],
+    "json",
+    true,
+    verbose
+  );
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data.map((raw) => ({
+    id: String(raw.id ?? ""),
+    name: String(raw.name ?? raw.id ?? "")
+  })).filter((env) => env.id).sort((a, b) => a.id.localeCompare(b.id));
+}
+function listConfigs(params) {
+  const { project, environment, verbose = false } = params;
+  const args = ["configs", "--json", "--project", project];
+  if (environment) {
+    args.push("--environment", environment);
+  }
+  const data = execDoppler(args, "json", true, verbose);
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data.map((raw) => ({
+    name: String(raw.name ?? ""),
+    environment: String(raw.environment ?? ""),
+    root: Boolean(raw.root)
+  })).filter((config) => config.name).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getSecret(params) {
+  const { project, config, name, verbose = false } = params;
+  try {
+    const data = execDoppler(
+      [
+        "secrets",
+        "get",
+        name,
+        "--project",
+        project,
+        "--config",
+        config,
+        "--plain",
+        "--raw"
+      ],
+      "string",
+      true,
+      verbose
+    );
+    if (typeof data !== "string") {
+      return null;
+    }
+    const value = data.replace(/\n$/, "");
+    return value.length > 0 ? value : "";
+  } catch {
+    return null;
+  }
+}
+function setSecret(params) {
+  const { project, config, name, value, verbose = false } = params;
+  const args = [
+    "secrets",
+    "set",
+    name,
+    "--project",
+    project,
+    "--config",
+    config,
+    "--no-interactive"
+  ];
+  if (verbose) {
+    console.log(
+      chalk.gray(
+        `   Executing: doppler ${args.join(" ")}  <stdin value (${value.length} chars)>`
+      )
+    );
+  }
+  const result = spawnSync("doppler", args, {
+    encoding: "utf-8",
+    input: value
+  });
+  if (result.error) {
+    throw new Error(result.error.message);
+  }
+  if (result.status !== 0) {
+    const stderr = (result.stderr || result.stdout || "").trim();
+    throw new Error(stderr || `doppler secrets set failed for ${name}`);
+  }
+}
+async function resolveProject(params) {
+  const { projects, projectOption } = params;
+  if (projectOption) {
+    const match = projects.find(
+      (project) => project.name === projectOption || project.id === projectOption
+    );
+    if (!match) {
+      throw new Error(
+        `Project "${projectOption}" not found. Available examples: ${projects.slice(0, 8).map((project) => project.name).join(", ")}`
+      );
+    }
+    return match.name;
+  }
+  if (projects.length === 0) {
+    throw new Error("No Doppler projects found for this account.");
+  }
+  let candidates = projects;
+  if (projects.length > 30) {
+    const filter = await prompt(
+      `  Filter projects (${projects.length} total, Enter for all): `
+    );
+    if (filter) {
+      const lower = filter.toLowerCase();
+      candidates = projects.filter(
+        (project) => project.name.toLowerCase().includes(lower) || project.id.toLowerCase().includes(lower)
+      );
+      if (candidates.length === 0) {
+        throw new Error(`No projects matched "${filter}".`);
+      }
+    }
+  }
+  const maxShown = 50;
+  const shown = candidates.slice(0, maxShown);
+  if (candidates.length > maxShown) {
+    console.log(
+      chalk.yellow(
+        `  Showing first ${maxShown} of ${candidates.length} matches \u2014 refine with a filter next time.`
+      )
+    );
+  }
+  const index = await promptChoice({
+    message: "Choose a Doppler project:",
+    options: shown.map(
+      (project) => project.description ? `${project.name} \u2014 ${project.description}` : project.name
+    )
+  });
+  const chosen = shown[index];
+  if (!chosen) {
+    throw new Error("No project selected");
+  }
+  return chosen.name;
+}
+async function resolveEnvironment(params) {
+  const { environments, environmentOption } = params;
+  if (environmentOption) {
+    const normalized = environmentOption.trim().toLowerCase();
+    if (normalized === "all" || normalized === "*") {
+      return "all";
+    }
+    const match = environments.find(
+      (env) => env.id.toLowerCase() === normalized || env.name.toLowerCase() === normalized
+    );
+    if (!match) {
+      throw new Error(
+        `Environment "${environmentOption}" not found. Available: ${environments.map((env) => env.id).join(", ")}`
+      );
+    }
+    return match.id;
+  }
+  if (environments.length === 0) {
+    return "all";
+  }
+  const options = [
+    ...environments.map((env) => `${env.id} (${env.name})`),
+    "all environments"
+  ];
+  const index = await promptChoice({
+    message: "Choose an environment:",
+    options
+  });
+  if (index === options.length - 1) {
+    return "all";
+  }
+  const chosen = environments[index];
+  if (!chosen) {
+    throw new Error("No environment selected");
+  }
+  return chosen.id;
+}
+async function resolveConfigs(params) {
+  const { configs, configOption, environment } = params;
+  const scoped = environment === "all" ? configs : configs.filter((config) => config.environment === environment);
+  if (scoped.length === 0) {
+    throw new Error(
+      environment === "all" ? "No configs found in this project." : `No configs found for environment "${environment}".`
+    );
+  }
+  if (configOption) {
+    const normalized = configOption.trim().toLowerCase();
+    if (normalized === "all" || normalized === "*") {
+      return scoped.map((config) => config.name);
+    }
+    const requested = configOption.split(",").map((value) => value.trim());
+    const names = new Set(scoped.map((config) => config.name));
+    const missing = requested.filter((name) => !names.has(name));
+    if (missing.length > 0) {
+      throw new Error(
+        `Config(s) not found: ${missing.join(", ")}. Available: ${[
+          ...names
+        ].join(", ")}`
+      );
+    }
+    return requested;
+  }
+  if (scoped.length === 1) {
+    const only = scoped[0];
+    if (!only) {
+      throw new Error("No config selected");
+    }
+    console.log(`  Config: ${only.name}`);
+    return [only.name];
+  }
+  const options = [
+    ...scoped.map(
+      (config) => config.root ? `${config.name} (root, env: ${config.environment})` : `${config.name} (env: ${config.environment})`
+    ),
+    `all configs listed (${scoped.length})`
+  ];
+  const index = await promptChoice({
+    message: "Choose a config:",
+    options
+  });
+  if (index === options.length - 1) {
+    return scoped.map((config) => config.name);
+  }
+  const chosen = scoped[index];
+  if (!chosen) {
+    throw new Error("No config selected");
+  }
+  return [chosen.name];
+}
+async function resolveSecretName(nameOption) {
+  if (nameOption) {
+    return nameOption;
+  }
+  const raw = await prompt("  Secret name (e.g. DATABASE_URL): ");
+  if (!raw) {
+    throw new Error("Secret name is required");
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw)) {
+    throw new Error(
+      "Secret name must be a valid env var identifier (letters, numbers, underscore)"
+    );
+  }
+  return raw;
+}
+async function resolveSecretValue(valueOption) {
+  if (valueOption !== void 0) {
+    return valueOption;
+  }
+  const raw = await prompt("  Secret value: ");
+  if (raw === "") {
+    const confirmEmpty = await promptYesNo({
+      message: "  Set an empty value?",
+      defaultYes: false
+    });
+    if (!confirmEmpty) {
+      throw new Error("Secret value is required");
+    }
+  }
+  return raw;
+}
+async function setSecretInteractive(options) {
+  const {
+    project: projectOption,
+    environment: environmentOption,
+    config: configOption,
+    name: nameOption,
+    value: valueOption,
+    yes = false,
+    verbose = false
+  } = options;
+  console.log(chalk.blue("\nSet Doppler secret"));
+  console.log("");
+  const projects = listProjects({ verbose });
+  const project = await resolveProject({ projects, projectOption });
+  console.log(`Project: ${project}`);
+  console.log("");
+  const environments = listEnvironments({ project, verbose });
+  const environment = await resolveEnvironment({
+    environments,
+    environmentOption
+  });
+  console.log(
+    environment === "all" ? "Environment: all" : `Environment: ${environment}`
+  );
+  console.log("");
+  const configs = listConfigs({
+    project,
+    environment: environment === "all" ? void 0 : environment,
+    verbose
+  });
+  const targetConfigs = await resolveConfigs({
+    configs,
+    configOption,
+    environment
+  });
+  console.log(`Config(s): ${targetConfigs.join(", ")}`);
+  console.log("");
+  const name = await resolveSecretName(nameOption);
+  const value = await resolveSecretValue(valueOption);
+  const existingByConfig = [];
+  for (const config of targetConfigs) {
+    const existing = getSecret({ project, config, name, verbose });
+    existingByConfig.push({ config, existing });
+  }
+  const overwrites = existingByConfig.filter(
+    (entry) => entry.existing !== null
+  );
+  console.log("");
+  console.log("Plan:");
+  console.log(`  Project:  ${project}`);
+  console.log(`  Configs:  ${targetConfigs.join(", ")}`);
+  console.log(`  Name:     ${name}`);
+  console.log(
+    `  Value:    ${value.length === 0 ? "(empty)" : `(${value.length} chars)`}`
+  );
+  if (overwrites.length > 0) {
+    console.log(
+      chalk.yellow(
+        `  Overwrite: ${overwrites.length} config(s) already have this secret (${overwrites.map((entry) => entry.config).join(", ")})`
+      )
+    );
+  } else {
+    console.log(chalk.green("  Overwrite: none (new secret on all targets)"));
+  }
+  console.log("");
+  if (!yes) {
+    const confirmed = await promptYesNo({
+      message: overwrites.length > 0 ? "Overwrite / set this secret?" : "Set this secret?",
+      defaultYes: false
+    });
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+    console.log("");
+  }
+  for (const config of targetConfigs) {
+    setSecret({ project, config, name, value, verbose });
+    console.log(chalk.green(`  \u2713 set ${name} on ${project}/${config}`));
+  }
+}
+
+export {
+  listProjects,
+  listEnvironments,
+  listConfigs,
+  getSecret,
+  setSecret,
+  setSecretInteractive
+};

package/esm/__chunks/QKDDLIWD.js

@@ -0,0 +1,146 @@
+import {
+  removeRecordOptionsSchema
+} from "./IZFGBYGE.js";
+import {
+  resolveHostedZone,
+  resolveName,
+  resolveRecordType
+} from "./G4NJHFFU.js";
+import {
+  deleteResourceRecordSet,
+  formatValues,
+  getResourceRecordSet,
+  hostedZoneLabel,
+  withoutTrailingDot
+} from "./33UYMUQD.js";
+import {
+  AwsCliError,
+  getCallerIdentity,
+  requireCommands
+} from "./FNXUONAV.js";
+import {
+  resolveProfile
+} from "./5GIUAFXL.js";
+import {
+  promptYesNo
+} from "./ZHKVJO2U.js";
+
+// src/commands/aws/route53/remove-record/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+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 \u2014 no changes made."));
+      return;
+    }
+    if (!yes) {
+      const confirmed = await promptYesNo({
+        message: `Delete this ${type} record?`,
+        defaultYes: false
+      });
+      if (!confirmed) {
+        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\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 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\u{1F4A1} Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  removeRecordCommand
+};