aspera-cli 4.7.0 → 4.8.0

data/lib/aspera/cli/plugins/config.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
+
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/extended_value'
 require 'aspera/cli/version'
+require 'aspera/cli/formater'
 require 'aspera/fasp/installation'
 require 'aspera/fasp/parameters'
 require 'aspera/fasp/transfer_spec'
@@ -27,37 +29,37 @@ module Aspera
       # manage the CLI config file
       class Config < Plugin
         # folder in $HOME for application files (config, cache)
-        ASPERA_HOME_FOLDER_NAME='.aspera'
+        ASPERA_HOME_FOLDER_NAME = '.aspera'
         # default config file
         DEFAULT_CONFIG_FILENAME = 'config.yaml'
         # reserved preset names
-        CONF_PRESET_CONFIG='config'
-        CONF_PRESET_VERSION='version'
-        CONF_PRESET_DEFAULT='default'
-        CONF_PRESET_GLOBAL='global_common_defaults'
-        CONF_PRESET_SECRETS='default_secrets' # pragma: allowlist secret
+        CONF_PRESET_CONFIG = 'config'
+        CONF_PRESET_VERSION = 'version'
+        CONF_PRESET_DEFAULT = 'default'
+        CONF_PRESET_GLOBAL = 'global_common_defaults'
+        CONF_PRESET_SECRETS = 'default_secrets' # pragma: allowlist secret
         CONF_PLUGIN_SYM = :config # Plugins::Config.name.split('::').last.downcase.to_sym
         CONF_GLOBAL_SYM = :config
         # old tool name
         PROGRAM_NAME_V1 = 'aslmcli'
         PROGRAM_NAME_V2 = 'mlia'
         # default redirect for AoC web auth
-        DEFAULT_REDIRECT='http://localhost:12345'
+        DEFAULT_REDIRECT = 'http://localhost:12345'
         # folder containing custom plugins in user's config folder
-        ASPERA_PLUGINS_FOLDERNAME='plugins'
-        RUBY_FILE_EXT='.rb'
-        AOC_COMMAND_V1='files'
-        AOC_COMMAND_V2='aspera'
-        AOC_COMMAND_V3='aoc'
-        AOC_COMMAND_CURRENT=AOC_COMMAND_V3
-        SERVER_COMMAND='server'
+        ASPERA_PLUGINS_FOLDERNAME = 'plugins'
+        RUBY_FILE_EXT = '.rb'
+        AOC_COMMAND_V1 = 'files'
+        AOC_COMMAND_V2 = 'aspera'
+        AOC_COMMAND_V3 = 'aoc'
+        AOC_COMMAND_CURRENT = AOC_COMMAND_V3
+        SERVER_COMMAND = 'server'
         CONNECT_WEB_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
         CONNECT_VERSIONS = 'connectversions.js'
         TRANSFER_SDK_ARCHIVE_URL = 'https://ibm.biz/aspera_transfer_sdk'
-        DEMO='demo'
-        DEMO_SERVER_PRESET='demoserver'
-        AOC_PATH_API_CLIENTS='admin/api-clients'
-        EMAIL_TEST_TEMPLATE=<<~END_OF_TEMPLATE
+        DEMO = 'demo'
+        DEMO_SERVER_PRESET = 'demoserver'
+        AOC_PATH_API_CLIENTS = 'admin/api-clients'
+        EMAIL_TEST_TEMPLATE = <<~END_OF_TEMPLATE
           From: <%=from_name%> <<%=from_email%>>
           To: <<%=to%>>
           Subject: Amelia email test
@@ -65,33 +67,33 @@ module Aspera
           It worked !
         END_OF_TEMPLATE
         # special extended values
-        EXTV_INCLUDE_PRESETS=:incps
-        EXTV_PRESET=:preset
-        PRESET_DIG_SEPARATOR='.'
-        DEFAULT_CHECK_NEW_VERSION_DAYS=7
-        DEFAULT_PRIV_KEY_FILENAME='aspera_aoc_key' # pragma: allowlist secret
-        DEFAULT_PRIVKEY_LENGTH=4096
+        EXTV_INCLUDE_PRESETS = :incps
+        EXTV_PRESET = :preset
+        PRESET_DIG_SEPARATOR = '.'
+        DEFAULT_CHECK_NEW_VERSION_DAYS = 7
+        DEFAULT_PRIV_KEY_FILENAME = 'aspera_aoc_key' # pragma: allowlist secret
+        DEFAULT_PRIVKEY_LENGTH = 4096
         private_constant :DEFAULT_CONFIG_FILENAME,:CONF_PRESET_CONFIG,:CONF_PRESET_VERSION,:CONF_PRESET_DEFAULT,
-        :CONF_PRESET_GLOBAL,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,
-        :RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO,
-        :TRANSFER_SDK_ARCHIVE_URL,:AOC_PATH_API_CLIENTS,:DEMO_SERVER_PRESET,:EMAIL_TEST_TEMPLATE,:EXTV_INCLUDE_PRESETS,
-        :EXTV_PRESET,:DEFAULT_CHECK_NEW_VERSION_DAYS,:DEFAULT_PRIV_KEY_FILENAME,:SERVER_COMMAND,:CONF_PRESET_SECRETS,
-        :PRESET_DIG_SEPARATOR
+          :CONF_PRESET_GLOBAL,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,
+          :RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO,
+          :TRANSFER_SDK_ARCHIVE_URL,:AOC_PATH_API_CLIENTS,:DEMO_SERVER_PRESET,:EMAIL_TEST_TEMPLATE,:EXTV_INCLUDE_PRESETS,
+          :EXTV_PRESET,:DEFAULT_CHECK_NEW_VERSION_DAYS,:DEFAULT_PRIV_KEY_FILENAME,:SERVER_COMMAND,:CONF_PRESET_SECRETS,
+          :PRESET_DIG_SEPARATOR
         def initialize(env,params)
           raise 'env and params must be Hash' unless env.is_a?(Hash) && params.is_a?(Hash)
-          raise 'missing param' unless [:name,:help,:version,:gem].sort.eql?(params.keys.sort)
+          raise 'missing param' unless %i[name help version gem].sort.eql?(params.keys.sort)
           super(env)
-          @info=params
-          @main_folder=default_app_main_folder
-          @plugins={}
-          @plugin_lookup_folders=[]
-          @use_plugin_defaults=true
-          @config_presets=nil
-          @connect_versions=nil
-          @vault=nil
-          @conf_file_default=File.join(@main_folder,DEFAULT_CONFIG_FILENAME)
-          @option_config_file=@conf_file_default
-          @pac_exec=nil
+          @info = params
+          @main_folder = default_app_main_folder
+          @plugins = {}
+          @plugin_lookup_folders = []
+          @use_plugin_defaults = true
+          @config_presets = nil
+          @connect_versions = nil
+          @vault = nil
+          @conf_file_default = File.join(@main_folder,DEFAULT_CONFIG_FILENAME)
+          @option_config_file = @conf_file_default
+          @pac_exec = nil
           Log.log.debug("#{@info[:name]} folder: #{@main_folder}")
           # set folder for FASP SDK
           add_plugin_lookup_folder(self.class.gem_plugins_folder)
@@ -113,7 +115,7 @@ module Aspera
           options.set_obj_attr(:use_product,self,:option_use_product)
           options.set_obj_attr(:preset,self,:option_preset)
           options.set_obj_attr(:plugin_folder,self,:option_plugin_folder)
-          options.add_opt_switch(:no_default,'-N','do not load default configuration for plugin') { @use_plugin_defaults=false }
+          options.add_opt_switch(:no_default,'-N','do not load default configuration for plugin') { @use_plugin_defaults = false }
           options.add_opt_boolean(:override,'Wizard: override existing value')
           options.add_opt_boolean(:use_generic_client,'Wizard: AoC: use global or org specific jwt client id')
           options.add_opt_boolean(:default,'Wizard: set as default configuration for specified plugin (also: update)')
@@ -140,9 +142,9 @@ module Aspera
           options.set_option(:sdk_folder,File.join(@main_folder,'sdk'))
           options.set_option(:override,:no)
           options.parse_options!
-          pac_script=options.get_option(:fpac,:optional)
+          pac_script = options.get_option(:fpac)
           # create PAC executor
-          @pac_exec=Aspera::ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
+          @pac_exec = Aspera::ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
         end
 
         # env var name to override the app's main folder
@@ -153,72 +155,81 @@ module Aspera
 
         def default_app_main_folder
           # find out application main folder
-          app_folder=ENV[conf_dir_env_var]
+          app_folder = ENV[conf_dir_env_var]
           # if env var undefined or empty
           if app_folder.nil? || app_folder.empty?
-            user_home_folder=Dir.home
+            user_home_folder = Dir.home
             raise CliError,"Home folder does not exist: #{user_home_folder}. Check your user environment or use #{conf_dir_env_var}." unless Dir.exist?(user_home_folder)
-            app_folder=File.join(user_home_folder,ASPERA_HOME_FOLDER_NAME,@info[:name])
+            app_folder = File.join(user_home_folder,ASPERA_HOME_FOLDER_NAME,@info[:name])
           end
           return app_folder
         end
 
         def check_gem_version
-          latest_version=begin
-            Rest.new(base_url: 'https://rubygems.org/api/v1').read("versions/#{@info[:gem]}/latest.json")[:data]['version']
-          rescue StandardError
-            Log.log.warn('Could not retrieve latest gem version on rubygems.')
-            '0'
-          end
+          latest_version =
+            begin
+              Rest.new(base_url: 'https://rubygems.org/api/v1').read("versions/#{@info[:gem]}/latest.json")[:data]['version']
+            rescue StandardError
+              Log.log.warn('Could not retrieve latest gem version on rubygems.')
+              '0'
+            end
           if Gem::Version.new(Environment.ruby_version) < Gem::Version.new(RUBY_FUTURE_MINIMUM_VERSION)
-            Log.log.warn("Note that a future version will require Ruby version #{RUBY_FUTURE_MINIMUM_VERSION} at minimum, you are using #{Environment.ruby_version}")
+            Log.log.warn("Note that a future version will require Ruby version #{RUBY_FUTURE_MINIMUM_VERSION} at minimum, "\
+              "you are using #{Environment.ruby_version}")
           end
-          return {name: @info[:gem], current: Aspera::Cli::VERSION, latest: latest_version, need_update: Gem::Version.new(Aspera::Cli::VERSION) < Gem::Version.new(latest_version)}
+          return {
+            name:        @info[:gem],
+            current:     Aspera::Cli::VERSION,
+            latest:      latest_version,
+            need_update: Gem::Version.new(Aspera::Cli::VERSION) < Gem::Version.new(latest_version)
+          }
         end
 
         def periodic_check_newer_gem_version
           # get verification period
-          delay_days=options.get_option(:version_check_days,:mandatory)
+          delay_days = options.get_option(:version_check_days,is_type: :mandatory)
           Log.log.info("check days: #{delay_days}")
           # check only if not zero day
           return if delay_days.eql?(0)
           # get last date from persistency
-          last_check_array=[]
-          check_date_persist=PersistencyActionOnce.new(
-          manager: persistency,
-          data:    last_check_array,
-          id:      'version_last_check')
+          last_check_array = []
+          check_date_persist = PersistencyActionOnce.new(
+            manager: persistency,
+            data:    last_check_array,
+            id:      'version_last_check')
           # get persisted date or nil
-          current_date=Date.today
-          last_check_days = begin
-            current_date-Date.strptime(last_check_array.first, '%Y/%m/%d')
-          rescue StandardError
-            # negative value will force check
-            -1
-          end
+          current_date = Date.today
+          last_check_days =
+            begin
+              current_date - Date.strptime(last_check_array.first, '%Y/%m/%d')
+            rescue StandardError
+              # negative value will force check
+              -1
+            end
           Log.log.debug("days elapsed: #{last_check_days}")
           return if last_check_days < delay_days
           # generate timestamp
-          last_check_array[0]=current_date.strftime('%Y/%m/%d')
+          last_check_array[0] = current_date.strftime('%Y/%m/%d')
           check_date_persist.save
           # compare this version and the one on internet
-          check_data=check_gem_version
-          Log.log.warn("A new version is available: #{check_data[:latest]}. You have #{check_data[:current]}. Upgrade with: gem update #{check_data[:name]}") if check_data[:need_update]
+          check_data = check_gem_version
+          Log.log.warn("A new version is available: #{check_data[:latest]}. "\
+            "You have #{check_data[:current]}. Upgrade with: gem update #{check_data[:name]}") if check_data[:need_update]
         end
 
         # retrieve structure from cloud (CDN) with all versions available
         def connect_versions
           if @connect_versions.nil?
-            api_connect_cdn=Rest.new({base_url: CONNECT_WEB_URL})
-            javascript=api_connect_cdn.call({operation: 'GET',subpath: CONNECT_VERSIONS})
+            api_connect_cdn = Rest.new({base_url: CONNECT_WEB_URL})
+            javascript = api_connect_cdn.call({operation: 'GET',subpath: CONNECT_VERSIONS})
             # get result on one line
-            connect_versions_javascript=javascript[:http].body.gsub(/\r?\n\s*/,'')
+            connect_versions_javascript = javascript[:http].body.gsub(/\r?\n\s*/,'')
             Log.log.debug("javascript=[\n#{connect_versions_javascript}\n]")
             # get javascript object only
-            found=connect_versions_javascript.match(/^.*? = (.*);/)
+            found = connect_versions_javascript.match(/^.*? = (.*);/)
             raise CliError,'Problen when getting connect versions from internet' if found.nil?
-            alldata=JSON.parse(found[1])
-            @connect_versions=alldata['entries']
+            alldata = JSON.parse(found[1])
+            @connect_versions = alldata['entries']
           end
           return @connect_versions
         end
@@ -228,9 +239,9 @@ module Aspera
         # try to find: conffile[conffile["default"][plugin_str]]
         # @param plugin_name_sym : symbol for plugin name
         def add_plugin_default_preset(plugin_name_sym)
-          default_config_name=get_plugin_default_config_name(plugin_name_sym)
+          default_config_name = get_plugin_default_config_name(plugin_name_sym)
           Log.log.debug("add_plugin_default_preset:#{plugin_name_sym}:#{default_config_name}")
-          options.add_option_preset(preset_by_name(default_config_name),:unshift) unless default_config_name.nil?
+          options.add_option_preset(preset_by_name(default_config_name),op: :unshift) unless default_config_name.nil?
           return nil
         end
 
@@ -240,7 +251,7 @@ module Aspera
           require 'openssl'
           priv_key = OpenSSL::PKey::RSA.new(length)
           File.write(private_key_path,priv_key.to_s)
-          File.write(private_key_path+'.pub',priv_key.public_key.to_s)
+          File.write(private_key_path + '.pub',priv_key.public_key.to_s)
           nil
         end
 
@@ -268,16 +279,6 @@ module Aspera
             # Module.nesting[2] is Aspera::Cli::Plugins
             return Object.const_get("#{module_full_name}::#{plugin_name_sym.to_s.capitalize}")
           end
-
-          def flatten_all_config(t)
-            r=[]
-            t.each do |k,v|
-              v.each do |kk,vv|
-                r.push({'config'=>k,'parameter'=>kk,'value'=>vv})
-              end
-            end
-            return r
-          end
         end
 
         # set parameter and value in global config
@@ -285,14 +286,14 @@ module Aspera
         # @return preset name that contains global default
         def set_global_default(key,value)
           # get default preset if it exists
-          global_default_preset_name=get_plugin_default_config_name(CONF_GLOBAL_SYM)
+          global_default_preset_name = get_plugin_default_config_name(CONF_GLOBAL_SYM)
           if global_default_preset_name.nil?
-            global_default_preset_name=CONF_PRESET_GLOBAL
-            @config_presets[CONF_PRESET_DEFAULT]||={}
-            @config_presets[CONF_PRESET_DEFAULT][CONF_GLOBAL_SYM.to_s]=global_default_preset_name
+            global_default_preset_name = CONF_PRESET_GLOBAL
+            @config_presets[CONF_PRESET_DEFAULT] ||= {}
+            @config_presets[CONF_PRESET_DEFAULT][CONF_GLOBAL_SYM.to_s] = global_default_preset_name
           end
-          @config_presets[global_default_preset_name]||={}
-          @config_presets[global_default_preset_name][key.to_s]=value
+          @config_presets[global_default_preset_name] ||= {}
+          @config_presets[global_default_preset_name][key.to_s] = value
           self.format.display_status("Updated: #{global_default_preset_name}: #{key} <- #{value}")
           save_presets_to_config_file
           return global_default_preset_name
@@ -310,12 +311,12 @@ module Aspera
         # @param include_path used to detect and avoid include loops
         def preset_by_name(config_name, include_path=[])
           raise CliError,'loop in include' if include_path.include?(config_name)
-          include_path=include_path.clone # avoid messing up if there are multiple branches
-          current=@config_presets
+          include_path = include_path.clone # avoid messing up if there are multiple branches
+          current = @config_presets
           config_name.split(PRESET_DIG_SEPARATOR).each do |name|
             raise CliError,"not a Hash: #{include_path} (#{current.class})" unless current.is_a?(Hash)
             include_path.push(name)
-            current=current[name]
+            current = current[name]
             raise CliError,"no such config preset: #{include_path}" if nil?
           end
           case current
@@ -331,10 +332,10 @@ module Aspera
         def expanded_with_preset_includes(hash_val, include_path=[])
           raise CliError,"#{EXTV_INCLUDE_PRESETS} requires a Hash, have #{hash_val.class}" unless hash_val.is_a?(Hash)
           if hash_val.has_key?(EXTV_INCLUDE_PRESETS)
-            memory=hash_val.clone
-            includes=memory[EXTV_INCLUDE_PRESETS]
+            memory = hash_val.clone
+            includes = memory[EXTV_INCLUDE_PRESETS]
             memory.delete(EXTV_INCLUDE_PRESETS)
-            hash_val={}
+            hash_val = {}
             raise "#{EXTV_INCLUDE_PRESETS} must be an Array" unless includes.is_a?(Array)
             raise "#{EXTV_INCLUDE_PRESETS} must contain names" unless includes.map(&:class).uniq.eql?([String])
             includes.each do |preset_name|
@@ -379,13 +380,13 @@ module Aspera
         end
 
         def convert_preset_path(old_name,new_name,files_to_copy)
-          old_subpath=File.join('',ASPERA_HOME_FOLDER_NAME,old_name,'')
-          new_subpath=File.join('',ASPERA_HOME_FOLDER_NAME,new_name,'')
+          old_subpath = File.join('',ASPERA_HOME_FOLDER_NAME,old_name,'')
+          new_subpath = File.join('',ASPERA_HOME_FOLDER_NAME,new_name,'')
           # convert possible keys located in config folder
           @config_presets.values.select{|p|p.is_a?(Hash)}.each do |preset|
-            preset.values.select{|v|v.is_a?(String) and v.include?(old_subpath)}.each do |value|
-              old_val=value.clone
-              included_path=File.expand_path(old_val.gsub(/^@file:/,''))
+            preset.values.select{|v|v.is_a?(String) && v.include?(old_subpath)}.each do |value|
+              old_val = value.clone
+              included_path = File.expand_path(old_val.gsub(/^@file:/,''))
               files_to_copy.push(included_path) unless files_to_copy.include?(included_path) || !File.exist?(included_path)
               value.gsub!(old_subpath,new_subpath)
               Log.log.warn("Converted config value: #{old_val} -> #{value}")
@@ -394,9 +395,9 @@ module Aspera
         end
 
         def convert_preset_plugin_name(old_name,new_name)
-          default_preset=@config_presets[CONF_PRESET_DEFAULT]
+          default_preset = @config_presets[CONF_PRESET_DEFAULT]
           return unless default_preset.is_a?(Hash) && default_preset.has_key?(old_name)
-          default_preset[new_name]=default_preset[old_name]
+          default_preset[new_name] = default_preset[old_name]
           default_preset.delete(old_name)
           Log.log.warn("Converted plugin default: #{old_name} -> #{new_name}")
         end
@@ -406,65 +407,65 @@ module Aspera
         def read_config_file
           begin
             Log.log.debug("config file is: #{@option_config_file}".red)
-            conf_file_v1=File.join(Dir.home,ASPERA_HOME_FOLDER_NAME,PROGRAM_NAME_V1,DEFAULT_CONFIG_FILENAME)
-            conf_file_v2=File.join(Dir.home,ASPERA_HOME_FOLDER_NAME,PROGRAM_NAME_V2,DEFAULT_CONFIG_FILENAME)
+            conf_file_v1 = File.join(Dir.home,ASPERA_HOME_FOLDER_NAME,PROGRAM_NAME_V1,DEFAULT_CONFIG_FILENAME)
+            conf_file_v2 = File.join(Dir.home,ASPERA_HOME_FOLDER_NAME,PROGRAM_NAME_V2,DEFAULT_CONFIG_FILENAME)
             # files search for configuration, by default the one given by user
-            search_files=[@option_config_file]
+            search_files = [@option_config_file]
             # if default file, then also look for older versions
             search_files.push(conf_file_v2,conf_file_v1) if @option_config_file.eql?(@conf_file_default)
             # find first existing file (or nil)
-            conf_file_to_load=search_files.select{|f| File.exist?(f)}.first
+            conf_file_to_load = search_files.find{|f| File.exist?(f)}
             # require save if old version of file
-            save_required= !@option_config_file.eql?(conf_file_to_load)
+            save_required = !@option_config_file.eql?(conf_file_to_load)
             # if no file found, create default config
             if conf_file_to_load.nil?
               Log.log.warn("No config file found. Creating empty configuration file: #{@option_config_file}")
-              @config_presets={CONF_PRESET_CONFIG=>{CONF_PRESET_VERSION=>@info[:version]}}
+              @config_presets = {CONF_PRESET_CONFIG => {CONF_PRESET_VERSION => @info[:version]}}
             else
               Log.log.debug("loading #{@option_config_file}")
-              @config_presets=YAML.load_file(conf_file_to_load)
+              @config_presets = YAML.load_file(conf_file_to_load)
             end
-            files_to_copy=[]
+            files_to_copy = []
             Log.log.debug("Available_presets: #{@config_presets}")
             raise 'Expecting YAML Hash' unless @config_presets.is_a?(Hash)
             # check there is at least the config section
             if !@config_presets.has_key?(CONF_PRESET_CONFIG)
               raise "Cannot find key: #{CONF_PRESET_CONFIG}"
             end
-            version=@config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]
+            version = @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]
             if version.nil?
               raise 'No version found in config section.'
             end
             # oldest compatible conf file format, update to latest version when an incompatible change is made
             # check compatibility of version of conf file
-            config_tested_version='0.4.5'
+            config_tested_version = '0.4.5'
             if Gem::Version.new(version) < Gem::Version.new(config_tested_version)
               raise "Unsupported config file version #{version}. Expecting min version #{config_tested_version}"
             end
-            config_tested_version='0.6.15'
+            config_tested_version = '0.6.15'
             if Gem::Version.new(version) < Gem::Version.new(config_tested_version)
               convert_preset_plugin_name(AOC_COMMAND_V1,AOC_COMMAND_V2)
-              version=@config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]=config_tested_version
-              save_required=true
+              version = @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = config_tested_version
+              save_required = true
             end
-            config_tested_version='0.8.10'
+            config_tested_version = '0.8.10'
             if Gem::Version.new(version) <= Gem::Version.new(config_tested_version)
               convert_preset_path(PROGRAM_NAME_V1,PROGRAM_NAME_V2,files_to_copy)
-              version=@config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]=config_tested_version
-              save_required=true
+              version = @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = config_tested_version
+              save_required = true
             end
-            config_tested_version='1.0'
+            config_tested_version = '1.0'
             if Gem::Version.new(version) <= Gem::Version.new(config_tested_version)
               convert_preset_plugin_name(AOC_COMMAND_V2,AOC_COMMAND_V3)
               convert_preset_path(PROGRAM_NAME_V2,@info[:name],files_to_copy)
-              version=@config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]=config_tested_version
-              save_required=true
+              version = @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = config_tested_version
+              save_required = true
             end
             Log.log.debug("conf version: #{version}")
             # Place new compatibility code here
             if save_required
               Log.log.warn('Saving automatic conversion.')
-              @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]=@info[:version]
+              @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = @info[:version]
               save_presets_to_config_file
               Log.log.warn('Copying referenced files')
               files_to_copy.each do |file|
@@ -477,7 +478,7 @@ module Aspera
             raise e
           rescue StandardError => e
             Log.log.debug("-> #{e}")
-            new_name="#{@option_config_file}.pre#{@info[:version]}.manual_conversion_needed"
+            new_name = "#{@option_config_file}.pre#{@info[:version]}.manual_conversion_needed"
             File.rename(@option_config_file,new_name)
             Log.log.warn("Renamed config file to #{new_name}.")
             Log.log.warn('Manual Conversion is required. Next time, a new empty file will be created.')
@@ -503,13 +504,13 @@ module Aspera
 
         def add_plugin_info(path)
           raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
-          plugin_symbol=File.basename(path,RUBY_FILE_EXT).to_sym
-          req=path.gsub(/#{RUBY_FILE_EXT}$/,'')
+          plugin_symbol = File.basename(path,RUBY_FILE_EXT).to_sym
+          req = path.gsub(/#{RUBY_FILE_EXT}$/o,'')
           if @plugins.has_key?(plugin_symbol)
             Log.log.warn("skipping plugin already registered: #{plugin_symbol}")
             return
           end
-          @plugins[plugin_symbol]={source: path,require_stanza: req}
+          @plugins[plugin_symbol] = {source: path,require_stanza: req}
         end
 
         def identify_plugin_for_url(url)
@@ -518,24 +519,27 @@ module Aspera
             next if plugin_name_sym.eql?(CONF_PLUGIN_SYM)
             # load plugin class
             require plugin_info[:require_stanza]
-            c=self.class.plugin_class(plugin_name_sym)
+            c = self.class.plugin_class(plugin_name_sym)
             next unless c.respond_to?(:detect)
-            current_url=url
-            detection_info=nil
+            current_url = url
+            detection_info = nil
             # first try : direct
             begin
-              detection_info=c.detect(current_url)
+              detection_info = c.detect(current_url)
+            rescue OpenSSL::SSL::SSLError => e
+              Log.log.warn(e.message)
+              Log.log.warn('Use option --insecure=yes to ignore certificate') if e.message.include?('cert')
             rescue StandardError => e
-              Log.log.debug("Cannot detect #{plugin_name_sym} : #{e.message}")
+              Log.log.debug("Cannot detect #{plugin_name_sym} : #{e.class}/#{e.message}")
             end
             # second try : is there a redirect ?
             if detection_info.nil?
               begin
                 # TODO: check if redirect ?
-                new_url=Rest.new(base_url: url).call(operation: 'GET',subpath: '',redirect_max: 1)[:http].uri.to_s
+                new_url = Rest.new(base_url: url).call(operation: 'GET',subpath: '',redirect_max: 1)[:http].uri.to_s
                 unless url.eql?(new_url)
-                  detection_info=c.detect(new_url)
-                  current_url=new_url
+                  detection_info = c.detect(new_url)
+                  current_url = new_url
                 end
               rescue StandardError => e
                 Log.log.debug("Cannot detect #{plugin_name_sym} : #{e.message}")
@@ -547,35 +551,35 @@ module Aspera
         end
 
         def execute_connect_action
-          command=options.get_next_command([:list,:info,:version])
-          if [:info,:version].include?(command)
-            connect_id=options.get_next_argument('id or title')
-            one_res=connect_versions.select{|i|i['id'].eql?(connect_id) || i['title'].eql?(connect_id)}.first
+          command = options.get_next_command(%i[list info version])
+          if %i[info version].include?(command)
+            connect_id = options.get_next_argument('id or title')
+            one_res = connect_versions.find{|i|i['id'].eql?(connect_id) || i['title'].eql?(connect_id)}
             raise CliNoSuchId.new(:connect,connect_id) if one_res.nil?
           end
           case command
           when :list
-            return {type: :object_list, data: connect_versions, fields: ['id','title','version']}
+            return {type: :object_list, data: connect_versions, fields: %w[id title version]}
           when :info # shows files used
             one_res.delete('links')
             return {type: :single_object, data: one_res}
           when :version # shows files used
-            all_links=one_res['links']
-            command=options.get_next_command([:list,:download,:open])
-            if [:download,:open].include?(command)
-              link_title=options.get_next_argument('title or rel')
-              one_link=all_links.select {|i| i['title'].eql?(link_title) or i['rel'].eql?(link_title)}.first
+            all_links = one_res['links']
+            command = options.get_next_command(%i[list download open])
+            if %i[download open].include?(command)
+              link_title = options.get_next_argument('title or rel')
+              one_link = all_links.find {|i| i['title'].eql?(link_title) || i['rel'].eql?(link_title)}
               raise 'no such value' if one_link.nil?
             end
             case command
             when :list # shows files used
               return {type: :object_list, data: all_links}
             when :download
-              folder_dest=transfer.destination_folder(Fasp::TransferSpec::DIRECTION_RECEIVE)
+              folder_dest = transfer.destination_folder(Fasp::TransferSpec::DIRECTION_RECEIVE)
               #folder_dest=self.options.get_next_argument('destination folder')
-              api_connect_cdn=Rest.new({base_url: CONNECT_WEB_URL})
+              api_connect_cdn = Rest.new({base_url: CONNECT_WEB_URL})
               fileurl = one_link['href']
-              filename=fileurl.gsub(%r{.*/},'')
+              filename = fileurl.gsub(%r{.*/},'')
               api_connect_cdn.call({operation: 'GET',subpath: fileurl,save_to_file: File.join(folder_dest,filename)})
               return Main.result_status("Downloaded: #{filename}")
             when :open
@@ -586,60 +590,69 @@ module Aspera
         end
 
         def execute_action_ascp
-          command=options.get_next_command([:connect,:use,:show,:products,:info,:install,:spec,:errors])
+          command = options.get_next_command(%i[connect use show products info install spec errors])
           case command
           when :connect
             return execute_connect_action
           when :use
-            ascp_path=options.get_next_argument('path to ascp')
-            ascp_version=Fasp::Installation.instance.get_ascp_version(ascp_path)
+            ascp_path = options.get_next_argument('path to ascp')
+            ascp_version = Fasp::Installation.instance.get_ascp_version(ascp_path)
             self.format.display_status("ascp version: #{ascp_version}")
-            preset_name=set_global_default(:ascp_path,ascp_path)
+            preset_name = set_global_default(:ascp_path,ascp_path)
             return Main.result_status("Saved to default global preset #{preset_name}")
           when :show # shows files used
             return {type: :status, data: Fasp::Installation.instance.path(:ascp)}
           when :info # shows files used
-            data=Fasp::Installation::FILES.each_with_object({}) do |v,m|
-              m[v.to_s]=Fasp::Installation.instance.path(v) rescue 'Not Found'
+            data = Fasp::Installation::FILES.each_with_object({}) do |v,m|
+              m[v.to_s] =
+                begin
+                  Fasp::Installation.instance.path(v)
+                rescue => e
+                  e.message
+                end
             end
             # read PATHs from ascp directly, and pvcl modules as well
             Open3.popen3(Fasp::Installation.instance.path(:ascp),'-DDL-') do |_stdin, _stdout, stderr, thread|
-              last_line=''
-              while (line=stderr.gets)
+              last_line = ''
+              while (line = stderr.gets)
                 line.chomp!
-                last_line=line
+                last_line = line
                 case line
-                when %r{^DBG Path ([^ ]+) (dir|file) +: (.*)$} then data[Regexp.last_match(1)]=Regexp.last_match(3)
-                when %r{^DBG Added module group:"([^"]+)" name:"([^"]+)", version:"([^"]+)" interface:"([^"]+)"$} then data[Regexp.last_match(2)]=Regexp.last_match(4)
-                when %r{^DBG License result \(/license/(\S+)\): (.+)$} then data[Regexp.last_match(1)]=Regexp.last_match(2)
-                when %r{^LOG (.+) version ([0-9.]+)$} then data['product_name']=Regexp.last_match(1);data['product_version']=Regexp.last_match(2)
-                when %r{^LOG Initializing FASP version ([^,]+),} then data['ascp_version']=Regexp.last_match(1)
+                when %r{^DBG Path ([^ ]+) (dir|file) +: (.*)$} then data[Regexp.last_match(1)] = Regexp.last_match(3)
+                when %r{^DBG Added module group:"([^"]+)" name:"([^"]+)", version:"([^"]+)" interface:"([^"]+)"$} then data[Regexp.last_match(2)] = Regexp.last_match(4)
+                when %r{^DBG License result \(/license/(\S+)\): (.+)$} then data[Regexp.last_match(1)] = Regexp.last_match(2)
+                when %r{^LOG (.+) version ([0-9.]+)$} then data['product_name'] = Regexp.last_match(1);data['product_version'] = Regexp.last_match(2)
+                when %r{^LOG Initializing FASP version ([^,]+),} then data['ascp_version'] = Regexp.last_match(1)
                 end
               end
               if !thread.value.exitstatus.eql?(1) && !data.has_key?('root')
                 raise last_line
               end
             end
-            data['keypass']=Fasp::Installation.instance.bypass_pass
+            data['keypass'] = Fasp::Installation.instance.bypass_pass
             return {type: :single_object, data: data}
           when :products
-            command=options.get_next_command([:list,:use])
+            command = options.get_next_command(%i[list use])
             case command
             when :list
-              return {type: :object_list, data: Fasp::Installation.instance.installed_products, fields: ['name','app_root']}
+              return {type: :object_list, data: Fasp::Installation.instance.installed_products, fields: %w[name app_root]}
             when :use
-              default_product=options.get_next_argument('product name')
+              default_product = options.get_next_argument('product name')
               Fasp::Installation.instance.use_ascp_from_product(default_product)
-              preset_name=set_global_default(:ascp_path,Fasp::Installation.instance.path(:ascp))
+              preset_name = set_global_default(:ascp_path,Fasp::Installation.instance.path(:ascp))
               return Main.result_status("Saved to default global preset #{preset_name}")
             end
           when :install
-            v=Fasp::Installation.instance.install_sdk(options.get_option(:sdk_url,:mandatory))
+            v = Fasp::Installation.instance.install_sdk(options.get_option(:sdk_url,is_type: :mandatory))
             return Main.result_status("Installed version #{v}")
           when :spec
-            return {type: :object_list, data: Fasp::Parameters.man_table, fields: ['name','type',Fasp::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s),'description'].flatten}
+            return {
+              type:   :object_list,
+              data:   Fasp::Parameters.man_table,
+              fields: ['name','type',Fasp::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s),'description'].flatten
+            }
           when :errors
-            error_data=[]
+            error_data = []
             Fasp::ERROR_INFO.each_pair do |code,prop|
               error_data.push(code: code, mnemonic: prop[:c], retry: prop[:r], info: prop[:a])
             end
@@ -649,24 +662,24 @@ module Aspera
         end
 
         # legacy actions available globally
-        PRESET_GBL_ACTIONS=[:list,:overview].freeze
+        PRESET_GBL_ACTIONS = %i[list overview].freeze
         # require existing preset
-        PRESET_EXST_ACTIONS=[:show,:delete,:get,:unset].freeze
+        PRESET_EXST_ACTIONS = %i[show delete get unset].freeze
         # require id
-        PRESET_INSTANCE_ACTIONS=[PRESET_EXST_ACTIONS,:initialize,:update,:ask,:set].flatten.freeze
-        PRESET_ALL_ACTIONS=[PRESET_GBL_ACTIONS,PRESET_INSTANCE_ACTIONS].flatten.freeze
+        PRESET_INSTANCE_ACTIONS = [PRESET_EXST_ACTIONS,%i[initialize update ask set]].flatten.freeze
+        PRESET_ALL_ACTIONS = [PRESET_GBL_ACTIONS,PRESET_INSTANCE_ACTIONS].flatten.freeze
 
         def execute_file_action(action,config_name)
-          action=options.get_next_command(PRESET_ALL_ACTIONS) if action.nil?
-          config_name=instance_identifier() if config_name.nil? && PRESET_INSTANCE_ACTIONS.include?(action)
+          action = options.get_next_command(PRESET_ALL_ACTIONS) if action.nil?
+          config_name = instance_identifier if config_name.nil? && PRESET_INSTANCE_ACTIONS.include?(action)
           # those operations require existing option
           raise "no such preset: #{config_name}" if PRESET_EXST_ACTIONS.include?(action) && !@config_presets.has_key?(config_name)
-          selected_preset=@config_presets[config_name]
+          selected_preset = @config_presets[config_name]
           case action
           when :list
             return {type: :value_list, data: @config_presets.keys, name: 'name'}
           when :overview
-            return {type: :object_list, data: self.class.flatten_all_config(@config_presets)}
+            return {type: :object_list, data: Formater.flatten_config_overview(@config_presets)}
           when :show
             raise "no such config: #{config_name}" if selected_preset.nil?
             return {type: :single_object, data: selected_preset}
@@ -675,67 +688,67 @@ module Aspera
             save_presets_to_config_file
             return Main.result_status("Deleted: #{config_name}")
           when :get
-            param_name=options.get_next_argument('parameter name')
-            value=selected_preset[param_name]
+            param_name = options.get_next_argument('parameter name')
+            value = selected_preset[param_name]
             raise "no such option in preset #{config_name} : #{param_name}" if value.nil?
             case value
             when Numeric,String then return {type: :text, data: ExtendedValue.instance.evaluate(value.to_s)}
             end
             return {type: :single_object, data: value}
           when :unset
-            param_name=options.get_next_argument('parameter name')
+            param_name = options.get_next_argument('parameter name')
             selected_preset.delete(param_name)
             save_presets_to_config_file
             return Main.result_status("Removed: #{config_name}: #{param_name}")
           when :set
-            param_name=options.get_next_argument('parameter name')
-            param_value=options.get_next_argument('parameter value')
+            param_name = options.get_next_argument('parameter name')
+            param_value = options.get_next_argument('parameter value')
             if !@config_presets.has_key?(config_name)
               Log.log.debug("no such config name: #{config_name}, initializing")
-              selected_preset=@config_presets[config_name]={}
+              selected_preset = @config_presets[config_name] = {}
             end
             if selected_preset.has_key?(param_name)
               Log.log.warn("overwriting value: #{selected_preset[param_name]}")
             end
-            selected_preset[param_name]=param_value
+            selected_preset[param_name] = param_value
             save_presets_to_config_file
             return Main.result_status("Updated: #{config_name}: #{param_name} <- #{param_value}")
           when :initialize
-            config_value=options.get_next_argument('extended value (Hash)')
+            config_value = options.get_next_argument('extended value (Hash)')
             if @config_presets.has_key?(config_name)
               Log.log.warn("configuration already exists: #{config_name}, overwriting")
             end
-            @config_presets[config_name]=config_value
+            @config_presets[config_name] = config_value
             save_presets_to_config_file
             return Main.result_status("Modified: #{@option_config_file}")
           when :update
             #  get unprocessed options
-            theopts=options.get_options_table
+            theopts = options.get_options_table
             Log.log.debug("opts=#{theopts}")
-            @config_presets[config_name]||={}
+            @config_presets[config_name] ||= {}
             @config_presets[config_name].merge!(theopts)
             # fix bug in 4.4 (creating key "true" in "default" preset)
             @config_presets[CONF_PRESET_DEFAULT].delete(true) if @config_presets[CONF_PRESET_DEFAULT].is_a?(Hash)
             save_presets_to_config_file
             return Main.result_status("Updated: #{config_name}")
           when :ask
-            options.ask_missing_mandatory=:yes
-            @config_presets[config_name]||={}
-            options.get_next_argument('option names',:multiple).each do |optionname|
-              option_value=options.get_interactive(:option,optionname)
-              @config_presets[config_name][optionname]=option_value
+            options.ask_missing_mandatory = :yes
+            @config_presets[config_name] ||= {}
+            options.get_next_argument('option names',expected: :multiple).each do |optionname|
+              option_value = options.get_interactive(:option,optionname)
+              @config_presets[config_name][optionname] = option_value
             end
             save_presets_to_config_file
             return Main.result_status("Updated: #{config_name}")
           end
         end
 
-        ACTIONS=[PRESET_GBL_ACTIONS,:id,:preset,:open,:documentation,:genkey,:gem,:plugin,:flush_tokens,:echo,:wizard,:export_to_cli,:detect,:coffee,:ascp,:email_test,
-                 :smtp_settings,:proxy_check,:folder,:file,:check_update,:initdemo,:vault].flatten.freeze
+        ACTIONS = [PRESET_GBL_ACTIONS,%i[id preset open documentation genkey gem plugin flush_tokens echo wizard export_to_cli detect coffee
+                                         ascp email_test smtp_settings proxy_check folder file check_update initdemo vault]].flatten.freeze
 
         # "config" plugin
         def execute_action
-          action=options.get_next_command(ACTIONS)
+          action = options.get_next_command(ACTIONS)
           case action
           when *PRESET_GBL_ACTIONS # older syntax
             return execute_file_action(action,nil)
@@ -747,31 +760,32 @@ module Aspera
             OpenApplication.instance.uri(@option_config_file.to_s) #file://
             return Main.result_nothing
           when :documentation
-            section=options.get_next_argument('private key file path',:single,:optional)
-            section='#'+section unless section.nil?
+            section = options.get_next_argument('private key file path',mandatory: false)
+            section = '#' + section unless section.nil?
             OpenApplication.instance.uri("#{@info[:help]}#{section}")
             return Main.result_nothing
           when :genkey # generate new rsa key
-            private_key_path=options.get_next_argument('private key file path')
-            generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
-            return Main.result_status('Generated key: '+private_key_path)
+            private_key_path = options.get_next_argument('private key file path')
+            private_key_length = options.get_next_argument('size in bits',mandatory: false) || DEFAULT_PRIVKEY_LENGTH
+            generate_rsa_private_key(private_key_path,private_key_length)
+            return Main.result_status('Generated key: ' + private_key_path)
           when :echo # display the content of a value given on command line
-            result={type: :other_struct, data: options.get_next_argument('value')}
+            result = {type: :other_struct, data: options.get_next_argument('value')}
             # special for csv
-            result[:type]=:object_list if result[:data].is_a?(Array) && result[:data].first.is_a?(Hash)
+            result[:type] = :object_list if result[:data].is_a?(Array) && result[:data].first.is_a?(Hash)
             return result
           when :flush_tokens
-            deleted_files=Oauth.flush_tokens
+            deleted_files = Oauth.flush_tokens
             return {type: :value_list, data: deleted_files, name: 'file'}
           when :plugin
-            case options.get_next_command([:list,:create])
+            case options.get_next_command(%i[list create])
             when :list
-              return {type: :object_list, data: @plugins.keys.map { |i| { 'plugin' => i.to_s, 'path' => @plugins[i][:source] } }, fields: ['plugin','path']}
+              return {type: :object_list, data: @plugins.keys.map { |i| { 'plugin' => i.to_s, 'path' => @plugins[i][:source] } }, fields: %w[plugin path]}
             when :create
-              plugin_name=options.get_next_argument('name',:single,:mandatory).downcase
-              plugin_folder=options.get_next_argument('folder',:single,:optional) || File.join(@main_folder,ASPERA_PLUGINS_FOLDERNAME)
-              plugin_file=File.join(plugin_folder,"#{plugin_name}.rb")
-              content=<<~END_OF_PLUGIN_CODE
+              plugin_name = options.get_next_argument('name',expected: :single).downcase
+              plugin_folder = options.get_next_argument('folder',expected: :single,mandatory: false) || File.join(@main_folder,ASPERA_PLUGINS_FOLDERNAME)
+              plugin_file = File.join(plugin_folder,"#{plugin_name}.rb")
+              content = <<~END_OF_PLUGIN_CODE
                 require 'aspera/cli/plugin'
                 module Aspera
                   module Cli
@@ -789,159 +803,62 @@ module Aspera
             end
           when :wizard
             # interactive mode
-            options.ask_missing_mandatory=true
+            options.ask_missing_mandatory = true
             # register url option
-            BasicAuthPlugin.new(@agents.merge(skip_option_header: true))
+            BasicAuthPlugin.register_options(@agents)
+            params={}
             # get from option, or ask
-            instance_url=options.get_option(:url,:mandatory)
+            params[:instance_url] = options.get_option(:url,is_type: :mandatory)
             # allow user to tell the preset name
-            preset_name=options.get_option(:id,:optional)
+            params[:preset_name] = options.get_option(:id)
             # allow user to specify type of application
-            application=options.get_option(:value,:optional)
-            application=application.nil? ? identify_plugin_for_url(instance_url)[:product] : application.to_sym
-            plugin_name='<replace per app>'
-            test_args='<replace per app>'
-            case application
+            params[:application] = options.get_option(:value)
+            params[:application] = params[:application].nil? ? identify_plugin_for_url(params[:instance_url])[:product] : params[:application].to_sym
+            params[:plugin_name]=params[:application]
+            params[:test_args] = '<replace per app>'
+            case params[:application]
+            when :faspex5
+              wizard_faspex5(params)
             when :aoc
-              self.format.display_status('Detected: Aspera on Cloud'.bold)
-              plugin_name=AOC_COMMAND_CURRENT
-              organization=AoC.parse_url(instance_url).first
-              # if not defined by user, generate name
-              preset_name=[application,organization].join('_') if preset_name.nil?
-              self.format.display_status("Preparing preset: #{preset_name}")
-              # init defaults if necessary
-              @config_presets[CONF_PRESET_DEFAULT]||={}
-              option_override=options.get_option(:override,:mandatory)
-              option_default=options.get_option(:default,:mandatory)
-              Log.log.error("override=#{option_override} -> #{option_override.class}")
-              raise CliError,"A default configuration already exists for plugin '#{plugin_name}' (use --override=yes or --default=no)" if !option_override && option_default && @config_presets[CONF_PRESET_DEFAULT].has_key?(plugin_name)
-              raise CliError,"Preset already exists: #{preset_name}  (use --override=yes or --id=<name>)" if !option_override && @config_presets.has_key?(preset_name)
-              # lets see if path to priv key is provided
-              private_key_path=options.get_option(:pkeypath,:optional)
-              # give a chance to provide
-              if private_key_path.nil?
-                self.format.display_status('Please provide path to your private RSA key, or empty to generate one:')
-                private_key_path=options.get_option(:pkeypath,:mandatory).to_s
-              end
-              # else generate path
-              if private_key_path.empty?
-                private_key_path=File.join(@main_folder,DEFAULT_PRIV_KEY_FILENAME)
-              end
-              if File.exist?(private_key_path)
-                self.format.display_status('Using existing key:')
-              else
-                self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
-                generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
-                self.format.display_status('Created:')
-              end
-              self.format.display_status(private_key_path)
-              pub_key_pem=OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
-              # declare command line options for AoC
-              require 'aspera/cli/plugins/aoc'
-              # make username mandatory for jwt, this triggers interactive input
-              options.get_option(:username,:mandatory)
-              # instanciate AoC plugin, so that command line options are known
-              aoc_api=self.class.plugin_class(plugin_name).new(@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path})).aoc_api
-              auto_set_pub_key=false
-              auto_set_jwt=false
-              use_browser_authentication=false
-              if options.get_option(:use_generic_client)
-                self.format.display_status('Using global client_id.')
-                self.format.display_status('Please Login to your Aspera on Cloud instance.'.red)
-                self.format.display_status('Navigate to your "Account Settings"'.red)
-                self.format.display_status('Check or update the value of "Public Key" to be:'.red.blink)
-                self.format.display_status(pub_key_pem.to_s)
-                if !options.get_option(:test_mode)
-                  self.format.display_status('Once updated or validated, press enter.')
-                  OpenApplication.instance.uri(instance_url)
-                  $stdin.gets
-                end
-              else
-                self.format.display_status('Using organization specific client_id.')
-                if options.get_option(:client_id,:optional).nil? || options.get_option(:client_secret,:optional).nil?
-                  self.format.display_status('Please login to your Aspera on Cloud instance.'.red)
-                  self.format.display_status('Go to: Apps->Admin->Organization->Integrations')
-                  self.format.display_status('Create or check if there is an existing integration named:')
-                  self.format.display_status("- name: #{@info[:name]}")
-                  self.format.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
-                  self.format.display_status('- origin: localhost')
-                  self.format.display_status('Once created or identified,')
-                  self.format.display_status('Please enter:'.red)
-                end
-                OpenApplication.instance.uri("#{instance_url}/#{AOC_PATH_API_CLIENTS}")
-                options.get_option(:client_id,:mandatory)
-                options.get_option(:client_secret,:mandatory)
-                use_browser_authentication=true
-              end
-              if use_browser_authentication
-                self.format.display_status('We will use web authentication to bootstrap.')
-                auto_set_pub_key=true
-                auto_set_jwt=true
-                aoc_api.oauth.params[:crtype]=:web
-                aoc_api.oauth.params[:web][:redirect_uri]=DEFAULT_REDIRECT
-                aoc_api.oauth.params[:scope]=AoC::SCOPE_FILES_ADMIN
-              end
-              myself=aoc_api.read('self')[:data]
-              if auto_set_pub_key
-                raise CliError,'Public key is already set in profile (use --override=yes)' unless myself['public_key'].empty? || option_override
-                self.format.display_status('Updating profile with new key')
-                aoc_api.update("users/#{myself['id']}",{'public_key'=>pub_key_pem})
-              end
-              if auto_set_jwt
-                self.format.display_status('Enabling JWT for client')
-                aoc_api.update("clients/#{options.get_option(:client_id)}",{'jwt_grant_enabled'=>true,'explicit_authorization_required'=>false})
-              end
-              self.format.display_status("Creating new config preset: #{preset_name}")
-              @config_presets[preset_name]={
-                :url.to_s           =>options.get_option(:url),
-                :username.to_s      =>myself['email'],
-                :auth.to_s          =>:jwt.to_s,
-                :private_key.to_s   =>'@file:'+private_key_path
-              }
-              # set only if non nil
-              [:client_id,:client_secret].each do |s|
-                o=options.get_option(s)
-                @config_presets[preset_name][s.to_s] = o unless o.nil?
-              end
-              test_args="#{plugin_name} user profile show"
+              wizard_aoc(params)
             else
-              raise CliBadArgument,"Supports only: aoc. Detected: #{application}"
+              raise CliBadArgument,"Supports only: aoc. Detected: #{params[:application]}"
             end # product
-            if option_default
-              self.format.display_status("Setting config preset as default for #{plugin_name}")
-              @config_presets[CONF_PRESET_DEFAULT][plugin_name]=preset_name
+            if params[:option_default]
+              self.format.display_status("Setting config preset as default for #{params[:plugin_name]}")
+              @config_presets[CONF_PRESET_DEFAULT][params[:plugin_name]] = params[:preset_name]
             else
-              test_args="-P#{preset_name} #{test_args}"
+              params[:test_args] = "-P#{params[:preset_name]} #{params[:test_args]}"
             end
             self.format.display_status('Saving config file.')
             save_presets_to_config_file
-            return Main.result_status("Done.\nYou can test with:\n#{@info[:name]} #{test_args}")
-          when :export_to_cli
+            return Main.result_status("Done.\nYou can test with:\n#{@info[:name]} #{params[:test_args]}")
+          when :export_to_cli # this method shall be deprecated in the future: it was used to export configuration to "aspera.exe" CLI
             self.format.display_status('Exporting: Aspera on Cloud')
             require 'aspera/cli/plugins/aoc'
             # need url / username
             add_plugin_default_preset(AOC_COMMAND_V3.to_sym)
             # instanciate AoC plugin
             self.class.plugin_class(AOC_COMMAND_CURRENT).new(@agents) # TODO: is this line needed ? get options ?
-            url=options.get_option(:url,:mandatory)
-            cli_conf_file=Fasp::Installation.instance.cli_conf_file
-            data=JSON.parse(File.read(cli_conf_file))
-            organization,instance_domain=AoC.parse_url(url)
-            key_basename='org_'+organization+'.pem'
-            key_file=File.join(File.dirname(File.dirname(cli_conf_file)),'etc',key_basename)
-            File.write(key_file,options.get_option(:private_key,:mandatory))
-            new_conf={
+            url = options.get_option(:url,is_type: :mandatory)
+            cli_conf_file = Fasp::Installation.instance.cli_conf_file
+            data = JSON.parse(File.read(cli_conf_file))
+            organization,instance_domain = AoC.parse_url(url)
+            key_basename = 'org_' + organization + '.pem'
+            key_file = File.join(File.dirname(File.dirname(cli_conf_file)),'etc',key_basename)
+            File.write(key_file,options.get_option(:private_key,is_type: :mandatory))
+            new_conf = {
               'organization'       => organization,
               'hostname'           => [organization,instance_domain].join('.'),
               'privateKeyFilename' => key_basename,
-              'username'           => options.get_option(:username,:mandatory)
+              'username'           => options.get_option(:username,is_type: :mandatory)
             }
-            new_conf['clientId']=options.get_option(:client_id,:optional)
-            new_conf['clientSecret']=options.get_option(:client_secret,:optional)
+            new_conf['clientId'] = options.get_option(:client_id)
+            new_conf['clientSecret'] = options.get_option(:client_secret)
             if new_conf['clientId'].nil?
-              new_conf['clientId'],new_conf['clientSecret']=AoC.get_client_info()
+              new_conf['clientId'],new_conf['clientSecret'] = AoC.get_client_info
             end
-            entry=data['AoCAccounts'].select{|i|i['organization'].eql?(organization)}.first
+            entry = data['AoCAccounts'].find{|i|i['organization'].eql?(organization)}
             if entry.nil?
               data['AoCAccounts'].push(new_conf)
               self.format.display_status("Creating new aoc entry: #{organization}")
@@ -953,15 +870,15 @@ module Aspera
             return Main.result_status("Updated: #{cli_conf_file}")
           when :detect
             # need url / username
-            BasicAuthPlugin.new(@agents)
-            return {type: :single_object, data: identify_plugin_for_url(options.get_option(:url,:mandatory))}
+            BasicAuthPlugin.register_options(@agents)
+            return {type: :single_object, data: identify_plugin_for_url(options.get_option(:url,is_type: :mandatory))}
           when :coffee
             OpenApplication.instance.uri('https://enjoyjava.com/wp-content/uploads/2018/01/How-to-make-strong-coffee.jpg')
             return Main.result_nothing
           when :ascp
             execute_action_ascp
           when :gem
-            case options.get_next_command([:path,:version,:name])
+            case options.get_next_command(%i[path version name])
             when :path then return Main.result_status(self.class.gem_src_root)
             when :version then return Main.result_status(Aspera::Cli::VERSION)
             when :name then return Main.result_status(@info[:gem])
@@ -977,8 +894,8 @@ module Aspera
             return {type: :single_object, data: email_settings}
           when :proxy_check
             # ensure fpac was provided
-            options.get_option(:fpac,:mandatory)
-            server_url=options.get_next_argument('server url')
+            options.get_option(:fpac,is_type: :mandatory)
+            server_url = options.get_next_argument('server url')
             return Main.result_status(@pac_exec.find_proxy_for_url(server_url))
           when :check_update
             return {type: :single_object, data: check_gem_version}
@@ -987,28 +904,32 @@ module Aspera
               Log.log.warn("Demo server preset already present: #{DEMO_SERVER_PRESET}")
             else
               Log.log.info("Creating Demo server preset: #{DEMO_SERVER_PRESET}")
-              @config_presets[DEMO_SERVER_PRESET]=
-{'url'=>'ssh://'+DEMO+'.asperasoft.com:33001','username'=>AOC_COMMAND_V2,'ssAP'.downcase.reverse+'drow'.reverse=>DEMO+AOC_COMMAND_V2}
+              @config_presets[DEMO_SERVER_PRESET] = {
+                'url'                                    => 'ssh://' + DEMO + '.asperasoft.com:33001',
+                'username'                               => AOC_COMMAND_V2,
+                'ssAP'.downcase.reverse + 'drow'.reverse => DEMO + AOC_COMMAND_V2
+              }
             end
-            @config_presets[CONF_PRESET_DEFAULT]||={}
+            @config_presets[CONF_PRESET_DEFAULT] ||= {}
             if @config_presets[CONF_PRESET_DEFAULT].has_key?(SERVER_COMMAND)
               Log.log.warn("Server default preset already set to: #{@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND]}")
-              Log.log.warn("Use #{DEMO_SERVER_PRESET} for demo: -P#{DEMO_SERVER_PRESET}") unless DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND])
+              Log.log.warn("Use #{DEMO_SERVER_PRESET} for demo: -P#{DEMO_SERVER_PRESET}") unless
+                DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND])
             else
-              @config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND]=DEMO_SERVER_PRESET
+              @config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND] = DEMO_SERVER_PRESET
               Log.log.info("Setting server default preset to : #{DEMO_SERVER_PRESET}")
             end
             save_presets_to_config_file
             return Main.result_status('Done')
           when :vault
-            command=options.get_next_command([:init,:list,:get,:set,:delete])
+            command = options.get_next_command(%i[init list get set delete])
             case command
             when :init
-              type=options.get_option(:value,:optional)
+              type = options.get_option(:value)
               case type
               when 'config',NilClass
                 raise 'default secrets already exists' if @config_presets.has_key?(CONF_PRESET_SECRETS)
-                @config_presets[CONF_PRESET_SECRETS]={}
+                @config_presets[CONF_PRESET_SECRETS] = {}
                 set_global_default(:secrets,"@preset:#{CONF_PRESET_SECRETS}")
               else raise 'no such vault type'
               end
@@ -1017,26 +938,26 @@ module Aspera
               return {type: :object_list, data: vault.list}
             when :set
               # register url option
-              BasicAuthPlugin.new(@agents.merge(skip_option_header: true))
-              username=options.get_option(:username,:mandatory)
-              url=options.get_option(:url,:mandatory)
-              description=options.get_option(:value,:optional)
-              secret=options.get_next_argument('secret')
+              BasicAuthPlugin.register_options(@agents)
+              username = options.get_option(:username,is_type: :mandatory)
+              url = options.get_option(:url,is_type: :mandatory)
+              description = options.get_option(:value)
+              secret = options.get_next_argument('secret')
               vault.set(username: username, url: url, description: description, secret: secret)
               save_presets_to_config_file if vault.is_a?(Keychain::EncryptedHash)
               return Main.result_status('Done')
             when :get
               # register url option
-              BasicAuthPlugin.new(@agents.merge(skip_option_header: true))
-              username=options.get_option(:username,:mandatory)
-              url=options.get_option(:url,:optional)
-              result=vault.get(username: username, url: url)
+              BasicAuthPlugin.register_options(@agents)
+              username = options.get_option(:username,is_type: :mandatory)
+              url = options.get_option(:url)
+              result = vault.get(username: username, url: url)
               return {type: :single_object, data: result}
             when :delete
               # register url option
-              BasicAuthPlugin.new(@agents.merge(skip_option_header: true))
-              username=options.get_option(:username,:mandatory)
-              url=options.get_option(:url,:optional)
+              BasicAuthPlugin.register_options(@agents)
+              username = options.get_option(:username,is_type: :mandatory)
+              url = options.get_option(:url)
               vault.delete(username: username, url: url)
               return Main.result_status('Done')
             end
@@ -1046,17 +967,17 @@ module Aspera
 
         # @return email server setting with defaults if not defined
         def email_settings
-          smtp=options.get_option(:smtp,:mandatory)
+          smtp = options.get_option(:smtp,is_type: :mandatory)
           # change string keys into symbol keys
-          smtp=smtp.keys.each_with_object({}){|v,m|m[v.to_sym]=smtp[v];}
+          smtp = smtp.keys.each_with_object({}){|v,m|m[v.to_sym] = smtp[v];}
           # defaults
-          smtp[:tls]||=true
-          smtp[:port]||=smtp[:tls]?587:25
-          smtp[:from_email]||=smtp[:username] if smtp.has_key?(:username)
-          smtp[:from_name]||=smtp[:from_email].gsub(/@.*$/,'').gsub(/[^a-zA-Z]/,' ').capitalize if smtp.has_key?(:username)
-          smtp[:domain]||=smtp[:from_email].gsub(/^.*@/,'') if smtp.has_key?(:from_email)
+          smtp[:tls] ||= true
+          smtp[:port] ||= smtp[:tls] ? 587 : 25
+          smtp[:from_email] ||= smtp[:username] if smtp.has_key?(:username)
+          smtp[:from_name] ||= smtp[:from_email].gsub(/@.*$/,'').gsub(/[^a-zA-Z]/,' ').capitalize if smtp.has_key?(:username)
+          smtp[:domain] ||= smtp[:from_email].gsub(/^.*@/,'') if smtp.has_key?(:from_email)
           # check minimum required
-          [:server,:port,:domain].each do |n|
+          %i[server port domain].each do |n|
             raise "Missing smtp parameter: #{n}" unless smtp.has_key?(n)
           end
           Log.log.debug("smtp=#{smtp}")
@@ -1069,25 +990,25 @@ module Aspera
         end
 
         def send_email_template(vars,email_template_default=nil)
-          vars[:to]||=options.get_option(:notif_to,:mandatory)
-          notif_template=options.get_option(:notif_template,email_template_default.nil? ? :mandatory : :optional) || email_template_default
-          mail_conf=email_settings
-          vars[:from_name]||=mail_conf[:from_name]
-          vars[:from_email]||=mail_conf[:from_email]
-          [:from_name,:from_email].each do |n|
+          vars[:to] ||= options.get_option(:notif_to,is_type: :mandatory)
+          notif_template = options.get_option(:notif_template,is_type: email_template_default.nil? ? :mandatory : :optional) || email_template_default
+          mail_conf = email_settings
+          vars[:from_name] ||= mail_conf[:from_name]
+          vars[:from_email] ||= mail_conf[:from_email]
+          %i[from_name from_email].each do |n|
             raise "Missing email parameter: #{n}" unless vars.has_key?(n)
           end
-          start_options=[mail_conf[:domain]]
+          start_options = [mail_conf[:domain]]
           start_options.push(mail_conf[:username],mail_conf[:password],:login) if mail_conf.has_key?(:username) && mail_conf.has_key?(:password)
           # create a binding with only variables defined in vars
-          template_binding=empty_binding
+          template_binding = empty_binding
           # add variables to binding
           vars.each do |k,v|
             raise "key (#{k.class}) must be Symbol" unless k.is_a?(Symbol)
             template_binding.local_variable_set(k,v)
           end
           # execute template
-          msg_with_headers=ERB.new(notif_template).result(template_binding)
+          msg_with_headers = ERB.new(notif_template).result(template_binding)
           Log.dump(:msg_with_headers,msg_with_headers)
           smtp = Net::SMTP.new(mail_conf[:server], mail_conf[:port])
           smtp.enable_starttls if mail_conf[:tls]
@@ -1113,9 +1034,11 @@ module Aspera
           end
           if @config_presets.has_key?(CONF_PRESET_DEFAULT) &&
           @config_presets[CONF_PRESET_DEFAULT].has_key?(plugin_sym.to_s)
-            default_config_name=@config_presets[CONF_PRESET_DEFAULT][plugin_sym.to_s]
+            default_config_name = @config_presets[CONF_PRESET_DEFAULT][plugin_sym.to_s]
             if !@config_presets.has_key?(default_config_name)
-              Log.log.error("Default config name [#{default_config_name}] specified for plugin [#{plugin_sym}], but it does not exist in config file.\nPlease fix the issue: either create preset with one parameter (#{@info[:name]} config id #{default_config_name} init @json:'{}') or remove default (#{@info[:name]} config id default remove #{plugin_sym}).")
+              Log.log.error("Default config name [#{default_config_name}] specified for plugin [#{plugin_sym}], but it does not exist in config file.\n"\
+                'Please fix the issue: either create preset with one parameter: '\
+                "(#{@info[:name]} config id #{default_config_name} init @json:'{}') or remove default (#{@info[:name]} config id default remove #{plugin_sym}).")
             end
             raise CliError,"Config name [#{default_config_name}] must be a hash, check config file." if !@config_presets[default_config_name].is_a?(Hash)
             return default_config_name
@@ -1125,15 +1048,15 @@ module Aspera
 
         def vault
           if @vault.nil?
-            vault_info=options.get_option(:secrets,:optional)
+            vault_info = options.get_option(:secrets)
             case vault_info
             when Hash
-              @vault=Keychain::EncryptedHash.new(vault_info)
+              @vault = Keychain::EncryptedHash.new(vault_info)
             when /^system/
-              name=vault_info.start_with?('system:') ? vault_info[7..-1] : nil
+              name = vault_info.start_with?('system:') ? vault_info[7..-1] : nil
               case Environment.os
               when Environment::OS_X
-                @vault=Keychain::MacosSecurity.new(name)
+                @vault = Keychain::MacosSecurity.new(name)
               when Environment::OS_WINDOWS,Environment::OS_LINUX,Environment::OS_AIX
                 raise 'not implemented'
               else raise 'Error'
@@ -1151,14 +1074,177 @@ module Aspera
         def get_secret(options)
           raise 'options shall be Hash' unless options.is_a?(Hash)
           raise 'options shall have username' unless options.has_key?(:username)
-          secret=self.options.get_option(:secret,:optional)
+          secret = self.options.get_option(:secret)
           if secret.nil?
-            secret=vault.get(options) rescue nil
+            secret = vault.get(options) rescue nil
             # mandatory by default
             raise "please provide secret for #{options[:username]}" if secret.nil? && (options[:mandatory].nil? || options[:mandatory])
           end
           return secret
         end
+
+        def wizard_aoc(params)
+          self.format.display_status('Detected: Aspera on Cloud'.bold)
+          params[:plugin_name] = AOC_COMMAND_CURRENT
+          organization = AoC.parse_url(params[:instance_url]).first
+          # if not defined by user, generate name
+          params[:preset_name] = [params[:application],organization].join('_') if params[:preset_name].nil?
+          self.format.display_status("Preparing preset: #{params[:preset_name]}")
+          # init defaults if necessary
+          @config_presets[CONF_PRESET_DEFAULT] ||= {}
+          option_override = options.get_option(:override,is_type: :mandatory)
+          params[:option_default] = options.get_option(:default,is_type: :mandatory)
+          Log.log.error("override=#{option_override} -> #{option_override.class}")
+          raise CliError,"A default configuration already exists for plugin '#{params[:plugin_name]}' (use --override=yes or --default=no)" \
+            if !option_override && params[:option_default] && @config_presets[CONF_PRESET_DEFAULT].has_key?(params[:plugin_name])
+          raise CliError,"Preset already exists: #{params[:preset_name]}  (use --override=yes or --id=<name>)" \
+            if !option_override && @config_presets.has_key?(params[:preset_name])
+          # lets see if path to priv key is provided
+          private_key_path = options.get_option(:pkeypath)
+          # give a chance to provide
+          if private_key_path.nil?
+            self.format.display_status('Please provide path to your private RSA key, or empty to generate one:')
+            private_key_path = options.get_option(:pkeypath,is_type: :mandatory).to_s
+          end
+          # else generate path
+          if private_key_path.empty?
+            private_key_path = File.join(@main_folder,DEFAULT_PRIV_KEY_FILENAME)
+          end
+          if File.exist?(private_key_path)
+            self.format.display_status('Using existing key:')
+          else
+            self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+            generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
+            self.format.display_status('Created:')
+          end
+          self.format.display_status(private_key_path)
+          pub_key_pem = OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
+          # declare command line options for AoC
+          require 'aspera/cli/plugins/aoc'
+          # make username mandatory for jwt, this triggers interactive input
+          options.get_option(:username,is_type: :mandatory)
+          # instanciate AoC plugin, so that command line options are known
+          aoc_api = self.class.plugin_class(params[:plugin_name]).new(@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path})).aoc_api
+          auto_set_pub_key = false
+          auto_set_jwt = false
+          use_browser_authentication = false
+          if options.get_option(:use_generic_client)
+            self.format.display_status('Using global client_id.')
+            self.format.display_status('Please Login to your Aspera on Cloud instance.'.red)
+            self.format.display_status('Navigate to your "Account Settings"'.red)
+            self.format.display_status('Check or update the value of "Public Key" to be:'.red.blink)
+            self.format.display_status(pub_key_pem.to_s)
+            if !options.get_option(:test_mode)
+              self.format.display_status('Once updated or validated, press enter.')
+              OpenApplication.instance.uri(params[:instance_url])
+              $stdin.gets
+            end
+          else
+            self.format.display_status('Using organization specific client_id.')
+            if options.get_option(:client_id).nil? || options.get_option(:client_secret,is_type: :optional).nil?
+              self.format.display_status('Please login to your Aspera on Cloud instance.'.red)
+              self.format.display_status('Go to: Apps->Admin->Organization->Integrations')
+              self.format.display_status('Create or check if there is an existing integration named:')
+              self.format.display_status("- name: #{@info[:name]}")
+              self.format.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
+              self.format.display_status('- origin: localhost')
+              self.format.display_status('Once created or identified,')
+              self.format.display_status('Please enter:'.red)
+            end
+            OpenApplication.instance.uri("#{params[:instance_url]}/#{AOC_PATH_API_CLIENTS}")
+            options.get_option(:client_id,is_type: :mandatory)
+            options.get_option(:client_secret,is_type: :mandatory)
+            use_browser_authentication = true
+          end
+          if use_browser_authentication
+            self.format.display_status('We will use web authentication to bootstrap.')
+            auto_set_pub_key = true
+            auto_set_jwt = true
+            aoc_api.oauth.gparams[:crtype] = :web
+            aoc_api.oauth.gparams[:scope] = AoC::SCOPE_FILES_ADMIN
+            aoc_api.oauth.sparams[:redirect_uri] = DEFAULT_REDIRECT
+          end
+          myself = aoc_api.read('self')[:data]
+          if auto_set_pub_key
+            raise CliError,'Public key is already set in profile (use --override=yes)' unless myself['public_key'].empty? || option_override
+            self.format.display_status('Updating profile with new key')
+            aoc_api.update("users/#{myself['id']}",{'public_key' => pub_key_pem})
+          end
+          if auto_set_jwt
+            self.format.display_status('Enabling JWT for client')
+            aoc_api.update("clients/#{options.get_option(:client_id)}",{'jwt_grant_enabled' => true,'explicit_authorization_required' => false})
+          end
+          self.format.display_status("Creating new config preset: #{params[:preset_name]}")
+          @config_presets[params[:preset_name]] = {
+            :url.to_s         => options.get_option(:url),
+            :username.to_s    => myself['email'],
+            :auth.to_s        => :jwt.to_s,
+            :private_key.to_s => '@file:' + private_key_path
+          }
+          # set only if non nil
+          %i[client_id client_secret].each do |s|
+            o = options.get_option(s)
+            @config_presets[params[:preset_name]][s.to_s] = o unless o.nil?
+          end
+          params[:test_args] = "#{params[:plugin_name]} user profile show"
+        end
+
+        def wizard_faspex5(params)
+          self.format.display_status('Detected: Faspex v5'.bold)
+          # if not defined by user, generate unique name
+          params[:preset_name] = [params[:application],URI.parse(params[:instance_url]).host.gsub(/[^a-z0-9.]/,'').split('.')].flatten.join('_') \
+            if params[:preset_name].nil?
+          self.format.display_status("Preparing preset: #{params[:preset_name]}")
+          # init defaults if necessary
+          @config_presets[CONF_PRESET_DEFAULT] ||= {}
+          option_override = options.get_option(:override,is_type: :mandatory)
+          params[:option_default] = options.get_option(:default,is_type: :mandatory)
+          Log.log.error("override=#{option_override} -> #{option_override.class}")
+          raise CliError,"A default configuration already exists for plugin '#{params[:plugin_name]}' (use --override=yes or --default=no)" \
+            if !option_override && params[:option_default] && @config_presets[CONF_PRESET_DEFAULT].has_key?(params[:plugin_name])
+          raise CliError,"Preset already exists: #{params[:preset_name]}  (use --override=yes or --id=<name>)" \
+            if !option_override && @config_presets.has_key?(params[:preset_name])
+          # lets see if path to priv key is provided
+          private_key_path = options.get_option(:pkeypath)
+          # give a chance to provide
+          if private_key_path.nil?
+            self.format.display_status('Please provide path to your private RSA key, or empty to generate one:')
+            private_key_path = options.get_option(:pkeypath,is_type: :mandatory).to_s
+          end
+          # else generate path
+          if private_key_path.empty?
+            private_key_path = File.join(@main_folder,DEFAULT_PRIV_KEY_FILENAME)
+          end
+          if File.exist?(private_key_path)
+            self.format.display_status('Using existing key:')
+          else
+            self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+            generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
+            self.format.display_status('Created:')
+          end
+          self.format.display_status(private_key_path)
+          pub_key_pem = OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
+          # declare command line options for AoC
+          require 'aspera/cli/plugins/faspex5'
+          self.class.plugin_class(params[:plugin_name]).new(@agents.merge({skip_basic_auth_options: true}))
+          self.format.display_status('Please login to Faspex 5.'.red)
+          OpenApplication.instance.uri(params[:instance_url])
+          self.format.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
+          self.format.display_status('Create a client with:')
+          self.format.display_status('- JWT enabled')
+          self.format.display_status('- The following public key:')
+          self.format.display_status(pub_key_pem.to_s)
+          self.format.display_status('Once created, copy the following parameters:')
+          @config_presets[params[:preset_name]] = {
+            :url.to_s           => options.get_option(:url),
+            :username.to_s      => options.get_option(:username),
+            :auth.to_s          => :jwt.to_s,
+            :private_key.to_s   => '@file:' + private_key_path,
+            :client_id.to_s     => options.get_option(:client_id,is_type: :mandatory),
+            :client_secret.to_s => options.get_option(:client_secret,is_type: :mandatory)
+          }
+          params[:test_args] = "#{params[:plugin_name]} user profile show"
+        end
       end
     end
   end