aspera-cli 4.20.0 → 4.21.1

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

@@ -9,11 +9,10 @@ require 'aspera/cli/formatter'
 require 'aspera/cli/info'
 require 'aspera/cli/transfer_progress'
 require 'aspera/ascp/installation'
-require 'aspera/ascp/products'
+require 'aspera/products/transferd'
 require 'aspera/transfer/error_info'
 require 'aspera/transfer/parameters'
 require 'aspera/transfer/spec'
-require 'aspera/keychain/encrypted_hash'
 require 'aspera/keychain/macos_security'
 require 'aspera/proxy_auto_config'
 require 'aspera/environment'
@@ -54,7 +53,7 @@ module Aspera
         PERSISTENCY_FOLDER = 'persist_store'
         ASPERA = 'aspera'
         SERVER_COMMAND = 'server'
-        APP_NAME_SDK = 'sdk'
+        DIR_SDK = 'sdk'
         CONNECT_WEB_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
         CONNECT_VERSIONS = 'connectversions.js' # cspell: disable-line
         DEMO_SERVER = 'demo'
@@ -78,6 +77,7 @@ module Aspera
         GEM_CHECK_DATE_FMT = '%Y/%m/%d'
         # for testing only
         SELF_SIGNED_CERT = OpenSSL::SSL.const_get(:enon_yfirev.to_s.upcase.reverse) # cspell: disable-line
+        CONF_OVERVIEW_KEYS = %w[preset parameter value].freeze
         private_constant :DEFAULT_CONFIG_FILENAME,
           :CONF_PRESET_CONFIG,
           :CONF_PRESET_VERSION,
@@ -98,7 +98,8 @@ module Aspera
           :WIZARD_RESULT_KEYS,
           :SELF_SIGNED_CERT,
           :PERSISTENCY_FOLDER,
-          :DEFAULT_PRIV_KEY_LENGTH
+          :DEFAULT_PRIV_KEY_LENGTH,
+          :CONF_OVERVIEW_KEYS
 
         class << self
           def generate_rsa_private_key(path:, length: DEFAULT_PRIV_KEY_LENGTH)
@@ -145,7 +146,7 @@ module Aspera
 
         def initialize(**env)
           # we need to defer parsing of options until we have the config file, so we can use @extend with @preset
-          super(**env)
+          super
           @use_plugin_defaults = true
           @config_presets = nil
           @config_checksum_on_disk = nil
@@ -213,7 +214,7 @@ module Aspera
           options.declare(:ascp_path, 'Path to ascp', handler: {o: Ascp::Installation.instance, m: :ascp_path})
           options.declare(:use_product, 'Use ascp from specified product', handler: {o: self, m: :option_use_product})
           options.declare(:sdk_url, 'URL to get SDK', default: SpecialValues::DEF)
-          options.declare(:sdk_folder, 'SDK folder path', handler: {o: Ascp::Installation.instance, m: :sdk_folder})
+          options.declare(:sdk_folder, 'SDK folder path', handler: {o: Products::Transferd, m: :sdk_directory})
           options.declare(:progress_bar, 'Display progress bar', values: :bool, default: Environment.terminal?)
           # email options
           options.declare(:smtp, 'SMTP configuration', types: Hash)
@@ -232,22 +233,22 @@ module Aspera
           options.parse_options!
           @progress_bar = TransferProgress.new if options.get_option(:progress_bar)
           # Check SDK folder is set or not, for compatibility, we check in two places
-          sdk_folder = Ascp::Installation.instance.sdk_folder rescue nil
-          if sdk_folder.nil?
+          sdk_dir = Products::Transferd.sdk_directory rescue nil
+          if sdk_dir.nil?
             @sdk_default_location = true
             Log.log.debug('SDK folder is not set, checking default')
             # new location
-            sdk_folder = self.class.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}"}
+            sdk_dir = self.class.default_app_main_folder(app_name: DIR_SDK)
+            Log.log.debug{"checking: #{sdk_dir}"}
+            if !Dir.exist?(sdk_dir)
+              Log.log.debug{"not exists: #{sdk_dir}"}
               # former location
-              former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: Info::CMD_NAME), APP_NAME_SDK)
+              former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: Info::CMD_NAME), DIR_SDK)
               Log.log.debug{"checking: #{former_sdk_folder}"}
-              sdk_folder = former_sdk_folder if Dir.exist?(former_sdk_folder)
+              sdk_dir = former_sdk_folder if Dir.exist?(former_sdk_folder)
             end
-            Log.log.debug{"using: #{sdk_folder}"}
-            Ascp::Installation.instance.sdk_folder = sdk_folder
+            Log.log.debug{"using: #{sdk_dir}"}
+            Products::Transferd.sdk_directory = sdk_dir
           end
           pac_script = options.get_option(:fpac)
           # create PAC executor
@@ -414,7 +415,7 @@ module Aspera
 
         def periodic_check_newer_gem_version
           # get verification period
-          delay_days = options.get_option(:version_check_days, mandatory: true)
+          delay_days = options.get_option(:version_check_days, mandatory: true).to_i
           # check only if not zero day
           return if delay_days.eql?(0)
           # get last date from persistency
@@ -663,10 +664,10 @@ module Aspera
           end
           case command
           when :list
-            return {type: :object_list, data: connect_versions, fields: %w[id title version]}
+            return Main.result_object_list(connect_versions, fields: %w[id title version])
           when :info
             one_res.delete('links')
-            return {type: :single_object, data: one_res}
+            return Main.result_single_object(one_res)
           when :version
             all_links = one_res['links']
             command = options.get_next_command(%i[list download open])
@@ -677,10 +678,9 @@ module Aspera
             end
             case command
             when :list
-              return {type: :object_list, data: all_links}
+              return Main.result_object_list(all_links)
             when :download
               folder_dest = transfer.destination_folder(Transfer::Spec::DIRECTION_RECEIVE)
-              # folder_dest=self.options.get_next_argument('destination folder')
               api_connect_cdn = Rest.new(base_url: CONNECT_WEB_URL)
               file_url = one_link['href']
               filename = file_url.gsub(%r{.*/}, '')
@@ -700,11 +700,12 @@ module Aspera
             return execute_connect_action
           when :use
             ascp_path = options.get_next_argument('path to ascp')
+            Ascp::Installation.instance.ascp_path = ascp_path
             formatter.display_status("ascp version: #{Ascp::Installation.instance.get_ascp_version(ascp_path)}")
             set_global_default(:ascp_path, ascp_path)
             return Main.result_nothing
           when :show
-            return {type: :status, data: Ascp::Installation.instance.path(:ascp)}
+            return Main.result_status(Ascp::Installation.instance.path(:ascp))
           when :info
             # collect info from ascp executable
             data = Ascp::Installation.instance.ascp_info
@@ -713,13 +714,13 @@ module Aspera
             # add keys
             DataRepository::ELEMENTS.each_with_object(data){|i, h|h[i.to_s] = DataRepository.instance.item(i)}
             # declare those as secrets
-            SecretHider::ADDITIONAL_KEYS_TO_HIDE.push(*DataRepository::ELEMENTS.map(&:to_s))
-            return {type: :single_object, data: data}
+            SecretHider::ADDITIONAL_KEYS_TO_HIDE.concat(DataRepository::ELEMENTS.map(&:to_s))
+            return Main.result_single_object(data)
           when :products
             command = options.get_next_command(%i[list use])
             case command
             when :list
-              return {type: :object_list, data: Ascp::Products.installed_products, fields: %w[name app_root]}
+              return Main.result_object_list(Ascp::Installation.instance.installed_products, fields: %w[name app_root])
             when :use
               default_product = options.get_next_argument('product name')
               Ascp::Installation.instance.use_ascp_from_product(default_product)
@@ -728,23 +729,44 @@ module Aspera
             end
           when :install
             # reset to default location, if older default was used
-            Ascp::Installation.instance.sdk_folder = self.class.default_app_main_folder(app_name: APP_NAME_SDK) if @sdk_default_location
-            n, v = Ascp::Installation.instance.install_sdk(url: options.get_option(:sdk_url, mandatory: true))
+            Products::Transferd.sdk_directory = self.class.default_app_main_folder(app_name: DIR_SDK) if @sdk_default_location
+            version = options.get_next_argument('transferd version', mandatory: false)
+            n, v = Ascp::Installation.instance.install_sdk(url: options.get_option(:sdk_url, mandatory: true), version: version)
             return Main.result_status("Installed #{n} version #{v}")
           when :spec
-            return {
-              type:   :object_list,
-              data:   Transfer::Parameters.man_table(formatter),
+            return Main.result_object_list(
+              Transfer::Parameters.man_table(formatter),
               fields: [%w[name type], Transfer::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s), %w[description]].flatten.freeze
-            }
+            )
           when :errors
             error_data = []
             Transfer::ERROR_INFO.each_pair do |code, prop|
               error_data.push(code: code, mnemonic: prop[:c], retry: prop[:r], info: prop[:a])
             end
-            return {type: :object_list, data: error_data}
+            return Main.result_object_list(error_data)
+          else Aspera.error_unexpected_value(command)
           end
-          raise "unexpected case: #{command}"
+          Aspera.error_unreachable_line
+        end
+
+        def execute_action_transferd
+          command = options.get_next_command(%i[list install])
+          case command
+          when :install
+            # reset to default location, if older default was used
+            Products::Transferd.sdk_directory = self.class.default_app_main_folder(app_name: DIR_SDK) if @sdk_default_location
+            version = options.get_next_argument('transferd version', mandatory: false)
+            n, v = Ascp::Installation.instance.install_sdk(url: options.get_option(:sdk_url, mandatory: true), version: version)
+            return Main.result_status("Installed #{n} version #{v}")
+          when :list
+            sdk_list = Ascp::Installation.sdk_locations
+            return Main.result_object_list(
+              sdk_list,
+              fields: sdk_list.first.keys - ['url']
+            )
+          else Aspera.error_unexpected_value(command)
+          end
+          Aspera.error_unreachable_line
         end
 
         # legacy actions available globally
@@ -763,12 +785,20 @@ module Aspera
           raise "no such preset: #{name}" if PRESET_EXIST_ACTIONS.include?(action) && !@config_presets.key?(name)
           case action
           when :list
-            return {type: :value_list, data: @config_presets.keys, name: 'name'}
+            return Main.result_value_list(@config_presets.keys, 'name')
           when :overview
             # display process modifies the value (hide secrets): we do not want to save removed secrets
-            return {type: :config_over, data: self.class.deep_clone(@config_presets)}
+            data = self.class.deep_clone(@config_presets)
+            formatter.hide_secrets(data)
+            result = []
+            data.each do |config, preset|
+              preset.each do |parameter, value|
+                result.push(CONF_OVERVIEW_KEYS.zip([config, parameter, value]).to_h)
+              end
+            end
+            return Main.result_object_list(result, fields: CONF_OVERVIEW_KEYS)
           when :show
-            return {type: :single_object, data: self.class.deep_clone(@config_presets[name])}
+            return Main.result_single_object(self.class.deep_clone(@config_presets[name]))
           when :delete
             @config_presets.delete(name)
             return Main.result_status("Deleted: #{name}")
@@ -779,7 +809,7 @@ module Aspera
             case value
             when Numeric, String then return {type: :text, data: ExtendedValue.instance.evaluate(value.to_s)}
             end
-            return {type: :single_object, data: value}
+            return Main.result_single_object(value)
           when :unset
             param_name = options.get_next_argument('parameter name')
             @config_presets[name].delete(param_name)
@@ -818,7 +848,7 @@ module Aspera
             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}
+            return Main.result_single_object(result)
           when :secure
             identifier = options.get_next_argument('config name', mandatory: false)
             preset_names = identifier.nil? ? @config_presets.keys : [identifier]
@@ -856,13 +886,15 @@ module Aspera
           remote_certificate
           gem
           plugins
-          flush_tokens
+          tokens
           echo
+          download
           wizard
           detect
           coffee
           image
           ascp
+          transferd
           email_test
           smtp_settings
           proxy_check
@@ -912,9 +944,27 @@ module Aspera
             end
           when :echo # display the content of a value given on command line
             return Formatter.auto_type(options.get_next_argument('value', validation: nil))
-          when :flush_tokens
-            deleted_files = OAuth::Factory.instance.flush_tokens
-            return {type: :value_list, data: deleted_files, name: 'file'}
+          when :download
+            file_url = options.get_next_argument('source URL').chomp
+            file_dest = options.get_next_argument('file path', mandatory: false)
+            if file_dest.nil?
+              file_dest = File.join(transfer.destination_folder(Transfer::Spec::DIRECTION_RECEIVE), file_url.gsub(%r{.*/}, ''))
+            end
+            formatter.display_status("Downloading: #{file_url}")
+            Rest.new(base_url: file_url).call(operation: 'GET', save_to_file: file_dest)
+            return Main.result_status("Saved to: #{file_dest}")
+          when :tokens
+            require 'aspera/api/node'
+            case options.get_next_command(%i{flush list show})
+            when :flush
+              return Main.result_value_list(OAuth::Factory.instance.flush_tokens, name: 'file')
+            when :list
+              return Main.result_object_list(OAuth::Factory.instance.persisted_tokens)
+            when :show
+              data = OAuth::Factory.instance.get_token_info(instance_identifier)
+              raise Cli::Error, 'No such identifier' if data.nil?
+              return Main.result_single_object(data)
+            end
           when :plugins
             case options.get_next_command(%i[list create])
             when :list
@@ -928,7 +978,7 @@ module Aspera
                   path:   PluginFactory.instance.plugin_source(name)
                 })
               end
-              return {type: :object_list, data: result, fields: %w[plugin detect wizard path]}
+              return Main.result_object_list(result, fields: %w[plugin detect wizard path])
             when :create
               plugin_name = options.get_next_argument('name').downcase
               destination_folder = options.get_next_argument('folder', mandatory: false) || File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME)
@@ -954,10 +1004,7 @@ module Aspera
             options.ask_missing_mandatory = true
             # detect plugins by url and optional query
             apps = identify_plugins_for_url.freeze
-            return {
-              type: :object_list,
-              data: apps
-            } if action.eql?(:detect)
+            return Main.result_object_list(apps) if action.eql?(:detect)
             return wizard_find(apps)
           when :coffee
             return Main.result_image(COFFEE_IMAGE, formatter: formatter)
@@ -965,6 +1012,8 @@ module Aspera
             return Main.result_image(options.get_next_argument('image uri or blob'), formatter: formatter)
           when :ascp
             execute_action_ascp
+          when :transferd
+            execute_action_transferd
           when :gem
             case options.get_next_command(%i[path version name])
             when :path then return Main.result_status(self.class.gem_src_root)
@@ -979,14 +1028,14 @@ module Aspera
             send_email_template(email_template_default: EMAIL_TEST_TEMPLATE)
             return Main.result_nothing
           when :smtp_settings
-            return {type: :single_object, data: email_settings}
+            return Main.result_single_object(email_settings)
           when :proxy_check
             # ensure fpac was provided
             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
-            return {type: :single_object, data: check_gem_version}
+            return Main.result_single_object(check_gem_version)
           when :initdemo
             if @config_presets.key?(DEMO_PRESET)
               Log.log.warn{"Demo server preset already present: #{DEMO_PRESET}"}
@@ -1085,7 +1134,7 @@ module Aspera
             wiz_preset_name = elements.join('_').strip.downcase.gsub(/[^a-z0-9]/, '_').squeeze('_')
           end
           # test mode does not change conf file
-          return {type: :single_object, data: wizard_result} if options.get_option(:test_mode)
+          return Main.result_single_object(wizard_result) if options.get_option(:test_mode)
           # Write configuration file
           formatter.display_status("Preparing preset: #{wiz_preset_name}")
           # init defaults if necessary
@@ -1196,7 +1245,8 @@ module Aspera
               Log.log.error do
                 "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::CMD_NAME} config id #{default_config_name} init @json:'{}') or remove default (#{Info::CMD_NAME} config id default remove #{plugin_name_sym})."
+                  "(#{Info::CMD_NAME} config id #{default_config_name} init @json:'{}') " \
+                  "or remove default (#{Info::CMD_NAME} config id default remove #{plugin_name_sym})."
               end
             end
             raise Cli::Error, "Config name [#{default_config_name}] must be a hash, check config file." if !@config_presets[default_config_name].is_a?(Hash)
@@ -1211,11 +1261,11 @@ module Aspera
           command = options.get_next_command(%i[info list show create delete password])
           case command
           when :info
-            return {type: :single_object, data: vault_info}
+            return Main.result_single_object(vault_info)
           when :list
-            return {type: :object_list, data: vault.list, fields: %w(label url username password description)}
+            return Main.result_object_list(vault.list, fields: %w(label url username password description))
           when :show
-            return {type: :single_object, data: vault.get(label: options.get_next_argument('label'))}
+            return Main.result_single_object(vault.get(label: options.get_next_argument('label')))
           when :create
             label = options.get_next_argument('label', validation: String)
             info = options.get_next_argument('info', validation: Hash)
@@ -1264,6 +1314,8 @@ module Aspera
             info = vault_info
             case info[:type]
             when 'file'
+              # this module requires comilation, so it is optinal
+              require 'aspera/keychain/encrypted_hash'
               # absolute_path? introduced in ruby 2.7
               @vault = Keychain::EncryptedHash.new(
                 info[:name].eql?(File.absolute_path(info[:name])) ? info[:name] : File.join(@main_folder, info[:name]),

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

@@ -19,6 +19,7 @@ module Aspera
           options.declare(:region, 'Storage region')
           options.declare(:identity, "Authentication URL (#{Api::CosNode::IBM_CLOUD_TOKEN_URL})", default: Api::CosNode::IBM_CLOUD_TOKEN_URL)
           options.parse_options!
+          Node.declare_options(options)
         end
 
         ACTIONS = %i[node].freeze

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

@@ -305,7 +305,7 @@ module Aspera
                 # authenticated user
                 delivery_info['sources'] ||= [{'paths' => []}]
                 first_source = delivery_info['sources'].first
-                first_source['paths'].push(*transfer.source_list)
+                first_source['paths'].concat(transfer.source_list)
                 source_id = instance_identifier(as_option: :remote_source) do |field, value|
                   Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
                   source_list = api_v3.read('source_shares')['items']
@@ -441,7 +441,9 @@ module Aspera
                 Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
                 self.class.get_source_id_by_name(value, source_list)
               end.to_i
-              source_name = source_list.find{|i|i['id'].eql?(source_id)}['name']
+              selected_source = source_list.find{|i|i['id'].eql?(source_id)}
+              raise 'No such source' if selected_source.nil?
+              source_name = selected_source['name']
               source_hash = options.get_option(:storage, mandatory: true)
               # check value of option
               Aspera.assert_type(source_hash, Hash, exception_class: Cli::Error){'storage option'}

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

@@ -237,15 +237,18 @@ module Aspera
           end
         end
 
+        # @param [Srting] job identifier
+        # @return [Hash] result of API call for job status
         def wait_for_job(job_id)
+          result = nil
           loop do
-            status = @api_v5.read("jobs/#{job_id}", {type: :formatted})
-            return status unless JOB_RUNNING.include?(status['status'])
-            formatter.long_operation_running(status['status'])
+            result = @api_v5.read("jobs/#{job_id}", {type: :formatted})
+            break unless JOB_RUNNING.include?(result['status'])
+            formatter.long_operation_running(result['status'])
             sleep(0.5)
           end
           formatter.long_operation_terminated
-          Aspera.error_unreachable_line
+          return result
         end
 
         # Get a (full or partial) list of all entities of a given type with query: offset/limit
@@ -253,9 +256,10 @@ module Aspera
         # @param query [Hash,nil] additional query parameters
         # @param real_path [String] real path if it's n ot just the type
         # @param item_list_key [String] key in the result to get the list of items
-        def list_entities(type:, real_path: nil, item_list_key: nil, query: {})
+        def list_entities(type:, real_path: nil, item_list_key: nil, query: nil)
           Log.log.trace1{"list_entities t=#{type} p=#{real_path} k=#{item_list_key} q=#{query}"}
           type = type.to_s if type.is_a?(Symbol)
+          query = {} if query.nil?
           Aspera.assert_type(type, String)
           Aspera.assert_type(query, Hash)
           item_list_key = type if item_list_key.nil?
@@ -555,9 +559,10 @@ module Aspera
             id_as_arg = 'type'
           when :accounts
             display_fields = Formatter.all_but('user_profile_data_attributes')
+            available_commands.push(:reset_password)
           when :oauth_clients
             display_fields = Formatter.all_but('public_key')
-            adm_api = Rest.new(**@api_v5.params.merge(base_url: "#{@faspex5_api_base_url}/#{PATH_AUTH}"))
+            adm_api = Rest.new(**@api_v5.params, base_url: "#{@faspex5_api_base_url}/#{PATH_AUTH}")
           when :shared_inboxes, :workgroups
             available_commands.push(:members, :saml_groups, :invite_external_collaborator)
             res_id_query = {'all': true}
@@ -642,7 +647,12 @@ module Aspera
                        value: value,
                        query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})})['id']
                    end
+          when :reset_password
+            contact_id = instance_identifier { |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
+            adm_api.create("#{res_type}/#{contact_id}/reset_password", {})
+            return Main.result_status('password reset, user shall check email')
           end
+          Aspera.error_unreachable_line
         end
 
         def execute_admin
@@ -655,16 +665,18 @@ module Aspera
           when *ADMIN_RESOURCES
             return execute_resource(command)
           when :clean_deleted
-            delete_data = value_create_modify(command: command, default: {days_before_deleting_package_records: 365})
+            delete_data = value_create_modify(command: command, default: {})
+            delete_data = @api_v5.read('configuration').slice('days_before_deleting_package_records') if delete_data.empty?
             res = @api_v5.create('internal/packages/clean_deleted', delete_data)
             return {type: :single_object, data: res}
           when :events
             event_type = options.get_next_command(%i[application webhook])
             case event_type
             when :application
-              return {type: :object_list, data: list_entities(type: 'application_events'), fields: %w[event_type created_at application user.name]}
+              return {type: :object_list, data: list_entities(type: 'application_events', query: query_read_delete),
+fields: %w[event_type created_at application user.name]}
             when :webhook
-              return {type: :object_list, data: list_entities(type: 'all_webhooks_events', item_list_key: 'events')}
+              return {type: :object_list, data: list_entities(type: 'all_webhooks_events', query: query_read_delete, item_list_key: 'events')}
             end
           when :configuration
             conf_path = 'configuration'

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

@@ -127,10 +127,13 @@ module Aspera
         # commands for execute_command_gen4
         COMMANDS_GEN4 = %i[mkdir rename delete upload download sync http_node_download show modify permission thumbnail v3].concat(NODE4_READ_ACTIONS).freeze
 
+        # commands supported in ATS for COS
         COMMANDS_COS = %i[upload download info access_keys api_details transfer].freeze
         COMMANDS_SHARES = (BASE_ACTIONS - %i[search]).freeze
         COMMANDS_FASPEX = COMMON_ACTIONS
 
+        GEN4_LS_FIELDS = %w[name type recursive_size size modified_time access_level].freeze
+
         def initialize(api: nil, **env)
           super(**env, basic_options: api.nil?)
           Node.declare_options(options) if api.nil?
@@ -484,22 +487,15 @@ module Aspera
           when :browse
             apifid = apifid_from_next_arg(top_file_id)
             file_info = apifid[:api].read_with_cache("files/#{apifid[:file_id]}")
-            if file_info['type'].eql?('folder')
-              result = apifid[:api].call(
-                operation: 'GET',
-                subpath:   "files/#{apifid[:file_id]}/files",
-                headers:   Api::Node.cache_control_headers,
-                query:     query_read_delete)
-              items = result[:data]
-              formatter.display_item_count(result[:data].length, result[:http]['X-Total-Count'])
-            else
-              items = [file_info]
+            unless file_info['type'].eql?('folder')
+              # a single file
+              return {type: :object_list, data: [file_info], fields: GEN4_LS_FIELDS}
             end
-            return {type: :object_list, data: items, fields: %w[name type recursive_size size modified_time access_level]}
+            return {type: :object_list, data: apifid[:api].list_files(apifid[:file_id]), fields: GEN4_LS_FIELDS}
           when :find
             apifid = apifid_from_next_arg(top_file_id)
-            test_block = Api::Node.file_matcher_from_argument(options)
-            return {type: :object_list, data: @api_node.find_files(apifid[:file_id], test_block), fields: ['path']}
+            find_lambda = Api::Node.file_matcher_from_argument(options)
+            return {type: :object_list, data: @api_node.find_files(apifid[:file_id], find_lambda), fields: ['path']}
           when :mkdir
             containing_folder_path = options.get_next_argument('path').split(Api::Node::PATH_SEPARATOR)
             new_folder = containing_folder_path.pop
@@ -608,12 +604,12 @@ module Aspera
             command_perm = options.get_next_command(%i[list create delete])
             case command_perm
             when :list
-              # generic options : TODO: as arg ? query_read_delete
-              list_options ||= {'include' => Rest.array_params(%w[access_level permission_count])}
-              # add which one to get
-              list_options['file_id'] = apifid[:file_id]
-              list_options['inherited'] ||= false
-              items = apifid[:api].read('permissions', list_options)
+              list_query = query_read_delete(default: {'include' => Rest.array_params(%w[access_level permission_count])})
+              # specify file to get permissions for unless not specified
+              list_query['file_id'] = apifid[:file_id] unless apifid[:file_id].to_s.empty?
+              list_query['inherited'] = false if list_query.key?('file_id') && !list_query.key?('inherited')
+              # NOTE: supports per_page and page and header X-Total-Count
+              items = apifid[:api].read('permissions', list_query)
               return {type: :object_list, data: items}
             when :delete
               return do_bulk_operation(command: command_perm, descr: 'identifier', values: :identifier) do |one_id|
@@ -802,42 +798,53 @@ module Aspera
             end
             case command
             when :list
+              transfer_filter = query_read_delete(default: {})
+              last_iteration_token = nil
               iteration_persistency = nil
-              iteration_data = []
               if options.get_option(:once_only, mandatory: true)
                 iteration_persistency = PersistencyActionOnce.new(
                   manager: persistency,
-                  data:    iteration_data,
+                  data:    [],
                   id:      IdGenerator.from_list([
                     'node_transfers',
                     options.get_option(:url, mandatory: true),
                     options.get_option(:username, mandatory: true)
                   ]))
+                if transfer_filter.delete('reset')
+                  iteration_persistency.data.clear
+                  iteration_persistency.save
+                  return Main.result_status('Persistency reset')
+                end
+                last_iteration_token = iteration_persistency.data.first
               end
-              transfer_filter = query_read_delete(default: {})
-              if transfer_filter.delete('reset')
-                iteration_data.clear
-                iteration_persistency&.save
-                return Main.result_status('Persistency reset')
-              end
+              raise 'reset only with once_only' if transfer_filter.key?('reset') && iteration_persistency.nil?
               max_items = transfer_filter.delete(MAX_ITEMS)
-              transfer_filter['iteration_token'] = iteration_persistency.data[0] unless iteration_data.empty?
               transfers_data = []
               loop do
+                transfer_filter['iteration_token'] = last_iteration_token unless last_iteration_token.nil?
                 result = @api_node.call(operation: 'GET', subpath: res_class_path, query: transfer_filter)
-                data = result[:data]
-                transfers_data.concat(data)
-                if !max_items.nil? && (transfers_data.length >= max_items)
+                # no data
+                break if result[:data].empty?
+                # get next iteration token from link
+                next_iteration_token = nil
+                link_info = result[:http]['Link']
+                unless link_info.nil?
+                  m = link_info.match(/<([^>]+)>/)
+                  raise "Cannot parse iteration in Link: #{link_info}" if m.nil?
+                  next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
+                end
+                # same as last iteration: stop
+                break if next_iteration_token&.eql?(last_iteration_token)
+                last_iteration_token = next_iteration_token
+                transfers_data.concat(result[:data])
+                if max_items&.<=(transfers_data.length)
+                  # if !max_items.nil? && (transfers_data.length >= max_items)
                   transfers_data = transfers_data.slice(0, max_items)
                   break
                 end
-                link_info = result[:http]['Link']
-                break if iteration_persistency.nil? || data.empty? || link_info.nil?
-                m = link_info.match(/<([^>]+)>/)
-                raise "Problem with iteration: #{link_info}" if m.nil?
-                iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
-                iteration_data[0] = transfer_filter['iteration_token'] = iteration_token
+                break if last_iteration_token.nil?
               end
+              iteration_persistency&.data&.[]=(0, last_iteration_token)
               iteration_persistency&.save
               return {
                 type:   :object_list,
@@ -1019,7 +1026,7 @@ module Aspera
             raise 'Missing key: url' unless parameters.key?(:url)
             uri = URI.parse(parameters[:url])
             server = WebServerSimple.new(uri, certificate: parameters[:certificate])
-            server.mount(uri.path, NodeSimulatorServlet, parameters[:credentials], transfer)
+            server.mount(uri.path, NodeSimulatorServlet, parameters[:credentials], NodeSimulator.new)
             server.start
             return Main.result_status('Simulator terminated')
           end

data/lib/aspera/cli/transfer_progress.rb

@@ -79,6 +79,8 @@ module Aspera
         new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.length}] #{@title}"
         @progress_bar.title = new_title unless @progress_bar.title.eql?(new_title)
         @progress_bar.increment if !progress_provided && !@completed
+      rescue ProgressBar::InvalidProgressError => e
+        Log.log.error{"Progress error: #{e}"}
       end
 
       private