@mtndev/cli 0.0.0-dev-20260618142325

package/esm/__chunks/HJSXC6HP.js

@@ -0,0 +1,117 @@
+import {
+  checkDependencies,
+  generateAllIcons,
+  validateBaseIcons
+} from "./FL7AILGH.js";
+import {
+  iconsCommandMetadata,
+  iconsCommandOptionsSchema
+} from "./6G4PXXKF.js";
+
+// src/commands/icons/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+async function iconsCommand(options) {
+  try {
+    const validatedOptions = iconsCommandOptionsSchema.parse(options);
+    if (validatedOptions.help) {
+      console.log(chalk.bold(`
+Usage: mtn icons <input> [options]`));
+      console.log(chalk.gray(iconsCommandMetadata.description));
+      console.log(chalk.bold("\nOptions:"));
+      Object.entries(iconsCommandOptionsSchema.shape).forEach(
+        ([key, fieldSchema]) => {
+          if (key === "input") return;
+          const description = fieldSchema.description || "No description available";
+          const optionMeta = (
+            /** @type {any} */
+            iconsCommandMetadata.options[key]
+          );
+          const defaultValue = optionMeta?.default ?? false;
+          const alias = optionMeta?.alias ? chalk.cyan(`, -${optionMeta.alias}`) : "";
+          console.log(
+            chalk.cyan(`  --${key}`) + alias + `  ${description} (default: ${defaultValue})`
+          );
+        }
+      );
+      console.log("");
+      return;
+    }
+    const { input, channels, iconTypes, verbose } = validatedOptions;
+    if (verbose) {
+      console.log(chalk.blue("\n\u{1F4F1} Icon Generation"));
+      console.log(chalk.gray(`   Input directory: ${input}`));
+      console.log(chalk.gray(`   Channels: ${channels.join(", ")}`));
+      console.log(chalk.gray(`   Icon types: ${iconTypes.join(", ")}`));
+    }
+    checkDependencies(verbose);
+    validateBaseIcons(input, iconTypes, verbose);
+    const result = generateAllIcons({
+      baseDir: input,
+      channels,
+      iconTypes,
+      verbose
+    });
+    console.log(chalk.bold("\n\u{1F4CA} Summary:"));
+    console.log(
+      chalk.green(
+        `   \u2713 Successfully generated: ${result.success.length} icon(s)`
+      )
+    );
+    if (result.failed.length > 0) {
+      console.log(chalk.red(`   \u2717 Failed: ${result.failed.length} icon(s)`));
+      result.failed.forEach(({ icon, error }) => {
+        console.log(chalk.red(`     - ${icon}: ${error}`));
+      });
+      process.exit(1);
+    }
+    console.log(chalk.green(`
+\u2705 All icons generated successfully!`));
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.error(chalk.red(`
+\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(`
+\u274C Icon generation 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} Troubleshooting tips:"));
+    console.error(
+      chalk.yellow(
+        "   \u2022 Ensure ImageMagick is installed (brew install imagemagick)"
+      )
+    );
+    console.error(
+      chalk.yellow(
+        "   \u2022 Make sure icon.png and adaptive-icon.png exist in the input directory"
+      )
+    );
+    console.error(
+      chalk.yellow("   \u2022 Verify the input directory path is correct")
+    );
+    console.error(
+      chalk.yellow("   \u2022 Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  iconsCommand
+};

package/esm/__chunks/LHVSSZI7.js

@@ -0,0 +1,52 @@
+// src/commands/doppler/schema.js
+import { z } from "zod";
+var dopplerCommandOptionsSchema = z.object({
+  action: z.enum(["download", "upload"], {
+    errorMap: () => ({
+      message: "Action must be either 'download' or 'upload'"
+    })
+  }).describe("Action to perform: download or upload configurations"),
+  environment: z.string().optional().default("dev").describe(
+    'Environment configuration to process (e.g., dev, stg, prd, or "all" for all configs)'
+  ),
+  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 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)
+
+Examples:
+  $ @mtndev/cli doppler download              # Download dev config to .env.dev
+  $ @mtndev/cli doppler download -e all       # Download all configs
+  $ @mtndev/cli doppler download -e stg       # Download staging config
+  $ @mtndev/cli doppler upload                # Upload .env.dev to Doppler
+  $ @mtndev/cli doppler upload -e prd         # Upload production config`,
+  options: {
+    environment: {
+      description: dopplerCommandOptionsSchema.shape.environment.description,
+      default: "dev",
+      alias: "t"
+    },
+    // Global options are included here for help display
+    verbose: {
+      description: dopplerCommandOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: dopplerCommandOptionsSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+export {
+  dopplerCommandOptionsSchema,
+  dopplerCommandMetadata
+};

package/esm/__chunks/O262GK4B.js

@@ -0,0 +1,401 @@
+import {
+  exec
+} from "./SJXQJ7RS.js";
+
+// src/commands/doppler/utils.js
+import { execSync } from "child_process";
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { createInterface } from "readline";
+import chalk from "chalk";
+var DEFAULT_DOPPLER_ENVIRONMENT = "dev";
+function execDoppler(args, parser = "string", silent = false, verbose = false) {
+  const command = `doppler ${args.join(" ")}`;
+  let verbosity = "default";
+  if (verbose) {
+    verbosity = "verbose";
+  } else if (silent) {
+    verbosity = "silent";
+  }
+  return exec(command, {
+    verbosity,
+    stdoutParser: parser,
+    throwOnError: true
+  });
+}
+function checkDependencies(verbose = false) {
+  if (verbose) {
+    console.log(chalk.blue("\n\u{1F50D} Checking Doppler dependencies..."));
+  }
+  try {
+    execSync("which doppler", { stdio: "pipe" });
+    if (verbose) {
+      console.log(chalk.green("   \u2713 Doppler CLI is installed"));
+    }
+  } catch {
+    throw new Error(
+      "Doppler is not installed. Please install Doppler (brew install dopplerhq/cli/doppler), login, setup, and try again."
+    );
+  }
+  try {
+    execDoppler(["me"], "string", true, verbose);
+    if (verbose) {
+      console.log(chalk.green("   \u2713 Doppler is authenticated"));
+    }
+  } catch {
+    throw new Error(
+      "Doppler is not logged in. Please run 'doppler login' then 'doppler setup' and try again."
+    );
+  }
+  try {
+    execDoppler(["configs", "--json"], "json", true, verbose);
+    if (verbose) {
+      console.log(chalk.green("   \u2713 Doppler project is configured"));
+    }
+  } catch {
+    throw new Error(
+      "Doppler is not configured. Please run 'doppler setup' and try again."
+    );
+  }
+}
+function getConfigs(environment, verbose = false) {
+  if (verbose) {
+    console.log(
+      chalk.blue(
+        `
+\u{1F4CB} Resolving configurations for environment: ${chalk.cyan(environment)}`
+      )
+    );
+  }
+  const availableConfigs = execDoppler(
+    ["configs", "--json"],
+    "json",
+    true,
+    verbose
+  );
+  const configNames = Array.isArray(availableConfigs) ? availableConfigs.map(
+    (config) => config.name
+  ) : [];
+  if (verbose && configNames.length > 0) {
+    console.log(
+      chalk.gray(`   Available configurations: ${configNames.join(", ")}`)
+    );
+  }
+  if (environment === "all") {
+    if (configNames.length === 0) {
+      throw new Error("No configurations found in Doppler");
+    }
+    if (verbose) {
+      console.log(
+        chalk.green(`   \u2713 Using all ${configNames.length} configurations`)
+      );
+    }
+    return configNames;
+  }
+  if (configNames.length > 0 && !configNames.includes(environment)) {
+    throw new Error(
+      `Configuration "${environment}" not found. Available configurations: ${configNames.join(", ")}`
+    );
+  }
+  if (verbose) {
+    console.log(chalk.green(`   \u2713 Using configuration: ${environment}`));
+  }
+  return [environment];
+}
+function normalizeEscapeSequences(content) {
+  return content.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+}
+function createDiff(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const diff = [];
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i] || "";
+    const newLine = newLines[i] || "";
+    if (oldLine !== newLine) {
+      if (oldLine && !newLine) {
+        diff.push(`-${oldLine}`);
+      } else if (!oldLine && newLine) {
+        diff.push(`+${newLine}`);
+      } else {
+        diff.push(`-${oldLine}`);
+        diff.push(`+${newLine}`);
+      }
+    }
+  }
+  return diff;
+}
+function promptConfirmation(message) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function downloadConfigs(options) {
+  const { environment, verbose } = options;
+  const actualEnvironment = environment ?? DEFAULT_DOPPLER_ENVIRONMENT;
+  const configs = getConfigs(actualEnvironment, verbose);
+  if (verbose) {
+    console.log(
+      chalk.blue(
+        `
+\u2B07\uFE0F  Starting download process for ${configs.length} configuration(s)...`
+      )
+    );
+  }
+  if (configs.length === 1 && environment !== "all") {
+    console.log(
+      "You can use -e all to download all configurations, or -e <env> for a specific environment."
+    );
+  }
+  for (const config of configs) {
+    const envFile = `.env.${config}`;
+    const backupFile = `${envFile}.backup`;
+    let backupMsg = "";
+    if (verbose) {
+      console.log(chalk.blue(`
+\u{1F4E6} Processing config: ${chalk.cyan(config)}`));
+    }
+    try {
+      if (existsSync(envFile)) {
+        if (verbose) {
+          console.log(chalk.gray(`   Creating backup: ${backupFile}`));
+        }
+        renameSync(envFile, backupFile);
+        backupMsg = "Backed up existing file, ";
+      }
+      if (verbose) {
+        console.log(chalk.gray(`   Downloading secrets from Doppler...`));
+      }
+      const content = execDoppler(
+        [
+          "secrets",
+          "download",
+          "--no-file",
+          "--format",
+          "env",
+          "--config",
+          config
+        ],
+        "string",
+        !verbose,
+        // Only silent if not verbose
+        verbose
+      );
+      if (typeof content === "string") {
+        writeFileSync(envFile, content, "utf-8");
+        if (verbose) {
+          console.log(chalk.gray(`   Written to: ${envFile}`));
+        }
+      } else {
+        throw new Error("Invalid content received from Doppler");
+      }
+      console.log(
+        `Config ${chalk.blue(config)}: ${backupMsg}downloaded successfully to ${chalk.green(envFile)}`
+      );
+      if (config === "dev" && !existsSync(".env")) {
+        copyFileSync(envFile, ".env");
+        console.log(
+          `Copied ${chalk.green(".env.dev")} to ${chalk.green(".env")}`
+        );
+      }
+      if (existsSync(backupFile)) {
+        if (verbose) {
+          console.log(chalk.gray(`   Removing backup file`));
+        }
+        unlinkSync(backupFile);
+      }
+    } catch (error) {
+      console.error(`Failed to download ${config}: ${error?.message || error}`);
+      if (existsSync(backupFile)) {
+        renameSync(backupFile, envFile);
+        console.log(`Restored backup for ${envFile}`);
+      }
+    }
+  }
+}
+async function uploadConfigs(options) {
+  const { environment, verbose } = options;
+  const configs = getConfigs(environment, verbose);
+  if (verbose) {
+    console.log(
+      chalk.blue(
+        `
+\u2B06\uFE0F  Starting upload process for ${configs.length} configuration(s)...`
+      )
+    );
+  }
+  for (const config of configs) {
+    const envFile = `.env.${config}`;
+    const backupFile = `${envFile}.doppler`;
+    const normalizedFile = `${envFile}.normalized`;
+    if (verbose) {
+      console.log(chalk.blue(`
+\u{1F4E6} Processing config: ${chalk.cyan(config)}`));
+    }
+    try {
+      if (!existsSync(envFile)) {
+        console.log(
+          `Config ${config}: ${chalk.green(envFile)} does not exist. Skipping upload.`
+        );
+        continue;
+      }
+      if (verbose) {
+        console.log(
+          chalk.gray(`   Creating backup of current Doppler config...`)
+        );
+      }
+      try {
+        const backupContent2 = execDoppler(
+          [
+            "secrets",
+            "download",
+            "--no-file",
+            "--format",
+            "env",
+            "--config",
+            config
+          ],
+          "string",
+          !verbose,
+          // Only silent if not verbose
+          verbose
+        );
+        if (typeof backupContent2 === "string") {
+          writeFileSync(backupFile, backupContent2, "utf-8");
+          if (verbose) {
+            console.log(chalk.gray(`   Backup created: ${backupFile}`));
+          }
+        } else {
+          throw new Error("Invalid backup content received from Doppler");
+        }
+      } catch {
+        console.log(
+          `Config ${config}: Failed to create backup. Skipping upload.`
+        );
+        continue;
+      }
+      if (verbose) {
+        console.log(chalk.gray(`   Reading local file: ${envFile}`));
+      }
+      const localContent = readFileSync(envFile, "utf-8");
+      const normalizedContent = normalizeEscapeSequences(localContent);
+      writeFileSync(normalizedFile, normalizedContent, "utf-8");
+      if (verbose) {
+        console.log(chalk.gray(`   Comparing local changes with Doppler...`));
+      }
+      const backupContent = readFileSync(backupFile, "utf-8");
+      const diff = createDiff(backupContent, normalizedContent);
+      if (diff.length === 0) {
+        console.log(`Config ${config}: No differences found. Skipping upload.`);
+        unlinkSync(backupFile);
+        unlinkSync(normalizedFile);
+        continue;
+      }
+      if (verbose) {
+        console.log(chalk.yellow(`   Found ${diff.length} line changes`));
+      }
+      console.log("\nChanges to be uploaded:");
+      for (const line of diff) {
+        if (line.startsWith("-")) {
+          console.log(chalk.red(line));
+        } else if (line.startsWith("+")) {
+          console.log(chalk.green(line));
+        }
+      }
+      const confirmed = await promptConfirmation(
+        "\nDo you want to proceed with the upload? (y/n) "
+      );
+      if (!confirmed) {
+        console.log(`Upload cancelled for ${chalk.green(envFile)}`);
+        unlinkSync(backupFile);
+        unlinkSync(normalizedFile);
+        continue;
+      }
+      if (verbose) {
+        console.log(chalk.gray(`   Uploading to Doppler...`));
+      }
+      try {
+        execDoppler(
+          ["secrets", "upload", normalizedFile, "--config", config, "--silent"],
+          "string",
+          !verbose,
+          // Only silent if not verbose
+          verbose
+        );
+        if (config === "dev") {
+          console.log(
+            `Config ${chalk.blue(config)}: Successfully uploaded ${chalk.green(envFile)}`
+          );
+        } else {
+          console.log(
+            `Config ${config}: Successfully uploaded ${chalk.green(envFile)}`
+          );
+        }
+      } catch {
+        console.error(
+          `Config ${config}: Failed to upload ${chalk.green(envFile)}. Restoring previous configuration.`
+        );
+        try {
+          if (verbose) {
+            console.log(chalk.gray(`   Restoring previous configuration...`));
+          }
+          execDoppler(
+            ["secrets", "upload", backupFile, "--config", config, "--silent"],
+            "string",
+            !verbose,
+            // Only silent if not verbose
+            verbose
+          );
+          console.log(
+            `Config ${config}: Successfully restored previous configuration`
+          );
+        } catch {
+          console.error(
+            `Config ${config}: Failed to restore previous configuration`
+          );
+        }
+      }
+      if (existsSync(backupFile)) {
+        unlinkSync(backupFile);
+      }
+      if (existsSync(normalizedFile)) {
+        unlinkSync(normalizedFile);
+      }
+    } catch (error) {
+      console.error(
+        `Error processing config ${config}: ${error?.message || error}`
+      );
+      if (existsSync(backupFile)) {
+        unlinkSync(backupFile);
+      }
+      if (existsSync(normalizedFile)) {
+        unlinkSync(normalizedFile);
+      }
+    }
+  }
+}
+
+export {
+  execDoppler,
+  checkDependencies,
+  getConfigs,
+  normalizeEscapeSequences,
+  createDiff,
+  promptConfirmation,
+  downloadConfigs,
+  uploadConfigs
+};

package/esm/__chunks/SJXQJ7RS.js

@@ -0,0 +1,92 @@
+// src/commands/doppler/utils/exec.js
+import { execSync } from "child_process";
+import chalk from "chalk";
+function exec(command, options = {}) {
+  const {
+    stdoutParser = "string",
+    throwOnError = true,
+    verbosity = "default",
+    stdio: userStdio,
+    ...execSyncOptions
+  } = options;
+  try {
+    if (verbosity === "verbose") {
+      console.log(chalk.gray(`   Executing: ${command}`));
+    }
+    let stdio;
+    if (userStdio) {
+      stdio = userStdio;
+    } else if (verbosity === "verbose") {
+      stdio = "inherit";
+    } else if (verbosity === "silent") {
+      stdio = "pipe";
+    } else {
+      stdio = ["pipe", "pipe", "pipe"];
+    }
+    const result = (
+      /** @type {string} */
+      execSync(command, {
+        encoding: "utf-8",
+        stdio,
+        ...execSyncOptions
+      })
+    );
+    if (stdio === "inherit") {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    if (!result || typeof result === "string" && !result.trim()) {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    switch (stdoutParser) {
+      case "json": {
+        try {
+          return JSON.parse(result);
+        } catch (parseError) {
+          if (throwOnError) {
+            throw new Error(
+              `Failed to parse JSON output: ${parseError.message}`
+            );
+          }
+          return void 0;
+        }
+      }
+      case "number": {
+        const num = parseFloat(result.trim());
+        if (isNaN(num)) {
+          if (throwOnError) {
+            throw new Error(`Failed to parse number from output: ${result}`);
+          }
+          return void 0;
+        }
+        return num;
+      }
+      case "string":
+      default:
+        return result;
+    }
+  } catch (error) {
+    if (!throwOnError) {
+      return void 0;
+    }
+    if (error.stderr) {
+      throw new Error(error.stderr.toString());
+    }
+    throw error;
+  }
+}
+function execString(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "string" });
+}
+function execJson(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "json" });
+}
+function execNumber(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "number" });
+}
+
+export {
+  exec,
+  execString,
+  execJson,
+  execNumber
+};

package/esm/commands/doppler/handler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main doppler command handler
+ * @param {unknown} options - Command options (will be validated)
+ */
+export function dopplerCommand(options: unknown): Promise<void>;

package/esm/commands/doppler/handler.js

@@ -0,0 +1,9 @@
+import {
+  dopplerCommand
+} from "../../__chunks/G6WUCFLD.js";
+import "../../__chunks/O262GK4B.js";
+import "../../__chunks/SJXQJ7RS.js";
+import "../../__chunks/LHVSSZI7.js";
+export {
+  dopplerCommand
+};

package/esm/commands/doppler/index.d.ts

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