aspera-cli 4.27.3 → 4.27.5

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

@@ -72,7 +72,7 @@ module Aspera
               username: options.get_option(:username, mandatory: true),
               password: options.get_option(:password, mandatory: true)
             },
-            test_args:    'files browse /'
+            test_args:    'browse /'
           }
         end
 
@@ -159,7 +159,7 @@ module Aspera
         end
 
         Sync::Operations::DIRECTIONS.each do |dir|
-          define_method(:"action_sync_#{dir}") { |path:, sync_info: {}, **| run_sync_transfer(dir, path: path, sync_info: sync_info) { server_transfer_spec } }
+          define_action_method([:sync, dir]) { |path:, sync_info: {}, **| run_sync_transfer(dir, path: path, sync_info: sync_info) { server_transfer_spec } }
         end
 
         # --- DSL ---
@@ -187,8 +187,7 @@ module Aspera
           Sync::Operations::DIRECTIONS.each do |dir|
             command dir, description: "#{dir.capitalize}-sync with server", transfer_paths: :send, arguments: SyncActions::PATH_AND_INFO_ARGS
           end
-          command :admin, description: 'Manage sync database (admin operations)'
-          SyncActions.register_sync_admin_commands(self, :admin)
+          sync_admin_commands :admin
         end
 
         commands_under :health do

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

@@ -247,19 +247,22 @@ module Aspera
             lookup:         :lookup_share_id
           command :user_permissions,
             description: 'Manage user permissions on a share',
-            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}]
+            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}],
+            setup: :setup_share_permissions
           command :group_permissions,
             description: 'Manage group permissions on a share',
-            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}]
+            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}],
+            setup: :setup_share_permissions
         end
 
-        # share user_permissions and group_permissions: Rails only exposes index+show (read-only)
-        %i[user_permissions group_permissions].each do |perm_type|
+        # share user_permissions and group_permissions: full CRUD, identified by the user or group id
+        {user_permissions: :user, group_permissions: :group}.each do |perm_type, entity_type|
           commands_under [:admin, :share, perm_type] do
-            SHARE_PERMISSIONS_OPS.each do |op|
-              command op, description: "#{op.capitalize} #{entity_noun(perm_type, singular: false)}",
-                arguments: op.eql?(:show) ? [{name: :permission_id, type: :identifier}] : nil
-            end
+            crud_commands entity: :"share_#{perm_type}",
+              api:     :@api_shares_admin,
+              name:    entity_noun(perm_type),
+              id_name: :"#{entity_type}_id",
+              lookup:  :"lookup_shares_#{entity_type}_all_id"
           end
         end
 
@@ -286,6 +289,12 @@ module Aspera
           {}
         end
 
+        # share_id: resolved by Phase A via arguments:(:identifier, lookup: :lookup_share_id) on the perm_type node
+        # @return [Hash] ctx with API path of user and group permissions of the share
+        def setup_share_permissions(share_id:, **)
+          %i[user_permissions group_permissions].to_h { |perm_type| [:"share_#{perm_type}", "data/shares/#{share_id}/#{perm_type}"] }
+        end
+
         # Lookup a share id by field/value using the admin API.
         def lookup_share_id(field, value, **)
           Rest::List.lookup_entity_generic(entity: 'share', field: field, value: value) { @api_shares_admin.read('data/shares') }['id']
@@ -328,7 +337,7 @@ module Aspera
         # @param op          [Symbol] CRUD operation
         # entity_id: resolved via arguments:(:identifier) on the setting node
         # permission_id: (share_permissions show) and data: (modify) resolved via arguments: on the leaf
-        def action_admin_entity_setting(entity_type, location, setting, op, entity_id:, permission_id: nil, data: nil)
+        def admin_entity_setting(entity_type, location, setting, op, entity_id:, permission_id: nil, data: nil)
           entity_path = "#{admin_entity_path(entity_type, location)}/#{entity_id}/#{setting}"
           send(:"entity_#{op}", api: @api_shares_admin, entity: entity_path, id: permission_id, is_singleton: !setting.eql?(:share_permissions), data: data)
         end
@@ -336,7 +345,7 @@ module Aspera
         # Shared handler for :users (group only)
         # group_id: resolved by Phase A via arguments:(:identifier) on the :users node
         # user_id: and data: resolved via arguments: on the leaf (GROUP_USERS_ARGS)
-        def action_admin_entity_users(entity_type, location, op, group_id:, user_id: nil, data: nil)
+        def admin_entity_users(entity_type, location, op, group_id:, user_id: nil, data: nil)
           path = admin_entity_path(entity_type, location)
           prefix = location.eql?(:all) ? '' : "#{location}_"
           send(:"entity_#{op}", api: @api_shares_admin, entity: "#{path}/#{group_id}/#{prefix}users", id: user_id, data: data)
@@ -353,7 +362,7 @@ module Aspera
                 setting_ops = setting.eql?(:share_permissions) ? SHARE_PERMISSIONS_OPS : %i[show modify]
                 setting_ops.each do |op|
                   define_action_method([:admin, entity_type, location, setting, op]) do |**kwargs|
-                    action_admin_entity_setting(entity_type, location, setting, op, entity_id: kwargs[:"#{entity_type}_id"], permission_id: kwargs[:permission_id], data: kwargs[setting])
+                    admin_entity_setting(entity_type, location, setting, op, entity_id: kwargs[:"#{entity_type}_id"], permission_id: kwargs[:permission_id], data: kwargs[setting])
                   end
                 end
               end
@@ -362,7 +371,7 @@ module Aspera
             # group users: no create route (Rails only exposes index+show+update+destroy)
             GROUP_USERS_OPS.each do |op|
               define_action_method([:admin, entity_type, location, :users, op]) do |group_id:, user_id: nil, user: nil, **|
-                action_admin_entity_users(entity_type, location, op, group_id: group_id, user_id: user_id, data: user)
+                admin_entity_users(entity_type, location, op, group_id: group_id, user_id: user_id, data: user)
               end
             end
           end
@@ -389,18 +398,6 @@ module Aspera
             end
           end
         end
-
-        # Handlers for admin > share > user_permissions|group_permissions > op
-        # share_id: resolved by Phase A via arguments:(:identifier, lookup: :lookup_share_id) on the perm_type node
-        # permission_id: resolved via arguments: on the show leaf
-        # Rails only exposes index+show for share permissions (read-only)
-        %i[user_permissions group_permissions].each do |perm_type|
-          SHARE_PERMISSIONS_OPS.each do |op|
-            define_action_method([:admin, :share, perm_type, op]) do |share_id:, permission_id: nil, **|
-              send(:"entity_#{op}", api: @api_shares_admin, entity: "data/shares/#{share_id}/#{perm_type}", id: permission_id)
-            end
-          end
-        end
       end
     end
   end

data/lib/aspera/cli/preset_actions.rb

@@ -52,6 +52,14 @@ module Aspera
 
       SECRET_KEYWORDS = %w[password secret].freeze
 
+      # @param name   [String]  preset name, or `GLOBAL` for the global default preset
+      # @param create [Boolean] `true` for an action writing in the preset: the global default preset is declared and created if needed
+      # @return [String] preset name
+      def preset_name(name, create: false)
+        return name unless name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        presets.global_default_preset(create: create)
+      end
+
       # If `option_name` ends with a secret keyword and the vault is configured,
       # move the clear-text value into the vault and replace it with a @vault: reference.
       # @param preset      [Hash]   the preset hash (modified in place)
@@ -82,16 +90,16 @@ module Aspera
       public
 
       def action_preset_show(name:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name)
         cp = presets.config_presets
-        raise "no such preset: #{name}" unless cp.key?(name)
+        raise Cli::BadArgument, "no such preset: #{name}" unless cp.key?(name)
         Result::SingleObject.new(PresetManager.deep_clone(cp[name]))
       end
 
       def action_preset_delete(name:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name)
         cp = presets.config_presets
-        raise "no such preset: #{name}" unless cp.key?(name)
+        raise Cli::BadArgument, "no such preset: #{name}" unless cp.key?(name)
         cp.delete(name)
         # Remove default declarations referring to the deleted preset
         defaults = cp[PresetManager::Key::DEFAULTS]
@@ -103,11 +111,11 @@ module Aspera
       end
 
       def action_preset_get(name:, param_name:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name)
         cp = presets.config_presets
-        raise "no such preset: #{name}" unless cp.key?(name)
+        raise Cli::BadArgument, "no such preset: #{name}" unless cp.key?(name)
         value = cp[name][param_name]
-        raise "no such option in preset #{name} : #{param_name}" if value.nil?
+        raise Cli::BadArgument, "no such option in preset #{name}: #{param_name}" if value.nil?
         case value
         when Numeric, String then return Result::Text.new(ExtendedValue.instance.evaluate(value.to_s, context: 'preset'))
         end
@@ -115,15 +123,15 @@ module Aspera
       end
 
       def action_preset_unset(name:, param_name:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name)
         cp = presets.config_presets
-        raise "no such preset: #{name}" unless cp.key?(name)
+        raise Cli::BadArgument, "no such preset: #{name}" unless cp.key?(name)
         cp[name].delete(param_name)
         Result::Status.new("Removed: #{name}: #{param_name}")
       end
 
       def action_preset_set(name:, param_name:, param_value:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name, create: true)
         param_name = Parser.option_line_to_name(param_name)
         presets.set_key(name, param_name, Parser.smart_convert(param_value))
         secure_preset_option(presets.config_presets[name], name, param_name)
@@ -131,15 +139,15 @@ module Aspera
       end
 
       def action_preset_initialize(name:, preset:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name, create: true)
         cp = presets.config_presets
         Log.log.warn { "configuration already exists: #{name}, overwriting" } if cp.key?(name)
         cp[name] = preset
-        Result::Status.new("Modified: #{@option_config_file}")
+        Result::Status.new("Initialized: #{name}")
       end
 
       def action_preset_update(name:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name, create: true)
         unprocessed_options = options.unprocessed_options_with_value
         Log.dump(:opts, unprocessed_options)
         cp = presets.config_presets
@@ -150,14 +158,16 @@ module Aspera
       end
 
       def action_preset_ask(name:, option_names:, **)
-        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        name = preset_name(name, create: true)
         cp = presets.config_presets
         cp[name] ||= {}
         # Option names are only known at runtime: cannot be declared as interactive arguments
-        option_names.each do |option_name|
-          option_value = options.get_interactive(option_name)
-          cp[name][option_name] = option_value
-          secure_preset_option(cp[name], name, option_name)
+        options.with_interactive do
+          option_names.each do |option_name|
+            option_value = options.get_interactive(option_name)
+            cp[name][option_name] = option_value
+            secure_preset_option(cp[name], name, option_name)
+          end
         end
         Result::Status.new("Updated: #{name}")
       end

data/lib/aspera/cli/preset_manager.rb

@@ -59,30 +59,38 @@ module Aspera
 
       # Read and validate the YAML config file.
       # Sets @config_presets and @checksum_on_disk.
+      # A file that cannot be read (YAML error, duplicate keys, access) is left untouched: it shall be fixed.
+      # A file with an unexpected structure is renamed for manual conversion, and a new one is created next time.
       def read_config_file
         Log.log.debug { "config file is: #{@config_file}".red }
         if File.exist?(@config_file)
           Log.log.debug { "loading #{@config_file}" }
-          @config_presets   = Yaml.safe_load(File.read(@config_file))
+          begin
+            @config_presets = Yaml.safe_load(File.read(@config_file))
+          rescue Psych::SyntaxError
+            Log.log.error { "YAML error in config file: #{@config_file}" }
+            raise
+          rescue StandardError => e
+            raise Cli::Error, "Config file #{@config_file}: #{e.message}"
+          end
           @checksum_on_disk = checksum
         else
           Log.log.warn { "No config file found. New configuration file: #{@config_file}" }
           @config_presets = {Key::CONFIG => {Key::VERSION => 'new file'}}
           # @checksum_on_disk remains nil: will be saved on first write
         end
-        validate_config_presets!
-      rescue Psych::SyntaxError => e
-        Log.log.error('YAML error in config file')
-        raise e
-      rescue StandardError => e
-        Log.log.debug { "-> #{e.class.name} : #{e}" }
-        if File.exist?(@config_file)
-          new_name = "#{@config_file}.pre#{Cli::VERSION}.manual_conversion_needed"
-          File.rename(@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.')
+        begin
+          validate_config_presets!
+        rescue StandardError => e
+          Log.log.debug { "-> #{e.class.name} : #{e}" }
+          if File.exist?(@config_file)
+            new_name = "#{@config_file}.pre#{Cli::VERSION}.manual_conversion_needed"
+            File.rename(@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.')
+          end
+          raise Cli::Error, e.to_s
         end
-        raise Cli::Error, e.to_s
       end
 
       # Save to disk only if content changed since last load/save.
@@ -132,7 +140,11 @@ module Aspera
         Aspera.assert(!include_path.include?(config_name), type: Cli::Error) { 'loop in include' }
         include_path = include_path.clone
         current = @config_presets
-        config_name.split(PRESET_DIG_SEPARATOR).each do |name|
+        # A preset name may contain a dot (e.g. a host name): the longest name of an existing preset is used
+        parts = config_name.split(PRESET_DIG_SEPARATOR)
+        count = parts.length.downto(1).find { |n| @config_presets.key?(parts.first(n).join(PRESET_DIG_SEPARATOR)) } || 1
+        names = [parts.first(count).join(PRESET_DIG_SEPARATOR)] + parts.drop(count)
+        names.each do |name|
           Aspera.assert_type(current, Hash, type: Cli::Error) { "sub key: #{include_path}" }
           include_path.push(name)
           current = current[name]
@@ -188,14 +200,17 @@ module Aspera
         nil
       end
 
-      # @return [String] name of the global default preset, creating it if needed
-      def global_default_preset
+      # @param create [Boolean] `true`: declare and create the global default preset if needed (to write in it)
+      # @return [String] name of the global default preset
+      def global_default_preset(create: true)
         result = plugin_default_name(CONF_GLOBAL_SYM)
         if result.nil?
           result = Key::GLOBAL
-          set_key(Key::DEFAULTS, CONF_GLOBAL_SYM, result)
-          # A default declaration requires the preset to exist
-          @config_presets[result] ||= {}
+          if create
+            set_key(Key::DEFAULTS, CONF_GLOBAL_SYM, result)
+            # A default declaration requires the preset to exist
+            @config_presets[result] ||= {}
+          end
         end
         result
       end

data/lib/aspera/cli/prompt.rb

@@ -8,12 +8,13 @@ module Aspera
     # Console input
     module Prompt
       # Prompt user for console input
+      # The prompt is displayed on `stderr`, like for sensitive input, so that `stdout` contains only results.
       # @param prompt [String]  prompt string to display
       # @param sensitive [Boolean] whether to hide typed input
       # @return [String] user input stripped of trailing newline
       def prompt_user_input(prompt, sensitive: false)
         return $stdin.getpass("#{prompt}> ") if sensitive
-        print("#{prompt}> ")
+        $stderr.print("#{prompt}> ")
         line = $stdin.gets
         Aspera.assert_type(line, String) { 'Unexpected end of standard input' }
         line.chomp

data/lib/aspera/cli/result.rb

@@ -43,10 +43,7 @@ module Aspera
         case formatter.format_type
         when :nagios then Nagios.process(@data)
         when :text   then formatter.display_message(:data, @data.to_s)
-        when :ruby   then formatter.display_message(:data, PP.pp(filtered_data, +''))
-        when :json   then formatter.display_message(:data, JSON.generate(filtered_data))
-        when :jsonpp then formatter.display_message(:data, JSON.pretty_generate(filtered_data))
-        when :yaml   then formatter.display_message(:data, YAML.dump(filtered_data))
+        when *STRUCTURED_FORMATS then display_structured(formatter, filtered_data)
         when :image
           if @data.nil?
             formatter.display_message(:data, formatter.special_format('null (no image)'))
@@ -81,6 +78,27 @@ module Aspera
         else Aspera.error_unexpected_value(formatter.format_type) { 'format' }
         end
       end
+
+      # Formats rendering the data structure itself
+      STRUCTURED_FORMATS = %i[ruby json jsonpp yaml].freeze
+
+      private
+
+      # Display a value in one of STRUCTURED_FORMATS
+      # @param formatter [Formatter] The formatter to use
+      # @param value     [Object]    Value to render
+      # @return [nil]
+      def display_structured(formatter, value)
+        text =
+          case formatter.format_type
+          when :ruby   then PP.pp(value, +'')
+          when :json   then JSON.generate(value)
+          when :jsonpp then JSON.pretty_generate(value)
+          when :yaml   then YAML.dump(value)
+          else Aspera.error_unexpected_value(formatter.format_type) { 'structured format' }
+          end
+        formatter.display_message(:data, text)
+      end
     end
 
     # Special result types - each has its own class
@@ -96,8 +114,11 @@ module Aspera
 
         def format(formatter)
           case formatter.format_type
-          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+          when :text, :nagios
             formatter.display_message(:data, @data.to_s)
+          when *STRUCTURED_FORMATS
+            # An empty list, or no value
+            display_structured(formatter, @data.eql?(:empty) ? [] : nil)
           when :table, :csv
             if @data.eql?(:nothing)
               Log.log.debug('no result expected')
@@ -132,8 +153,10 @@ module Aspera
         def format(formatter)
           data = formatter.hide_secrets? ? formatter.hide_secrets_in_string(@data) : @data
           case formatter.format_type
-          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+          when :text, :nagios
             formatter.display_message(:data, data)
+          when *STRUCTURED_FORMATS
+            display_structured(formatter, data)
           when :table, :csv
             formatter.display_message(:info, data)
           else
@@ -161,14 +184,8 @@ module Aspera
           case formatter.format_type
           when :text, :nagios
             formatter.display_message(:data, data.to_s)
-          when :ruby
-            formatter.display_message(:data, PP.pp(data, +''))
-          when :json
-            formatter.display_message(:data, JSON.generate(data))
-          when :jsonpp
-            formatter.display_message(:data, JSON.pretty_generate(data))
-          when :yaml
-            formatter.display_message(:data, YAML.dump(data))
+          when *STRUCTURED_FORMATS
+            display_structured(formatter, data)
           when :table, :csv
             formatter.display_message(:data, data)
           else
@@ -271,14 +288,8 @@ module Aspera
             formatter.display_table(@data.map { |i| {@name => i} }, [@name])
           when :text
             formatter.display_message(:data, @data.join("\n"))
-          when :ruby
-            formatter.display_message(:data, PP.pp(@data, +''))
-          when :json
-            formatter.display_message(:data, JSON.generate(@data))
-          when :jsonpp
-            formatter.display_message(:data, JSON.pretty_generate(@data))
-          when :yaml
-            formatter.display_message(:data, YAML.dump(@data))
+          when *STRUCTURED_FORMATS
+            display_structured(formatter, @data)
           else
             super
           end

data/lib/aspera/cli/runner.rb

@@ -348,9 +348,7 @@ module Aspera
         # Create command line manager with arguments
         @context.options = Parser.new(Info::CMD_NAME, @argv)
         ExtendedValue.instance.on(EXTEND_ARGS) { |v| @context.options.args_as_extended(v) }
-        # Formatter: declare metadata (class method), then bind to the instance
-        Formatter.declare_options(@context.options)
-        @context.formatter.bind_options(@context.options)
+        @context.formatter.declare_options(@context.options)
         # Compare $0 with expected name
         current_prog_name = File.basename($PROGRAM_NAME)
         Aspera.assert(current_prog_name.eql?(Info::CMD_NAME), type: :warn) { "Please use '#{Info::CMD_NAME}' instead of '#{current_prog_name}'" }
@@ -378,8 +376,6 @@ module Aspera
         @context.secret_finder = SecretFinder.new(@context.options, @context.presets)
         # The TransferAgent plugin may use the @preset parser
         @context.transfer = TransferAgent.new(@context)
-        # Add commands for config plugin after all options have been added
-        @context.config.add_manual_header(false)
         @context.validate
         # Set banner when all environment is created so that additional extended value modifiers are known, e.g. @preset
       end

data/lib/aspera/cli/sync_actions.rb

@@ -17,55 +17,56 @@ module Aspera
         (23..24).map { |i| "P(#{i})" }).freeze
       # Positional arguments shared by sync transfer commands (push/pull/bidi) and sync admin commands.
       PATH_AND_INFO_ARGS = [{name: :path}, {name: :sync_info, type: Hash, mandatory: false, default: {}}].freeze
-      # Names of the leaf commands registered under any `sync admin` node.
-      ADMIN_COMMANDS = %i[find status meta counters file_info overview query].freeze
       # When a plugin class includes SyncActions, register the :sql option
-      # in that class's DSL registry so Base#initialize auto-declares it.
+      # in that class's DSL registry so Base#initialize auto-declares it,
+      # and add the class-level DSL methods of ClassMethods.
       class << self
         def included(base)
           base.option(:sql, description: 'SQL suffix appended to sqlite3 queries for admin subcommands (e.g. WHERE clause)')
+          base.extend(ClassMethods)
         end
+      end
 
-        # DSL helper: register the 7 `sync admin` leaf commands under the given parent path.
-        # Called at class-load time from any plugin that includes SyncActions.
-        # @param base        [Class]          the plugin class (receiver of DSL methods)
-        # @param admin_path  [Symbol, Array<Symbol>]  path relative to current scope, e.g. :admin
-        def register_sync_admin_commands(base, admin_path)
-          base.commands_under(admin_path) do
-            base.command(
+      # Class-level DSL methods added to the plugin class that includes SyncActions.
+      module ClassMethods
+        # DSL class method: declare the `sync admin` node and its 7 leaf commands.
+        # @param parent [Symbol, Array<Symbol>] path relative to current scope, e.g. :admin
+        def sync_admin_commands(parent)
+          commands_under(parent, description: 'Manage sync database (admin operations)') do
+            command(
               :find, description: 'Find sync database files', arguments: [{name: :path}],
               action: lambda do |path:, **|
                 dbs = Sync::Operations.list_db_files(path)
                 Result::ObjectList.new(dbs.keys.map { |n| {name: n, path: dbs[n]} })
               end
             )
-            base.command(
+            command(
               :status, description: 'Show sync session status', arguments: PATH_AND_INFO_ARGS,
               action: ->(path:, sync_info: {}, **) { Result::SingleObject.new(Sync::Operations.admin_status(async_info_from_args(path: path, sync_info: sync_info))) }
             )
-            base.command(
+            command(
               :meta, description: 'Show sync session metadata', arguments: PATH_AND_INFO_ARGS,
               action: lambda do |path:, sync_info: {}, **|
                 require 'aspera/sync/database'
                 Result::SingleObject.new(db_from_args(path: path, sync_info: sync_info).meta(options.get_option(:sql)))
               end
             )
-            base.command(
+            command(
               :counters, description: 'Show sync counters', arguments: PATH_AND_INFO_ARGS,
               action: lambda do |path:, sync_info: {}, **|
                 require 'aspera/sync/database'
                 Result::SingleObject.new(db_from_args(path: path, sync_info: sync_info).counters(options.get_option(:sql)))
               end
             )
-            base.command(:file_info, description: 'Show per-file sync state', arguments: PATH_AND_INFO_ARGS, action: :action_sync_admin_file_info)
-            base.command(
+            command(:file_info, description: 'Show per-file sync state', arguments: PATH_AND_INFO_ARGS, action: :action_sync_admin_file_info)
+            command(
               :overview, description: 'Show sync database overview', arguments: PATH_AND_INFO_ARGS,
               action: lambda do |path:, sync_info: {}, **|
                 require 'aspera/sync/database'
                 Result::ObjectList.new(db_from_args(path: path, sync_info: sync_info).overview, fields: %w[table name type])
               end
             )
-            base.command(
+            command(
               :query, description: 'Execute a raw SQL query', arguments: PATH_AND_INFO_ARGS,
               action: lambda do |path:, sync_info: {}, **|
                 require 'aspera/sync/database'

data/lib/aspera/cli/transfer_actions.rb

@@ -15,7 +15,8 @@ module Aspera
     #
     # Architecture:
     #   - remote-daemon agents (desktop, node, connect, transferd): transfer_id + agent_params
-    #     are persisted in AsyncTransferStore; status is re-queried via Agent::Xxx.transfer_status
+    #     are persisted in AsyncTransferStore (without secrets, taken from current options);
+    #     status is re-queried via Agent::Xxx.transfer_status
     #   - direct agent: transfers live in Ruby threads - store is the agent's @sessions;
     #     status is not persistable across process restarts (returns an informational message)
     module TransferActions
@@ -25,10 +26,12 @@ module Aspera
         store = async_transfer_store
         entry = store.read(job_id)
         Aspera.assert(!entry.nil?, type: Cli::BadArgument) { "Unknown job_id: #{job_id}" }
+        # Secrets are not persisted: take them from current transfer options (e.g. `--transfer`), for the same agent type
+        agent_params = current_agent_params(entry['agent_type']).merge(entry['agent_params'] || {})
         # Inject the in-process agent reference (direct/httpgw) if still alive in this process.
         ref = store.agent_ref(job_id)
-        entry['agent_params']['_agent_ref'] = ref if ref
-        live = query_live_status(entry)
+        agent_params['_agent_ref'] = ref if ref
+        live = query_live_status(entry.merge('agent_params' => agent_params))
         if live
           entry.merge!(live)
           store.write(job_id, entry)
@@ -53,6 +56,14 @@ module Aspera
 
       private
 
+      # @param agent_type [String] agent of the async transfer
+      # @return [Hash] agent parameters from current transfer options (e.g. `--transfer`), if for the same agent type
+      def current_agent_params(agent_type)
+        current = context.transfer.transfer_options
+        return {} unless (current['agent'] || 'direct').to_s.eql?(agent_type)
+        current.except('agent', 'asynchronous')
+      end
+
       # Lazy accessor - requires context.persistency (available in all Base sub-classes).
       # Delegate to the TransferAgent's store so that the in-memory agent-ref
       # registry is shared between the two components in the same process.

data/lib/aspera/cli/transfer_agent.rb

@@ -44,7 +44,7 @@ module Aspera
 
       extend OptionDeclarator
 
-      option :ts,            description: 'Override transfer spec values', schema: Schema::Registry::TRANSFER_SPEC
+      option :ts,            description: 'Override transfer spec values', schema: Schema::Registry::TRANSFER_SPEC, on_set: :user_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
@@ -64,8 +64,8 @@ module Aspera
         @transfer_paths = nil
         # HTTPGW URL provided by webapp
         @httpgw_url_lambda = nil
-        self.class.declare_options(@context.options)
-        @context.options.on_set(:ts, method(:user_transfer_spec=))
+        # Instance variables used by `on_set` callbacks are set above
+        self.class.declare_options(@context.options, target: self)
         @context.options.parse_options!
         @notification_cb = nil
         if !@context.options.get_option(:notify_to).nil?
@@ -115,8 +115,10 @@ module Aspera
             agent_options.merge!(@context.presets.by_name(param_set_name).symbolize_keys)
           end
         when :direct
-          # by default do not display ascp native progress bar
+          # By default, no native `ascp` progress bar
           agent_options[:quiet] = true unless agent_options.key?(:quiet)
+          # Native `ascp` progress bar requested: no other progress bar, unless option `progress_bar` is set
+          agent_options[:progress] = nil if !agent_options[:quiet] && @context.options.option_def(:progress_bar).source.eql?(:default)
           agent_options[:check_ignore_cb] = ->(host, port) { @context.http_config.ignore_cert?(host, port) }
           # JRuby
           agent_options[:trusted_certs] = @context.http_config.trusted_cert_locations unless agent_options.key?(:trusted_certs)