aspera-cli 4.16.0 → 4.17.0

data/lib/aspera/cli/plugin.rb

@@ -19,6 +19,7 @@ module Aspera
       MAX_PAGES = 'pmax'
       # special identifier format: look for this name to find where supported
       REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/.freeze
+      INIT_PARAMS = %i[options transfer config formatter persistency only_manual].freeze
 
       class << self
         def declare_generic_options(options)
@@ -33,12 +34,18 @@ module Aspera
         end
       end
 
-      def initialize(env)
-        assert_type(env, Hash)
-        @agents = env
+      attr_accessor(*INIT_PARAMS)
+
+      def initialize(options:, transfer:, config:, formatter:, persistency:, only_manual:)
+        @options = options
+        @transfer = transfer
+        @config = config
+        @formatter = formatter
+        @persistency = persistency
+        @only_manual = only_manual
         # check presence in descendant of mandatory method and constant
-        assert(respond_to?(:execute_action)){"Missing method 'execute_action' in #{self.class}"}
-        assert(self.class.constants.include?(:ACTIONS)){'ACTIONS shall be redefined by subclass'}
+        Aspera.assert(respond_to?(:execute_action)){"Missing method 'execute_action' in #{self.class}"}
+        Aspera.assert(self.class.constants.include?(:ACTIONS)){'ACTIONS shall be redefined by subclass'}
         # manual header for all plugins
         options.parser.separator('')
         options.parser.separator("COMMAND: #{self.class.name.split('::').last.downcase}")
@@ -46,6 +53,11 @@ module Aspera
         options.parser.separator('OPTIONS:')
       end
 
+      def init_params
+        # return a hash of instance variables
+        INIT_PARAMS.map{|p| [p, instance_variable_get("@#{p}".to_sym)]}.to_h
+      end
+
       # must be called AFTER the instance action, ... folder browse <call instance_identifier>
       # @param description [String] description of the identifier
       # @param as_option [Symbol] option name to use if identifier is an option
@@ -76,7 +88,7 @@ module Aspera
       # @param id_result [String] key in result hash to use as identifier
       # @param fields [Array] fields to display
       def do_bulk_operation(command:, descr:, values: Hash, id_result: 'id', fields: :default)
-        assert(block_given?){'missing block'}
+        Aspera.assert(block_given?){'missing block'}
         is_bulk = options.get_option(:bulk)
         case values
         when :identifier
@@ -238,23 +250,18 @@ module Aspera
         value = default if value.nil?
         unless type.nil?
           type = [type] unless type.is_a?(Array)
-          assert(type.all?(Class)){"check types must be a Class, not #{type.map(&:class).join(',')}"}
+          Aspera.assert(type.all?(Class)){"check types must be a Class, not #{type.map(&:class).join(',')}"}
           if bulk
-            assert_type(value, Array, exception_class: Cli::BadArgument)
+            Aspera.assert_type(value, Array, exception_class: Cli::BadArgument)
             value.each do |v|
-              assert_values(v.class, type, exception_class: Cli::BadArgument)
+              Aspera.assert_values(v.class, type, exception_class: Cli::BadArgument)
             end
           else
-            assert_values(value.class, type, exception_class: Cli::BadArgument)
+            Aspera.assert_values(value.class, type, exception_class: Cli::BadArgument)
           end
         end
         return value
       end
-
-      # shortcuts helpers for plugin environment
-      %i[options transfer config formatter persistency].each do |name|
-        define_method(name){@agents[name]}
-      end
     end # Plugin
   end # Cli
 end # Aspera

data/lib/aspera/cli/plugin_factory.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'singleton'
+module Aspera
+  module Cli
+    # option is retrieved from another object using accessor
+    class PluginFactory
+      include Singleton
+      attr_reader :lookup_folders, :plugins
+
+      RUBY_FILE_EXT = '.rb'
+      PLUGINS_MODULE = 'Plugins'
+      private_constant :RUBY_FILE_EXT
+      class << self
+        # instantiate a plugin
+        # plugins must be Capitalized
+        def plugin_class(plugin_name_sym)
+          # Module.nesting[2] is Cli::Plugins
+          return Object.const_get("#{Module.nesting[2]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
+        end
+      end
+
+      def initialize
+        @lookup_folders = []
+        @plugins = {}
+      end
+
+      def add_plugin_info(path)
+        raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
+        plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
+        req = path.sub(/#{RUBY_FILE_EXT}$/o, '')
+        if @plugins.key?(plugin_symbol)
+          Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
+          return
+        end
+        @plugins[plugin_symbol] = {source: path, require_stanza: req}
+      end
+
+      def add_lookup_folder(folder)
+        @lookup_folders.unshift(folder)
+      end
+
+      # find plugins in defined paths
+      def add_plugins_from_lookup_folders
+        @lookup_folders.each do |folder|
+          next unless File.directory?(folder)
+          # TODO: add gem root to load path ? and require short folder ?
+          # $LOAD_PATH.push(folder) if i[:add_path]
+          Dir.entries(folder).select{|file|file.end_with?(RUBY_FILE_EXT)}.each do |source|
+            add_plugin_info(File.join(folder, source))
+          end
+        end
+      end
+
+      def create(plugin_name_sym, **args)
+        # TODO: check that ancestor is Plugin?
+        self.class.plugin_class(plugin_name_sym).new(**args)
+      end
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'aspera/aoc'
+require 'aspera/api/aoc'
 
 module Aspera
   module Cli
     module Plugins
-      class Alee < Aspera::Cli::BasicAuthPlugin
+      class Alee < Cli::BasicAuthPlugin
         ACTIONS = %i[entitlement].freeze
 
         def execute_action
@@ -14,11 +14,11 @@ module Aspera
           when :entitlement
             entitlement_id = options.get_option(:username, mandatory: true)
             customer_id = options.get_option(:password, mandatory: true)
-            api_metering = AoC.metering_api(entitlement_id, customer_id)
+            api_metering = Api::AoC.metering_api(entitlement_id, customer_id)
             return {type: :single_object, data: api_metering.read('entitlement')[:data]}
           end
         end
-      end # Aspera
-    end # Plugins
-  end # Cli
-end # Aspera
+      end
+    end
+  end
+end

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

@@ -4,10 +4,10 @@ require 'aspera/cli/plugins/node'
 require 'aspera/cli/plugins/ats'
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/transfer_agent'
-require 'aspera/fasp/agent_node'
-require 'aspera/fasp/transfer_spec'
-require 'aspera/aoc'
-require 'aspera/node'
+require 'aspera/agent/node'
+require 'aspera/transfer/spec'
+require 'aspera/api/aoc'
+require 'aspera/api/node'
 require 'aspera/persistency_action_once'
 require 'aspera/id_generator'
 require 'aspera/assert'
@@ -17,11 +17,13 @@ require 'date'
 module Aspera
   module Cli
     module Plugins
-      class Aoc < Aspera::Cli::BasicAuthPlugin
+      class Aoc < Cli::BasicAuthPlugin
         AOC_PATH_API_CLIENTS = 'admin/api-clients'
         # default redirect for AoC web auth
-        DEFAULT_REDIRECT = 'http://localhost:12345'
-        private_constant :AOC_PATH_API_CLIENTS, :DEFAULT_REDIRECT
+        REDIRECT_LOCALHOST = 'http://localhost:12345'
+        # OAuth methods supported
+        STD_AUTH_TYPES = %i[web jwt].freeze
+        private_constant :AOC_PATH_API_CLIENTS, :REDIRECT_LOCALHOST, :STD_AUTH_TYPES
         class << self
           def application_name
             'Aspera on Cloud'
@@ -31,13 +33,13 @@ module Aspera
             # no protocol ?
             base_url = "https://#{base_url}" unless base_url.match?(%r{^[a-z]{1,6}://})
             # only org provided ?
-            base_url = "#{base_url}.#{Aspera::AoC::PROD_DOMAIN}" unless base_url.include?('.')
+            base_url = "#{base_url}.#{Api::AoC::PROD_DOMAIN}" unless base_url.include?('.')
             # AoC is only https
             return nil unless base_url.start_with?('https://')
-            result = Rest.new({base_url: base_url, redirect_max: 10}).read('')
+            result = Rest.new(base_url: base_url, redirect_max: 10).read('')
             # Any AoC is on this domain
-            return nil unless result[:http].uri.host.end_with?(Aspera::AoC::PROD_DOMAIN)
-            Log.log.debug{'AoC Main page: #{result[:http].body.include?(Aspera::AoC::PRODUCT_NAME)}'}
+            return nil unless result[:http].uri.host.end_with?(Api::AoC::PROD_DOMAIN)
+            Log.log.debug{"AoC Main page: #{result[:http].body.include?(Api::AoC::PRODUCT_NAME)}"}
             base_url = result[:http].uri.to_s if result[:http].uri.path.include?('/public')
             # either in standard domain, or product name in page
             return {
@@ -48,7 +50,7 @@ module Aspera
 
           def private_key_required?(url)
             # pub link do not need private key
-            return AoC.link_info(url)[:token].nil?
+            return Api::AoC.link_info(url)[:token].nil?
           end
 
           # @param [Hash] env : options, formatter
@@ -61,9 +63,9 @@ module Aspera
             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 = AoC.link_info(instance_url)
+            pub_link_info = Api::AoC.link_info(instance_url)
             if !pub_link_info[:token].nil?
-              pub_api = Rest.new({base_url: "https://#{URI.parse(pub_link_info[:url]).host}/api/v1"})
+              pub_api = Rest.new(base_url: "https://#{URI.parse(pub_link_info[:url]).host}/api/v1")
               pub_info = pub_api.read('env/url_token_check', {token: pub_link_info[:token]})[:data]
               preset_value = {
                 link: instance_url
@@ -100,7 +102,7 @@ module Aspera
                 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("- redirect uri: #{DEFAULT_REDIRECT}")
+                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
@@ -113,13 +115,14 @@ module Aspera
               formatter.display_status('We will use web authentication to bootstrap.')
               auto_set_pub_key = true
               auto_set_jwt = true
-              aoc_api.oauth.generic_parameters[:grant_method] = :web
-              aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
-              aoc_api.oauth.specific_parameters[:redirect_uri] = DEFAULT_REDIRECT
+              raise 'TODO'
+              # aoc_api.oauth.grant_method = :web
+              # aoc_api.oauth.scope = Api::AoC::SCOPE_FILES_ADMIN
+              # aoc_api.oauth.specific_parameters[:redirect_uri] = REDIRECT_LOCALHOST
             end
             myself = object.aoc_api.read('self')[:data]
             if auto_set_pub_key
-              assert(myself['public_key'].empty?, exception_class: Cli::Error){'Public key is already set in profile (use --override=yes)'} unless option_override
+              Aspera.assert(myself['public_key'].empty?, exception_class: Cli::Error){'Public key is already set in profile (use --override=yes)'} unless option_override
               formatter.display_status('Updating profile with the public key.')
               aoc_api.update("users/#{myself['id']}", {'public_key' => pub_key_pem})
             end
@@ -172,19 +175,19 @@ module Aspera
           'received'    => true,
           'completed'   => true}.freeze
 
-        def initialize(env)
-          super(env)
+        def initialize(**env)
+          super
           @cache_workspace_info = nil
           @cache_home_node_file = nil
           @cache_api_aoc = nil
-          options.declare(:auth, 'OAuth type of authentication', values: Oauth::STD_AUTH_TYPES, default: :jwt)
+          options.declare(:auth, 'OAuth type of authentication', values: STD_AUTH_TYPES, default: :jwt)
           options.declare(:client_id, 'OAuth API client identifier')
           options.declare(:client_secret, 'OAuth API client secret')
-          options.declare(:scope, 'OAuth scope for AoC API calls', default: AoC::SCOPE_FILES_USER)
+          options.declare(:scope, 'OAuth scope for AoC API calls', default: Api::AoC::SCOPE_FILES_USER)
           options.declare(:redirect_uri, 'OAuth API client redirect URI')
           options.declare(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
           options.declare(:passphrase, 'RSA private key passphrase')
-          options.declare(:workspace, 'Name of workspace', types: [String, NilClass], default: Aspera::AoC::DEFAULT_WORKSPACE)
+          options.declare(:workspace, 'Name of workspace', types: [String, NilClass], default: Api::AoC::DEFAULT_WORKSPACE)
           options.declare(:new_user_option, 'New user creation option for unknown package recipients')
           options.declare(:validate_metadata, 'Validate shared inbox metadata', values: :bool, default: true)
           options.parse_options!
@@ -195,9 +198,9 @@ module Aspera
         OPTIONS_NEW = %i[url auth client_id client_secret scope redirect_uri private_key passphrase username password workspace].freeze
 
         def api_from_options(new_base_path)
-          create_values = {subpath: new_base_path, secret_finder: @agents[:config]}
+          create_values = {subpath: new_base_path, secret_finder: config}
           # create an API object with the same options, but with a different subpath
-          return Aspera::AoC.new(**OPTIONS_NEW.each_with_object(create_values) { |i, m|m[i] = options.get_option(i) unless options.get_option(i).nil?})
+          return Api::AoC.new(**OPTIONS_NEW.each_with_object(create_values) { |i, m|m[i] = options.get_option(i) unless options.get_option(i).nil?})
         rescue ArgumentError => e
           if (m = e.message.match(/missing keyword: :(.*)$/))
             raise Cli::Error, "Missing option: #{m[1]}"
@@ -206,7 +209,14 @@ module Aspera
         end
 
         def aoc_api
-          @cache_api_aoc = api_from_options(AoC::API_V1) if @cache_api_aoc.nil?
+          if @cache_api_aoc.nil?
+            @cache_api_aoc = api_from_options(Api::AoC::API_V1)
+            organization = @cache_api_aoc.read('organization')[:data]
+            if organization['http_gateway_enabled'] && organization['http_gateway_server_url']
+              transfer.httpgw_url_cb = lambda { organization['http_gateway_server_url'] }
+              # @cache_api_aoc.current_user_info['connect_disabled']
+            end
+          end
           return @cache_api_aoc
         end
 
@@ -214,7 +224,7 @@ module Aspera
         # @return identifier
         def get_resource_id_from_args(resource_class_path)
           return instance_identifier do |field, value|
-            assert(field.eql?('name'), exception_class: Cli::BadArgument){'only selection by name is supported'}
+            Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only selection by name is supported'}
             aoc_api.lookup_by_name(resource_class_path, value)['id']
           end
         end
@@ -226,8 +236,8 @@ module Aspera
         # Call block with same query using paging and response information
         # @return [Hash] {data: , total: }
         def api_call_paging(base_query={})
-          assert_type(base_query, Hash){'query'}
-          assert(block_given?)
+          Aspera.assert_type(base_query, Hash){'query'}
+          Aspera.assert(block_given?)
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
           base_query['per_page'] = 1000 unless base_query.key?('per_page')
           max_items = base_query.delete(MAX_ITEMS)
@@ -265,8 +275,8 @@ module Aspera
 
         # list all entities, given additional, default and user's queries
         def result_list(resource_class_path, fields: nil, base_query: {}, default_query: {})
-          assert_type(base_query, Hash)
-          assert_type(default_query, Hash)
+          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?
@@ -277,11 +287,13 @@ module Aspera
           if query.key?('dropbox_name')
             # convenience: specify name instead of id
             raise 'not both dropbox_name and dropbox_id' if query.key?('dropbox_id')
+            # TODO : craft a query that looks for dropbox only in current workspace
             query['dropbox_id'] = aoc_api.lookup_by_name('dropboxes', query['dropbox_name'])['id']
             query.delete('dropbox_name')
           end
           query['workspace_id'] ||= aoc_api.context[:workspace_id] unless aoc_api.context[:workspace_id].eql?(:undefined)
-          query['exclude_dropbox_packages'] = true unless query.key?('dropbox_id')
+          # by default show dropbox packages only for dropboxes
+          query['exclude_dropbox_packages'] = !query.key?('dropbox_id') unless query.key?('exclude_dropbox_packages')
         end
 
         NODE4_EXT_COMMANDS = %i[transfer].concat(Node::COMMANDS_GEN4).freeze
@@ -297,7 +309,7 @@ module Aspera
             scope:          scope
           )
           file_id = top_node_api.read("access_keys/#{top_node_api.app_info[:node_info]['access_key']}")[:data]['root_file_id'] if file_id.nil?
-          node_plugin = Node.new(@agents, api: top_node_api)
+          node_plugin = Node.new(**init_params, api: top_node_api)
           case command_repo
           when *Node::COMMANDS_GEN4
             return node_plugin.execute_command_gen4(command_repo, file_id)
@@ -309,20 +321,20 @@ module Aspera
             source_folder = options.get_next_argument('folder of source files', type: String)
             case push_pull
             when :push
-              client_direction = Fasp::TransferSpec::DIRECTION_SEND
+              client_direction = Transfer::Spec::DIRECTION_SEND
               client_folder = source_folder
               server_folder = transfer.destination_folder(client_direction)
             when :pull
-              client_direction = Fasp::TransferSpec::DIRECTION_RECEIVE
+              client_direction = Transfer::Spec::DIRECTION_RECEIVE
               client_folder = transfer.destination_folder(client_direction)
               server_folder = source_folder
-            else error_unreachable_line
+            else Aspera.error_unreachable_line
             end
             client_apfid = top_node_api.resolve_api_fid(file_id, client_folder)
             server_apfid = top_node_api.resolve_api_fid(file_id, server_folder)
             # force node as transfer agent
-            @agents[:transfer].agent_instance = Fasp::AgentNode.new({
-              url:      client_apfid[:api].params[:base_url],
+            transfer.agent_instance = Agent::Node.new({
+              url:      client_apfid[:api].base_url,
               username: client_apfid[:api].app_info[:node_info]['access_key'],
               password: client_apfid[:api].oauth_token,
               root_id:  client_apfid[:file_id]
@@ -337,14 +349,14 @@ module Aspera
               server_apfid[:file_id],
               client_direction,
               add_ts)))
-          else error_unreachable_line
+          else Aspera.error_unreachable_line
           end # command_repo
-          error_unreachable_line
+          Aspera.error_unreachable_line
         end # execute_nodegen4_command
 
         def execute_admin_action
           # upgrade scope to admin
-          aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
+          aoc_api.oauth.scope = Api::AoC::SCOPE_FILES_ADMIN
           command_admin = options.get_next_command(%i[ats resource usage_reports analytics subscription auth_providers])
           case command_admin
           when :auth_providers
@@ -411,15 +423,15 @@ module Aspera
             result = bss_api.create('graphql', {'variables' => {'organization_id' => org['id']}, 'query' => graphql_query})[:data]['data']
             return {type: :single_object, data: result['aoc']['bssSubscription']}
           when :ats
-            ats_api = Rest.new(aoc_api.params.deep_merge({
-              base_url: "#{aoc_api.params[:base_url]}/admin/ats/pub/v1",
-              auth:     {scope: AoC::SCOPE_FILES_ADMIN_USER}
+            ats_api = Rest.new(**aoc_api.params.deep_merge({
+              base_url: "#{aoc_api.base_url}/admin/ats/pub/v1",
+              auth:     {scope: Api::AoC::SCOPE_FILES_ADMIN_USER}
             }))
-            return Ats.new(@agents).execute_action_gen(ats_api)
+            return Ats.new(**init_params).execute_action_gen(ats_api)
           when :analytics
-            analytics_api = Rest.new(aoc_api.params.deep_merge({
-              base_url: "#{aoc_api.params[:base_url].gsub('/api/v1', '')}/analytics/v2",
-              auth:     {scope: AoC::SCOPE_FILES_ADMIN_USER}
+            analytics_api = Rest.new(**aoc_api.params.deep_merge({
+              base_url: "#{aoc_api.base_url.gsub('/api/v1', '')}/analytics/v2",
+              auth:     {scope: Api::AoC::SCOPE_FILES_ADMIN_USER}
             }))
             command_analytics = options.get_next_command(%i[application_events transfers])
             case command_analytics
@@ -435,14 +447,14 @@ module Aspera
                 when :organizations then aoc_api.current_user_info['organization_id']
                 when :users then aoc_api.current_user_info['id']
                 when :nodes then aoc_api.current_user_info['id'] # TODO: consistent ? # rubocop:disable Lint/DuplicateBranch
-                else error_unreachable_line
+                else Aspera.error_unreachable_line
                 end
               filter = options.get_option(:query) || {}
               filter['limit'] ||= 100
               if options.get_option(:once_only, mandatory: true)
                 saved_date = []
                 start_date_persistency = PersistencyActionOnce.new(
-                  manager: @agents[:persistency],
+                  manager: persistency,
                   data: saved_date,
                   id: IdGenerator.from_list([
                     'aoc_ana_date',
@@ -549,7 +561,7 @@ module Aspera
               # init context
               aoc_api.context(:files)
               return execute_nodegen4_command(command_repo, res_id)
-            else error_unexpected_value(command)
+            else Aspera.error_unexpected_value(command)
             end
           when :usage_reports
             return result_list('usage_reports', base_query: {workspace_id: aoc_api.context(:files)[:workspace_id]})
@@ -574,10 +586,10 @@ module Aspera
           when :reminder
             # send an email reminder with list of orgs
             user_email = options.get_option(:username, mandatory: true)
-            Rest.new(base_url: "#{AoC.api_base_url}/#{AoC::API_V1}").create('organization_reminders', {email: user_email})[:data]
+            Rest.new(base_url: "#{Api::AoC.api_base_url}/#{Api::AoC::API_V1}").create('organization_reminders', {email: user_email})[:data]
             return Main.result_status("List of organizations user is member of, has been sent by e-mail to #{user_email}")
           when :servers
-            return {type: :object_list, data: Rest.new(base_url: "#{AoC.api_base_url}/#{AoC::API_V1}").read('servers')[:data]}
+            return {type: :object_list, data: Rest.new(base_url: "#{Api::AoC.api_base_url}/#{Api::AoC::API_V1}").read('servers')[:data]}
           when :bearer_token
             return {type: :text, data: aoc_api.oauth_token}
           when :organization
@@ -659,7 +671,7 @@ module Aspera
               if options.get_option(:once_only, mandatory: true)
                 # TODO: add query info to id
                 skip_ids_persistency = PersistencyActionOnce.new(
-                  manager: @agents[:persistency],
+                  manager: persistency,
                   data: skip_ids_data,
                   id: IdGenerator.from_list(
                     ['aoc_recv',
@@ -670,12 +682,12 @@ module Aspera
               case ids_to_download
               when ExtendedValue::ALL, ExtendedValue::INIT
                 query = query_read_delete(default: PACKAGE_RECEIVED_BASE_QUERY)
-                assert_type(query, Hash){'query'}
+                Aspera.assert_type(query, Hash){'query'}
                 resolve_dropbox_name_default_ws_id(query)
                 # remove from list the ones already downloaded
                 all_ids = api_read_all('packages', query)[:data].map{|e|e['id']}
                 if ids_to_download.eql?(ExtendedValue::INIT)
-                  assert(skip_ids_persistency){'Only with option once_only'}
+                  Aspera.assert(skip_ids_persistency){'Only with option once_only'}
                   skip_ids_persistency.data.clear.concat(all_ids)
                   skip_ids_persistency.save
                   return Main.result_status("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
@@ -690,7 +702,7 @@ module Aspera
               formatter.display_status("found #{ids_to_download.length} package(s).")
               ids_to_download.each do |package_id|
                 package_info = aoc_api.read("packages/#{package_id}")[:data]
-                formatter.display_status("downloading package: #{package_info['name']}")
+                formatter.display_status("downloading package: [#{package_info['id']}] #{package_info['name']}")
                 package_node_api = aoc_api.node_api_from(
                   node_id: package_info['node_id'],
                   workspace_id: aoc_api.context[:workspace_id],
@@ -699,7 +711,7 @@ module Aspera
                 statuses = transfer.start(
                   package_node_api.transfer_spec_gen4(
                     package_info['contents_file_id'],
-                    Fasp::TransferSpec::DIRECTION_RECEIVE,
+                    Transfer::Spec::DIRECTION_RECEIVE,
                     {'paths'=> [{'source' => '.'}]}),
                   rest_token: package_node_api)
                 result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
@@ -722,19 +734,19 @@ module Aspera
                      end
             when :delete
               return do_bulk_operation(command: package_command, descr: 'identifier', values: identifier) do |id|
-                assert_values(id.class, [String, Integer]){'identifier'}
+                Aspera.assert_values(id.class, [String, Integer]){'identifier'}
                 aoc_api.delete("packages/#{id}")[:data]
               end
             when *Node::NODE4_READ_ACTIONS
               package_id = instance_identifier
               package_info = aoc_api.read("packages/#{package_id}")[:data]
-              return execute_nodegen4_command(package_command, package_info['node_id'], file_id: package_info['file_id'], scope: Aspera::Node::SCOPE_USER)
+              return execute_nodegen4_command(package_command, package_info['node_id'], file_id: package_info['file_id'], scope: Api::Node::SCOPE_USER)
             end
           when :files
             command_repo = options.get_next_command([:short_link].concat(NODE4_EXT_COMMANDS))
             case command_repo
             when *NODE4_EXT_COMMANDS
-              return execute_nodegen4_command(command_repo, aoc_api.context[:home_node_id], file_id: aoc_api.context[:home_file_id], scope: Aspera::Node::SCOPE_USER)
+              return execute_nodegen4_command(command_repo, aoc_api.context[:home_node_id], file_id: aoc_api.context[:home_file_id], scope: Api::Node::SCOPE_USER)
             when :short_link
               link_type = options.get_next_argument('link type', expected: %i[public private])
               short_link_command = options.get_next_command(%i[create delete list])
@@ -752,7 +764,7 @@ module Aspera
               purpose = case link_type
               when :public  then 'token_auth_redirection'
               when :private then 'shared_folder_auth_link'
-              else error_unreachable_line
+              else Aspera.error_unreachable_line
               end
               case short_link_command
               when :delete
@@ -812,7 +824,7 @@ module Aspera
                 if link_type.eql?(:public)
                   # TODO: merge with node permissions ?
                   # TODO: access level as arg
-                  access_levels = Aspera::Node::ACCESS_LEVELS # ['delete','list','mkdir','preview','read','rename','write']
+                  access_levels = Api::Node::ACCESS_LEVELS # ['delete','list','mkdir','preview','read','rename','write']
                   folder_name = File.basename(folder_dest)
                   perm_data = {
                     'file_id'       => shared_apfid[:file_id],
@@ -841,9 +853,7 @@ module Aspera
           when :automation
             Log.log.warn('BETA: work under progress')
             # automation api is not in the same place
-            automation_rest_params = aoc_api.params.clone
-            automation_rest_params[:base_url].gsub!('/api/', '/automation/')
-            automation_api = Rest.new(automation_rest_params)
+            automation_api = Rest.new(**aoc_api.params.merge(base_url: aoc_api.base_url.gsub('/api/', '/automation/')))
             command_automation = options.get_next_command(%i[workflows instances])
             case command_automation
             when :instances
@@ -878,19 +888,15 @@ module Aspera
             uri = URI.parse(url)
             server = WebServerSimple.new(uri)
             server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.context(:files)[:workspace_id])
-            trap('INT') { server.shutdown }
-            formatter.display_status("Faspex 4 gateway listening on #{url}")
-            Log.log.info("Listening on #{url}")
-            # this is blocking until server exits
             server.start
             return Main.result_status('Gateway terminated')
-          else error_unreachable_line
+          else Aspera.error_unreachable_line
           end # action
-          error_unreachable_line
+          Aspera.error_unreachable_line
         end
 
         private :execute_admin_action
-      end # AoC
-    end # Plugins
-  end # Cli
-end # Aspera
+      end
+    end
+  end
+end