aspera-cli 4.25.3 → 4.26.0.pre

data/lib/aspera/cli/manager.rb

@@ -194,7 +194,9 @@ module Aspera
           [error_msg, 'Use:'].concat(accept_list.map{ |c| "- #{c}"}.sort).join("\n")
         end
 
-        # change option name with dash to name with underscore
+        # Change option name with dash to name with underscore
+        # @param name [String] option name
+        # @return [String]
         def option_line_to_name(name)
           return name.gsub(OPTION_SEP_LINE, OPTION_SEP_SYMBOL)
         end
@@ -211,7 +213,7 @@ module Aspera
       def initialize(program_name, argv = nil)
         # command line values *not* starting with '-'
         @unprocessed_cmd_line_arguments = []
-        # command line values starting with '-'
+        # command line values starting with at least one '-'
         @unprocessed_cmd_line_options = []
         # a copy of all initial options
         @initial_cli_options = []
@@ -330,7 +332,7 @@ module Aspera
 
       # @param descr       [String] description for help
       # @param mandatory   [Boolean] if true, raise error if option not set
-      # @param multiple    [Boolean] if true, return remaining arguments (Array)
+      # @param multiple    [Boolean] if true, return remaining arguments (Array) until END
       # @param accept_list [Array, NilClass] list of allowed values (Symbol)
       # @param validation  [Class, Array, NilClass] Accepted value type(s) or list of Symbols
       # @param aliases     [Hash] map of aliases: key = alias, value = real value
@@ -345,10 +347,19 @@ module Aspera
         descr = "#{descr} (#{validation.join(', ')})" unless validation.nil? || validation.eql?(Allowed::TYPES_STRING)
         result =
           if !@unprocessed_cmd_line_arguments.empty?
-            how_many = multiple ? @unprocessed_cmd_line_arguments.length : 1
-            values = @unprocessed_cmd_line_arguments.shift(how_many)
+            if multiple
+              index = @unprocessed_cmd_line_arguments.index(SpecialValues::EOA)
+              if index.nil?
+                values = @unprocessed_cmd_line_arguments.shift(@unprocessed_cmd_line_arguments.length)
+              else
+                values = @unprocessed_cmd_line_arguments.shift(index)
+                @unprocessed_cmd_line_arguments.shift # remove EOA
+              end
+            else
+              values = [@unprocessed_cmd_line_arguments.shift]
+            end
             values = values.map{ |v| ExtendedValue.instance.evaluate(v, context: "argument: #{descr}", allowed: validation)}
-            # if expecting list and only one arg of type array : it is the list
+            # If expecting list and only one arg of type array : it is the list
             values = values.first if multiple && values.length.eql?(1) && values.first.is_a?(Array)
             if accept_list
               allowed_values = [].concat(accept_list)
@@ -457,21 +468,17 @@ module Aspera
       # @return [Hash] options as taken from config file and command line just before command execution
       def unprocessed_options_with_value
         result = {}
-        @initial_cli_options.each do |option_value|
-          case option_value
-          when /^#{OPTION_PREFIX}([^=]+)$/o
-            # ignore
-          when /^#{OPTION_PREFIX}([^=]+)=(.*)$/o
-            name = Regexp.last_match(1)
-            value = Regexp.last_match(2)
-            name.gsub!(OPTION_SEP_LINE, OPTION_SEP_SYMBOL)
-            value = ExtendedValue.instance.evaluate(value, context: "option: #{name}")
-            Log.log.debug{"option #{name}=#{value}"}
-            result[name] = value
-            @unprocessed_cmd_line_options.delete(option_value)
-          else
-            raise Cli::BadArgument, "wrong option format: #{option_value}"
-          end
+        @initial_cli_options.each do |option_argument|
+          # ignore short options
+          next unless option_argument.start_with?(OPTION_PREFIX)
+          name, value = option_argument[OPTION_PREFIX.length..-1].split(OPTION_VALUE_SEPARATOR, 2)
+          # ignore options without value
+          next if value.nil?
+          Log.log.debug{"option #{name}=#{value}"}
+          path = name.split(DotContainer::SEPARATOR)
+          path[0] = self.class.option_line_to_name(path[0])
+          DotContainer.dotted_to_container(path, smart_convert(value), result)
+          @unprocessed_cmd_line_options.delete(option_argument)
         end
         return result
       end
@@ -507,20 +514,25 @@ module Aspera
         rescue OptionParser::InvalidOption => e
           Log.log.trace1{"InvalidOption #{e}".red}
           # An option like --a.b.c=d does: a={"b":{"c":ext_val(d)}}
-          if (m = e.args.first.match(/^--([a-z\-]+)\.([^=]+)=(.+)$/))
-            option, path, value = m.captures
-            option_sym = self.class.option_line_to_name(option).to_sym
-            if @declared_options.key?(option_sym)
-              set_option(option_sym, DotContainer.dotted_to_container(path, smart_convert(value), get_option(option_sym)), where: 'dotted')
-              retry
+          if e.args.first.start_with?(OPTION_PREFIX)
+            name, value = e.args.first[OPTION_PREFIX.length..-1].split(OPTION_VALUE_SEPARATOR, 2)
+            if !value.nil?
+              path = name.split(DotContainer::SEPARATOR)
+              option_sym = self.class.option_line_to_name(path.shift)
+              if @declared_options.key?(option_sym)
+                # it's a known option, so let's process it
+                set_option(option_sym, DotContainer.dotted_to_container(path, smart_convert(value), get_option(option_sym)), where: 'dotted')
+                # resume to next
+                retry
+              end
             end
           end
-          # save for later processing
+          # Save for later processing
           unknown_options.push(e.args.first)
           retry
         end
         Log.log.trace1{"remains: #{unknown_options}"}
-        # set unprocessed options for next time
+        # Set unprocessed options for next time
         @unprocessed_cmd_line_options = unknown_options
       end
 
@@ -587,9 +599,9 @@ module Aspera
         ExtendedValue.assert_no_value(arg, :p)
         result = nil
         get_next_argument(:args, multiple: true).each do |arg|
-          Aspera.assert(arg.include?(OPTION_VALUE_SEPARATOR)){"Positional argument: #{arg} does not inlude #{OPTION_VALUE_SEPARATOR}"}
+          Aspera.assert(arg.include?(OPTION_VALUE_SEPARATOR)){"Positional argument: #{arg} does not include #{OPTION_VALUE_SEPARATOR}"}
           path, value = arg.split(OPTION_VALUE_SEPARATOR, 2)
-          result = DotContainer.dotted_to_container(path, smart_convert(value), result)
+          result = DotContainer.dotted_to_container(path.split(DotContainer::SEPARATOR), smart_convert(value), result)
         end
         result
       end

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

@@ -233,8 +233,7 @@ module Aspera
             defaults:      {workspace: nil},
             scope:         @scope,
             subpath:       aoc_base_path,
-            secret_finder: config,
-            progress_disp: formatter
+            secret_finder: config
           ))
         end
 
@@ -256,7 +255,10 @@ module Aspera
         # @param hash   [Hash,nil] Optional base `Hash` (modified)
         # @param string [Boolean] `true` to set key as `String`, else as `Symbol`
         # @param name   [Boolean] Include name
-        # @return [Hash] with key `workspace_[id,name]` (symbol or string) only if defined
+        # @return [Hash{Symbol, String => String}] the modified hash containing:
+        #   * `workspace_id` [String] the unique identifier.
+        #   * `workspace_name` [String] (optional) the name, included if +name+ is true.
+        # @note The key type (String or Symbol) depends on the +string+ parameter.
         def workspace_id_hash(hash = nil, string: false, name: false)
           info = aoc_api.workspace
           hash = {} if hash.nil?
@@ -742,7 +744,7 @@ module Aspera
         # Short link entity: `short_links` have:
         # - a numerical id, e.g. `764412`
         # - a resource type, e.g. `UrlToken`
-        # - a ressource id, e.g. `scQ7uXPbvQ`
+        # - a resource id, e.g. `scQ7uXPbvQ`
         # - a short URL path, e.g. `dxyRpT9`
         # @param shared_data [Hash] Information for shared data: dropbox_id+name or file_id+node_id
         # @param &perm_block [Proc] Optional: create/modify/delete permissions on node
@@ -885,7 +887,7 @@ module Aspera
 
         def reject_packages_from_persistency(all_packages, skip_ids_persistency)
           return if skip_ids_persistency.nil?
-          skip_package = skip_ids_persistency.data.each_with_object({}){ |i, m| m[i] = true}
+          skip_package = skip_ids_persistency.data.to_h{ |i| [i, true]}
           all_packages.reject!{ |pkg| skip_package[pkg['id']]}
         end
 

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

@@ -190,7 +190,7 @@ module Aspera
             return Main.result_single_object(api.read(one_res_path), fields: display_fields)
           when :list
             if tclo
-              data, total = list_entities_limit_offset_total_count(api: api, entity:, items_key: items_key, query: query_read_delete(default: list_query))
+              data, total = api.list_entities_limit_offset_total_count(entity:, items_key: items_key, query: query_read_delete(default: list_query))
               return Main.result_object_list(data, total: total, fields: display_fields)
             end
             data, http = api.read(entity, query_read_delete, ret: :both)
@@ -259,86 +259,9 @@ module Aspera
           return value
         end
 
-        # Get a (full or partial) list of all entities of a given type with query: offset/limit
-        # @param api       [Rest]          API object
-        # @param entity    [String,Symbol] API endpoint of entity to list
-        # @param items_key [String]        Key in the result to get the list of items (Default: same as `entity`)
-        # @param query     [Hash,nil]      Additional query parameters
-        # @return [Array<(Array<Hash>, Integer)>] items, total_count
-        def list_entities_limit_offset_total_count(
-          api:,
-          entity:,
-          items_key: nil,
-          query: nil
-        )
-          entity = entity.to_s if entity.is_a?(Symbol)
-          items_key = entity.split('/').last if items_key.nil?
-          query = {} if query.nil?
-          Aspera.assert_type(entity, String)
-          Aspera.assert_type(items_key, String)
-          Aspera.assert_type(query, Hash)
-          Log.log.debug{"list_entities t=#{entity} k=#{items_key} q=#{query}"}
-          result = []
-          offset = 0
-          max_items = query.delete(MAX_ITEMS)
-          remain_pages = query.delete(MAX_PAGES)
-          # Merge default parameters, by default 100 per page
-          query = {'limit'=> PER_PAGE_DEFAULT}.merge(query)
-          total_count = nil
-          loop do
-            query['offset'] = offset
-            page_result = api.read(entity, query)
-            Aspera.assert_type(page_result[items_key], Array)
-            result.concat(page_result[items_key])
-            # Reach the limit set by user ?
-            if !max_items.nil? && (result.length >= max_items)
-              result = result.slice(0, max_items)
-              break
-            end
-            total_count ||= page_result['total_count']
-            break if result.length >= total_count
-            remain_pages -= 1 unless remain_pages.nil?
-            break if remain_pages == 0
-            offset += page_result[items_key].length
-            formatter.long_operation_running
-          end
-          formatter.long_operation_terminated
-          return result, total_count
-        end
-
-        # Lookup an entity id from its name.
-        # Uses query `q` if `query` is `:default` and `field` is `name`.
-        # @param entity    [String] Type of entity to lookup, by default it is the path, and it is also the field name in result
-        # @param value     [String] Value to lookup
-        # @param field     [String] Field to match, by default it is `'name'`
-        # @param items_key [String] Key in the result to get the list of items (override entity)
-        # @param query     [Hash]   Additional query parameters (Default: `:default`)
-        def lookup_entity_by_field(api:, entity:, value:, field: 'name', items_key: nil, query: :default)
-          if query.eql?(:default)
-            Aspera.assert(field.eql?('name')){'Default query is on name only'}
-            query = {'q'=> value}
-          end
-          lookup_entity_generic(entity: entity, field: field, value: value){list_entities_limit_offset_total_count(api: api, entity: entity, items_key: items_key, query: query).first}
-        end
-
-        # Lookup entity by field and value. Extract single result from list of result returned by block.
-        # @param entity    [String] Type of entity to lookup, by default it is the path, and it is also the field name in result
-        # @param value     [String] Value to lookup
-        # @param field     [String] Field to match, by default it is `'name'`
-        # @param block     [Proc]   Get list of entity matching query.
-        def lookup_entity_generic(entity:, value:, field: 'name', &block)
-          Aspera.assert(block_given?)
-          found = yield
-          Aspera.assert_array_all(found, Hash)
-          found = found.select{ |i| i[field].eql?(value)}
-          return found.first if found.length.eql?(1)
-          raise Cli::BadIdentifier.new(entity, value, field: field, count: found.length)
-        end
-
-        PER_PAGE_DEFAULT = 1000
         # Percent selector: select by this field for this value
         REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/
-        private_constant :PER_PAGE_DEFAULT, :REGEX_LOOKUP_ID_BY_FIELD
+        private_constant :REGEX_LOOKUP_ID_BY_FIELD
       end
     end
   end

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

@@ -191,7 +191,8 @@ module Aspera
         def setup_rest_and_transfer_runtime
           RestParameters.instance.user_agent = Info::CMD_NAME
           RestParameters.instance.progress_bar = @progress_bar
-          RestParameters.instance.session_cb = lambda{ |http_session| update_http_session(http_session)}
+          RestParameters.instance.session_cb = ->(http_session){update_http_session(http_session)}
+          RestParameters.instance.spinner_cb = ->(title = nil, action: :spin){formatter.long_operation(title, action: action)}
           # Check http options that are global
           keys_to_delete = []
           @option_http_options.each do |k, v|

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

@@ -211,7 +211,7 @@ module Aspera
                 end
               # add special key
               package['items'] = package['link'].is_a?(Array) ? package['link'].length : 0
-              package['metadata'] = package['metadata']['field'].each_with_object({}){ |i, m| m[i['name']] = i['content']}
+              package['metadata'] = package['metadata']['field'].to_h{ |i| [i['name'], i['content']]}
               # if we look for a specific package
               stop_condition = true if !stop_at_id.nil? && stop_at_id.eql?(package[PACKAGE_MATCH_FIELD])
               # keep only those for the specified recipient

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

@@ -108,16 +108,17 @@ module Aspera
         end
 
         # if recipient is just an email, then convert to expected API hash : name and type
-        def normalize_recipients(parameters)
-          return unless parameters.key?('recipients')
-          Aspera.assert_type(parameters['recipients'], Array){'recipients'}
+        def normalize_recipients(parameters, type)
+          type = type.to_s
+          return unless parameters.key?(type)
+          Aspera.assert_type(parameters[type], Array){type}
           recipient_types = Api::Faspex::RECIPIENT_TYPES
           if parameters.key?('recipient_types')
             recipient_types = parameters['recipient_types']
             parameters.delete('recipient_types')
             recipient_types = [recipient_types] unless recipient_types.is_a?(Array)
           end
-          parameters['recipients'].map! do |recipient_data|
+          parameters[type].map! do |recipient_data|
             # If just a string, make a general lookup and build expected name/type hash
             if recipient_data.is_a?(String)
               matched = @api_v5.lookup_by_name('contacts', recipient_data, query: Rest.php_style({context: 'packages', type: recipient_types}))
@@ -157,17 +158,17 @@ module Aspera
           end
         end
 
-        # @param [Srting] job identifier
+        # @param [String] job identifier
         # @return [Hash] result of API call for job status
         def wait_for_job(job_id)
           result = nil
           loop do
             result = @api_v5.read("jobs/#{job_id}", {type: :formatted})
             break unless Api::Faspex::JOB_RUNNING.include?(result['status'])
-            formatter.long_operation_running(result['status'])
+            RestParameters.instance.spinner_cb.call(result['status'])
             sleep(0.5)
           end
-          formatter.long_operation_terminated
+          RestParameters.instance.spinner_cb.call(action: :success)
           return result
         end
 
@@ -182,16 +183,22 @@ module Aspera
             when *Api::Faspex::API_LIST_MAILBOX_TYPES then "#{box}/packages"
             else
               group_type = options.get_option(:group_type)
-              "#{group_type}/#{lookup_entity_by_field(api: @api_v5, entity: group_type, value: box)['id']}/packages"
+              "#{group_type}/#{@api_v5.lookup_entity_by_field(entity: group_type, value: box)['id']}/packages"
             end
-          list, total = list_entities_limit_offset_total_count(
-            api: @api_v5,
-            entity: entity,
-            query:  query_read_delete(default: query)
-          )
+          list, total = @api_v5.list_entities_limit_offset_total_count(entity: entity, query: query_read_delete(default: query))
           return list.select(&filter), total
         end
 
+        # Build query to get package recipients based on package info in case of shared inbox or workgroup recipient
+        # @param package_id [String] the package id to get info from
+        def recipient_query(package_id)
+          package_info = @api_v5.read("packages/#{package_id}")
+          base_query = {}
+          base_query['recipient_workgroup_id'] = package_info['recipients'].first['id'] if WORKGROUP_TYPES.include?(package_info['recipients'].first['recipient_type'])
+          base_query['recipient_user_id'] = package_info['recipients'].first['id'] if package_info['recipients'].first['recipient_type'].eql?('user')
+          base_query
+        end
+
         def package_receive(package_ids)
           # prepare persistency if needed
           skip_ids_persistency = nil
@@ -241,7 +248,7 @@ module Aspera
             type:          Api::Faspex.box_type(box),
             transfer_type: Api::Faspex::TRANSFER_CONNECT
           }
-          download_params[:recipient_workgroup_id] = lookup_entity_by_field(api: @api_v5, entity: options.get_option(:group_type), value: box)['id'] if !Api::Faspex::API_LIST_MAILBOX_TYPES.include?(box) && box != SpecialValues::ALL
+          # download_params[:recipient_workgroup_id] = @api_v5.lookup_entity_by_field(entity: options.get_option(:group_type), value: box)['id'] if !Api::Faspex::API_LIST_MAILBOX_TYPES.include?(box) && box != SpecialValues::ALL
           packages.each do |package|
             pkg_id = package['id']
             formatter.display_status("Receiving package #{pkg_id}")
@@ -249,7 +256,7 @@ module Aspera
             transfer_spec = @api_v5.call(
               operation:    'POST',
               subpath:      "packages/#{pkg_id}/transfer_spec/download",
-              query:        download_params,
+              query:        download_params.merge(recipient_query(pkg_id)),
               content_type: Mime::JSON,
               body:         param_file_list,
               headers:      {'Accept' => Mime::JSON}
@@ -276,7 +283,7 @@ module Aspera
               recipient_type: @api_v5.pub_link_context['recipient_type']
             }]
           end
-          normalize_recipients(parameters)
+          PACKAGE_RECIPIENT_TYPES.each{ |type| normalize_recipients(parameters, type)}
           # User specified content prot in tspec, but faspex requires in package creation
           # `transfer_spec/upload` will set `content_protection`
           if transfer.user_transfer_spec['content_protection'] && !parameters.key?('ear_enabled')
@@ -298,8 +305,7 @@ module Aspera
           else
             # send from remote shared folder
             if (m = Base.percent_selector(shared_folder))
-              shared_folder = lookup_entity_by_field(
-                api: @api_v5,
+              shared_folder = @api_v5.lookup_entity_by_field(
                 entity: 'shared_folders',
                 field: m[:field],
                 value: m[:value]
@@ -319,9 +325,9 @@ module Aspera
 
         # Browse a folder
         # @param browse_endpoint [String] the endpoint to browse
-        def browse_folder(browse_endpoint)
+        def browse_folder(browse_endpoint, base_query = {})
           folders_to_process = [options.get_next_argument('folder path', default: '/')]
-          query = query_read_delete(default: {})
+          query = base_query.merge(query_read_delete(default: {}))
           filters = query.delete('filters'){{}}
           Aspera.assert_type(filters, Hash)
           filters['basenames'] ||= []
@@ -357,7 +363,7 @@ module Aspera
               end
               folders_to_process.concat(data['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']}) if recursive
               if use_paging
-                iteration_token = http[Api::Faspex::HEADER_ITERATION_TOKEN]
+                iteration_token = http[Api::Faspex::HEADER_X_NEXT_ITER_TOKEN]
                 break if iteration_token.nil? || iteration_token.empty?
                 query['iteration_token'] = iteration_token
               else
@@ -365,12 +371,11 @@ module Aspera
                 break if data['item_count'].eql?(0)
                 query['offset'] += data['item_count']
               end
-              formatter.long_operation_running(all_items.count)
+              RestParameters.instance.spinner_cb.call(all_items.count)
             end
             query.delete('iteration_token')
           end
-          formatter.long_operation_terminated
-
+          RestParameters.instance.spinner_cb.call(action: :success)
           return Main.result_object_list(all_items, total: total_count)
         end
 
@@ -384,7 +389,7 @@ module Aspera
           when :show
             return Main.result_single_object(@api_v5.read("packages/#{package_id}"))
           when :browse
-            return browse_folder("packages/#{package_id}/files/#{Api::Faspex.box_type(options.get_option(:box))}")
+            return browse_folder("packages/#{package_id}/files/#{Api::Faspex.box_type(options.get_option(:box))}", recipient_query(package_id))
           when :status
             status_list = options.get_next_argument('list of states, or nothing', mandatory: false, validation: Array)
             status = wait_package_status(package_id, status_list: status_list)
@@ -447,18 +452,20 @@ module Aspera
             res_id_query = {'all': true}
           when :nodes
             available_commands += %i[shared_folders browse]
+          when :jobs
+            exec_args[:display_fields] = %w[id job_name job_type status]
           end
           res_command = options.get_next_command(available_commands)
           return Main.result_value_list(Api::Faspex::EMAIL_NOTIF_LIST, name: 'email_id') if res_command.eql?(:list) && res_sym.eql?(:email_notifications)
           case res_command
           when *ALL_OPS
             return entity_execute(command: res_command, **exec_args) do |field, value|
-                     lookup_entity_by_field(api: @api_v5, entity: exec_args[:entity], value: value, field: field, items_key: exec_args[:items_key], query: res_id_query)['id']
+                     @api_v5.lookup_entity_by_field(entity: exec_args[:entity], value: value, field: field, items_key: exec_args[:items_key], query: res_id_query)['id']
                    end
           when :shared_folders
             # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(api: @api_v5, entity: 'nodes', field: field, value: value)['id']
+              @api_v5.lookup_entity_by_field(entity: 'nodes', field: field, value: value)['id']
             end
             shfld_entity = "nodes/#{node_id}/shared_folders"
             sh_command = options.get_next_command(ALL_OPS + [:user])
@@ -469,33 +476,32 @@ module Aspera
                 entity: shfld_entity,
                 command: sh_command
               ) do |field, value|
-                       lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
+                       @api_v5.lookup_entity_by_field(entity: shfld_entity, field: field, value: value)['id']
                      end
             when :user
               sh_id = instance_identifier do |field, value|
-                lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
+                @api_v5.lookup_entity_by_field(entity: shfld_entity, field: field, value: value)['id']
               end
               user_path = "#{shfld_entity}/#{sh_id}/custom_access_users"
               return entity_execute(api: @api_v5, entity: user_path, items_key: 'users') do |field, value|
-                       lookup_entity_by_field(api: @api_v5, entity: user_path, items_key: 'users', field: field, value: value)['id']
+                       @api_v5.lookup_entity_by_field(entity: user_path, items_key: 'users', field: field, value: value)['id']
                      end
 
             end
           when :browse
             # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(api: @api_v5, entity: 'nodes', value: value, field: field)['id']
+              @api_v5.lookup_entity_by_field(entity: 'nodes', value: value, field: field)['id']
             end
             return browse_folder("nodes/#{node_id}/browse")
           when :invite_external_collaborator
             # :shared_inboxes, :workgroups
-            shared_inbox_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
+            shared_inbox_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
             creation_payload = value_create_modify(command: res_command, type: [Hash, String])
             creation_payload = {'email_address' => creation_payload} if creation_payload.is_a?(String)
             result = @api_v5.create("#{res_sym}/#{shared_inbox_id}/external_collaborator", creation_payload)
             formatter.display_status(result['message'])
-            result = lookup_entity_by_field(
-              api: @api_v5,
+            result = @api_v5.lookup_entity_by_field(
               entity: "#{res_sym}/#{shared_inbox_id}/members",
               items_key: 'members',
               value: creation_payload['email_address'],
@@ -504,7 +510,7 @@ module Aspera
             return Main.result_single_object(result)
           when :members, :saml_groups
             # res_command := :shared_inboxes, :workgroups
-            res_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
+            res_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
             res_path = "#{res_sym}/#{res_id}/#{res_command}"
             list_key = res_command.to_s
             list_key = 'groups' if res_command.eql?(:saml_groups)
@@ -515,8 +521,7 @@ module Aspera
               users = [users] unless users.is_a?(Array)
               users = users.map do |user|
                 if (m = Base.percent_selector(user))
-                  lookup_entity_by_field(
-                    api: @api_v5,
+                  @api_v5.lookup_entity_by_field(
                     entity: 'accounts',
                     field: m[:field],
                     value: m[:value],
@@ -537,8 +542,7 @@ module Aspera
               command: sub_command,
               items_key: list_key
             ) do |field, value|
-                     lookup_entity_by_field(
-                       api: @api_v5,
+                     @api_v5.lookup_entity_by_field(
                        entity: res_path,
                        field: field,
                        value: value,
@@ -547,7 +551,7 @@ module Aspera
                    end
           when :reset_password
             # :accounts
-            contact_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: 'accounts', field: field, value: value, query: res_id_query)['id']}
+            contact_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: 'accounts', field: field, value: value, query: res_id_query)['id']}
             @api_v5.create("accounts/#{contact_id}/reset_password", {})
             return Main.result_status('password reset, user shall check email')
           end
@@ -568,16 +572,10 @@ module Aspera
             event_type = options.get_next_command(%i[application webhook])
             case event_type
             when :application
-              list, total = list_entities_limit_offset_total_count(
-                api: @api_v5,
-                entity: 'application_events',
-                query: query_read_delete
-              )
-
+              list, total = @api_v5.list_entities_limit_offset_total_count(entity: 'application_events', query: query_read_delete)
               return Main.result_object_list(list, total: total, fields: %w[event_type created_at application user.name])
             when :webhook
-              list, total = list_entities_limit_offset_total_count(
-                api: @api_v5,
+              list, total = @api_v5.list_entities_limit_offset_total_count(
                 entity: 'all_webhooks_events',
                 query: query_read_delete,
                 items_key: 'events'
@@ -694,7 +692,7 @@ module Aspera
                 items_key: invitation_endpoint,
                 display_fields: %w[id public recipient_type recipient_name email_address]
               ) do |field, value|
-                lookup_entity_by_field(api: @api_v5, entity: invitation_endpoint, field: field, value: value, query: {})['id']
+                @api_v5.lookup_entity_by_field(entity: invitation_endpoint, field: field, value: value, query: {})['id']
               end
             end
           when :gateway
@@ -719,8 +717,10 @@ module Aspera
         end
         SHARED_INBOX_MEMBER_LEVELS = %i[submit_only standard shared_inbox_admin].freeze
         ACCOUNT_TYPES = %w{local_user saml_user self_registered_user external_user}.freeze
-        CONTACT_TYPES = %w{workgroup shared_inbox distribution_list user external_user}.freeze
-        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES
+        WORKGROUP_TYPES = %w{workgroup shared_inbox}.freeze
+        CONTACT_TYPES = (WORKGROUP_TYPES + %w{distribution_list user external_user}).freeze
+        PACKAGE_RECIPIENT_TYPES = %i{recipients private_recipients notified_on_upload notified_on_download notified_on_receipt}
+        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES, :PACKAGE_RECIPIENT_TYPES
       end
     end
   end

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

@@ -93,12 +93,9 @@ module Aspera
             options.declare(:validator, 'Identifier of validator (optional for central)')
             options.declare(:asperabrowserurl, 'URL for simple aspera web ui', default: 'https://asperabrowser.mybluemix.net')
             options.declare(
-              :default_ports, 'Gen4: Use standard FASP ports (true) or get from node API (false)', allowed: Allowed::TYPES_BOOLEAN, default: true,
-              handler: {o: Api::Node, m: :use_standard_ports}
-            )
-            options.declare(
-              :node_cache, 'Gen4: Set to no to force actual file system read', allowed: Allowed::TYPES_BOOLEAN,
-              handler: {o: Api::Node, m: :use_node_cache}
+              :node_api, 'Gen4: standard_ports: Use standard FASP ports (true) or get from node API (false). cache: Set to false to force actual file system read',
+              allowed: Hash,
+              handler: {o: Api::Node, m: :api_options}
             )
             options.declare(:root_id, 'Gen4: File id of top folder when using access key (override AK root id)')
             options.declare(:dynamic_key, 'Private key PEM to use for dynamic key auth', handler: {o: Api::Node, m: :use_dynamic_key})
@@ -242,14 +239,14 @@ module Aspera
               break if all_items.count >= total_count
               offset += items.count
               query['skip'] = offset
-              formatter.long_operation_running(all_items.count)
+              RestParameters.instance.spinner_cb.call(all_items.count)
             end
             query.delete('skip')
           end
           @prefixer&.remove_in_object_list!(all_items)
           return Main.result_object_list(all_items)
         ensure
-          formatter.long_operation_terminated
+          RestParameters.instance.spinner_cb.call(action: :success)
         end
 
         # Create async transfer spec request from direction and folders
@@ -388,7 +385,7 @@ module Aspera
           when :transport
             return Main.result_single_object(@api_node.transport_params)
           when :spec
-            return Main.result_single_object(@api_node.base_spec)
+            return Main.result_single_object(@api_node.base_spec, fields: Formatter.all_but(Transfer::Spec::SPECIFIC))
           end
           Aspera.error_unreachable_line
         end
@@ -523,7 +520,7 @@ module Aspera
             return Main.result_text(result[:password])
           when :browse
             apifid = apifid_from_next_arg(top_file_id)
-            file_info = apifid[:api].read("files/#{apifid[:file_id]}", **Api::Node.cache_control)
+            file_info = apifid[:api].read("files/#{apifid[:file_id]}", headers: Api::Node.add_cache_control)
             unless file_info['type'].eql?('folder')
               # a single file
               return Main.result_object_list([file_info], fields: GEN4_LS_FIELDS)
@@ -931,10 +928,8 @@ module Aspera
                 # do not process last one
                 break if end_date.nil?
                 # init data for this period
-                period_bandwidth = Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).each_with_object({}) do |direction, h|
-                  h[direction] = dir_info.each_with_object({}) do |k2, h2|
-                    h2[k2] = 0
-                  end
+                period_bandwidth = Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).to_h do |direction|
+                  [direction, dir_info.to_h{ |k2| [k2, 0]}]
                 end
                 # find all transfers that were active at this time
                 transfers_data.each do |transfer|