aspera-cli 4.20.0 → 4.21.1

data/lib/aspera/cli/formatter.rb

@@ -14,7 +14,6 @@ require 'pp'
 
 module Aspera
   module Cli
-    CONF_OVERVIEW_KEYS = %w[preset parameter value].freeze
     # This class is used to transform a complex structure into a simple hash
     class Flattener
       def initialize(formatter)
@@ -30,17 +29,6 @@ module Aspera
         return @result
       end
 
-      # Special method for configuration overview
-      def config_over(something)
-        @result = []
-        something.each do |config, preset|
-          preset.each do |parameter, value|
-            @result.push(CONF_OVERVIEW_KEYS.zip([config, parameter, value]).to_h)
-          end
-        end
-        return @result
-      end
-
       private
 
       # Recursive function to flatten any type
@@ -101,9 +89,10 @@ module Aspera
       DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv image].freeze
       # user output levels
       DISPLAY_LEVELS = %i[info data error].freeze
-      FIELD_VALUE_HEADINGS = %i[key value].freeze
+      # column names for single object display in table
+      SINGLE_OBJECT_COLUMN_NAMES = %i[field value].freeze
 
-      private_constant :DISPLAY_FORMATS, :DISPLAY_LEVELS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR, :FIELD_VALUE_HEADINGS
+      private_constant :FIELDS_LESS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :SINGLE_OBJECT_COLUMN_NAMES
       # prefix to display error messages in user messages (terminal)
       ERROR_FLASH = 'ERROR:'.bg_red.gray.blink.freeze
       WARNING_FLASH = 'WARNING:'.bg_brown.black.blink.freeze
@@ -172,12 +161,37 @@ module Aspera
         @spinner = nil
       end
 
-      # options are: format, output, display, fields, select, table_style, flat_hash, transpose_single
+      def declare_options(options)
+        default_table_style = if Environment.instance.terminal_supports_unicode?
+          {border: :unicode_round}
+        else
+          {}
+        end
+        options.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
+        options.declare(:output, 'Destination for results', types: String, handler: {o: self, m: :option_handler})
+        options.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
+        options.declare(
+          :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
+          types: [String, Array, Regexp, Proc],
+          default: SpecialValues::DEF)
+        options.declare(:select, 'Select only some items in lists: column, value', types: [Hash, Proc], handler: {o: self, m: :option_handler})
+        options.declare(:table_style, 'Table display style', types: [Hash], handler: {o: self, m: :option_handler}, default: default_table_style)
+        options.declare(:flat_hash, '(Table) Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_handler}, default: true)
+        options.declare(
+          :multi_single, '(Table) Control how object list is displayed as single table, or multiple objects', values: %i[no yes single],
+          handler: {o: self, m: :option_handler}, default: :no)
+        options.declare(:show_secrets, 'Show secrets on command output', values: :bool, handler: {o: self, m: :option_handler}, default: false)
+        options.declare(:image, 'Options for image display', types: Hash, handler: {o: self, m: :option_handler}, default: {})
+      end
+
+      # method accessed by option manager
+      # options are: format, output, display, fields, select, table_style, flat_hash, multi_single
       def option_handler(option_symbol, operation, value=nil)
         Aspera.assert_values(operation, %i[set get])
         case operation
         when :set
           @options[option_symbol] = value
+          # special handling of some options
           case option_symbol
           when :output
             $stdout = if value.eql?('-')
@@ -186,7 +200,9 @@ module Aspera
               File.open(value, 'w')
             end
           when :image
+            # get list if key arguments of method
             allowed_options = Preview::Terminal.method(:build).parameters.select{|i|i[0].eql?(:key)}.map{|i|i[1]}
+            # check that only supported options are given
             unknown_options = value.keys.map(&:to_sym) - allowed_options
             raise "Invalid parameter(s) for option image: #{unknown_options.join(', ')}, use #{allowed_options.join(', ')}" unless unknown_options.empty?
           end
@@ -196,28 +212,6 @@ module Aspera
         nil
       end
 
-      def declare_options(options)
-        default_table_style = if Environment.instance.terminal_supports_unicode?
-          {border: :unicode_round}
-        else
-          {}
-        end
-        options.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
-        options.declare(:output, 'Destination for results', types: String, handler: {o: self, m: :option_handler})
-        options.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
-        options.declare(
-          :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
-          types: [String, Array, Regexp, Proc],
-          default: SpecialValues::DEF)
-        options.declare(:select, 'Select only some items in lists: column, value', types: [Hash, Proc], handler: {o: self, m: :option_handler})
-        options.declare(:table_style, 'Table display style', types: [Hash], handler: {o: self, m: :option_handler}, default: default_table_style)
-        options.declare(:flat_hash, '(Table) Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_handler}, default: true)
-        options.declare(:transpose_single, '(Table) Single object fields output vertically', values: :bool, handler: {o: self, m: :option_handler}, default: true)
-        options.declare(:multi_table, '(Table) Each element of a table are displayed as a table', values: :bool, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:show_secrets, 'Show secrets on command output', values: :bool, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:image, 'Options for image display', types: Hash, handler: {o: self, m: :option_handler}, default: {})
-      end
-
       # main output method
       # data: for requested data, not displayed if level==error
       # info: additional info, displayed if level==info
@@ -244,6 +238,116 @@ module Aspera
         display_status(count_msg)
       end
 
+      def hide_secrets(data)
+        SecretHider.deep_remove_secret(data) unless @options[:show_secrets] || @options[:display].eql?(:data)
+      end
+
+      # this method displays the results, especially the table format
+      # @param type [Symbol] type of data
+      # @param data [Object] data to display
+      # @param total [Integer] total number of items
+      # @param fields [Array<String>] list of fields to display
+      # @param name [String] name of the column to display
+      def display_results(type:, data: nil, total: nil, fields: nil, name: nil)
+        Log.log.debug{"display_results: #{type} class=#{data.class}"}
+        Log.log.trace1{"display_results:data=#{data}"}
+        Aspera.assert_type(type, Symbol){'result must have type'}
+        Aspera.assert(!data.nil? || %i[empty nothing].include?(type)){'result must have data'}
+        display_item_count(data.length, total) unless total.nil?
+        hide_secrets(data)
+        case @options[:format]
+        when :text
+          display_message(:data, data.to_s)
+        when :nagios
+          Nagios.process(data)
+        when :ruby
+          display_message(:data, PP.pp(filter_list_on_fields(data), +''))
+        when :json
+          display_message(:data, JSON.generate(filter_list_on_fields(data)))
+        when :jsonpp
+          display_message(:data, JSON.pretty_generate(filter_list_on_fields(data)))
+        when :yaml
+          display_message(:data, YAML.dump(filter_list_on_fields(data)))
+        when :image
+          # assume it is an url
+          url = data
+          case type
+          when :single_object, :object_list
+            url = [url] if type.eql?(:single_object)
+            raise 'image display requires a single result' unless url.length == 1
+            fields = compute_fields(url, fields)
+            raise 'select a field to display' unless fields.length == 1
+            url = url.first
+            raise 'no such field' unless url.key?(fields.first)
+            url = url[fields.first]
+          end
+          raise "not url: #{url.class} #{url}" unless url.is_a?(String)
+          display_message(:data, status_image(url))
+        when :table, :csv
+          case type
+          when :object_list, :single_object
+            obj_list = data
+            if type.eql?(:single_object)
+              obj_list = [obj_list]
+              @options[:multi_single] = :yes
+            end
+            Aspera.assert_type(obj_list, Array)
+            Aspera.assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
+            # :object_list is an array of hash tables, where key=colum name
+            obj_list = obj_list.map{|obj|Flattener.new(self).flatten(obj)} if @options[:flat_hash]
+            display_table(obj_list, compute_fields(obj_list, fields))
+          when :value_list
+            # :value_list is a simple array of values, name of column provided in the :name
+            display_table(data.map { |i| { name => i } }, [name])
+          when :empty # no table
+            display_message(:info, special_format('empty'))
+            return
+          when :nothing # no result expected
+            Log.log.debug('no result expected')
+          when :status # no table
+            # :status displays a simple message
+            display_message(:info, data)
+          when :text # no table
+            # :status displays a simple message
+            display_message(:data, data)
+          when :other_struct # no table
+            # :other_struct is any other type of structure
+            display_message(:data, PP.pp(data, +''))
+          else
+            raise "unknown data type: #{type}"
+          end
+        else
+          raise "not expected: #{@options[:format]}"
+        end
+      end
+
+      # @return text suitable to display an image from url
+      # @param blob [String] either a URL or image data
+      def status_image(blob)
+        # check if URL
+        begin
+          URI.parse(blob)
+          url = blob
+          unless Environment.instance.url_method.eql?(:text)
+            Environment.instance.open_uri(url)
+            return ''
+          end
+          blob = UriReader.read(url)
+        rescue URI::InvalidURIError
+          nil
+        end
+        # try base64
+        begin
+          blob = Base64.strict_decode64(blob)
+        rescue
+          nil
+        end
+        return Preview::Terminal.build(blob, **@options[:image].symbolize_keys)
+      end
+      #==========================================================================================
+
+      private
+
       def all_fields(data)
         data.each_with_object({}){|v, m|v.each_key{|c|m[c] = true}}.keys
       end
@@ -300,7 +404,7 @@ module Aspera
         return data if @options[:fields].eql?(SpecialValues::DEF)
         selected_fields = compute_fields(data, @options[:fields])
         return data.map{|i|i[selected_fields.first]} if selected_fields.length == 1
-        return data.map{|i|i.select{|k, _|selected_fields.include?(k)}}
+        return data.map{|i|i.slice(*selected_fields)}
       end
 
       # filter the list of items on the select option
@@ -314,9 +418,9 @@ module Aspera
         end
       end
 
-      # this method displays a table
-      # object_array: array of hash
-      # fields: list of column names
+      # displays a list of objects
+      # @param object_array  [Array] array of hash
+      # @param fields        [Array] list of column names
       def display_table(object_array, fields)
         Aspera.assert(!fields.nil?){'missing fields parameter'}
         filter_columns_on_select(object_array)
@@ -330,13 +434,6 @@ module Aspera
           display_message(:data, object_array.first[fields.first])
           return
         end
-        single_transposed = @options[:transpose_single] && object_array.length == 1
-        # Special case if only one row (it could be object_list or single_object)
-        if single_transposed
-          single = object_array.first
-          object_array = fields.map { |i| FIELD_VALUE_HEADINGS.zip([i, single[i]]).to_h }
-          fields = FIELD_VALUE_HEADINGS
-        end
         Log.log.debug{Log.dump(:object_array, object_array)}
         # convert data to string, and keep only display fields
         final_table_rows = object_array.map { |r| fields.map { |c| r[c].to_s } }
@@ -345,11 +442,12 @@ module Aspera
         # here : fields : list of column names
         case @options[:format]
         when :table
-          if @options[:multi_table] && !single_transposed
+          if @options[:multi_single].eql?(:yes) ||
+              (@options[:multi_single].eql?(:single) && final_table_rows.length.eql?(1))
             final_table_rows.each do |row|
               Log.log.debug{Log.dump(:row, row)}
               display_message(:data, Terminal::Table.new(
-                headings:  FIELD_VALUE_HEADINGS,
+                headings:  SINGLE_OBJECT_COLUMN_NAMES,
                 rows:      fields.zip(row),
                 style:     @options[:table_style]&.symbolize_keys))
             end
@@ -366,110 +464,6 @@ module Aspera
           raise "not expected: #{@options[:format]}"
         end
       end
-
-      # @return text suitable to display an image from url
-      def status_image(blob)
-        begin
-          raise URI::InvalidURIError, 'not uri' if !(blob =~ /\A#{URI::RFC2396_PARSER.make_regexp}\z/)
-          # it's a url
-          url = blob
-          unless Environment.instance.url_method.eql?(:text)
-            Environment.instance.open_uri(url)
-            return ''
-          end
-          # remote_image = Rest.new(base_url: url).read('')
-          # mime = remote_image[:http]['content-type']
-          # blob = remote_image[:http].body
-          # Log.log.warn("Image ? #{remote_image[:http]['content-type']}") unless mime.include?('image/')
-          blob = UriReader.read(url)
-        rescue URI::InvalidURIError
-          nil
-        end
-        # try base64
-        begin
-          blob = Base64.strict_decode64(blob)
-        rescue
-          nil
-        end
-        return Preview::Terminal.build(blob, **@options[:image].symbolize_keys)
-      end
-
-      # this method displays the results, especially the table format
-      # @param type [Symbol] type of data
-      # @param data [Object] data to display
-      # @param total [Integer] total number of items
-      # @param fields [Array<String>] list of fields to display
-      # @param name [String] name of the column to display
-      def display_results(type:, data: nil, total: nil, fields: nil, name: nil)
-        Log.log.debug{"display_results: #{type} class=#{data.class} data=#{data}"}
-        Aspera.assert_type(type, Symbol){'result must have type'}
-        Aspera.assert(!data.nil? || %i[empty nothing].include?(type)){'result must have data'}
-        display_item_count(data.length, total) unless total.nil?
-        SecretHider.deep_remove_secret(data) unless @options[:show_secrets] || @options[:display].eql?(:data)
-        case @options[:format]
-        when :text
-          display_message(:data, data.to_s)
-        when :nagios
-          Nagios.process(data)
-        when :ruby
-          display_message(:data, PP.pp(filter_list_on_fields(data), +''))
-        when :json
-          display_message(:data, JSON.generate(filter_list_on_fields(data)))
-        when :jsonpp
-          display_message(:data, JSON.pretty_generate(filter_list_on_fields(data)))
-        when :yaml
-          display_message(:data, YAML.dump(filter_list_on_fields(data)))
-        when :image
-          # assume it is an url
-          url = data
-          case type
-          when :single_object, :object_list
-            url = [url] if type.eql?(:single_object)
-            raise 'image display requires a single result' unless url.length == 1
-            fields = compute_fields(url, fields)
-            raise 'select a field to display' unless fields.length == 1
-            url = url.first
-            raise 'no such field' unless url.key?(fields.first)
-            url = url[fields.first]
-          end
-          raise "not url: #{url.class} #{url}" unless url.is_a?(String)
-          display_message(:data, status_image(url))
-        when :table, :csv
-          case type
-          when :config_over
-            display_table(Flattener.new(self).config_over(data), CONF_OVERVIEW_KEYS)
-          when :object_list, :single_object
-            obj_list = data
-            obj_list = [obj_list] if type.eql?(:single_object)
-            Aspera.assert_type(obj_list, Array)
-            Aspera.assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
-            # :object_list is an array of hash tables, where key=colum name
-            obj_list = obj_list.map{|obj|Flattener.new(self).flatten(obj)} if @options[:flat_hash]
-            display_table(obj_list, compute_fields(obj_list, fields))
-          when :value_list
-            # :value_list is a simple array of values, name of column provided in the :name
-            display_table(data.map { |i| { name => i } }, [name])
-          when :empty # no table
-            display_message(:info, special_format('empty'))
-            return
-          when :nothing # no result expected
-            Log.log.debug('no result expected')
-          when :status # no table
-            # :status displays a simple message
-            display_message(:info, data)
-          when :text # no table
-            # :status displays a simple message
-            display_message(:data, data)
-          when :other_struct # no table
-            # :other_struct is any other type of structure
-            display_message(:data, PP.pp(data, +''))
-          else
-            raise "unknown data type: #{type}"
-          end
-        else
-          raise "not expected: #{@options[:format]}"
-        end
-      end
     end
   end
 end

data/lib/aspera/cli/info.rb

@@ -12,7 +12,7 @@ module Aspera
       SRC_URL  = 'https://github.com/IBM/aspera-cli'
       # set this to warn in advance when minimum required ruby version will increase
       # see also required_ruby_version in gemspec file
-      RUBY_FUTURE_MINIMUM_VERSION = '3.0'
+      RUBY_FUTURE_MINIMUM_VERSION = '3.2'
     end
   end
 end

data/lib/aspera/cli/main.rb

@@ -63,6 +63,18 @@ module Aspera
         def result_image(blob, formatter:)
           return Main.result_status(formatter.status_image(blob))
         end
+
+        def result_single_object(data)
+          return {type: :single_object, data: data}
+        end
+
+        def result_object_list(data, fields: nil, total: nil)
+          return {type: :object_list, data: data, fields: fields, total: nil}
+        end
+
+        def result_value_list(data, name)
+          return {type: :value_list, data: data, name: name}
+        end
       end
 
       private

data/lib/aspera/cli/manager.rb

@@ -105,13 +105,14 @@ module Aspera
         # @param descr [String] description for help
         # @param to_check [Object] value to check
         # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
+        # @param check_array [bool] set to true if it is a list of values to check
         def validate_type(what, descr, to_check, type_list, check_array: false)
           return nil if type_list.nil?
           Aspera.assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
           value_list = check_array ? to_check : [to_check]
           value_list.each do |value|
             raise Cli::BadArgument,
-              "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless \
+              "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless
               type_list.any?{|t|value.is_a?(t)}
           end
         end
@@ -500,7 +501,6 @@ module Aspera
             self.class.multi_choice_assert(false, message, accept_list)
           end
         end
-        result = nil
         sensitive = option && @declared_options[descr.to_sym].is_a?(Hash) && @declared_options[descr.to_sym][:sensitive]
         default_prompt = "#{what}: #{descr}"
         # ask interactively

data/lib/aspera/cli/plugin.rb

@@ -220,12 +220,12 @@ module Aspera
         query = options.get_option(:query)
         # dup default, as it could be frozen
         query = default.dup if query.nil?
-        Log.log.debug{"Query=#{query}".bg_red}
+        Log.log.debug{"query_read_delete=#{query}".bg_red}
         begin
           # check it is suitable
           URI.encode_www_form(query) unless query.nil?
         rescue StandardError => e
-          raise Cli::BadArgument, "Query must be an extended value which can be encoded with URI.encode_www_form. Refer to manual. (#{e.message})"
+          raise Cli::BadArgument, "Query must be an extended value (Hash, Array) which can be encoded with URI.encode_www_form. Refer to manual. (#{e.message})"
         end
         return query
       end

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

@@ -66,14 +66,14 @@ module Aspera
             base_url = "#{base_url}.#{Api::AoC::SAAS_DOMAIN_PROD}" unless base_url.include?('.')
             # AoC is only https
             return nil unless base_url.start_with?('https://')
-            res_http = Rest.new(base_url: base_url, redirect_max: 10).call(operation: 'GET')[:http]
-            # Any AoC is on this domain
-            return nil unless res_http.uri.host.end_with?(Api::AoC::SAAS_DOMAIN_PROD)
-            Log.log.debug{"AoC Main page: #{res_http.body.include?(Api::AoC::PRODUCT_NAME)}"}
-            base_url = res_http.uri.to_s if res_http.uri.path.include?('/public')
+            res_http = Rest.new(base_url: base_url, redirect_max: 0).call(operation: 'GET', subpath: 'auth/ping', return_error: true)[:http]
+            return nil if res_http['Location'].nil?
+            redirect_uri = URI.parse(res_http['Location'])
+            od = Api::AoC.split_org_domain(URI.parse(base_url))
+            return nil unless redirect_uri.path.end_with?("oauth2/#{od[:organization]}/login")
             # either in standard domain, or product name in page
             return {
-              version: 'SaaS',
+              version: Api::AoC.saas_url?(base_url) ? 'SaaS' : 'Self-managed',
               url:     base_url
             }
           end
@@ -92,8 +92,6 @@ module Aspera
             # set vars to look like object
             options = object.options
             formatter = object.formatter
-            options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: true)
-            options.parse_options!
             instance_url = options.get_option(:url, mandatory: true)
             pub_link_info = Api::AoC.link_info(instance_url)
             if !pub_link_info[:token].nil?
@@ -108,6 +106,8 @@ module Aspera
                 test_args:    'organization'
               }
             end
+            options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: Api::AoC.saas_url?(instance_url))
+            options.parse_options!
             # make username mandatory for jwt, this triggers interactive input
             wiz_username = options.get_option(:username, mandatory: true)
             raise "Username shall be an email in AoC: #{wiz_username}" if !(wiz_username =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i)
@@ -133,15 +133,15 @@ module Aspera
                 formatter.display_status('Please login to your Aspera on Cloud instance.'.red)
                 formatter.display_status('Navigate to: 𓃑  → Admin → Integrations → API Clients')
                 formatter.display_status('Check or create in integration:')
-                formatter.display_status("- name: #{@info[:name]}")
+                formatter.display_status('- name: cli')
                 formatter.display_status("- redirect uri: #{REDIRECT_LOCALHOST}")
                 formatter.display_status('- origin: localhost')
                 formatter.display_status('Use the generated client id and secret in the following prompts.'.red)
               end
-              Environment.instance.open_uri("#{instance_url}/admin/api-clients")
+              Environment.instance.open_uri("#{instance_url}/admin/integrations/api-clients")
               options.get_option(:client_id, mandatory: true)
               options.get_option(:client_secret, mandatory: true)
-              use_browser_authentication = true
+              # use_browser_authentication = true
             end
             if use_browser_authentication
               formatter.display_status('We will use web authentication to bootstrap.')
@@ -282,13 +282,17 @@ module Aspera
         end
 
         # list all entities, given additional, default and user's queries
+        # @param resource_class_path path to query on API
+        # @param fields fields to display
+        # @param base_query a query applied always
+        # @param default_query default query unless overriden by user
         def result_list(resource_class_path, fields: nil, base_query: {}, default_query: {})
           Aspera.assert_type(base_query, Hash)
           Aspera.assert_type(default_query, Hash)
           user_query = query_read_delete(default: default_query)
           # caller may add specific modifications or checks
           yield(user_query) if block_given?
-          return {type: :object_list, fields: fields}.merge(api_read_all(resource_class_path, base_query.merge(user_query)))
+          return {type: :object_list, fields: fields}.merge(api_read_all(resource_class_path, base_query.merge(user_query).compact))
         end
 
         def resolve_dropbox_name_default_ws_id(query)
@@ -411,8 +415,8 @@ module Aspera
             when :operation then default_fields = nil
             when :short_link then default_fields.push('short_url', 'data.url_token_data.purpose')
             when :user then default_fields.push('name', 'email')
-            when :group_membership then default_fields.push(*%w[group_id member_type member_id])
-            when :workspace_membership then default_fields.push(*%w[workspace_id member_type member_id])
+            when :group_membership then default_fields.push('group_id', 'member_type', 'member_id')
+            when :workspace_membership then default_fields.push('workspace_id', 'member_type', 'member_id')
             end
             return result_list(resource_class_path, fields: default_fields, default_query: default_query)
           when :show
@@ -801,6 +805,12 @@ module Aspera
               else
                 ids_to_download = [ids_to_download] unless ids_to_download.is_a?(Array)
               end
+              file_list =
+                begin
+                  transfer.source_list.map{|i|{'source'=>i}}
+                rescue Cli::BadArgument
+                  [{'source' => '.'}]
+                end
               # list here
               result_transfer = []
               formatter.display_status("found #{ids_to_download.length} package(s).")
@@ -816,7 +826,7 @@ module Aspera
                   package_node_api.transfer_spec_gen4(
                     package_info['contents_file_id'],
                     Transfer::Spec::DIRECTION_RECEIVE,
-                    {'paths'=> [{'source' => '.'}]}),
+                    {'paths'=> file_list}),
                   rest_token: package_node_api)
                 result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
                 # update skip list only if all transfer sessions completed
@@ -837,14 +847,14 @@ module Aspera
                        resolve_dropbox_name_default_ws_id(query)
                      end
             when :delete
-              return do_bulk_operation(command: package_command, descr: 'identifier', values: identifier) do |id|
+              return do_bulk_operation(command: package_command, descr: 'identifier', values: instance_identifier) do |id|
                 Aspera.assert_values(id.class, [String, Integer]){'identifier'}
                 aoc_api.delete("packages/#{id}")
               end
             when *Node::NODE4_READ_ACTIONS
               package_id = instance_identifier
               package_info = aoc_api.read("packages/#{package_id}")
-              return execute_nodegen4_command(package_command, package_info['node_id'], file_id: package_info['file_id'], scope: Api::Node::SCOPE_USER)
+              return execute_nodegen4_command(package_command, package_info['node_id'], file_id: package_info['contents_file_id'], scope: Api::Node::SCOPE_USER)
             end
           when :files
             command_repo = options.get_next_command([:short_link].concat(NODE4_EXT_COMMANDS))
@@ -891,7 +901,7 @@ module Aspera
           when :automation
             Log.log.warn('BETA: work under progress')
             # automation api is not in the same place
-            automation_api = Rest.new(**aoc_api.params.merge(base_url: aoc_api.base_url.gsub('/api/', '/automation/')))
+            automation_api = Rest.new(**aoc_api.params, base_url: aoc_api.base_url.gsub('/api/', '/automation/'))
             command_automation = options.get_next_command(%i[workflows instances])
             case command_automation
             when :instances