@mtndev/cli 0.0.1

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/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/OXGTO4KT.js

@@ -0,0 +1,22 @@
+// src/commands/schema.js
+import { z } from "zod";
+var globalOptionsSchema = z.object({
+  verbose: z.boolean().default(false).optional().describe("Enable verbose logging for detailed output and error traces")
+});
+var globalCommandsMetadata = {
+  name: "mtndev-cli",
+  version: "0.0.1",
+  description: "CLI tool for mtndev projects",
+  options: {
+    verbose: {
+      description: globalOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    }
+  }
+};
+
+export {
+  globalOptionsSchema,
+  globalCommandsMetadata
+};

package/esm/__chunks/QSRTFPAA.js

@@ -0,0 +1,100 @@
+import {
+  checkDependencies,
+  downloadConfigs,
+  uploadConfigs
+} from "./O262GK4B.js";
+import {
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema
+} from "./XPAQNFHZ.js";
+
+// src/commands/doppler/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+async function dopplerCommand(options) {
+  try {
+    const validatedOptions = dopplerCommandOptionsSchema.parse(options);
+    if (validatedOptions.help) {
+      console.log(
+        chalk.bold(`
+Usage: @mtndev/cli doppler [options] <action>`)
+      );
+      console.log(chalk.gray(dopplerCommandMetadata.description));
+      console.log(chalk.bold("\nOptions:"));
+      Object.entries(dopplerCommandOptionsSchema.shape).forEach(
+        ([key, fieldSchema]) => {
+          if (key === "action") return;
+          const description = fieldSchema.description || "No description available";
+          const optionMeta = (
+            /** @type {any} */
+            dopplerCommandMetadata.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 { action, environment, verbose } = validatedOptions;
+    checkDependencies(verbose);
+    if (action === "download") {
+      await downloadConfigs({ environment, verbose });
+    } else if (action === "upload") {
+      await uploadConfigs({ environment, verbose });
+    }
+    console.log(chalk.green(`
+\u2705 Doppler ${action} completed 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 action = (
+      /** @type {any} */
+      options?.action || "operation"
+    );
+    const verbose = (
+      /** @type {any} */
+      options?.verbose || false
+    );
+    console.error(chalk.red(`
+\u274C Doppler ${action} 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 Doppler CLI is installed (brew install dopplerhq/cli/doppler)"
+      )
+    );
+    console.error(
+      chalk.yellow("   \u2022 Make sure you're logged in (doppler login)")
+    );
+    console.error(
+      chalk.yellow("   \u2022 Verify project is configured (doppler setup)")
+    );
+    console.error(
+      chalk.yellow("   \u2022 Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  dopplerCommand
+};