aspera-cli 4.12.0 → 4.14.0

data/bin/ascli

@@ -1,8 +1,9 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby -EUTF-8:UTF-8
 # frozen_string_literal: true
 
 require 'rubygems'
 require 'securerandom'
+# compute gem root based on  this script location
 GEM_ROOT = File.realpath(File.join(File.dirname(File.realpath(__FILE__)), '..'))
 # coverage for tests
 if ENV.key?('ENABLE_COVERAGE')
@@ -20,10 +21,9 @@ if ENV.key?('ENABLE_COVERAGE')
   end
   SimpleCov.start
 end
+# if in development, add path to gem
 $LOAD_PATH.unshift(File.join(GEM_ROOT, 'lib'))
 require 'aspera/cli/main'
 require 'aspera/environment'
-Encoding.default_internal = Encoding::UTF_8
-Encoding.default_external = Encoding::UTF_8
 Aspera::Environment.fix_home
 Aspera::Cli::Main.new(ARGV).process_command_line

data/examples/dascli

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # set env var image to specify another docker image
-: "${image:=martinlaurent/ascli}"
+: "${image:=docker.io/martinlaurent/ascli}"
 # set env var version to specify another image version (default: latest version)
 : "${version:=latest}"
 # set env var imgtag to specify a specific image/version

data/examples/rubyc

@@ -0,0 +1,24 @@
+#!/bin/bash
+# https://github.com/you54f/ruby-packer
+# https://github.com/YOU54F/ruby-packer/releases
+set -e
+FOLDER="$(dirname $0)/../tmp"
+RUBYC="$FOLDER/rubyc"
+if test ! -e "$RUBYC"; then
+    mkdir -p "$FOLDER"
+    case $(uname -sm|tr ' ' -) in
+        Darwin-arm64)
+            curl -L https://github.com/YOU54F/ruby-packer/releases/download/rel-20230812/rubyc-Darwin-arm64.tar.gz | tar -xz -C "$FOLDER"
+            mv "$FOLDER/rubyc-Darwin-arm64" "$RUBYC"
+            ;;
+        Linux-x86_64)
+            curl -L https://github.com/YOU54F/ruby-packer/releases/download/rel-20230812/rubyc-Linux-x86_64.tar.gz | tar -xz -C "$FOLDER"
+            mv "$FOLDER/rubyc-Linux-x86_64" "$RUBYC"
+            ;;
+        *)
+            echo "This architecture is not supported." >&2
+            exit 1
+            ;;
+    esac
+fi
+exec "$RUBYC" "$@"

data/lib/aspera/aoc.rb

@@ -42,6 +42,9 @@ module Aspera
     OAUTH_API_SUBPATH = 'api/v1/oauth2'
     # minimum fields for user info if retrieval fails
     USER_INFO_FIELDS_MIN = %w[name email id default_workspace_id organization_id].freeze
+    # types of events for shared folder creation
+    # Node events: permission.created permission.modified permission.deleted
+    PERMISSIONS_CREATED = ['permission.created'].freeze
 
     private_constant :MAX_REDIRECT,
       :GLOBAL_CLIENT_APPS,
@@ -50,7 +53,8 @@ module Aspera
       :PUBLIC_LINK_PATHS,
       :JWT_AUDIENCE,
       :OAUTH_API_SUBPATH,
-      :USER_INFO_FIELDS_MIN
+      :USER_INFO_FIELDS_MIN,
+      :PERMISSIONS_CREATED
 
     # various API scopes supported
     SCOPE_FILES_SELF = 'self'
@@ -63,8 +67,6 @@ module Aspera
     FILES_APP = 'files'
     PACKAGES_APP = 'packages'
     API_V1 = 'api/v1'
-    # error message when entity not found
-    ENTITY_NOT_FOUND = 'No such'
 
     # class static methods
     class << self
@@ -252,25 +254,30 @@ module Aspera
       return @cache_user_info
     end
 
-    # @returns [Aspera::Node] a node API for access key
     # @param node_id [String] identifier of node in AoC
+    # @param workspace_id [String] workspace identifier
+    # @param workspace_name [String] workspace name
     # @param scope e.g. SCOPE_NODE_USER, or nil (requires secret)
-    def node_api_from(node_id: nil, workspace_info: nil, package_info: nil, scope: nil)
-      if node_id.nil?
-        if package_info.nil?
-          raise 'INTERNAL ERROR: either node_id or package_info is required'
-        else
-          node_id = package_info['node_id']
-        end
+    # @param package_info [Hash] created package information
+    # @returns [Aspera::Node] a node API for access key
+    def node_api_from(node_id:, workspace_id: nil, workspace_name: nil, scope: SCOPE_NODE_USER, package_info: nil)
+      raise 'invalid type for node_id' unless node_id.is_a?(String)
+      node_info = read("nodes/#{node_id}")[:data]
+      if workspace_name.nil? && !workspace_id.nil?
+        workspace_name = read("workspaces/#{workspace_id}")[:data]['name']
       end
-      if workspace_info.nil?
-        if package_info.nil?
-          raise 'INTERNAL ERROR: either workspace_info or package_info is required'
-        else
-          workspace_info = package_info['workspace_id']
-        end
+      app_info = {
+        api:            self, # for callback
+        app:            package_info.nil? ? FILES_APP : PACKAGES_APP,
+        node_info:      node_info,
+        workspace_id:   workspace_id,
+        workspace_name: workspace_name
+      }
+      if PACKAGES_APP.eql?(app_info[:app])
+        raise 'package info required' if package_info.nil?
+        app_info[:package_id] = package_info['id']
+        app_info[:package_name] = package_info['name']
       end
-      node_info = read("nodes/#{node_id}")[:data]
       node_rest_params = {base_url: node_info['url']}
       # if secret is available
       if scope.nil?
@@ -286,38 +293,9 @@ module Aspera
         # special header required for bearer token only
         node_rest_params[:headers] = {Aspera::Node::HEADER_X_ASPERA_ACCESS_KEY => node_info['access_key']}
       end
-      app_info = {
-        node_info:      node_info,
-        workspace_info: workspace_info,
-        app:            package_info.nil? ? FILES_APP : PACKAGES_APP,
-        api:            self # for callback
-      }
-      app_info[:package_info] = package_info unless package_info.nil?
       return Node.new(params: node_rest_params, app_info: app_info)
     end
 
-    # Query entity type by name and returns the id if a single entry only
-    # @param entity_type path of entity in API
-    # @param entity_name name of searched entity
-    # @param options additional search options
-    def lookup_entity_by_name(entity_type, entity_name, options={})
-      # returns entities whose name contains value (case insensitive)
-      matching_items = read(entity_type, options.merge({'q' => CGI.escape(entity_name)}))[:data]
-      case matching_items.length
-      when 1 then return matching_items.first
-      when 0 then raise %Q{#{ENTITY_NOT_FOUND} #{entity_type}: "#{entity_name}"}
-      else
-        # multiple case insensitive partial matches, try case insensitive full match
-        # (anyway AoC does not allow creation of 2 entities with same case insensitive name)
-        name_matches = matching_items.select{|i|i['name'].casecmp?(entity_name)}
-        case name_matches.length
-        when 1 then return name_matches.first
-        when 0 then raise %Q(#{entity_type}: multiple case insensitive partial match for: "#{entity_name}": #{matching_items.map{|i|i['name']}} but no case insensitive full match. Please be more specific or give exact name.) # rubocop:disable Layout/LineLength
-        else raise "Two entities cannot have the same case insensitive name: #{name_matches.map{|i|i['name']}}"
-        end
-      end
-    end
-
     # Check metadata: remove when validation is done server side
     def validate_metadata(pkg_data)
       # validate only for shared inboxes
@@ -369,7 +347,7 @@ module Aspera
           # email: user, else dropbox
           entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
           begin
-            full_recipient_info = lookup_entity_by_name(entity_type, short_recipient_info, {'current_workspace_id' => ws_id})
+            full_recipient_info = lookup_by_name(entity_type, short_recipient_info, {'current_workspace_id' => ws_id})
           rescue RuntimeError => e
             raise e unless e.message.start_with?(ENTITY_NOT_FOUND)
             # dropboxes cannot be created on the fly
@@ -433,7 +411,10 @@ module Aspera
       #  create a new package container
       created_package = create('packages', package_data)[:data]
 
-      package_node_api = node_api_from(package_info: created_package, scope: AoC::SCOPE_NODE_USER)
+      package_node_api = node_api_from(
+        node_id: created_package['node_id'],
+        workspace_id: created_package['workspace_id'],
+        package_info: created_package)
 
       # tell AoC what to expect in package: 1 transfer (can also be done after transfer)
       # TODO: if multi session was used we should probably tell
@@ -454,15 +435,14 @@ module Aspera
       transfer_type = Fasp::TransferSpec.action(transfer_spec)
       # Analytics tags
       ################
-      ws_info = app_info[:workspace_info]
       transfer_spec.deep_merge!({
         'tags' => {
-          'aspera' => {
-            'usage_id' => "aspera.files.workspace.#{ws_info['id']}", # activity tracking
+          Fasp::TransferSpec::TAG_RESERVED => {
+            'usage_id' => "aspera.files.workspace.#{app_info[:workspace_id]}", # activity tracking
             'files'    => {
               'files_transfer_action' => "#{transfer_type}_#{app_info[:app].gsub(/s$/, '')}",
-              'workspace_name'        => ws_info['name'], # activity tracking
-              'workspace_id'          => ws_info['id']
+              'workspace_name'        => app_info[:workspace_name], # activity tracking
+              'workspace_id'          => app_info[:workspace_id]
             }
           }
         }
@@ -477,37 +457,40 @@ module Aspera
       ##################
       case app_info[:app]
       when FILES_APP
-        file_id = transfer_spec['tags']['aspera']['node']['file_id']
-        transfer_spec.deep_merge!({'tags' => {'aspera' => {'files' => {'parentCwd' => "#{app_info[:node_info]['id']}:#{file_id}"}}}}) \
+        file_id = transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED]['node']['file_id']
+        transfer_spec.deep_merge!({'tags' => {Fasp::TransferSpec::TAG_RESERVED => {'files' => {'parentCwd' => "#{app_info[:node_info]['id']}:#{file_id}"}}}}) \
           unless transfer_spec.key?('remote_access_key')
       when PACKAGES_APP
         transfer_spec.deep_merge!({
           'tags' => {
-            'aspera' => {
+            Fasp::TransferSpec::TAG_RESERVED => {
               'files' => {
-                'package_id'        => app_info[:package_info]['id'],
-                'package_name'      => app_info[:package_info]['name'],
+                'package_id'        => app_info[:package_id],
+                'package_name'      => app_info[:package_name],
                 'package_operation' => transfer_type
               }}}})
       end
-      transfer_spec['tags']['aspera']['files']['node_id'] = app_info[:node_info]['id']
-      transfer_spec['tags']['aspera']['app'] = app_info[:app]
+      transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED]['files']['node_id'] = app_info[:node_info]['id']
+      transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED]['app'] = app_info[:app]
     end
 
     ID_AK_ADMIN = 'ASPERA_ACCESS_KEY_ADMIN'
     # Callback from Plugins::Node
-    def permissions_create_params(create_param:, app_info:)
+    # add application specific tags to permissions creation
+    # @param create_param [Hash] parameters for creating permissions
+    # @param app_info [Hash] application information
+    def permissions_set_create_params(create_param:, app_info:)
       # workspace shared folder:
-      # access_id = "#{ID_AK_ADMIN}_WS_#{ app_info[:workspace_info]['id']}"
+      # access_id = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
       default_params = {
         # 'access_type'   => 'user', # mandatory: user or group
         # 'access_id'     => access_id, # id of user or group
         'tags' => {
-          'aspera' => {
+          Fasp::TransferSpec::TAG_RESERVED => {
             'files' => {
               'workspace' => {
-                'id'                => app_info[:workspace_info]['id'],
-                'workspace_name'    => app_info[:workspace_info]['name'],
+                'id'                => app_info[:workspace_id],
+                'workspace_name'    => app_info[:workspace_name],
                 'user_name'         => current_user_info['name'],
                 'shared_by_user_id' => current_user_info['id'],
                 'shared_by_name'    => current_user_info['name'],
@@ -517,28 +500,34 @@ module Aspera
                 'node'              => app_info[:node_info]['name']}}}}}
       create_param.deep_merge!(default_params)
       if create_param.key?('with')
-        contact_info = lookup_entity_by_name(
+        contact_info = lookup_by_name(
           'contacts',
           create_param['with'],
-          {'current_workspace_id' => app_info[:workspace_info]['id'], 'context' => 'share_folder'})
+          {'current_workspace_id' => app_info[:workspace_id], 'context' => 'share_folder'})
         create_param.delete('with')
         create_param['access_type'] = contact_info['source_type']
         create_param['access_id'] = contact_info['source_id']
-        create_param['tags']['aspera']['files']['workspace']['shared_with_name'] = contact_info['email']
+        create_param['tags'][Fasp::TransferSpec::TAG_RESERVED]['files']['workspace']['shared_with_name'] = contact_info['email']
       end
       # optional
       app_info[:opt_link_name] = create_param.delete('link_name')
     end
 
     # Callback from Plugins::Node
-    def permissions_create_event(created_data:, app_info:)
+    # send shared folder event to AoC
+    # @param created_data [Hash] response from permission creation
+    # @param app_info [Hash] hash with app info
+    # @param types [Array] event types
+    def permissions_send_event(created_data:, app_info:, types: PERMISSIONS_CREATED)
+      raise "INTERNAL: (assert) Invalid event types: #{types}" unless types.is_a?(Array) && !types.empty?
       event_creation = {
-        'types'        => ['permission.created'],
+        'types'        => types,
         'node_id'      => app_info[:node_info]['id'],
-        'workspace_id' => app_info[:workspace_info]['id'],
-        'data'         => created_data # Response from previous step
+        'workspace_id' => app_info[:workspace_id],
+        'data'         => created_data
       }
-      # (optional). The name of the folder to be displayed to the destination user. Use it if its value is different from the "share_as" field.
+      # (optional). The name of the folder to be displayed to the destination user.
+      # Use it if its value is different from the "share_as" field.
       event_creation['link_name'] = app_info[:opt_link_name] unless app_info[:opt_link_name].nil?
       create('events', event_creation)
     end

data/lib/aspera/ascmd.rb

@@ -24,10 +24,11 @@ module Aspera
       # concatenate arguments, enclose in double quotes, protect backslash and double quotes, add "as_" command and as_exit
       stdin_input = (args || []).map{|v| '"' + v.gsub(/["\\]/n) {|s| '\\' + s } + '"'}.unshift('as_' + action_sym.to_s).join(' ') + "\nas_exit\n"
       # execute, get binary output
-      bytebuffer = @command_executor.execute('ascmd', stdin_input).unpack('C*')
+      byte_buffer = @command_executor.execute('ascmd', stdin_input).unpack('C*')
+      raise 'ERROR: empty answer from server' if byte_buffer.empty?
       # get hash or table result
-      result = self.class.parse(bytebuffer, :result)
-      raise 'ERROR: unparsed bytes remaining' unless bytebuffer.empty?
+      result = self.class.parse(byte_buffer, :result)
+      raise 'ERROR: unparsed bytes remaining' unless byte_buffer.empty?
       # get and delete info,always present in results
       system_info = result[:info]
       result.delete(:info)
@@ -126,6 +127,7 @@ module Aspera
           byte_array = buffer.shift(num_bytes)
           byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
+          result.force_encoding('UTF-8') if type_name.eql?(:zstr)
           Log.log.debug{"#{'   .' * indent_level}-> base:#{byte_array} -> #{result}"}
           result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -9,9 +9,9 @@ module Aspera
     class BasicAuthPlugin < Aspera::Cli::Plugin
       class << self
         def register_options(env)
-          env[:options].add_opt_simple(:url, 'URL of application, e.g. https://org.asperafiles.com')
-          env[:options].add_opt_simple(:username, 'username to log in')
-          env[:options].add_opt_simple(:password, "user's password")
+          env[:options].declare(:url, 'URL of application, e.g. https://org.asperafiles.com')
+          env[:options].declare(:username, 'Username to log in')
+          env[:options].declare(:password, "User's password")
           env[:options].parse_options!
         end
       end
@@ -23,14 +23,14 @@ module Aspera
 
       # returns a Rest object with basic auth
       def basic_auth_params(subpath=nil)
-        api_url = options.get_option(:url, is_type: :mandatory)
+        api_url = options.get_option(:url, mandatory: true)
         api_url = api_url + '/' + subpath unless subpath.nil?
         return {
           base_url: api_url,
           auth:     {
             type:     :basic,
-            username: options.get_option(:username, is_type: :mandatory),
-            password: options.get_option(:password, is_type: :mandatory)
+            username: options.get_option(:username, mandatory: true),
+            password: options.get_option(:password, mandatory: true)
           }}
       end
 

data/lib/aspera/cli/extended_value.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'aspera/cli/plugins/config'
 require 'aspera/uri_reader'
 require 'aspera/environment'
 require 'json'
@@ -39,38 +38,33 @@ module Aspera
 
       def initialize
         @handlers = {
-          decoder: {
-            base64: lambda{|v|Base64.decode64(v)},
-            json:   lambda{|v|JSON.parse(v)},
-            zlib:   lambda{|v|Zlib::Inflate.inflate(v)},
-            ruby:   lambda{|v|Environment.secure_eval(v)},
-            csvt:   lambda{|v|ExtendedValue.decode_csvt(v)},
-            lines:  lambda{|v|v.split("\n")},
-            list:   lambda{|v|v[1..-1].split(v[0])}
-          },
-          reader:  {
-            val:   lambda{|v|v},
-            file:  lambda{|v|File.read(File.expand_path(v))},
-            path:  lambda{|v|File.expand_path(v)},
-            env:   lambda{|v|ENV[v]},
-            uri:   lambda{|v|UriReader.read(v)},
-            stdin: lambda{|v|raise 'no value allowed for stdin' unless v.empty?; $stdin.read} # rubocop:disable Style/Semicolon
-          }
+          base64: lambda{|v|Base64.decode64(v)},
+          csvt:   lambda{|v|ExtendedValue.decode_csvt(v)},
+          env:    lambda{|v|ENV[v]},
+          file:   lambda{|v|File.read(File.expand_path(v))},
+          json:   lambda{|v|JSON.parse(v)},
+          lines:  lambda{|v|v.split("\n")},
+          list:   lambda{|v|v[1..-1].split(v[0])},
+          path:   lambda{|v|File.expand_path(v)},
+          ruby:   lambda{|v|Environment.secure_eval(v)},
+          secret: lambda{|v|raise 'no value allowed for secret' unless v.empty?; $stdin.getpass('secret> ')}, # rubocop:disable Style/Semicolon
+          stdin:  lambda{|v|raise 'no value allowed for stdin' unless v.empty?; $stdin.read}, # rubocop:disable Style/Semicolon
+          uri:    lambda{|v|UriReader.read(v)},
+          val:    lambda{|v|v},
+          zlib:   lambda{|v|Zlib::Inflate.inflate(v)}
           # other handlers can be set using set_handler, e.g. preset is reader in config plugin
         }
       end
 
       public
 
-      def modifiers; @handlers.keys.map{|i|@handlers[i].keys}.flatten.map(&:to_s); end
+      def modifiers; @handlers.keys; end
 
-      # add a new :reader or :decoder
-      # decoder can be chained, reader is last one on right
-      def set_handler(name, type, method)
-        Log.log.debug{"setting #{type} handler for #{name}"}
+      # add a new handler
+      def set_handler(name, method)
+        Log.log.debug{"setting handler for #{name}"}
         raise 'name must be Symbol' unless name.is_a?(Symbol)
-        raise "type #{type} must be one of #{@handlers.keys}" unless @handlers.key?(type)
-        @handlers[type][name] = method
+        @handlers[name] = method
       end
 
       # parse an option value if it is a String using supported extended value modifiers
@@ -78,20 +72,13 @@ module Aspera
       def evaluate(value)
         return value if !value.is_a?(String)
         # first determine decoders, in reversed order
-        decoders_reversed = []
-        while (m = value.match(/^@([^:]+):(.*)/)) && @handlers[:decoder].include?(m[1].to_sym)
-          decoders_reversed.unshift(m[1].to_sym)
+        handlers_reversed = []
+        while (m = value.match(/^@([^:]+):(.*)/)) && @handlers.include?(m[1].to_sym)
+          handlers_reversed.unshift(m[1].to_sym)
           value = m[2]
         end
-        # then read value
-        @handlers[:reader].each do |reader, method|
-          if (m = value.match(/^@#{reader}:(.*)/))
-            value = method.call(m[1])
-            break
-          end
-        end
-        decoders_reversed.each do |decoder|
-          value = @handlers[:decoder][decoder].call(value)
+        handlers_reversed.each do |handler|
+          value = @handlers[handler].call(value)
         end
         return value
       end # parse

data/lib/aspera/cli/formatter.rb

@@ -18,9 +18,10 @@ module Aspera
       # user output levels
       DISPLAY_LEVELS = %i[info data error].freeze
       CONF_OVERVIEW_KEYS = %w[config parameter value].freeze
+      KEY_VALUE = %w[key value].freeze
 
       private_constant :FIELDS_ALL, :FIELDS_DEFAULT, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR,
-        :CONF_OVERVIEW_KEYS
+        :CONF_OVERVIEW_KEYS, :KEY_VALUE
 
       class << self
         # special for Aspera on Cloud display node
@@ -81,22 +82,14 @@ module Aspera
         @option_flat_hash = true
         @option_transpose_single = true
         @option_show_secrets = false
-        opt_mgr.set_obj_attr(:format, self, :option_format)
-        opt_mgr.set_obj_attr(:display, self, :option_display)
-        opt_mgr.set_obj_attr(:fields, self, :option_fields)
-        opt_mgr.set_obj_attr(:select, self, :option_select)
-        opt_mgr.set_obj_attr(:table_style, self, :option_table_style)
-        opt_mgr.set_obj_attr(:flat_hash, self, :option_flat_hash)
-        opt_mgr.set_obj_attr(:transpose_single, self, :option_transpose_single)
-        opt_mgr.set_obj_attr(:show_secrets, self, :option_show_secrets)
-        opt_mgr.add_opt_list(:format, DISPLAY_FORMATS, 'output format')
-        opt_mgr.add_opt_list(:display, DISPLAY_LEVELS, 'output only some information')
-        opt_mgr.add_opt_simple(:fields, "comma separated list of fields, or #{FIELDS_ALL}, or #{FIELDS_DEFAULT}")
-        opt_mgr.add_opt_simple(:select, 'select only some items in lists, extended value: hash (column, value)')
-        opt_mgr.add_opt_simple(:table_style, 'table display style')
-        opt_mgr.add_opt_boolean(:flat_hash, 'display hash values as additional keys')
-        opt_mgr.add_opt_boolean(:transpose_single, 'single object fields output vertically')
-        opt_mgr.add_opt_boolean(:show_secrets, 'show secrets on command output')
+        opt_mgr.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_format})
+        opt_mgr.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_display})
+        opt_mgr.declare(:fields, "Comma separated list of fields, or #{FIELDS_ALL}, or #{FIELDS_DEFAULT}", handler: {o: self, m: :option_fields})
+        opt_mgr.declare(:select, 'Select only some items in lists: column, value', types: Hash, handler: {o: self, m: :option_select})
+        opt_mgr.declare(:table_style, 'Table display style', handler: {o: self, m: :option_table_style})
+        opt_mgr.declare(:flat_hash, 'Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_flat_hash})
+        opt_mgr.declare(:transpose_single, 'Single object fields output vertically', values: :bool, handler: {o: self, m: :option_transpose_single})
+        opt_mgr.declare(:show_secrets, 'Show secrets on command output', values: :bool, handler: {o: self, m: :option_show_secrets})
       end
 
       # main output method
@@ -116,6 +109,12 @@ module Aspera
         display_message(:info, status)
       end
 
+      def display_item_count(number, total)
+        count_msg = "Items: #{number}/#{total}"
+        count_msg = count_msg.bg_red unless number.to_i.eql?(total.to_i)
+        display_status(count_msg)
+      end
+
       def result_default_fields(results, table_rows_hash_val)
         unless results[:fields].nil?
           raise "internal error: [fields] must be Array, not #{results[:fields].class}" unless results[:fields].is_a?(Array)
@@ -189,7 +188,7 @@ module Aspera
           when :single_object # goes to table display
             # :single_object is a simple hash table  (can be nested)
             raise "internal error: expecting Hash: got #{res_data.class}: #{res_data}" unless res_data.is_a?(Hash)
-            final_table_columns = results[:columns] || %w[key value]
+            final_table_columns = results[:columns] || KEY_VALUE
             if @option_flat_hash
               res_data = self.class.flattened_object(res_data, expand_last: results[:option_expand_last])
               self.class.flatten_name_value_list(res_data)
@@ -201,6 +200,11 @@ module Aspera
               else user_asked_fields_list_str.split(',')
               end
             table_rows_hash_val = asked_fields.map { |i| { final_table_columns.first => i, final_table_columns.last => res_data[i] } }
+            # if only one row, and columns are key/value, then display the value only
+            if table_rows_hash_val.length == 1 && final_table_columns.eql?(KEY_VALUE)
+              display_message(:data, res_data.values.first)
+              return
+            end
           when :value_list # goes to table display
             # :value_list is a simple array of values, name of column provided in the :name
             final_table_columns = [results[:name]]
@@ -229,7 +233,7 @@ module Aspera
           # here we expect: table_rows_hash_val and final_table_columns
           raise 'no field specified' if final_table_columns.nil?
           if table_rows_hash_val.empty?
-            display_message(:info, 'empty'.gray) unless @option_format.eql?(:csv)
+            display_message(:info, 'empty'.gray) if @option_format.eql?(:table)
             return
           end
           # convert to string with special function. here table_rows_hash_val is an array of hash
@@ -246,12 +250,6 @@ module Aspera
           when :table
             style = @option_table_style.chars
             # display the table !
-            # display_message(:data,Text::Table.new(
-            # head:  final_table_columns,
-            # rows:  final_table_rows,
-            # horizontal_boundary:    style[0],
-            # vertical_boundary:      style[1],
-            # boundary_intersection:  style[2]))
             display_message(:data, Terminal::Table.new(
               headings:  final_table_columns,
               rows:      final_table_rows,

data/lib/aspera/cli/info.rb

@@ -10,9 +10,7 @@ module Aspera
     GEM_URL  = "https://rubygems.org/gems/#{GEM_NAME}"
     SRC_URL  = 'https://github.com/IBM/aspera-cli'
     # set this to warn in advance when minimum required ruby version will increase
-    # for example currently minimum version is 2.4 in gemspec, but future minimum will be different
-    # set to current minimum if there is no deprecation
-    # the actual current minimum required version is in gemspec at required_ruby_version
-    RUBY_FUTURE_MINIMUM_VERSION = '2.7'
+    # see also required_ruby_version in gemspec file
+    RUBY_FUTURE_MINIMUM_VERSION = '3.0'
   end
 end