@mtndev/cli 1.1.0 → 2.0.1

package/esm/commands/doppler/utils.js

@@ -1,30 +1,396 @@
-import {
-  checkDependencies,
-  createDiff,
-  downloadConfigs,
-  execDoppler,
-  getConfigs,
-  normalizeEscapeSequences,
-  promptConfirmation,
-  uploadConfigs
-} from "../../__chunks/O262GK4B.js";
-import {
-  exec,
-  execJson,
-  execNumber,
-  execString
-} from "../../__chunks/SJXQJ7RS.js";
-export {
-  checkDependencies,
-  createDiff,
-  downloadConfigs,
-  exec,
-  execDoppler,
-  execJson,
-  execNumber,
-  execString,
-  getConfigs,
-  normalizeEscapeSequences,
-  promptConfirmation,
-  uploadConfigs
-};
+import { exec, execJson, execNumber, execString } from "./utils/exec.js";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { copyFileSync, existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+import { tmpdir } from "os";
+//#region src/commands/doppler/utils.js
+/**
+* @typedef {import('./utils/exec.js').VerbosityLevel} VerbosityLevel
+* @typedef {import('./utils/exec.js').ExecOptions} ExecOptions
+*/
+const DEFAULT_DOPPLER_ENVIRONMENT = "dev";
+const DOPPLER_INTERNAL_KEYS = /* @__PURE__ */ new Set([
+	"DOPPLER_CONFIG",
+	"DOPPLER_ENVIRONMENT",
+	"DOPPLER_PROJECT"
+]);
+/**
+* Execute a doppler command and return the result
+* @param {string[]} args - Command arguments
+* @param {'string' | 'json'} parser - How to parse the output
+* @param {boolean} silent - Suppress output
+* @param {boolean} verbose - Show verbose output
+* @returns {string | any}
+*/
+function execDoppler(args, parser = "string", silent = false, verbose = false) {
+	const command = `doppler ${args.join(" ")}`;
+	/** @type {import('./utils/exec.js').VerbosityLevel} */
+	let verbosity = "default";
+	if (verbose) verbosity = "verbose";
+	else if (silent) verbosity = "silent";
+	return exec(command, {
+		verbosity,
+		stdoutParser: parser,
+		throwOnError: true
+	});
+}
+/**
+* Check if the Doppler CLI is installed and the user is logged in.
+* Does not require a local project setup (doppler setup).
+* @param {boolean} verbose - Show verbose output
+*/
+function checkDopplerAuth(verbose = false) {
+	if (verbose) console.log(chalk.blue("\n🔍 Checking Doppler authentication..."));
+	try {
+		execSync("which doppler", { stdio: "pipe" });
+		if (verbose) console.log(chalk.green("   ✓ Doppler CLI is installed"));
+	} catch {
+		throw new Error("Doppler is not installed. Please install Doppler (brew install dopplerhq/cli/doppler), login, and try again.");
+	}
+	try {
+		execDoppler(["me"], "string", true, verbose);
+		if (verbose) console.log(chalk.green("   ✓ Doppler is authenticated"));
+	} catch {
+		throw new Error("Doppler is not logged in. Please run 'doppler login' and try again.");
+	}
+}
+/**
+* Check if doppler CLI is installed, logged in, and a project is configured.
+* @param {boolean} verbose - Show verbose output
+*/
+function checkDependencies(verbose = false) {
+	checkDopplerAuth(verbose);
+	if (verbose) console.log(chalk.blue("\n🔍 Checking Doppler project setup..."));
+	try {
+		execDoppler(["configs", "--json"], "json", true, verbose);
+		if (verbose) console.log(chalk.green("   ✓ Doppler project is configured"));
+	} catch {
+		throw new Error("Doppler is not configured. Please run 'doppler setup' and try again.");
+	}
+}
+/**
+* Get list of configurations based on environments parameter
+* @param {string} environments - Comma-separated env names ('all', 'dev', 'dev,stg', etc.)
+* @param {boolean} verbose - Show verbose output
+* @param {string | null} project - Optional Doppler project name
+* @returns {string[]}
+*/
+function getConfigs(environments, verbose = false, project = null) {
+	if (verbose) console.log(chalk.blue(`\n📋 Resolving configurations for environments: ${chalk.cyan(environments)}`));
+	const configArgs = ["configs", "--json"];
+	if (project) configArgs.push("--project", project);
+	const availableConfigs = execDoppler(configArgs, "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 (environments === "all") {
+		if (configNames.length === 0) throw new Error("No configurations found in Doppler");
+		if (verbose) console.log(chalk.green(`   ✓ Using all ${configNames.length} configurations`));
+		return configNames;
+	}
+	const requested = environments.split(",").map((e) => e.trim());
+	if (configNames.length > 0) {
+		const missing = requested.filter((e) => !configNames.includes(e));
+		if (missing.length > 0) throw new Error(`Configurations not found: ${missing.join(", ")}. Available: ${configNames.join(", ")}`);
+	}
+	if (verbose) console.log(chalk.green(`   ✓ Using configurations: ${requested.join(", ")}`));
+	return requested;
+}
+/**
+* Normalize escape sequences in file content
+* @param {string} content - File content
+* @returns {string}
+*/
+function normalizeEscapeSequences(content) {
+	return content.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+}
+/**
+* Create a unified diff between two strings
+* @param {string} oldContent - Original content
+* @param {string} newContent - New content
+* @returns {string[]}
+*/
+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;
+}
+/**
+* Prompt user for confirmation
+* @param {string} message - Prompt message
+* @returns {Promise<boolean>}
+*/
+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");
+		});
+	});
+}
+/**
+* Download configurations from Doppler
+* @param {{
+* verbose: boolean;
+* environments: string;
+* }} options - Options for downloading configurations
+*/
+async function downloadConfigs(options) {
+	const { environments, verbose } = options;
+	const actualEnvironments = environments ?? DEFAULT_DOPPLER_ENVIRONMENT;
+	const configs = getConfigs(actualEnvironments, verbose);
+	if (verbose) console.log(chalk.blue(`\n⬇️  Starting download process for ${configs.length} configuration(s)...`));
+	if (configs.length === 1 && actualEnvironments !== "all") console.log("You can use -e all to download all configurations, or -e dev,stg for specific environments.");
+	for (const config of configs) {
+		const envFile = `.env.${config}`;
+		const backupFile = `${envFile}.backup`;
+		let backupMsg = "";
+		if (verbose) console.log(chalk.blue(`\n📦 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, 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}`);
+			}
+		}
+	}
+}
+/**
+* Upload configurations to Doppler
+* @param {{
+* environments: string;
+* verbose: boolean;
+* }} options - Options for uploading configurations
+*/
+async function uploadConfigs(options) {
+	const { environments, verbose } = options;
+	const configs = getConfigs(environments, verbose);
+	if (verbose) console.log(chalk.blue(`\n⬆️  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(`\n📦 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 backupContent = execDoppler([
+					"secrets",
+					"download",
+					"--no-file",
+					"--format",
+					"env",
+					"--config",
+					config
+				], "string", !verbose, verbose);
+				if (typeof backupContent === "string") {
+					writeFileSync(backupFile, backupContent, "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 normalizedContent = normalizeEscapeSequences(readFileSync(envFile, "utf-8"));
+			writeFileSync(normalizedFile, normalizedContent, "utf-8");
+			if (verbose) console.log(chalk.gray(`   Comparing local changes with Doppler...`));
+			const diff = createDiff(readFileSync(backupFile, "utf-8"), 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));
+			if (!await promptConfirmation("\nDo you want to proceed with the upload? (y/n) ")) {
+				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, 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, 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);
+		}
+	}
+}
+/**
+* Clone secrets from one Doppler project to another
+* @param {{
+* from: string;
+* to: string;
+* environments: string;
+* force: boolean;
+* verbose: boolean;
+* }} options
+*/
+async function cloneProject({ from, to, environments, force, verbose }) {
+	if (verbose) console.log(chalk.blue(`\n🔁 Cloning from ${chalk.cyan(from)} to ${chalk.cyan(to)}...`));
+	const configsToClone = getConfigs(environments, verbose, from);
+	if (configsToClone.length === 0) throw new Error(`No configurations found in source project "${from}"`);
+	const targetConfigsRaw = execDoppler([
+		"configs",
+		"--json",
+		"--project",
+		to
+	], "json", true, verbose);
+	const targetConfigNames = Array.isArray(targetConfigsRaw) ? targetConfigsRaw.map((c) => c.name) : [];
+	const missingInTarget = configsToClone.filter((c) => !targetConfigNames.includes(c));
+	if (missingInTarget.length > 0) throw new Error(`Configs missing in target project "${to}": ${missingInTarget.join(", ")}. Create them in Doppler first.`);
+	for (const config of configsToClone) {
+		if (verbose) console.log(chalk.blue(`\n📦 Processing config: ${chalk.cyan(config)}`));
+		const sourceSecrets = execDoppler([
+			"secrets",
+			"--json",
+			"--project",
+			from,
+			"--config",
+			config
+		], "json", true, verbose);
+		const sourceKeys = sourceSecrets ? Object.keys(sourceSecrets).filter((k) => !DOPPLER_INTERNAL_KEYS.has(k)) : [];
+		const targetSecrets = execDoppler([
+			"secrets",
+			"--json",
+			"--project",
+			to,
+			"--config",
+			config
+		], "json", true, verbose);
+		const targetKeys = targetSecrets ? Object.keys(targetSecrets) : [];
+		const conflicts = sourceKeys.filter((k) => targetKeys.includes(k));
+		if (conflicts.length > 0) {
+			if (process.env["CI"]) throw new Error(`Config "${config}" has ${conflicts.length} conflicting key(s) in target: ${conflicts.join(", ")}`);
+			if (!force) {
+				console.log(`\nConfig ${chalk.cyan(config)}: ${conflicts.length} key(s) already exist in ${chalk.cyan(to)}:`);
+				conflicts.forEach((k) => console.log(chalk.yellow(`  • ${k}`)));
+				if (!await promptConfirmation(`\nOverwrite these keys in "${to}/${config}"? (y/n) `)) {
+					console.log(`Skipped ${chalk.blue(config)}`);
+					continue;
+				}
+			}
+		}
+		const tmpFile = join(tmpdir(), `doppler-clone-${config}-${Date.now()}.env`);
+		try {
+			const content = execDoppler([
+				"secrets",
+				"download",
+				"--no-file",
+				"--format",
+				"env",
+				"--project",
+				from,
+				"--config",
+				config
+			], "string", true, verbose);
+			if (typeof content !== "string" || !content) throw new Error(`No secrets returned for config "${config}"`);
+			const filtered = content.split("\n").filter((line) => {
+				const key = line.split("=")[0] ?? "";
+				return !DOPPLER_INTERNAL_KEYS.has(key);
+			}).join("\n");
+			writeFileSync(tmpFile, filtered, "utf-8");
+			execDoppler([
+				"secrets",
+				"upload",
+				tmpFile,
+				"--project",
+				to,
+				"--config",
+				config,
+				"--silent"
+			], "string", true, verbose);
+			console.log(`Config ${chalk.blue(config)}: cloned to ${chalk.green(to)}`);
+		} finally {
+			if (existsSync(tmpFile)) unlinkSync(tmpFile);
+		}
+	}
+}
+//#endregion
+export { checkDependencies, checkDopplerAuth, cloneProject, createDiff, downloadConfigs, exec, execDoppler, execJson, execNumber, execString, getConfigs, normalizeEscapeSequences, promptConfirmation, uploadConfigs };

package/esm/commands/icons/handler.js

@@ -1,8 +1,79 @@
-import {
-  iconsCommand
-} from "../../__chunks/HJSXC6HP.js";
-import "../../__chunks/FL7AILGH.js";
-import "../../__chunks/6G4PXXKF.js";
-export {
-  iconsCommand
-};
+import { iconsCommandMetadata, iconsCommandOptionsSchema } from "./schema.js";
+import { checkDependencies, generateAllIcons, validateBaseIcons } from "./utils.js";
+import chalk from "chalk";
+import { ZodError } from "zod";
+//#region src/commands/icons/handler.js
+/**
+* Main icons command handler
+* @param {unknown} options - Command options (will be validated)
+*/
+async function iconsCommand(options) {
+	try {
+		const validatedOptions = iconsCommandOptionsSchema.parse(options);
+		if (validatedOptions.help) {
+			console.log(chalk.bold(`\nUsage: 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 = 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📱 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📊 Summary:"));
+		console.log(chalk.green(`   ✓ Successfully generated: ${result.success.length} icon(s)`));
+		if (result.failed.length > 0) {
+			console.log(chalk.red(`   ✗ Failed: ${result.failed.length} icon(s)`));
+			result.failed.forEach(({ icon, error }) => {
+				console.log(chalk.red(`     - ${icon}: ${error}`));
+			});
+			process.exit(1);
+		}
+		console.log(chalk.green(`\n✅ All icons generated successfully!`));
+	} catch (error) {
+		if (error instanceof ZodError) {
+			console.error(chalk.red(`\n❌ Invalid command options:`));
+			error.errors.forEach((err) => {
+				console.error(chalk.red(`   ${err.path.join(".")}: ${err.message}`));
+			});
+			process.exit(1);
+		}
+		const verbose = options?.verbose || false;
+		console.error(chalk.red(`\n❌ 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💡 Troubleshooting tips:"));
+		console.error(chalk.yellow("   • Ensure ImageMagick is installed (brew install imagemagick)"));
+		console.error(chalk.yellow("   • Make sure icon.png and adaptive-icon.png exist in the input directory"));
+		console.error(chalk.yellow("   • Verify the input directory path is correct"));
+		console.error(chalk.yellow("   • Use --verbose for detailed error information\n"));
+		process.exit(1);
+	}
+}
+//#endregion
+export { iconsCommand };

package/esm/commands/icons/index.js

@@ -1,31 +1,4 @@
-import "../../__chunks/SNCKIAOR.js";
-import {
-  iconsCommand
-} from "../../__chunks/HJSXC6HP.js";
-import {
-  checkDependencies,
-  generateAllIcons,
-  generateIcon,
-  validateBaseIcons
-} from "../../__chunks/FL7AILGH.js";
-import {
-  CHANNELS,
-  CHANNEL_TEXT_MAP,
-  ICON_SIZE_MAP,
-  ICON_TYPES,
-  iconsCommandMetadata,
-  iconsCommandOptionsSchema
-} from "../../__chunks/6G4PXXKF.js";
-export {
-  CHANNELS,
-  CHANNEL_TEXT_MAP,
-  ICON_SIZE_MAP,
-  ICON_TYPES,
-  checkDependencies,
-  generateAllIcons,
-  generateIcon,
-  iconsCommand,
-  iconsCommandMetadata,
-  iconsCommandOptionsSchema,
-  validateBaseIcons
-};
+import { CHANNELS, CHANNEL_TEXT_MAP, ICON_SIZE_MAP, ICON_TYPES, iconsCommandMetadata, iconsCommandOptionsSchema } from "./schema.js";
+import { checkDependencies, generateAllIcons, generateIcon, validateBaseIcons } from "./utils.js";
+import { iconsCommand } from "./handler.js";
+export { CHANNELS, CHANNEL_TEXT_MAP, ICON_SIZE_MAP, ICON_TYPES, checkDependencies, generateAllIcons, generateIcon, iconsCommand, iconsCommandMetadata, iconsCommandOptionsSchema, validateBaseIcons };

package/esm/commands/icons/schema.d.ts

@@ -30,8 +30,8 @@ export const iconsCommandOptionsSchema: z.ZodObject<{
     help: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     verbose: boolean;
-    help: boolean;
     input: string;
+    help: boolean;
     channels: ("dev" | "staging" | "test" | "local")[];
     iconTypes: ("icon" | "adaptive-icon")[];
 }, {

package/esm/commands/icons/schema.js

@@ -1,16 +1,98 @@
-import {
-  CHANNELS,
-  CHANNEL_TEXT_MAP,
-  ICON_SIZE_MAP,
-  ICON_TYPES,
-  iconsCommandMetadata,
-  iconsCommandOptionsSchema
-} from "../../__chunks/6G4PXXKF.js";
-export {
-  CHANNELS,
-  CHANNEL_TEXT_MAP,
-  ICON_SIZE_MAP,
-  ICON_TYPES,
-  iconsCommandMetadata,
-  iconsCommandOptionsSchema
+import { z } from "zod";
+//#region src/commands/icons/schema.js
+/**
+* Available channels for icon generation
+*/
+const CHANNELS = [
+	"dev",
+	"staging",
+	"test"
+];
+/**
+* Available icon types
+*/
+const ICON_TYPES = ["icon", "adaptive-icon"];
+/**
+* Channel text mapping for icon overlay
+*/
+const CHANNEL_TEXT_MAP = {
+	dev: "DEV",
+	local: "LOC",
+	staging: "STG",
+	test: "TST"
 };
+/**
+* Icon type to point size mapping
+*/
+const ICON_SIZE_MAP = {
+	"adaptive-icon": 250,
+	icon: 378
+};
+/**
+* Zod schema for icons command options
+*/
+const iconsCommandOptionsSchema = z.object({
+	input: z.string().describe("Path to the input image directory containing icon.png and adaptive-icon.png"),
+	channels: z.array(z.enum([
+		"dev",
+		"local",
+		"staging",
+		"test"
+	])).optional().default([
+		"dev",
+		"local",
+		"staging",
+		"test"
+	]).describe("Channels to generate icons for"),
+	iconTypes: z.array(z.enum(["icon", "adaptive-icon"])).optional().default(["icon", "adaptive-icon"]).describe("Icon types to generate"),
+	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")
+});
+/**
+* Icons command metadata
+*/
+const iconsCommandMetadata = {
+	name: "icons",
+	description: `Generate app channel version icons with overlay text
+
+This command generates icon variants for different app channels (dev, local, staging, test)
+by overlaying text on base icon images using ImageMagick.
+
+Requirements:
+  • ImageMagick must be installed (brew install imagemagick)
+  • Base icons (icon.png, adaptive-icon.png) must exist in the input directory
+
+Examples:
+  $ mtn icons ./apps/my-app/assets          # Generate all channel icons
+  $ mtn icons ./assets -c dev,staging       # Generate only dev and staging icons
+  $ mtn icons ./assets -t icon              # Generate only standard icons
+  $ mtn icons ./assets -v                   # Verbose output`,
+	options: {
+		input: {
+			description: iconsCommandOptionsSchema.shape.input.description,
+			required: true
+		},
+		channels: {
+			description: iconsCommandOptionsSchema.shape.channels.description,
+			default: "dev,local,staging,test",
+			alias: "c"
+		},
+		iconTypes: {
+			description: iconsCommandOptionsSchema.shape.iconTypes.description,
+			default: "icon,adaptive-icon",
+			alias: "t"
+		},
+		verbose: {
+			description: iconsCommandOptionsSchema.shape.verbose.description,
+			default: false,
+			alias: "v"
+		},
+		help: {
+			description: iconsCommandOptionsSchema.shape.help.description,
+			default: false,
+			alias: "h"
+		}
+	}
+};
+//#endregion
+export { CHANNELS, CHANNEL_TEXT_MAP, ICON_SIZE_MAP, ICON_TYPES, iconsCommandMetadata, iconsCommandOptionsSchema };