aspera-cli 4.12.0 → 4.14.0

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

@@ -40,19 +40,15 @@ module Aspera
         CONF_PRESET_GLOBAL = 'global_common_defaults'
         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'
         # 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
+        ASPERA = 'aspera'
+        AOC_COMMAND = 'aoc'
         SERVER_COMMAND = 'server'
+        APP_NAME_SDK = 'sdk'
         CONNECT_WEB_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
         CONNECT_VERSIONS = 'connectversions.js'
         TRANSFER_SDK_ARCHIVE_URL = 'https://ibm.biz/aspera_transfer_sdk'
@@ -74,20 +70,17 @@ module Aspera
         DEFAULT_CHECK_NEW_VERSION_DAYS = 7
         DEFAULT_PRIV_KEY_FILENAME = 'aspera_aoc_key' # pragma: allowlist secret
         DEFAULT_PRIVKEY_LENGTH = 4096
+        COFFEE_IMAGE = 'https://enjoyjava.com/wp-content/uploads/2018/01/How-to-make-strong-coffee.jpg'
         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,
+          :ASPERA,
+          :AOC_COMMAND,
           :DEMO,
           :TRANSFER_SDK_ARCHIVE_URL,
           :AOC_PATH_API_CLIENTS,
@@ -99,7 +92,8 @@ module Aspera
           :DEFAULT_CHECK_NEW_VERSION_DAYS,
           :DEFAULT_PRIV_KEY_FILENAME,
           :SERVER_COMMAND,
-          :PRESET_DIG_SEPARATOR
+          :PRESET_DIG_SEPARATOR,
+          :COFFEE_IMAGE
         def initialize(env, params)
           raise 'env and params must be Hash' unless env.is_a?(Hash) && params.is_a?(Hash)
           raise 'missing param' unless %i[name help version gem].sort.eql?(params.keys.sort)
@@ -115,57 +109,63 @@ module Aspera
           @conf_file_default = File.join(@main_folder, DEFAULT_CONFIG_FILENAME)
           @option_config_file = @conf_file_default
           @pac_exec = nil
+          @sdk_default_location = false
           Log.log.debug{"#{@info[:name]} folder: #{@main_folder}"}
           # set folder for FASP SDK
           add_plugin_lookup_folder(self.class.gem_plugins_folder)
           add_plugin_lookup_folder(File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME))
           # do file parameter first
-          options.set_obj_attr(:config_file, self, :option_config_file)
-          options.add_opt_simple(:config_file, "read parameters from file in YAML format, current=#{@option_config_file}")
+          options.declare(:config_file, "Read parameters from file in YAML format, current=#{@option_config_file}", handler: {o: self, m: :option_config_file})
           options.parse_options!
           # read correct file (set @config_presets)
           read_config_file
           # add preset handler (needed for smtp)
-          ExtendedValue.instance.set_handler(EXTV_PRESET, :reader, lambda{|v|preset_by_name(v)})
-          ExtendedValue.instance.set_handler(EXTV_INCLUDE_PRESETS, :decoder, lambda{|v|expanded_with_preset_includes(v)})
-          ExtendedValue.instance.set_handler(EXTV_VAULT, :decoder, lambda{|v|vault_value(v)})
+          ExtendedValue.instance.set_handler(EXTV_PRESET, lambda{|v|preset_by_name(v)})
+          ExtendedValue.instance.set_handler(EXTV_INCLUDE_PRESETS, lambda{|v|expanded_with_preset_includes(v)})
+          ExtendedValue.instance.set_handler(EXTV_VAULT, lambda{|v|vault_value(v)})
           # load defaults before it can be overridden
           add_plugin_default_preset(CONF_GLOBAL_SYM)
           options.parse_options!
-          options.set_obj_attr(:ascp_path, Fasp::Installation.instance, :ascp_path)
-          options.set_obj_attr(:sdk_folder, Fasp::Installation.instance, :sdk_folder)
-          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_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)')
-          options.add_opt_boolean(:test_mode, 'Wizard: skip private key check step')
-          options.add_opt_simple(:preset, '-PVALUE', 'load the named option preset from current config file')
-          options.add_opt_simple(:pkeypath, 'Wizard: path to private key for JWT')
-          options.add_opt_simple(:ascp_path, 'Path to ascp')
-          options.add_opt_simple(:use_product, 'Use ascp from specified product')
-          options.add_opt_simple(:smtp, 'SMTP configuration (extended value: hash)')
-          options.add_opt_simple(:fpac, 'Proxy auto configuration script')
-          options.add_opt_simple(:proxy_credentials, 'HTTP proxy credentials (Array with user and password)')
-          options.add_opt_simple(:secret, 'Secret for access keys')
-          options.add_opt_simple(:vault, 'Vault for secrets')
-          options.add_opt_simple(:vault_password, 'Vault password')
-          options.add_opt_simple(:sdk_url, 'URL to get SDK')
-          options.add_opt_simple(:sdk_folder, 'SDK folder path')
-          options.add_opt_simple(:notif_to, 'Email recipient for notification of transfers')
-          options.add_opt_simple(:notif_template, 'Email ERB template for notification of transfers')
-          options.add_opt_simple(:version_check_days, Integer, 'Period in days to check new version (zero to disable)')
-          options.add_opt_simple(:plugin_folder, 'Folder where to find additional plugins')
-          options.set_option(:use_generic_client, true)
-          options.set_option(:test_mode, false)
-          options.set_option(:default, true)
-          options.set_option(:version_check_days, DEFAULT_CHECK_NEW_VERSION_DAYS)
-          options.set_option(:sdk_url, TRANSFER_SDK_ARCHIVE_URL)
-          options.set_option(:sdk_folder, File.join(@main_folder, 'sdk'))
-          options.set_option(:override, :no)
+          options.declare(:no_default, 'Do not load default configuration for plugin', values: :none, short: 'N') { @use_plugin_defaults = false }
+          options.declare(:override, 'Wizard: override existing value', values: :bool, default: :no)
+          options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: true)
+          options.declare(:default, 'Wizard: set as default configuration for specified plugin (also: update)', values: :bool, default: true)
+          options.declare(:test_mode, 'Wizard: skip private key check step', values: :bool, default: false)
+          options.declare(:preset, 'Load the named option preset from current config file', short: 'P', handler: {o: self, m: :option_preset})
+          options.declare(:pkeypath, 'Wizard: path to private key for JWT')
+          options.declare(:ascp_path, 'Path to ascp', handler: {o: Fasp::Installation.instance, m: :ascp_path})
+          options.declare(:use_product, 'Use ascp from specified product', handler: {o: self, m: :option_use_product})
+          options.declare(:smtp, 'SMTP configuration', types: Hash)
+          options.declare(:fpac, 'Proxy auto configuration script')
+          options.declare(:proxy_credentials, 'HTTP proxy credentials (Array with user and password)')
+          options.declare(:secret, 'Secret for access keys')
+          options.declare(:vault, 'Vault for secrets')
+          options.declare(:vault_password, 'Vault password')
+          options.declare(:sdk_url, 'URL to get SDK', default: TRANSFER_SDK_ARCHIVE_URL)
+          options.declare(:sdk_folder, 'SDK folder path', handler: {o: Fasp::Installation.instance, m: :sdk_folder})
+          options.declare(:notif_to, 'Email recipient for notification of transfers')
+          options.declare(:notif_template, 'Email ERB template for notification of transfers')
+          options.declare(:version_check_days, 'Period in days to check new version (zero to disable)', coerce: Integer, default: DEFAULT_CHECK_NEW_VERSION_DAYS)
+          options.declare(:plugin_folder, 'Folder where to find additional plugins', handler: {o: self, m: :option_plugin_folder})
           options.parse_options!
+          # Check SDK folder is set or not, for compatibility, we check in two places
+          sdk_folder = Fasp::Installation.instance.sdk_folder rescue nil
+          if sdk_folder.nil?
+            @sdk_default_location = true
+            Log.log.debug('SDK folder is not set, checking default')
+            # new location
+            sdk_folder = default_app_main_folder(app_name: APP_NAME_SDK)
+            Log.log.debug{"checking: #{sdk_folder}"}
+            if !Dir.exist?(sdk_folder)
+              Log.log.debug{"not exists: #{sdk_folder}"}
+              # former location
+              former_sdk_folder = File.join(default_app_main_folder, APP_NAME_SDK)
+              Log.log.debug{"checking: #{former_sdk_folder}"}
+              sdk_folder = former_sdk_folder if Dir.exist?(former_sdk_folder)
+            end
+            Log.log.debug{"using: #{sdk_folder}"}
+            Fasp::Installation.instance.sdk_folder = sdk_folder
+          end
           pac_script = options.get_option(:fpac)
           # create PAC executor
           @pac_exec = Aspera::ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
@@ -184,15 +184,20 @@ module Aspera
           return "#{@info[:name]}_home".upcase
         end
 
-        def default_app_main_folder
+        # return product family folder (~/.aspera)
+        def module_family_folder
+          user_home_folder = Dir.home
+          raise CliError, "Home folder does not exist: #{user_home_folder}. Check your user environment." unless Dir.exist?(user_home_folder)
+          return File.join(user_home_folder, ASPERA_HOME_FOLDER_NAME)
+        end
+
+        # return product config folder (~/.aspera/<name>)
+        def default_app_main_folder(app_name: nil)
+          app_name = @info[:name] if app_name.nil?
           # find out application main folder
           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
-            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])
-          end
+          app_folder = File.join(module_family_folder, app_name) if app_folder.nil? || app_folder.empty?
           return app_folder
         end
 
@@ -220,7 +225,7 @@ module Aspera
 
         def periodic_check_newer_gem_version
           # get verification period
-          delay_days = options.get_option(:version_check_days, is_type: :mandatory)
+          delay_days = options.get_option(:version_check_days, mandatory: true)
           Log.log.info{"check days: #{delay_days}"}
           # check only if not zero day
           return if delay_days.eql?(0)
@@ -281,17 +286,17 @@ module Aspera
 
         private
 
-        def generate_rsa_private_key(private_key_path, length)
-          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)
-          Environment.restrict_file_access(private_key_path)
-          Environment.restrict_file_access(private_key_path + '.pub')
-          nil
-        end
-
         class << self
+          def generate_rsa_private_key(path:, length: DEFAULT_PRIVKEY_LENGTH)
+            require 'openssl'
+            priv_key = OpenSSL::PKey::RSA.new(length)
+            File.write(path, priv_key.to_s)
+            File.write(path + '.pub', priv_key.public_key.to_s)
+            Environment.restrict_file_access(path)
+            Environment.restrict_file_access(path + '.pub')
+            nil
+          end
+
           # folder containing plugins in the gem's main folder
           def gem_plugins_folder
             File.dirname(File.expand_path(__FILE__))
@@ -350,7 +355,7 @@ module Aspera
           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, "Expecting Hash for subkey: #{include_path} (#{current.class})" unless current.is_a?(Hash)
+            raise CliError, "Expecting Hash for sub key: #{include_path} (#{current.class})" unless current.is_a?(Hash)
             include_path.push(name)
             current = current[name]
             raise CliError, "No such config preset: #{include_path}" if current.nil?
@@ -415,43 +420,15 @@ module Aspera
           end
         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, '')
-          # 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) && 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}"}
-            end
-          end
-        end
-
-        def convert_preset_plugin_name(old_name, new_name)
-          default_preset = @config_presets[CONF_PRESET_DEFAULT]
-          return unless default_preset.is_a?(Hash) && default_preset.key?(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
-
         # read config file and validate format
-        # tries to convert from older version if possible and required
         def read_config_file
           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)
           # files search for configuration, by default the one given by user
           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.find{|f| File.exist?(f)}
           # require save if old version of file
-          save_required = !@option_config_file.eql?(conf_file_to_load)
+          save_required = false
           # 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}"}
@@ -471,32 +448,8 @@ module Aspera
           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'
-          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'
-          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
-          end
-          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
-          end
-          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
-          end
           Log.log.debug{"conf version: #{version}"}
+          # if there are any conversion needed, those happen here.
           # Place new compatibility code here
           if save_required
             Log.log.warn('Saving automatic conversion.')
@@ -550,13 +503,18 @@ module Aspera
           @plugins[plugin_symbol] = {source: path, require_stanza: req}
         end
 
-        def identify_plugin_for_url(url)
+        # Find a plugin, and issue the "require"
+        # @return [Hash] plugin info: { product: , url:, version: }
+        def identify_plugin_for_url(url, check_only: nil)
+          check_only = check_only.to_sym unless check_only.nil?
           plugins.each do |plugin_name_sym, plugin_info|
             # no detection for internal plugin
             next if plugin_name_sym.eql?(CONF_PLUGIN_SYM)
+            next if check_only && !check_only.eql?(plugin_name_sym)
             # load plugin class
             require plugin_info[:require_stanza]
             c = self.class.plugin_class(plugin_name_sym)
+            # requires detection method
             next unless c.respond_to?(:detect)
             current_url = url
             detection_info = nil
@@ -565,7 +523,7 @@ module Aspera
               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')
+              Log.log.warn('Use option --insecure=yes to allow unchecked certificate') if e.message.include?('cert')
             rescue StandardError => e
               Log.log.debug{"Cannot detect #{plugin_name_sym} : #{e.class}/#{e.message}"}
             end
@@ -674,6 +632,10 @@ module Aspera
               end
             end
             data['keypass'] = Fasp::Installation.instance.bypass_pass
+            # log is "-" no need to display
+            data.delete('log')
+            # show command line transfer spec
+            data['ts'] = transfer.updated_ts
             return {type: :single_object, data: data}
           when :products
             command = options.get_next_command(%i[list use])
@@ -687,7 +649,9 @@ module Aspera
               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, is_type: :mandatory))
+            # reset to default location, if older default was used
+            Fasp::Installation.instance.sdk_folder = default_app_main_folder(app_name: APP_NAME_SDK) if @sdk_default_location
+            v = Fasp::Installation.instance.install_sdk(options.get_option(:sdk_url, mandatory: true))
             return Main.result_status("Installed version #{v}")
           when :spec
             return {
@@ -747,6 +711,7 @@ module Aspera
           when :set
             param_name = options.get_next_argument('parameter name')
             param_value = options.get_next_argument('parameter value')
+            param_name = Manager.option_line_to_name(param_name)
             if !@config_presets.key?(name)
               Log.log.debug{"no such config name: #{name}, initializing"}
               selected_preset = @config_presets[name] = {}
@@ -786,8 +751,8 @@ module Aspera
             return Main.result_status("Updated: #{name}")
           when :lookup
             BasicAuthPlugin.register_options(@agents)
-            url = options.get_option(:url, is_type: :mandatory)
-            user = options.get_option(:username, is_type: :mandatory)
+            url = options.get_option(:url, mandatory: true)
+            user = options.get_option(:username, mandatory: true)
             result = lookup_preset(url: url, username: user)
             raise 'no such config found' if result.nil?
             return {type: :single_object, data: result}
@@ -820,7 +785,6 @@ module Aspera
         end
 
         ACTIONS = %i[
-          id
           preset
           open
           documentation
@@ -830,7 +794,6 @@ module Aspera
           flush_tokens
           echo
           wizard
-          export_to_cli
           detect
           coffee
           ascp
@@ -841,19 +804,12 @@ module Aspera
           file
           check_update
           initdemo
-          vault].concat(PRESET_GBL_ACTIONS).freeze
+          vault].freeze
 
         # "config" plugin
         def execute_action
           action = options.get_next_command(ACTIONS)
           case action
-          when *PRESET_GBL_ACTIONS # older syntax
-            Log.log.warn{"This syntax is deprecated, use command: preset #{action}"}
-            return execute_preset(action: action)
-          when :id # older syntax
-            identifier = options.get_next_argument('config name')
-            Log.log.warn{"This syntax is deprecated, use command: preset <verb> #{identifier}"}
-            return execute_preset(name: identifier)
           when :preset # newer syntax
             return execute_preset
           when :open
@@ -867,7 +823,7 @@ module Aspera
           when :genkey # generate new rsa key
             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)
+            self.class.generate_rsa_private_key(path: private_key_path, length: 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')}
@@ -909,72 +865,89 @@ module Aspera
             BasicAuthPlugin.register_options(@agents)
             params = {}
             # get from option, or ask
-            params[:instance_url] = options.get_option(:url, is_type: :mandatory)
+            params[:instance_url] = options.get_option(:url, mandatory: true)
+            # check it is a well formatted url: starts with scheme
+            if !params[:instance_url].match?(%r{^[a-z]{1,6}://})
+              new_url = "https://#{params[:instance_url]}"
+              Log.log.warn("URL #{params[:instance_url]} does not start with a scheme, using #{new_url}")
+              params[:instance_url] = new_url
+            end
             # allow user to tell the preset name
             params[:preset_name] = options.get_option(:id)
-            # allow user to specify type of 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
-              wizard_aoc(params)
-            else
-              raise CliBadArgument, "Supports only: aoc. Detected: #{params[:application]}"
-            end # product
-            if params[:option_default]
-              formatter.display_status("Setting config preset as default for #{params[:plugin_name]}")
-              @config_presets[CONF_PRESET_DEFAULT][params[:plugin_name]] = params[:preset_name]
+            # allow user to specify type of application (symbol)
+            identification = identify_plugin_for_url(params[:instance_url], check_only: value_or_query(allowed_types: String))
+            Log.log.debug{"Detected: #{identification}"}
+            formatter.display_status("Detected: #{identification[:name]} at #{identification[:url]}".bold)
+            # we detected application (not set by user)
+            params[:plugin_sym] = identification[:product]
+            # update the url option
+            params[:instance_url] = identification[:url]
+            options.set_option(:url, params[:instance_url])
+            # instantiate plugin: command line options are known and wizard can be called
+            plugin_instance = self.class.plugin_class(params[:plugin_sym]).new(@agents.merge({skip_basic_auth_options: true}))
+            raise CliBadArgument, "Detected: #{params[:plugin_sym]}, no wizard available for this application" unless plugin_instance.respond_to?(:wizard)
+            # get default preset name if not set by user
+            params[:prepare] = true
+            plugin_instance.send(:wizard, params)
+            params[:prepare] = false
+
+            if params[:need_private_key]
+              # 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?
+                formatter.display_status('Please provide path to your private RSA key, or empty to generate one:')
+                private_key_path = options.get_option(:pkeypath, mandatory: true).to_s
+                # private_key_path = File.expand_path(private_key_path)
+              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)
+                formatter.display_status('Using existing key:')
+              else
+                formatter.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+                Config.generate_rsa_private_key(path: private_key_path)
+                formatter.display_status('Created key:')
+              end
+              formatter.display_status(private_key_path)
+              params[:pub_key_pem] = OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
+              params[:private_key_path] = private_key_path
+            end
+
+            formatter.display_status("Preparing preset: #{params[:preset_name]}")
+            # init defaults if necessary
+            @config_presets[CONF_PRESET_DEFAULT] ||= {}
+            option_override = options.get_option(:override, mandatory: true)
+            raise CliError, "A default configuration already exists for plugin '#{params[:plugin_sym]}' (use --override=yes or --default=no)" \
+              if !option_override && options.get_option(:default, mandatory: true) && @config_presets[CONF_PRESET_DEFAULT].key?(params[:plugin_sym])
+            raise CliError, "Preset already exists: #{params[:preset_name]}  (use --override=yes or --id=<name>)" \
+              if !option_override && @config_presets.key?(params[:preset_name])
+            wizard_result = plugin_instance.send(:wizard, params)
+            Log.log.debug{"wizard result: #{wizard_result}"}
+            raise "Internal error: missing keys in wizard result: #{wizard_result.keys}" unless %i[preset_value test_args].eql?(wizard_result.keys.sort)
+            @config_presets[params[:preset_name]] = wizard_result[:preset_value].stringify_keys
+            params[:test_args] = wizard_result[:test_args]
+            if options.get_option(:default, mandatory: true)
+              formatter.display_status("Setting config preset as default for #{params[:plugin_sym]}")
+              @config_presets[CONF_PRESET_DEFAULT][params[:plugin_sym].to_s] = params[:preset_name]
             else
               params[:test_args] = "-P#{params[:preset_name]} #{params[:test_args]}"
             end
             formatter.display_status('Saving config file.')
             save_presets_to_config_file
             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
-            formatter.display_status('Exporting: Aspera on Cloud')
-            require 'aspera/cli/plugins/aoc'
-            # need url / username
-            add_plugin_default_preset(AOC_COMMAND_V3.to_sym)
-            # instantiate AoC plugin
-            self.class.plugin_class(AOC_COMMAND_CURRENT).new(@agents) # TODO: is this line needed ? get options ?
-            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, is_type: :mandatory)
-            }
-            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
-            end
-            entry = data['AoCAccounts'].find{|i|i['organization'].eql?(organization)}
-            if entry.nil?
-              data['AoCAccounts'].push(new_conf)
-              formatter.display_status("Creating new aoc entry: #{organization}")
-            else
-              formatter.display_status("Updating existing aoc entry: #{organization}")
-              entry.merge!(new_conf)
-            end
-            File.write(cli_conf_file, JSON.pretty_generate(data))
-            return Main.result_status("Updated: #{cli_conf_file}")
           when :detect
             # need url / username
             BasicAuthPlugin.register_options(@agents)
-            return {type: :single_object, data: identify_plugin_for_url(options.get_option(:url, is_type: :mandatory))}
+            return {type: :single_object, data: identify_plugin_for_url(options.get_option(:url, mandatory: true))}
           when :coffee
-            OpenApplication.instance.uri('https://enjoyjava.com/wp-content/uploads/2018/01/How-to-make-strong-coffee.jpg')
+            if OpenApplication.instance.url_method.eql?(:text)
+              require 'aspera/preview/terminal'
+              return Main.result_status(Preview::Terminal.build(Rest.new(base_url: COFFEE_IMAGE).read('')[:http].body, reserved_lines: 3))
+            end
+            OpenApplication.instance.uri(COFFEE_IMAGE)
             return Main.result_nothing
           when :ascp
             execute_action_ascp
@@ -995,7 +968,7 @@ module Aspera
             return {type: :single_object, data: email_settings}
           when :proxy_check
             # ensure fpac was provided
-            options.get_option(:fpac, is_type: :mandatory)
+            options.get_option(:fpac, mandatory: true)
             server_url = options.get_next_argument('server url')
             return Main.result_status(@pac_exec.find_proxy_for_url(server_url))
           when :check_update
@@ -1007,8 +980,8 @@ module Aspera
               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
+                'username'                               => ASPERA,
+                'ssAP'.downcase.reverse + 'drow'.reverse => DEMO + ASPERA # cspell:disable-line
               }
             end
             @config_presets[CONF_PRESET_DEFAULT] ||= {}
@@ -1029,18 +1002,24 @@ module Aspera
 
         # @return email server setting with defaults if not defined
         def email_settings
-          smtp = options.get_option(:smtp, is_type: :mandatory)
+          smtp = options.get_option(:smtp, mandatory: true, allowed_types: [Hash])
           # change string keys into symbol keys
-          smtp = smtp.keys.each_with_object({}){|v, m|m[v.to_sym] = smtp[v]; }
+          smtp = smtp.symbolize_keys
           # defaults
-          smtp[:tls] ||= true
-          smtp[:port] ||= smtp[:tls] ? 587 : 25
+          smtp[:tls] = !smtp[:ssl] unless smtp.key?(:tls)
+          smtp[:port] ||= if smtp[:tls]
+            587
+          elsif smtp[:ssl]
+            465
+          else
+            25
+          end
           smtp[:from_email] ||= smtp[:username] if smtp.key?(:username)
           smtp[:from_name] ||= smtp[:from_email].gsub(/@.*$/, '').gsub(/[^a-zA-Z]/, ' ').capitalize if smtp.key?(:username)
           smtp[:domain] ||= smtp[:from_email].gsub(/^.*@/, '') if smtp.key?(:from_email)
           # check minimum required
           %i[server port domain].each do |n|
-            raise "Missing smtp parameter: #{n}" unless smtp.key?(n)
+            raise "Missing mandatory smtp parameter: #{n}" unless smtp.key?(n)
           end
           Log.log.debug{"smtp=#{smtp}"}
           return smtp
@@ -1052,8 +1031,8 @@ module Aspera
         end
 
         def send_email_template(email_template_default: nil, values: {})
-          values[: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
+          values[:to] ||= options.get_option(:notif_to, mandatory: true)
+          notif_template = options.get_option(:notif_template, mandatory: email_template_default.nil?) || email_template_default
           mail_conf = email_settings
           values[:from_name] ||= mail_conf[:from_name]
           values[:from_email] ||= mail_conf[:from_email]
@@ -1074,6 +1053,7 @@ module Aspera
           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]
+          smtp.enable_tls if mail_conf[:ssl]
           smtp.start(*start_options) do |smtp_session|
             smtp_session.send_message(msg_with_headers, values[:from_email], values[:to])
           end
@@ -1090,20 +1070,20 @@ module Aspera
 
         # returns [String] name if config_presets has default
         # returns nil if there is no config or bypass default params
-        def get_plugin_default_config_name(plugin_sym)
+        def get_plugin_default_config_name(plugin_name_sym)
           raise 'internal error: config_presets shall be defined' if @config_presets.nil?
           if !@use_plugin_defaults
             Log.log.debug('skip default config')
             return nil
           end
           if @config_presets.key?(CONF_PRESET_DEFAULT) &&
-              @config_presets[CONF_PRESET_DEFAULT].key?(plugin_sym.to_s)
-            default_config_name = @config_presets[CONF_PRESET_DEFAULT][plugin_sym.to_s]
+              @config_presets[CONF_PRESET_DEFAULT].key?(plugin_name_sym.to_s)
+            default_config_name = @config_presets[CONF_PRESET_DEFAULT][plugin_name_sym.to_s]
             if !@config_presets.key?(default_config_name)
               Log.log.error do
-                "Default config name [#{default_config_name}] specified for plugin [#{plugin_sym}], but it does not exist in config file.\n"\
+                "Default config name [#{default_config_name}] specified for plugin [#{plugin_name_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})."
+                  "(#{@info[:name]} config id #{default_config_name} init @json:'{}') or remove default (#{@info[:name]} config id default remove #{plugin_name_sym})."
               end
             end
             raise CliError, "Config name [#{default_config_name}] must be a hash, check config file." if !@config_presets[default_config_name].is_a?(Hash)
@@ -1153,7 +1133,7 @@ module Aspera
         def vault
           if @vault.nil?
             vault_info = options.get_option(:vault) || {'type' => 'file', 'name' => 'vault.bin'}
-            vault_password = options.get_option(:vault_password, is_type: :mandatory)
+            vault_password = options.get_option(:vault_password, mandatory: true)
             raise 'vault must be Hash' unless vault_info.is_a?(Hash)
             vault_type = vault_info['type'] || 'file'
             vault_name = vault_info['name'] || (vault_type.eql?('file') ? 'vault.bin' : PROGRAM_NAME)
@@ -1207,169 +1187,6 @@ module Aspera
           end
           return secret
         end
-
-        def wizard_aoc(params)
-          formatter.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?
-          formatter.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].key?(params[:plugin_name])
-          raise CliError, "Preset already exists: #{params[:preset_name]}  (use --override=yes or --id=<name>)" \
-            if !option_override && @config_presets.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?
-            formatter.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)
-            formatter.display_status('Using existing key:')
-          else
-            formatter.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
-            generate_rsa_private_key(private_key_path, DEFAULT_PRIVKEY_LENGTH)
-            formatter.display_status('Created:')
-          end
-          formatter.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)
-          # instantiate 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)
-            formatter.display_status('Using global client_id.')
-            formatter.display_status('Please Login to your Aspera on Cloud instance.'.red)
-            formatter.display_status('Navigate to your "Account Settings"'.red)
-            formatter.display_status('Check or update the value of "Public Key" to be:'.red.blink)
-            formatter.display_status(pub_key_pem.to_s)
-            if !options.get_option(:test_mode)
-              formatter.display_status('Once updated or validated, press enter.')
-              OpenApplication.instance.uri(params[:instance_url])
-              $stdin.gets
-            end
-          else
-            formatter.display_status('Using organization specific client_id.')
-            if options.get_option(:client_id).nil? || options.get_option(:client_secret, is_type: :optional).nil?
-              formatter.display_status('Please login to your Aspera on Cloud instance.'.red)
-              formatter.display_status('Go to: Apps->Admin->Organization->Integrations')
-              formatter.display_status('Create or check if there is an existing integration named:')
-              formatter.display_status("- name: #{@info[:name]}")
-              formatter.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
-              formatter.display_status('- origin: localhost')
-              formatter.display_status('Once created or identified,')
-              formatter.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
-            formatter.display_status('We will use web authentication to bootstrap.')
-            auto_set_pub_key = true
-            auto_set_jwt = true
-            aoc_api.oauth.generic_parameters[:grant_method] = :web
-            aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
-            aoc_api.oauth.specific_parameters[: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
-            formatter.display_status('Updating profile with new key')
-            aoc_api.update("users/#{myself['id']}", {'public_key' => pub_key_pem})
-          end
-          if auto_set_jwt
-            formatter.display_status('Enabling JWT for client')
-            aoc_api.update("clients/#{options.get_option(:client_id)}", {'jwt_grant_enabled' => true, 'explicit_authorization_required' => false})
-          end
-          formatter.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)
-          formatter.display_status('Detected: Faspex v5'.bold)
-          # if not defined by user, generate unique name
-          params[:preset_name] = [params[:application]].concat(URI.parse(params[:instance_url]).host.gsub(/[^a-z0-9.]/, '').split('.')).join('_') \
-            if params[:preset_name].nil?
-          formatter.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].key?(params[:plugin_name])
-          raise CliError, "Preset already exists: #{params[:preset_name]}  (use --override=yes or --id=<name>)" \
-            if !option_override && @config_presets.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?
-            formatter.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)
-            formatter.display_status('Using existing key:')
-          else
-            formatter.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
-            generate_rsa_private_key(private_key_path, DEFAULT_PRIVKEY_LENGTH)
-            formatter.display_status('Created:')
-          end
-          formatter.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}))
-          formatter.display_status('Please login to Faspex 5.'.red)
-          OpenApplication.instance.uri(params[:instance_url])
-          formatter.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
-          formatter.display_status('Create a client with:')
-          formatter.display_status('- JWT enabled')
-          formatter.display_status('- The following public key:')
-          formatter.display_status(pub_key_pem.to_s)
-          formatter.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