@mtndev/cli 0.0.0-dev-20260618142325

package/cjs/commands/icons/index.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../__chunks/B2KFW7T7.cjs');
+
+
+var _INFOPAHNcjs = require('../../__chunks/INFOPAHN.cjs');
+
+
+
+
+
+var _4SFWHCB3cjs = require('../../__chunks/4SFWHCB3.cjs');
+
+
+
+
+
+
+
+var _J36P6UNEcjs = require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHANNELS = _J36P6UNEcjs.CHANNELS; exports.CHANNEL_TEXT_MAP = _J36P6UNEcjs.CHANNEL_TEXT_MAP; exports.ICON_SIZE_MAP = _J36P6UNEcjs.ICON_SIZE_MAP; exports.ICON_TYPES = _J36P6UNEcjs.ICON_TYPES; exports.checkDependencies = _4SFWHCB3cjs.checkDependencies; exports.generateAllIcons = _4SFWHCB3cjs.generateAllIcons; exports.generateIcon = _4SFWHCB3cjs.generateIcon; exports.iconsCommand = _INFOPAHNcjs.iconsCommand; exports.iconsCommandMetadata = _J36P6UNEcjs.iconsCommandMetadata; exports.iconsCommandOptionsSchema = _J36P6UNEcjs.iconsCommandOptionsSchema; exports.validateBaseIcons = _4SFWHCB3cjs.validateBaseIcons;

package/cjs/commands/icons/index.d.ts

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

package/cjs/commands/icons/schema.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _J36P6UNEcjs = require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+
+
+exports.CHANNELS = _J36P6UNEcjs.CHANNELS; exports.CHANNEL_TEXT_MAP = _J36P6UNEcjs.CHANNEL_TEXT_MAP; exports.ICON_SIZE_MAP = _J36P6UNEcjs.ICON_SIZE_MAP; exports.ICON_TYPES = _J36P6UNEcjs.ICON_TYPES; exports.iconsCommandMetadata = _J36P6UNEcjs.iconsCommandMetadata; exports.iconsCommandOptionsSchema = _J36P6UNEcjs.iconsCommandOptionsSchema;

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

@@ -0,0 +1,86 @@
+/**
+ * Available channels for icon generation
+ */
+export const CHANNELS: string[];
+/**
+ * Available icon types
+ */
+export const ICON_TYPES: string[];
+export namespace CHANNEL_TEXT_MAP {
+    let dev: string;
+    let local: string;
+    let staging: string;
+    let test: string;
+}
+/**
+ * Icon type to point size mapping
+ */
+export const ICON_SIZE_MAP: {
+    "adaptive-icon": number;
+    icon: number;
+};
+/**
+ * Zod schema for icons command options
+ */
+export const iconsCommandOptionsSchema: z.ZodObject<{
+    input: z.ZodString;
+    channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["dev", "local", "staging", "test"]>, "many">>>;
+    iconTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["icon", "adaptive-icon"]>, "many">>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    help: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose: boolean;
+    help: boolean;
+    input: string;
+    channels: ("dev" | "staging" | "test" | "local")[];
+    iconTypes: ("icon" | "adaptive-icon")[];
+}, {
+    input: string;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+    channels?: ("dev" | "staging" | "test" | "local")[] | undefined;
+    iconTypes?: ("icon" | "adaptive-icon")[] | undefined;
+}>;
+export namespace iconsCommandMetadata {
+    let name: string;
+    let description: string;
+    namespace options {
+        namespace input {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            export let required: boolean;
+        }
+        namespace channels {
+            let description_2: string | undefined;
+            export { description_2 as description };
+            let _default: string;
+            export { _default as default };
+            export let alias: string;
+        }
+        namespace iconTypes {
+            let description_3: string | undefined;
+            export { description_3 as description };
+            let _default_1: string;
+            export { _default_1 as default };
+            let alias_1: string;
+            export { alias_1 as alias };
+        }
+        namespace verbose {
+            let description_4: string | undefined;
+            export { description_4 as description };
+            let _default_2: boolean;
+            export { _default_2 as default };
+            let alias_2: string;
+            export { alias_2 as alias };
+        }
+        namespace help {
+            let description_5: string | undefined;
+            export { description_5 as description };
+            let _default_3: boolean;
+            export { _default_3 as default };
+            let alias_3: string;
+            export { alias_3 as alias };
+        }
+    }
+}
+import { z } from "zod";

package/cjs/commands/icons/utils.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _4SFWHCB3cjs = require('../../__chunks/4SFWHCB3.cjs');
+require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+exports.checkDependencies = _4SFWHCB3cjs.checkDependencies; exports.generateAllIcons = _4SFWHCB3cjs.generateAllIcons; exports.generateIcon = _4SFWHCB3cjs.generateIcon; exports.validateBaseIcons = _4SFWHCB3cjs.validateBaseIcons;

package/cjs/commands/icons/utils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Check if ImageMagick is installed
+ * @param {boolean} verbose - Show verbose output
+ * @throws {Error} If ImageMagick is not installed
+ */
+export function checkDependencies(verbose?: boolean): void;
+/**
+ * Validate that required base icons exist
+ * @param {string} baseDir - Base directory containing icons
+ * @param {string[]} iconTypes - Icon types to validate
+ * @param {boolean} verbose - Show verbose output
+ * @throws {Error} If required icons are missing
+ */
+export function validateBaseIcons(baseDir: string, iconTypes: string[], verbose?: boolean): void;
+/**
+ * Generate a single icon with channel overlay
+ * @param {{
+ *   baseDir: string;
+ *   channel: string;
+ *   iconType: string;
+ *   verbose: boolean;
+ * }} options - Generation options
+ * @returns {string} Path to generated icon
+ */
+export function generateIcon(options: {
+    baseDir: string;
+    channel: string;
+    iconType: string;
+    verbose: boolean;
+}): string;
+/**
+ * Generate all icons for specified channels and types
+ * @param {{
+ *   baseDir: string;
+ *   channels: string[];
+ *   iconTypes: string[];
+ *   verbose: boolean;
+ * }} options - Generation options
+ * @returns {{ success: string[]; failed: { icon: string; error: string }[] }}
+ */
+export function generateAllIcons(options: {
+    baseDir: string;
+    channels: string[];
+    iconTypes: string[];
+    verbose: boolean;
+}): {
+    success: string[];
+    failed: {
+        icon: string;
+        error: string;
+    }[];
+};

package/cjs/commands/index.cjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _FFFTVBURcjs = require('../__chunks/FFFTVBUR.cjs');
+require('../__chunks/B2KFW7T7.cjs');
+
+
+var _INFOPAHNcjs = require('../__chunks/INFOPAHN.cjs');
+require('../__chunks/4SFWHCB3.cjs');
+
+
+var _J36P6UNEcjs = require('../__chunks/J36P6UNE.cjs');
+require('../__chunks/WNJ3ZYLI.cjs');
+
+
+var _HFSXD6YEcjs = require('../__chunks/HFSXD6YE.cjs');
+require('../__chunks/EMMC33QA.cjs');
+require('../__chunks/NIMXXHJQ.cjs');
+
+
+var _QBNNK2WXcjs = require('../__chunks/QBNNK2WX.cjs');
+
+// src/commands/index.js
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _commander = require('commander');
+function displayWelcomeMessage() {
+  console.log(_chalk2.default.bold.blue("\n\u{1F680} @mtndev/cli"));
+  console.log(_chalk2.default.gray(`   ${_FFFTVBURcjs.globalCommandsMetadata.description}
+`));
+}
+displayWelcomeMessage();
+_commander.program.name(_FFFTVBURcjs.globalCommandsMetadata.name).description(_FFFTVBURcjs.globalCommandsMetadata.description).version(_FFFTVBURcjs.globalCommandsMetadata.version).option(
+  `-${_FFFTVBURcjs.globalCommandsMetadata.options.verbose.alias}, --verbose`,
+  _FFFTVBURcjs.globalCommandsMetadata.options.verbose.description,
+  _FFFTVBURcjs.globalCommandsMetadata.options.verbose.default
+);
+_commander.program.command("doppler <action>").description(_QBNNK2WXcjs.dopplerCommandMetadata.description).option(
+  `-${_QBNNK2WXcjs.dopplerCommandMetadata.options.environment.alias}, --environment <env>`,
+  _QBNNK2WXcjs.dopplerCommandMetadata.options.environment.description,
+  _QBNNK2WXcjs.dopplerCommandMetadata.options.environment.default
+).option(
+  `-${_QBNNK2WXcjs.dopplerCommandMetadata.options.help.alias}, --help`,
+  _QBNNK2WXcjs.dopplerCommandMetadata.options.help.description,
+  _QBNNK2WXcjs.dopplerCommandMetadata.options.help.default
+).action(async (action, options, cmd) => {
+  const globalOptions = _optionalChain([cmd, 'access', _ => _.parent, 'optionalAccess', _2 => _2.opts, 'call', _3 => _3()]) || {};
+  await _HFSXD6YEcjs.dopplerCommand.call(void 0, {
+    action,
+    environment: options.environment,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+_commander.program.command("icons <input>").description(_J36P6UNEcjs.iconsCommandMetadata.description).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.channels.alias}, --channels <channels>`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.channels.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.channels.default
+).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.alias}, --icon-types <types>`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.default
+).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.help.alias}, --help`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.help.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.help.default
+).action(async (input, options, cmd) => {
+  const globalOptions = _optionalChain([cmd, 'access', _4 => _4.parent, 'optionalAccess', _5 => _5.opts, 'call', _6 => _6()]) || {};
+  const channels = typeof options.channels === "string" ? options.channels.split(",").map((c) => c.trim()) : options.channels;
+  const iconTypes = typeof options.iconTypes === "string" ? options.iconTypes.split(",").map((t) => t.trim()) : options.iconTypes;
+  await _INFOPAHNcjs.iconsCommand.call(void 0, {
+    input,
+    channels,
+    iconTypes,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+_commander.program.on("command:*", () => {
+  _commander.program.help();
+});
+if (process.argv.length <= 2) {
+  _commander.program.help();
+}
+_commander.program.parse();

package/cjs/commands/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cjs/commands/schema.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _FFFTVBURcjs = require('../__chunks/FFFTVBUR.cjs');
+
+
+
+exports.globalCommandsMetadata = _FFFTVBURcjs.globalCommandsMetadata; exports.globalOptionsSchema = _FFFTVBURcjs.globalOptionsSchema;

package/cjs/commands/schema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Zod schema for global command options
+ * These options are available across all commands
+ */
+export const globalOptionsSchema: z.ZodObject<{
+    verbose: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose?: boolean | undefined;
+}, {
+    verbose?: boolean | undefined;
+}>;
+export namespace globalCommandsMetadata {
+    let name: string;
+    let version: string;
+    let description: string;
+    namespace options {
+        namespace verbose {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            let _default: boolean;
+            export { _default as default };
+            export let alias: string;
+        }
+    }
+}
+import { z } from "zod";

package/cjs/index.cjs

@@ -0,0 +1,5 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/index.js
+var src_default = void 0;
+
+
+exports.default = src_default;

package/cjs/index.d.ts

@@ -0,0 +1,2 @@
+declare const undefined: undefined;
+export default undefined;

package/esm/__chunks/6G4PXXKF.js

@@ -0,0 +1,75 @@
+// src/commands/icons/schema.js
+import { z } from "zod";
+var CHANNELS = ["dev", "staging", "test"];
+var ICON_TYPES = ["icon", "adaptive-icon"];
+var CHANNEL_TEXT_MAP = {
+  dev: "DEV",
+  local: "LOC",
+  staging: "STG",
+  test: "TST"
+};
+var ICON_SIZE_MAP = {
+  "adaptive-icon": 250,
+  icon: 378
+};
+var 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")
+});
+var 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:
+  \u2022 ImageMagick must be installed (brew install imagemagick)
+  \u2022 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"
+    }
+  }
+};
+
+export {
+  CHANNELS,
+  ICON_TYPES,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  iconsCommandOptionsSchema,
+  iconsCommandMetadata
+};

package/esm/__chunks/EC6MPHID.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: "1.0.0",
+  description: "CLI tool for mtndev projects",
+  options: {
+    verbose: {
+      description: globalOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    }
+  }
+};
+
+export {
+  globalOptionsSchema,
+  globalCommandsMetadata
+};

package/esm/__chunks/FL7AILGH.js

@@ -0,0 +1,133 @@
+import {
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP
+} from "./6G4PXXKF.js";
+
+// src/commands/icons/utils.js
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import chalk from "chalk";
+function checkDependencies(verbose = false) {
+  if (verbose) {
+    console.log(chalk.blue("\n\u{1F50D} Checking dependencies..."));
+  }
+  try {
+    execSync("which magick", { stdio: "pipe" });
+    if (verbose) {
+      console.log(chalk.green("   \u2713 ImageMagick is installed"));
+    }
+  } catch {
+    throw new Error(
+      "ImageMagick is not installed. Please install it (brew install imagemagick) and try again."
+    );
+  }
+}
+function validateBaseIcons(baseDir, iconTypes, verbose = false) {
+  if (verbose) {
+    console.log(chalk.blue("\n\u{1F4C1} Validating base icons..."));
+  }
+  const resolvedDir = resolve(baseDir);
+  if (!existsSync(resolvedDir)) {
+    throw new Error(`Input directory does not exist: ${resolvedDir}`);
+  }
+  const missingIcons = [];
+  for (const iconType of iconTypes) {
+    const iconPath = join(resolvedDir, `${iconType}.png`);
+    if (!existsSync(iconPath)) {
+      missingIcons.push(`${iconType}.png`);
+    } else if (verbose) {
+      console.log(chalk.green(`   \u2713 Found: ${iconType}.png`));
+    }
+  }
+  if (missingIcons.length > 0) {
+    throw new Error(
+      `Missing base icons in ${resolvedDir}: ${missingIcons.join(", ")}`
+    );
+  }
+}
+function generateIcon(options) {
+  const { baseDir, channel, iconType, verbose } = options;
+  const resolvedDir = resolve(baseDir);
+  const inputFile = join(resolvedDir, `${iconType}.png`);
+  const outputFile = join(resolvedDir, `${iconType}-${channel}.png`);
+  const size = ICON_SIZE_MAP[
+    /** @type {keyof typeof ICON_SIZE_MAP} */
+    iconType
+  ] || 378;
+  const text = CHANNEL_TEXT_MAP[
+    /** @type {keyof typeof CHANNEL_TEXT_MAP} */
+    channel
+  ] || channel.toUpperCase().slice(0, 3);
+  const command = [
+    "magick",
+    `"${inputFile}"`,
+    `-pointsize ${size}`,
+    "-fill white",
+    "-gravity center",
+    "-font Arial-Black",
+    "-stroke black",
+    "-strokewidth 5",
+    `-draw "rotate -45 text 0,0 '${text}'"`,
+    `"${outputFile}"`
+  ].join(" ");
+  if (verbose) {
+    console.log(chalk.gray(`   Command: ${command}`));
+  }
+  try {
+    execSync(command, { stdio: verbose ? "inherit" : "pipe" });
+    return outputFile;
+  } catch (error) {
+    throw new Error(
+      `Failed to generate ${iconType}-${channel}.png: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function generateAllIcons(options) {
+  const { baseDir, channels, iconTypes, verbose } = options;
+  const success = [];
+  const failed = [];
+  const totalIcons = channels.length * iconTypes.length;
+  let current = 0;
+  if (verbose) {
+    console.log(chalk.blue(`
+\u{1F3A8} Generating ${totalIcons} icon(s)...`));
+  }
+  for (const channel of channels) {
+    for (const iconType of iconTypes) {
+      current++;
+      const iconName = `${iconType}-${channel}.png`;
+      if (verbose) {
+        console.log(
+          chalk.blue(`
+[${current}/${totalIcons}] Generating ${iconName}...`)
+        );
+      }
+      try {
+        const outputPath = generateIcon({
+          baseDir,
+          channel,
+          iconType,
+          verbose
+        });
+        success.push(outputPath);
+        console.log(chalk.green(`   \u2713 Generated: ${iconName}`));
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        failed.push({ icon: iconName, error: errorMessage });
+        console.log(chalk.red(`   \u2717 Failed: ${iconName}`));
+        if (verbose) {
+          console.log(chalk.red(`     ${errorMessage}`));
+        }
+      }
+    }
+  }
+  return { success, failed };
+}
+
+export {
+  checkDependencies,
+  validateBaseIcons,
+  generateIcon,
+  generateAllIcons
+};

package/esm/__chunks/G6WUCFLD.js

@@ -0,0 +1,100 @@
+import {
+  checkDependencies,
+  downloadConfigs,
+  uploadConfigs
+} from "./O262GK4B.js";
+import {
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema
+} from "./LHVSSZI7.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
+};