aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/cli/transfer_agent.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require 'aspera/agent/factory'
+require 'aspera/schema/registry'
+require 'aspera/cli/option_declarator'
+require 'aspera/transfer/result'
 require 'aspera/transfer/spec'
 require 'aspera/cli/info'
+require 'aspera/cli/async_transfer_store'
 require 'aspera/log'
 require 'aspera/assert'
-require 'aspera/schema/registry'
+require 'securerandom'
 
 module Aspera
   module Cli
@@ -28,53 +32,46 @@ module Aspera
         <%=ts.to_yaml%>
       END_OF_TEMPLATE
       CP4I_REMOTE_HOST_LB = 'N/A'
-      private_constant :FILE_LIST_FROM_ARGS,
-        :FILE_LIST_FROM_TRANSFER_SPEC,
+      private_constant :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
         :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
 
-      class << self
-        # Analyze transfer session statuses and return a global status
-        #
-        # @param statuses [Array] list of session status, each status is :success or an error message string
-        # @return [:success]  if all sessions statuses returned by "start" are success
-        # @return [Exception] if one sessions statuses returned by "start" is failed
-        def session_status(statuses)
-          error_statuses = statuses.reject{ |i| i.eql?(:success)}
-          return :success if error_statuses.empty?
-          return error_statuses.first
-        end
-      end
+      extend OptionDeclarator
+
+      option :ts,            description: 'Override transfer spec values', schema: Schema::Registry::TRANSFER_SPEC
+      option :to_folder,     description: 'Destination folder for transferred files'
+      option :sources,       description: "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})",               default: FILE_LIST_FROM_ARGS
+      option :src_type,      description: 'Type of file list',                                                                        allowed: %i[list pair], default: :list
+      option :transfer,      description: 'Transfer agent type, or agent parameters with optional agent key',                         allowed: [Hash, String], schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
+      option :transfer_info, description: 'Parameters for transfer agent',                                                            deprecation: 'use --transfer instead', schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
 
-      # @param opt_mgr       [Manager] Option manager
-      # @param config_plugin [Config]  Config plugin
-      def initialize(opt_mgr, config_plugin)
-        @opt_mgr = opt_mgr
-        @config = config_plugin
+      # @param context [Context] Application context
+      def initialize(context)
+        Aspera.assert_type(context, Context) { 'context' }
+        Aspera.assert_type(context.options, Parser) { 'context.options' }
+        @context = context
         # Command line can override transfer spec
         @user_transfer_spec = {
           'create_dir'    => true,
           'resume_policy' => 'sparse_csum'
         }
-        # options for transfer agent
-        @transfer_info = {}
+        # options for transfer agent (agent type + agent-specific parameters)
+        @transfer_options = {}
         # the currently selected transfer agent
         @agent = nil
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths = nil
         # HTTPGW URL provided by webapp
         @httpgw_url_lambda = nil
-        @opt_mgr.declare(:ts, 'Override transfer spec values', allowed: Hash, handler: {o: self, m: :user_transfer_spec}, schema: Schema::Registry::TRANSFER_SPEC)
-        @opt_mgr.declare(:to_folder, 'Destination folder for transferred files')
-        @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})", default: FILE_LIST_FROM_ARGS)
-        @opt_mgr.declare(:src_type, 'Type of file list', allowed: %i[list pair], default: :list)
-        @opt_mgr.declare(:transfer, 'Type of transfer agent', allowed: Agent::Factory::ALL.keys, default: :direct)
-        @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', allowed: Hash, handler: {o: self, m: :transfer_info}, schema: Schema::Registry::TRANSFER_INFO)
-        @opt_mgr.parse_options!
+        self.class.declare_options(@context.options)
+        @context.options.set_handler(:ts,            object: self, method: :user_transfer_spec)
+        @context.options.set_handler(:transfer,      object: self, method: :option_transfer)
+        @context.options.set_handler(:transfer_info, object: self, method: :transfer_options)
+        @context.options.parse_options!
         @notification_cb = nil
-        if !@opt_mgr.get_option(:notify_to).nil?
+        if !@context.options.get_option(:notify_to).nil?
           @notification_cb = ->(transfer_spec, global_status) do
-            @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIFY_TEMPLATE, values: {
+            @context.mailer.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIFY_TEMPLATE, values: {
               subject: "#{Info::CMD_NAME} transfer: #{global_status}",
               status:  global_status,
               ts:      transfer_spec
@@ -83,7 +80,23 @@ module Aspera
         end
       end
 
-      attr_accessor :user_transfer_spec, :transfer_info
+      attr_accessor :user_transfer_spec, :transfer_options
+
+      # Composite option handler for :transfer
+      # String value: shorthand for agent type, stored as {'agent' => value}
+      # Hash value:   merged into @transfer_options (may include 'agent' key)
+      def option_transfer(_option_sym, operation, value = nil)
+        Aspera.assert_values(operation, %i[set get])
+        case operation
+        when :set
+          value = {'agent' => value} if value.is_a?(String)
+          Aspera.assert_type(value, Hash)
+          @transfer_options = @transfer_options.deep_merge(value)
+        when :get
+          return @transfer_options
+        end
+        nil
+      end
 
       def agent_instance=(instance)
         @agent = instance
@@ -92,25 +105,27 @@ module Aspera
       # analyze options and create new agent if not already created or set
       def agent_instance
         return @agent unless @agent.nil?
-        agent_type = @opt_mgr.get_option(:transfer, mandatory: true)
-        # set keys as symbols
-        agent_options = @opt_mgr.get_option(:transfer_info).symbolize_keys
-        agent_options[:progress] = @config.progress_bar
-        agent_options[:config_dir] = @config.main_folder
+        # agent type: from composite option 'agent' key, default :direct
+        raw_type = @transfer_options['agent'] || :direct
+        agent_type = Parser.get_from_list(raw_type.to_s, 'transfer agent', Agent::Factory::ALL.keys)
+        # set keys as symbols, strip internal keys not forwarded to the agent constructor
+        agent_options = @transfer_options.except('agent', 'asynchronous').symbolize_keys
+        agent_options[:progress] = @context.progress_bar
+        agent_options[:config_dir] = @context.main_folder
         # special cases
         case agent_type
         when :node
           if !agent_options.key?(:url)
-            param_set_name = @config.get_plugin_default_config_name(:node)
-            raise Cli::BadArgument, "No default node configured. Please specify #{Manager.option_name_to_line(:transfer_info)}" if param_set_name.nil?
-            agent_options.merge!(@config.preset_by_name(param_set_name).symbolize_keys)
+            param_set_name = @context.presets.plugin_default_name(:node)
+            Aspera.assert(!param_set_name.nil?, type: Cli::BadArgument) { "No default node configured. Please specify #{Options.option_name_to_line(:transfer)}.url or #{Options.option_name_to_line(:transfer)}" }
+            agent_options.merge!(@context.presets.by_name(param_set_name).symbolize_keys)
           end
         when :direct
           # by default do not display ascp native progress bar
           agent_options[:quiet] = true unless agent_options.key?(:quiet)
-          agent_options[:check_ignore_cb] = ->(host, port){@config.ignore_cert?(host, port)}
+          agent_options[:check_ignore_cb] = ->(host, port) { @context.http_config.ignore_cert?(host, port) }
           # JRuby
-          agent_options[:trusted_certs] = @config.trusted_cert_locations unless agent_options.key?(:trusted_certs)
+          agent_options[:trusted_certs] = @context.http_config.trusted_cert_locations unless agent_options.key?(:trusted_certs)
         when :httpgw
           unless agent_options.key?(:url) || @httpgw_url_lambda.nil?
             Log.log.debug('retrieving HTTPGW URL from webapp')
@@ -119,7 +134,7 @@ module Aspera
         end
         # get agent instance
         self.agent_instance = Agent::Factory.instance.create(agent_type, agent_options)
-        Log.log.debug{"transfer agent is a #{@agent.class}"}
+        Log.log.debug { "transfer agent is a #{@agent.class}" }
         return @agent
       end
 
@@ -127,7 +142,7 @@ module Aspera
       # @param direction [String] `send`` or `receive``
       # @return [String] Destination folder for transfers (with default based on direction)
       def destination_folder(direction)
-        dest_folder = @opt_mgr.get_option(:to_folder)
+        dest_folder = @context.options.get_option(:to_folder)
         # do not expand path, if user wants to expand path: user @path:
         return dest_folder unless dest_folder.nil?
         dest_folder = @user_transfer_spec['destination_root']
@@ -150,22 +165,22 @@ module Aspera
 
       # @param httpgw_url_proc [Proc]
       def httpgw_url_cb=(httpgw_url_proc)
-        Aspera.assert_type(httpgw_url_proc, Proc){'httpgw_url_cb'}
+        Aspera.assert_type(httpgw_url_proc, Proc) { 'httpgw_url_cb' }
         @httpgw_url_lambda = httpgw_url_proc
       end
 
       # Transform the list of paths to a list of hash with source/dest
       # @param file_list [Array<Hash>]
       def list_to_paths(file_list)
-        source_type = @opt_mgr.get_option(:src_type, mandatory: true)
+        source_type = @context.options.get_option(:src_type, mandatory: true)
         @transfer_paths =
           case source_type
           when :list
             # when providing a list, just specify source
-            file_list.map{ |i| {'source' => i}}
+            file_list.map { |i| {'source' => i} }
           when :pair
-            Aspera.assert(file_list.length.even?, type: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
-            file_list.each_slice(2).map{ |s, d| {'source' => s, 'destination' => d}}
+            Aspera.assert(file_list.length.even?, type: Cli::BadArgument) { "When using pair, provide an even number of paths: #{file_list.length}" }
+            file_list.each_slice(2).map { |s, d| {'source' => s, 'destination' => d} }
           else Aspera.error_unexpected_value(source_type)
           end
       end
@@ -181,41 +196,41 @@ module Aspera
         # start with lower priority : get paths from transfer spec on command line
         @transfer_paths = @user_transfer_spec['paths'] if @user_transfer_spec.key?('paths')
         # is there a source list option ?
-        sources = @opt_mgr.get_option(:sources)
+        sources = @context.options.get_option(:sources)
         @transfer_paths =
           case sources
           when FILE_LIST_FROM_ARGS
             Log.log.debug('getting file list as parameters')
             Aspera.assert_type(default, Array, NilClass)
             # get remaining arguments
-            list = @opt_mgr.get_next_argument('source file list', multiple: true, default: default)
+            list = @context.options.get_next_argument('source file list', multiple: true, default: default)
             raise Cli::BadArgument, 'specify at least one file on command line or use ' \
               "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !list.is_a?(Array) || list.empty?
             list_to_paths(list)
           when FILE_LIST_FROM_TRANSFER_SPEC
             Log.log.debug('assume list provided in transfer spec')
             special_case_direct_with_list =
-              @opt_mgr.get_option(:transfer, mandatory: true).eql?(:direct) &&
-              Transfer::Parameters.ascp_args_file_list?(@opt_mgr.get_option(:transfer_info)['ascp_args'])
-            raise Cli::BadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
+              (@transfer_options['agent'] || :direct).to_sym.eql?(:direct) &&
+              Transfer::Parameters.ascp_args_file_list?(@transfer_options['ascp_args'])
+            Aspera.assert(!@transfer_paths.nil? || special_case_direct_with_list, type: Cli::BadArgument) { 'transfer spec on command line must have sources' }
             # can be nil
             @transfer_paths
           when Array
             Log.log.debug('getting file list as extended value')
-            Aspera.assert_array_all(sources, String, type: Cli::BadArgument){'sources must be a Array of String'}
+            Aspera.assert_array_all(sources, String, type: Cli::BadArgument) { 'sources must be a Array of String' }
             list_to_paths(sources)
-          else Aspera.error_unexpected_value(sources){'sources'}
+          else Aspera.error_unexpected_value(sources) { 'sources' }
           end
-        Log.log.debug{"paths=#{@transfer_paths}"}
+        Log.dump(:paths, @transfer_paths)
         return @transfer_paths
       end
 
       # Start a transfer and wait for completion, plugins shall use this method
-      # @param transfer_spec [Hash]
-      # @param rest_token    [Rest] if oauth token regeneration supported
+      # @param transfer_spec [Hash] transfer specification
+      # @param rest_token    [Rest, nil] if oauth token regeneration supported
       def start(transfer_spec, rest_token: nil)
         # check parameters
-        Aspera.assert_type(transfer_spec, Hash){'transfer_spec'}
+        Aspera.assert_type(transfer_spec, Hash) { 'transfer_spec' }
         raise "Wrong remote host: #{CP4I_REMOTE_HOST_LB}" if transfer_spec['remote_host'].eql?(CP4I_REMOTE_HOST_LB)
         # process :src option
         case transfer_spec['direction']
@@ -240,15 +255,60 @@ module Aspera
         @user_transfer_spec['paths'] = transfer_spec['paths'] || ts_source_paths
         # updated transfer spec with command line
         transfer_spec.deep_merge!(@user_transfer_spec)
+        # resolve pseudo-parameter: target_rate -> target_rate_kbps (overrides target_rate_kbps if both are present)
+        transfer_spec['target_rate_kbps'] = Transfer::Spec.rate_string_to_kbps(transfer_spec.delete('target_rate')) if transfer_spec.key?('target_rate')
         # recursively remove values that are nil (user wants to delete)
-        transfer_spec.deep_do{ |hash, key, value, _unused| hash.delete(key) if value.nil?}
+        transfer_spec.deep_do { |hash, key, value, _unused| hash.delete(key) if value.nil? }
         # if TS from app has content_protection (e.g. F5), that means content is protected: ask password if not provided
-        transfer_spec['content_protection_password'] = @opt_mgr.prompt_user_input('content protection password', sensitive: true) if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
+        transfer_spec['content_protection_password'] = @context.options.prompt_user_input('content protection password', sensitive: true) if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
         # create transfer agent
         agent_instance.start_transfer(transfer_spec, token_regenerator: rest_token)
-        # list of: :success or "error message string"
+        # --- async mode ---
+        if @transfer_options['asynchronous']
+          agent_type = (@transfer_options['agent'] || 'direct').to_s
+          # In-process agents (direct, httpgw) expose last_job_id directly.
+          # Remote-daemon agents do not override last_job_id (returns nil): generate a UUID.
+          job_id = agent_instance.last_job_id || SecureRandom.uuid
+          # Base agent_params from transfer options (strip internal keys)
+          agent_params = @transfer_options.except('agent', 'asynchronous')
+          # For daemon agents: capture any runtime-resolved connection detail
+          case agent_type
+          when 'desktop'
+            agent_params['application_id'] = agent_instance.application_id
+          when 'connect'
+            agent_params['app_id'] = agent_instance.app_id
+          when 'transferd'
+            agent_params['url'] = agent_instance.daemon_endpoint
+          end
+          # Register an in-process agent reference for direct/httpgw agents so that
+          # config transfer status can re-query them while the same process is alive
+          # (e.g. MCP server mode). The ref is stored in AsyncTransferStore's memory map,
+          # never on disk.
+          async_store.register_agent_ref(job_id, agent_instance) if %w[direct httpgw].include?(agent_type)
+          # transfer_id: in-process agents use job_id; daemon agents expose @transfer_id
+          transfer_id =
+            if %w[direct httpgw].include?(agent_type)
+              job_id
+            else
+              agent_instance.instance_variable_get(:@transfer_id).to_s
+            end
+          async_store.write(job_id, {
+            'job_id'            => job_id,
+            'agent_type'        => agent_type,
+            'transfer_id'       => transfer_id,
+            'agent_params'      => agent_params,
+            'status'            => 'running',
+            'bytes_transferred' => 0,
+            'started_at'        => Time.now.utc.iso8601,
+            'ended_at'          => nil,
+            'error'             => nil
+          })
+          Log.log.info { "Async transfer started: job_id=#{job_id}, agent=#{agent_type}" }
+          return Transfer::Result.async(job_id: job_id)
+        end
+        # --- synchronous mode (default) ---
         result = agent_instance.wait_for_completion
-        @notification_cb&.call(transfer_spec, self.class.session_status(result))
+        @notification_cb&.call(transfer_spec, result)
         return result
       end
 
@@ -256,6 +316,11 @@ module Aspera
       def shutdown
         @agent.shutdown if @agent.respond_to?(:shutdown)
       end
+
+      # Lazy accessor for the async transfer store (shared with TransferActions via context.transfer).
+      def async_store
+        @async_store ||= AsyncTransferStore.new(@context.persistency)
+      end
     end
   end
 end

data/lib/aspera/cli/transfer_progress.rb

@@ -25,16 +25,16 @@ module Aspera
       end
 
       # Called by user of progress bar with a status on a transfer session
-      # @param session_id the unique identifier of a transfer session
+      # @param session_id [String] the unique identifier of a transfer session
       # @param type [Symbol] one of: sessions_init, session_start, session_size, transfer, session_end and end
-      # @param info optional specific additional info for the given event type
+      # @param info [Object, nil] optional specific additional info for the given event type
       def event(type, session_id: nil, info: nil)
-        Log.log.trace1{"progress: #{type} #{session_id} #{info}"}
+        Log.log.trace1 { "progress: #{type} #{session_id} #{info}" }
         return if @completed
         if @progress_bar.nil?
           @progress_bar = ProgressBar.create(
             format:      '%t %a %B %p%% %r Mbps %E',
-            rate_scale:  lambda{ |rate| rate / Environment::BYTES_PER_MEBIBIT},
+            rate_scale:  lambda { |rate| rate / Environment::BYTES_PER_MEBIBIT },
             title:       '',
             total:       nil
           )
@@ -50,7 +50,7 @@ module Aspera
         when :session_start
           Aspera.assert_type(session_id, String)
           Aspera.assert(info.nil?, 'info must be nil for :session_start event')
-          raise "Session #{session_id} already started" if @sessions[session_id]
+          Aspera.assert(!@sessions[session_id]) { "Session #{session_id} already started" }
           @sessions[session_id] = {
             job_size: 0, # Total size of transfer (pre-calc)
             current:  0,
@@ -83,19 +83,19 @@ module Aspera
           Aspera.assert(session_id.nil?, 'session_id must be nil for :end event')
           Aspera.assert(info.nil?, 'info must be nil for :end event')
           @progress_bar.finish
-        else Aspera.error_unexpected_value(type){'event type'}
+        else Aspera.error_unexpected_value(type) { 'event type' }
         end
-        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.count{ |_i, d| d[:running]}}] #{@title}"
+        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.count { |_i, d| d[:running] }}] #{@title}"
         @progress_bar&.title = new_title unless @progress_bar&.title.eql?(new_title)
         @progress_bar&.increment if !progress_provided && @progress_bar.progress.nil?
       rescue ProgressBar::InvalidProgressError => e
-        Log.log.error{"Progress error: #{e}"}
+        Log.log.error { "Progress error: #{e}" }
       end
 
       private
 
       def total(key)
-        @sessions.values.inject(0){ |m, s| m + s[key]}
+        @sessions.values.inject(0) { |m, s| m + s[key] }
       end
     end
   end

data/lib/aspera/cli/vault_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/error'
+require 'aspera/log'
+require 'aspera/assert'
+require 'json'
+
+module Aspera
+  module Cli
+    # Mixin providing vault/keychain functionality to Plugin::Config.
+    # Depends on `options` and `context.main_folder` being available in the including class.
+    module VaultManager
+      def action_vault_show(label:, id: nil, **)
+        v = vault_required
+        kwargs = id && v.method(:get).parameters.any? { |_t, n| n == :id } ? {id: id} : {}
+        Result::SingleObject.new(v.get(label: label, **kwargs))
+      end
+
+      def action_vault_create(info:, **)
+        vault_required.set(info.symbolize_keys)
+        Result::Status.new('Secret added')
+      end
+
+      # Import secrets from a JSON array; skips entries missing :label
+      def action_vault_import(secrets:, **)
+        bulk_result(secrets, command: :import, id_result: 'label') do |entry|
+          vault_required.set(entry.symbolize_keys)
+          {'label' => entry['label'] || entry[:label]}
+        end
+      end
+
+      def action_vault_delete(label:, id: nil, **)
+        v = vault_required
+        kwargs = id && v.method(:delete).parameters.any? { |_t, n| n == :id } ? {id: id} : {}
+        v.delete(label: label, **kwargs)
+        Result::Status.new("Secret deleted: #{label}")
+      end
+
+      def action_vault_password(new_password:, **)
+        Aspera.assert(vault_required.respond_to?(:change_password), 'Vault does not support password change')
+        vault_required.change_password(new_password)
+        Result::Status.new('Vault password updated')
+      end
+
+      # @return [Keychain::Base] vault instance, raises if not configured
+      def vault_required
+        Aspera.assert(!vault.nil?, type: Cli::BadArgument) { 'Missing mandatory option: vault' }
+        vault
+      end
+
+      # @return [String] value from vault matching <name>.<param>
+      def vault_value(name)
+        m = name.split('.')
+        Aspera.assert(m.length.eql?(2), type: BadArgument) { 'vault name shall match <name>.<param>' }
+        info = vault_required.get(label: m[0])
+        value = info[m[1].to_sym]
+        raise "no such entry value: #{m[1]}" if value.nil?
+        return value
+      end
+
+      # @return [Keychain::Base, nil] vault instance, lazily created from options, or nil if not configured
+      def vault
+        return @vault_instance if @vault_instance_initialized
+        @vault_instance_initialized = true
+        info = options.get_option(:vault, mandatory: false)
+        return @vault_instance = nil if info.nil? || (info.is_a?(Hash) && info.empty?)
+        info = info.symbolize_keys
+        info[:type] ||= 'file'
+        require 'aspera/keychain/factory'
+        @vault_instance = Keychain::Factory.create(
+          info,
+          Info::CMD_NAME,
+          context.main_folder,
+          options.get_option(:vault_password)
+        )
+      end
+    end
+  end
+end

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # For beta add extension : .beta1
     # For dev version add extension : .pre
-    VERSION = '4.26.2'
+    VERSION = '4.27.1'
   end
 end

data/lib/aspera/cli/wizard.rb

@@ -2,27 +2,30 @@
 
 require 'aspera/oauth/jwt'
 require 'aspera/assert'
+require 'aspera/cli/option_declarator'
 require 'aspera/cli/plugins/factory'
 
 module Aspera
   module Cli
     # The wizard detects applications and generates a config
     class Wizard
+      extend OptionDeclarator
+
       WIZARD_RESULT_KEYS = %i[preset_value test_args].freeze
       DEFAULT_PRIV_KEY_FILENAME = 'my_private_key.pem' # pragma: allowlist secret
-      private_constant :WIZARD_RESULT_KEYS,
-        :DEFAULT_PRIV_KEY_FILENAME
+      private_constant :WIZARD_RESULT_KEYS, :DEFAULT_PRIV_KEY_FILENAME
+
+      option :override, description: 'Wizard: override existing value',                                          allowed: Type::BOOLEAN, default: false
+      option :default,  description: 'Wizard: set as default configuration for specified plugin (also: update)', allowed: Type::BOOLEAN, default: true
+      option :key_path, description: 'Wizard: path to private key for JWT'
 
       def initialize(parent, main_folder)
         @parent = parent
         @main_folder = main_folder
-        # Wizard options
-        options.declare(:override, 'Wizard: override existing value', allowed: Allowed::TYPES_BOOLEAN, default: false)
-        options.declare(:default, 'Wizard: set as default configuration for specified plugin (also: update)', allowed: Allowed::TYPES_BOOLEAN, default: true)
-        options.declare(:key_path, 'Wizard: path to private key for JWT')
+        self.class.declare_options(options)
       end
 
-      # @return false if in test mode to avoid interactive input
+      # @return [Boolean] false if in test mode to avoid interactive input
       def required
         !ENV['ASCLI_WIZ_TEST']
       end
@@ -35,20 +38,15 @@ module Aspera
         @parent.formatter
       end
 
-      def config
-        @parent.config
-      end
-
       def check_email(email)
-        Aspera.assert(email =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i, type: ParameterError){"Username shall be an email: #{email}"}
+        Aspera.assert(email =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i, type: ParameterError) { "Username shall be an email: #{email}" }
       end
 
       # Find a plugin, and issue the "require"
       # @return [Hash] plugin info: { product:, name:, url:, version: }
-      def identify_plugins_for_url
-        app_url = options.get_next_argument('url', mandatory: true)
-        check_only = options.get_next_argument('plugin name', mandatory: false)
-        check_only = check_only.to_sym unless check_only.nil?
+      def identify_plugins_for_url(url:, plugin_name: nil)
+        app_url = url
+        check_only = plugin_name&.to_sym
         found_apps = []
         my_self_plugin_sym = self.class.name.split('::').last.downcase.to_sym
         Plugins::Factory.instance.plugin_list.each do |plugin_name_sym|
@@ -61,26 +59,26 @@ module Aspera
           next unless plugin_klass.respond_to?(:detect)
           detection_info = nil
           begin
-            Log.log.debug{"detecting #{plugin_name_sym} at #{app_url}"}
+            Log.log.debug { "detecting #{plugin_name_sym} at #{app_url}" }
             RestParameters.instance.spinner_cb.call(plugin_name_sym.to_s)
             detection_info = plugin_klass.detect(app_url)
           rescue OpenSSL::SSL::SSLError => e
             Log.log.warn(e.message)
             Log.log.warn('Use option --insecure=yes to allow unchecked certificate') if e.message.include?('cert')
           rescue StandardError => e
-            Log.log.debug{"detect error: [#{e.class}] #{e}"}
+            Log.log.debug { "detect error: [#{e.class}] #{e}" }
             next
           end
           next if detection_info.nil?
           Aspera.assert_type(detection_info, Hash)
           Aspera.assert_type(detection_info[:url], String) if detection_info.key?(:url)
-          app_name = plugin_klass.respond_to?(:application_name) ? plugin_klass.application_name : plugin_klass.name.split('::').last
+          app_name = plugin_klass.application_name
           # If there is a redirect, then the detector can override the url.
           found_apps.push({product: plugin_name_sym, name: app_name, url: app_url, version: 'unknown'}.merge(detection_info))
         end
         RestParameters.instance.spinner_cb.call(action: :success)
-        raise "No known application found at #{app_url}" if found_apps.empty?
-        Aspera.assert(found_apps.all?{ |a| a.keys.all?(Symbol)}, 'all app info keys must be symbols')
+        Aspera.assert(!found_apps.empty?) { "No known application found at #{app_url}" }
+        Aspera.assert(found_apps.all? { |a| a.keys.all?(Symbol) }, 'all app info keys must be symbols')
         return found_apps
       end
 
@@ -122,18 +120,18 @@ module Aspera
 
       # Wizard function, creates configuration
       # @param apps [Array] list of detected apps
-      def find(apps)
+      def find(apps, preset_name: '')
         identification = if apps.length.eql?(1)
-          Log.log.debug{"Detected: #{identification}"}
+          Log.log.debug { "Detected: #{identification}" }
           apps.first
         else
           formatter.display_status('Multiple applications detected, please select from:')
           require 'aspera/cli/result'
           formatter.display_results(Result::ObjectList.new(apps, fields: %w[product url version]))
-          answer = options.prompt_user_input_in_list('product', apps.map{ |a| a[:product]})
-          apps.find{ |a| a[:product].eql?(answer)}
+          answer = options.prompt_user_input_in_list('product', apps.map { |a| a[:product] })
+          apps.find { |a| a[:product].eql?(answer) }
         end
-        wiz_preset_name = options.get_next_argument('preset name', default: '')
+        wiz_preset_name = preset_name
         Log.dump(:identification, identification)
         wiz_url = identification[:url]
         formatter.display_status("Using: #{identification[:name]} at #{wiz_url}".bold)
@@ -141,11 +139,11 @@ module Aspera
         options.add_option_preset({url: wiz_url}, 'wizard')
         # Instantiate plugin: command line options will be known, e.g. private_key, and wizard can be called
         plugin_instance = Plugins::Factory.instance.plugin_class(identification[:product]).new(context: @parent.context)
-        Aspera.assert(plugin_instance.respond_to?(:wizard), type: Cli::BadArgument){"Detected: #{identification[:product]}, but this application has no wizard"}
+        Aspera.assert(plugin_instance.respond_to?(:wizard), type: Cli::BadArgument) { "Detected: #{identification[:product]}, but this application has no wizard" }
         # Call the wizard
         wizard_result = plugin_instance.wizard(self, wiz_url)
-        Log.log.debug{"wizard result: #{wizard_result}"}
-        Aspera.assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)){"missing or extra keys in wizard result: #{wizard_result.keys}"}
+        Log.log.debug { "wizard result: #{wizard_result}" }
+        Aspera.assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)) { "missing or extra keys in wizard result: #{wizard_result.keys}" }
         # Get preset name from user or default
         if wiz_preset_name.empty?
           elements = [
@@ -160,7 +158,7 @@ module Aspera
         # Init defaults if necessary
         option_override = options.get_option(:override, mandatory: true)
         option_default = options.get_option(:default, mandatory: true)
-        config.defaults_set(identification[:product], wiz_preset_name, wizard_result[:preset_value].stringify_keys, option_default, option_override)
+        @parent.context.presets.defaults_set(identification[:product], wiz_preset_name, wizard_result[:preset_value].stringify_keys, option_default, option_override)
         test_args = wizard_result[:test_args]
         test_args = "-P#{wiz_preset_name} #{test_args}" unless option_default
         # TODO: actually test the command

data/lib/aspera/colors.rb

@@ -52,9 +52,9 @@ class String
           0 # by default reset all
         end
       )
-      define_method(name){"#{begin_seq}#{self}#{end_seq}"}
+      define_method(name) { "#{begin_seq}#{self}#{end_seq}" }
     else
-      define_method(name){self}
+      define_method(name) { self }
     end
   end
 
@@ -62,7 +62,7 @@ class String
   # @param colors [Array<Symbol>] List of decorations.
   # @return [String] Enhanced String.
   def apply(*colors)
-    colors.reduce(self){ |s, c| s.public_send(c)}
+    colors.reduce(self) { |s, c| s.public_send(c) }
   end
 
   # Transform capitalized to snake case