text: import traceback
  
  from baker import logger
  from baker import settings
  from baker.cli import Parser
  from baker.recipe import RecipeParser
  from baker.repository import Repository
  from baker.secret import SecretKey, Encryption
  from baker.template import ReplaceTemplate
  from baker.repository import ListRecipes, download
  
  
  class Commands:
      """
      Commands available for baker
      """
      @staticmethod
      def config(args):
          """
          List of current baker configs
          """
          configs = settings.values(custom_only=not args.all)
          for key, value in configs.items():
              logger.log(key + '=' + str(value))
  
      @staticmethod
      def encrypt(args):
          """
          Encrypt values from recipe file or list of strings
          """
          secret_key = str(SecretKey().key)
          enc = Encryption(secret_key)
  
          if args.file:
              parser = RecipeParser(args.file, case_sensitive=True)
              for instruction in parser.instructions:
                  instruction.plan_to_secrets()
              parser.update_secrets()
          elif args.plantexts:
              for text in args.plantexts:
                  logger.log(text, enc.encrypt(text))
  
      @staticmethod
      def generate_key(args):
          """
          Generate and storage secret key from key pass to encrypt secret values
          """
          SecretKey.generate(args.keypass)
  
      @staticmethod
      def pull(args):
          """
          Pull recipe from repository and version specific
          """
          Repository(args.name).pull(args.force)
  
      @staticmethod
      def recipes(args):
          """
          List all recipes locally
          """
          ListRecipes.list(args.all)
  
      @staticmethod
      def rm_recipe(args):
          """
          Remove local recipe from id
          """
          Repository.remove(args.recipe_id)
  
      @staticmethod
      def run(args):
          """
          Run a recipe from local path or get it from repository
          """
          if args.name and not args.path:
              repo = Repository(args.name)
              repo.pull(args.force)
              path = repo.local_path
          elif not args.name and args.path:
              path = args.path
          else:
              raise ValueError("Run command does not support 'name' and '--path' options together")
  
          recipe = RecipeParser(path)
          for instruction in recipe.instructions:
              instruction.secrets_to_plan()
              if instruction.is_remote:
                  instruction.template = download(instruction.template, force=args.force)
  
          template = ReplaceTemplate(recipe.instructions)
          template.replace()
  
  
  def execute_command_line(args):
      """
      Execute command line and wrap exceptions to show a friendly message
      """
      del args[0]
      parser = Parser(args, Commands)
      options = parser.options
  
      try:
          settings.load(DEBUG=options.verbose)
          logger.init()
  
          if 'multiprocess' in options:
              logger.log('Baker start <:::> \n')
  
          parser.execute()
  
          if 'multiprocess' in options:
              logger.log('\nAll done with success! \\ o /')
      except Exception as e:
          logger.debug(str(traceback.format_exc()))
          logger.log(str(e))
          parser.exit_with_error(
              '\nERROR: Unexpected error was caught. Add --verbose option for more information.\n')
  