aspera-cli 4.26.0 → 4.26.2

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

@@ -27,12 +27,14 @@ module Aspera
           client
           client_access_key
           client_registration_token
+          configuration_policy
           contact
           dropbox
           dropbox_membership
           group
           group_membership
           kms_profile
+          network_policy
           node
           operation
           organization
@@ -100,7 +102,7 @@ module Aspera
           # @param fld.               [Array]  List of fields of package
           def unique_folder(package_info, destination_folder, fld: nil, seq: false, opt: false)
             Aspera.assert_array_all(fld, String, type: BadArgument){'fld'}
-            Aspera.assert([1, 2].include?(fld.length)){'fld must have 1 or 2 elements'}
+            Aspera.assert_values(fld.length, [1, 2]){'fld length'}
             folder = Environment.instance.sanitized_filename(package_info[fld[0]])
             if seq
               folder = next_available_folder(folder, always: !opt)
@@ -178,7 +180,7 @@ module Aspera
           end
           myself = aoc_api.read('self')
           if auto_set_pub_key
-            Aspera.assert(myself['public_key'].empty?, type: Error){'Public key is already set in profile (use --override=yes)'} unless option_override
+            Aspera.assert(myself['public_key'].empty?, 'Public key is already set in profile (use --override=yes)', type: Error) unless option_override
             formatter.display_status('Updating profile with the public key.')
             aoc_api.update("users/#{myself['id']}", {'public_key' => pub_key_pem})
           end
@@ -289,7 +291,7 @@ module Aspera
         # @return identifier
         def get_resource_id_from_args(resource_class_path)
           return options.instance_identifier do |field, value|
-            Aspera.assert(field.eql?('name'), type: BadArgument){'only selection by name is supported'}
+            Aspera.assert_values(field, ['name'], type: BadArgument){'selector field'}
             aoc_api.lookup_with_q(resource_class_path, value: value)['id']
           end
         end
@@ -304,7 +306,7 @@ module Aspera
         # @param fields fields to display
         # @param base_query a query applied always
         # @param default_query default query unless overridden by user
-        # @param &block (Optional) calls block with user's or default query
+        # @yieldparam query [Hash] The user's or default query for modification
         def result_list(resource_class_path, fields: nil, base_query: {}, default_query: {})
           Aspera.assert_type(base_query, Hash)
           Aspera.assert_type(default_query, Hash)
@@ -312,7 +314,7 @@ module Aspera
           # caller may add specific modifications or checks to query
           yield(query) if block_given?
           result = aoc_api.read_with_paging(resource_class_path, base_query.merge(query).compact)
-          return Main.result_object_list(result[:items], fields: fields, total: result[:total])
+          return Result::ObjectList.new(result[:items], fields: fields, total: result[:total])
         end
 
         # Translates `dropbox_name` to `dropbox_id` and fills current workspace_id
@@ -389,7 +391,7 @@ module Aspera
               'destination_root_id' => server_apifid.file_id,
               'source_root_id'      => client_apifid.file_id
             }
-            return Main.result_transfer(transfer.start(server_apifid.node_api.transfer_spec_gen4(
+            return Runner.result_transfer(transfer.start(server_apifid.node_api.transfer_spec_gen4(
               server_apifid.file_id,
               client_direction,
               add_ts
@@ -402,34 +404,53 @@ module Aspera
         # Execute an action on admin resources
         # @param resource_type [Symbol] One of ADMIN_OBJECTS
         def execute_resource_action(resource_type)
+          # Set to `true` is resource creation requires a workspace id
           require_workspace_id = false
+          # Default fields to display
           list_default_fields = %w[id name]
+          # Default query for `list` action
           list_default_query = {}
+          # In result of create, what is the field that contains the id of the created resource
+          id_result = 'id'
           supported_operations = Operations::ALL
+          # API path
           resource_class_path = "#{resource_type}s"
+          resource_class_path = resource_class_path.gsub(/ys$/, 'ies')
+          # path in openapi where post is located to get creation schema
+          create_schema_path = resource_class_path
           case resource_type
           when :client
             supported_operations += %i[set_pub_key]
+            # schema_create_modify = Schema::Registry.req_body(Schema::Registry::AOC, "#{resource_class_path}.post")
           when :client_access_key
             resource_class_path = "admin/#{resource_type}s"
           when :client_registration_token
             resource_class_path = "admin/#{resource_type}s"
-            list_default_fields = %w[id value data.client_subject_scopes created_at]
+            list_default_fields = %w[id value data.client_subject_scopes data.name created_at]
+            id_result = 'token'
           when :contact
             list_default_fields = %w[source_type source_id name email]
             # list_default_query = {'include_only_user_personal_contacts' => true} if @scope == Api::AoC::Scope::USER
+          when :configuration_policy, :network_policy
+            list_default_fields = nil
           when :dropbox
             require_workspace_id = true
             resource_class_path = "#{resource_type}es"
+            create_schema_path = resource_class_path
+          when :group, :saml_configuration
+            create_schema_path = nil
           when :group_membership
             list_default_fields = %w[id group_id member_type member_id]
+            create_schema_path = nil
           when :kms_profile
             resource_class_path = "integrations/#{resource_type}s"
+            create_schema_path = nil
           when :node
             list_default_fields = %w[id name host access_key]
             supported_operations += %i[do bearer_token]
           when :operation
-            list_default_fields = nil
+            list_default_fields = %w[id type status created_at updated_at workspace_id user_id workspace_membership_id group_membership_id]
+            supported_operations = %i[list show modify]
           when :organization, :self
             supported_operations = Operations::SINGLETON
             resource_instance_path = resource_class_path = resource_type
@@ -443,6 +464,8 @@ module Aspera
           when :workspace_membership
             list_default_fields = %w[id workspace_id member_type member_id]
           end
+          # Default location of creation payload in schema
+          schema_create_modify = Schema::Registry.req_body(Schema::Registry::AOC, "#{create_schema_path}.post") if create_schema_path && supported_operations.include?(:create)
           command = options.get_next_command(supported_operations)
           # Require identifier for non global commands
           if (supported_operations != Operations::SINGLETON) && !Operations::GLOBAL.include?(command)
@@ -451,12 +474,10 @@ module Aspera
           end
           case command
           when :create
-            id_result = 'id'
-            id_result = 'token' if resource_class_path.eql?('admin/client_registration_tokens')
             # TODO: report inconsistency: creation url is !=, and does not return id.
             resource_class_path = 'admin/client_registration/token' if resource_class_path.eql?('admin/client_registration_tokens')
             workspace_id = aoc_api.workspace_info[:id] if require_workspace_id
-            return do_bulk_operation(command: command, descr: 'creation data', id_result: id_result) do |params|
+            return do_bulk_operation(command: command, descr: 'creation data', id_result: id_result, schema: schema_create_modify) do |params|
               params['workspace_id'] = workspace_id if require_workspace_id && workspace_id && !params.key?('workspace_id')
               aoc_api.create(resource_class_path, params)
             end
@@ -464,9 +485,9 @@ module Aspera
             return result_list(resource_class_path, fields: list_default_fields, default_query: list_default_query)
           when :show
             object = aoc_api.read(resource_instance_path, query_read_delete)
-            return Main.result_single_object(object, fields: Formatter.all_but('certificate'))
+            return Result::SingleObject.new(object, fields: Formatter.all_but('certificate'))
           when :modify
-            changes = options.get_next_argument('properties', validation: Hash)
+            changes = options.get_next_argument('properties', validation: Hash, schema: schema_create_modify)
             return do_bulk_operation(command: command, values: res_id) do |one_id|
               aoc_api.update("#{resource_class_path}/#{one_id}", changes)
               {'id' => one_id}
@@ -481,7 +502,7 @@ module Aspera
             the_private_key = options.get_next_argument('private_key PEM value', validation: String)
             the_public_key = OpenSSL::PKey::RSA.new(the_private_key).public_key.to_s
             aoc_api.update(resource_instance_path, {jwt_grant_enabled: true, public_key: the_public_key})
-            return Main.result_success
+            return Result::Success.new
           when :do
             command_repo = options.get_next_command(FILES_COMMANDS)
             return execute_nodegen4_command(command_repo, res_id, scope: Api::Node::Scope::ADMIN)
@@ -490,27 +511,33 @@ module Aspera
               node_id: res_id,
               scope:   options.get_next_argument('scope', default: Api::Node::Scope::ADMIN)
             )
-            return Main.result_text(node_api.oauth.authorization)
+            return Result::Text.new(node_api.oauth.authorization)
           when :dropbox
             command_shared = options.get_next_command(%i[list])
             case command_shared
             when :list
               query = options.get_option(:query) || {}
               res_data = aoc_api.read('dropboxes', query.merge({'workspace_id'=>res_id}))
-              return Main.result_object_list(res_data, fields: %w[id name description])
+              return Result::ObjectList.new(res_data, fields: %w[id name description])
             end
           when :shared_folder
             query = options.get_option(:query) || Api::AoC.workspace_access(res_id).merge({'admin' => true})
             shared_folders = aoc_api.read_with_paging("#{resource_instance_path}/permissions", query)[:items]
             # inside a workspace
-            command_shared = options.get_next_command(%i[list member])
+            command_shared = options.get_next_command(%i[list node member])
             case command_shared
             when :list
-              return Main.result_object_list(shared_folders, fields: %w[id node_name node_id file_id file.path tags.aspera.files.workspace.share_as])
+              return Result::ObjectList.new(shared_folders, fields: %w[id node_name node_id file_id file.path tags.aspera.files.workspace.share_as])
+            when :node
+              shared_folder_id = options.instance_identifier(description: 'Shared folder ID')
+              shared_folder = shared_folders.find{ |i| i['id'].eql?(shared_folder_id)}
+              Aspera.assert(shared_folder, 'shared folder not found')
+              command_repo = options.get_next_command(FILES_COMMANDS)
+              return execute_nodegen4_command(command_repo, shared_folder['node_id'], file_id: shared_folder['file_id'], scope: Api::Node::Scope::ADMIN)
             when :member
-              shared_folder_id = options.instance_identifier
+              shared_folder_id = options.instance_identifier(description: 'Shared folder ID')
               shared_folder = shared_folders.find{ |i| i['id'].eql?(shared_folder_id)}
-              Aspera.assert(shared_folder)
+              Aspera.assert(shared_folder, 'shared folder not found')
               command_shared_member = options.get_next_command(%i[list])
               case command_shared_member
               when :list
@@ -536,17 +563,17 @@ module Aspera
                   end
                 end
                 # TODO : read users and group name and add, if query "include_members"
-                return Main.result_object_list(result, fields: %w[access_type access_id access_level last_updated_at member.name member.email member.system_group_type member.system_group])
+                return Result::ObjectList.new(result, fields: %w[access_type access_id access_level last_updated_at member.name member.email member.system_group_type member.system_group])
               end
             end
           when :preferences, :notifications
             user_preferences_res = "#{resource_instance_path}/#{command.eql?(:preferences) ? 'user_interaction_preferences' : 'notification_preferences'}"
             case options.get_next_command(%i[show modify])
             when :show
-              return Main.result_single_object(aoc_api.read(user_preferences_res))
+              return Result::SingleObject.new(aoc_api.read(user_preferences_res))
             when :modify
               aoc_api.update(user_preferences_res, options.get_next_argument('properties', validation: Hash))
-              return Main.result_status('modified')
+              return Result::Status.new('modified')
             end
           else Aspera.error_unexpected_value(command)
           end
@@ -554,21 +581,22 @@ module Aspera
 
         def execute_application_action
           apps_info = aoc_api.read('admin/apps')
-          all_app_types = apps_info.map{ |i| i['app_type'].to_sym}
+          # List of allowed symbols for app type
+          all_app_syms = apps_info.map{ |i| i['app_type'].to_sym}
           command_apps = options.get_next_command(%i[types settings instance membership])
           case command_apps
           when :types
-            return Main.result_object_list(apps_info)
+            return Result::ObjectList.new(apps_info)
           when :settings
-            app_type = options.get_next_command(all_app_types)
+            app_type = options.get_next_command(all_app_syms)
             cmd_path = "/apps/#{app_type}/settings"
             command_app_settings = options.get_next_command(Operations::SINGLETON)
             case command_app_settings
             when :show
-              return Main.result_single_object(aoc_api.read(cmd_path))
+              return Result::SingleObject.new(aoc_api.read(cmd_path))
             when :modify
               aoc_api.update(cmd_path, options.get_next_argument('properties', validation: Hash))
-              return Main.result_status('modified')
+              return Result::Status.new('modified')
             end
           when :instance
             list_default_query = {workspace_id: aoc_api.workspace_info[:id]}
@@ -576,17 +604,17 @@ module Aspera
             command_app_instances = options.get_next_command(%i[list] + Operations::SINGLETON)
             resource_path = 'admin/apps_new'
             if Operations::SINGLETON.include?(command_app_instances)
-              app_type = options.get_next_command(all_app_types)
+              app_type = options.get_next_command(all_app_syms)
               resource_path = "#{resource_path}/#{app_type}/#{options.instance_identifier(description: "#{app_type} identifier")}"
             end
             case command_app_instances
             when :list
               return result_list(resource_path, fields: list_default_fields, default_query: list_default_query)
             when :show
-              return Main.result_single_object(aoc_api.read(resource_path, query_read_delete))
+              return Result::SingleObject.new(aoc_api.read(resource_path, query_read_delete))
             when :modify
               aoc_api.update(resource_path, options.get_next_argument('properties', validation: Hash))
-              return Main.result_status('modified')
+              return Result::Status.new('modified')
             end
           when :membership
             resource_path = 'apps/app_memberships'
@@ -596,13 +624,16 @@ module Aspera
             when :list
               return result_list(resource_path)
             when :delete
-              aoc_api.delete("#{resource_path}}")
-              return Main.result_status('deleted')
+              aoc_api.delete(resource_path)
+              return Result::Status.new('deleted')
             when :show
-              return Main.result_single_object(aoc_api.read(resource_path, query_read_delete))
+              return Result::SingleObject.new(aoc_api.read(resource_path, query_read_delete))
             when :create
-              aoc_api.update(resource_path, options.get_next_argument('membership properties', validation: Hash))
-              return Main.result_status('modified')
+              data = options.get_next_argument('membership properties', validation: Hash)
+              app_type = data.delete('app_type')
+              Aspera.assert_type(app_type, String){'app_type'}
+              Aspera.assert_values(app_type.to_sym, all_app_syms){'app_type'}
+              return Result::SingleObject.new(aoc_api.create("apps/#{app_type}/app_memberships", data))
             end
           end
         end
@@ -615,7 +646,7 @@ module Aspera
           command_admin = options.get_next_command(ADMIN_ACTIONS)
           case command_admin
           when :bearer_token
-            return Main.result_text(aoc_api.oauth.authorization)
+            return Result::Text.new(aoc_api.oauth.authorization)
           when *ADMIN_OBJECTS
             return execute_resource_action(command_admin)
           when :application
@@ -687,7 +718,7 @@ module Aspera
               GRAPHQL
               # cspell:enable
               result = bss_graphql.create(nil, {query: graphql_query, variables: {organization_id: org['id']}})['data']
-              return Main.result_single_object(result['aoc']['bssSubscription'])
+              return Result::SingleObject.new(result['aoc']['bssSubscription'])
             when :usage
               # cspell:disable
               graphql_query = <<-GRAPHQL
@@ -738,7 +769,7 @@ module Aspera
                   }
                 }
               )['data']
-              return Main.result_single_object(result['aoc'])
+              return Result::SingleObject.new(result['aoc'])
             end
           when :ats
             ats_api = Rest.new(**aoc_api.params.deep_merge({
@@ -756,7 +787,7 @@ module Aspera
             when :application_events
               event_type = command_analytics.to_s
               events = analytics_api.read("organizations/#{aoc_api.current_user_info['organization_id']}/#{event_type}")[event_type]
-              return Main.result_object_list(events)
+              return Result::ObjectList.new(events)
             when :transfers
               event_type = command_analytics.to_s
               event_resource_type = options.get_next_argument('resource', accept_list: %i[organizations users nodes])
@@ -795,7 +826,7 @@ module Aspera
                   config.send_email_template(values: {ev: tr_event})
                 end
               end
-              return Main.result_object_list(events)
+              return Result::ObjectList.new(events)
             when :files
               event_type = command_analytics.to_s
               event_resource_type = options.get_next_argument('resource', accept_list: %i[organizations users nodes])
@@ -811,7 +842,7 @@ module Aspera
               filter = query_read_delete(default: {})
               filter['limit'] ||= 100
               events = analytics_api.read("#{event_resource_type}/#{event_resource_id}/transfers/#{event_uuid}/#{event_type}", filter)[event_type]
-              return Main.result_object_list(events)
+              return Result::ObjectList.new(events)
             end
           when :usage_reports
             return result_list('usage_reports', base_query: workspace_id_hash)
@@ -825,7 +856,10 @@ module Aspera
         # - 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
+        # @param shared_data [Hash] Shared data for the short link
+        # @yieldparam operation [Symbol] Operation type (:create, :update, :delete)
+        # @yieldparam resource_id [String] Resource ID for permission management
+        # @yieldparam access_levels [Object] Access levels for permissions
         def short_link_command(**shared_data, &perm_block)
           link_type = options.get_next_argument('link access (public or private)', accept_list: %i[public private])
           if shared_data.keys.sort == %i[dropbox_id name]
@@ -873,7 +907,7 @@ module Aspera
             result_create_short_link = aoc_api.create('short_links', create_payload)
             # Creation: perm_block: permission on node
             yield(:create, result_create_short_link['resource_id'], access_levels) if block_given? && link_type.eql?(:public)
-            return Main.result_single_object(result_create_short_link)
+            return Result::SingleObject.new(result_create_short_link)
           when :delete, :list, :show, :modify
             workspace_id_hash(shared_data)
             query = if link_type.eql?(:private)
@@ -906,14 +940,14 @@ module Aspera
                 edit_access: true,
                 json_query:  shared_data.to_json
               })
-              return Main.result_status('deleted')
+              return Result::Status.new('deleted')
             when :list
-              return Main.result_object_list(short_list[:items], fields: Formatter.all_but('data'), total: short_list[:total])
+              return Result::ObjectList.new(short_list[:items], fields: Formatter.all_but('data'), total: short_list[:total])
             when :show
               one_id = options.instance_identifier(description: 'short link id')
               found = short_list[:items].find{ |item| item['id'].eql?(one_id)}
               raise BadIdentifier.new('Short link', one_id) if found.nil?
-              return Main.result_single_object(found, fields: Formatter.all_but('data'))
+              return Result::SingleObject.new(found, fields: Formatter.all_but('data'))
             when :modify
               one_id = options.instance_identifier(description: 'short link id')
               node_file = shared_data.slice(:node_id, :file_id)
@@ -941,7 +975,7 @@ module Aspera
               end
               modify_payload.deep_merge!(custom_data)
               aoc_api.update("short_links/#{one_id}", modify_payload)
-              return Main.result_status('modified')
+              return Result::Status.new('modified')
             end
           else Aspera.error_unexpected_value(command)
           end
@@ -985,46 +1019,48 @@ module Aspera
           when :reminder
             # send an email reminder with list of orgs
             user_email = options.get_option(:username, mandatory: true)
-            Rest.new(base_url: "#{Api::AoC.api_base_url}/#{Api::AoC::API_V1}").create('organization_reminders', {email: user_email})
-            return Main.result_status("List of organizations user is member of, has been sent by e-mail to #{user_email}")
+            no_auth_api = Api::AoC.new(url: options.get_option(:url), auth: :none)
+            no_auth_api.create('organization_reminders', {email: user_email})
+            return Result::Status.new("List of organizations user is member of, has been sent by e-mail to #{user_email}")
           when :servers
-            return Main.result_object_list(Rest.new(base_url: "#{Api::AoC.api_base_url}/#{Api::AoC::API_V1}").read('servers'))
+            no_auth_api = Api::AoC.new(url: options.get_option(:url), auth: :none)
+            return Result::ObjectList.new(no_auth_api.read('servers'))
           when :bearer_token
-            return Main.result_text(aoc_api.oauth.authorization)
+            return Result::Text.new(aoc_api.oauth.authorization)
           when :organization
-            return Main.result_single_object(aoc_api.read('organization'))
+            return Result::SingleObject.new(aoc_api.read('organization'))
           when :tier_restrictions
-            return Main.result_single_object(aoc_api.read('tier_restrictions'))
+            return Result::SingleObject.new(aoc_api.read('tier_restrictions'))
           when :user
-            user_cmd = options.get_next_command(%i[workspaces profile preferences notifications contacts])
+            user_cmd = options.get_next_command(%i[workspaces profile preferences notifications contacts settings])
             case user_cmd
             when :contacts
               return execute_resource_action(:contact)
-            # when :settings
-            # return Main.result_object_list(aoc_api.read('client_settings/'))
+            when :settings
+              return entity_execute(api: aoc_api, entity: 'client_settings')
             when :workspaces
               case options.get_next_command(%i[list current])
               when :list
                 return result_list('workspaces', fields: %w[id name])
               when :current
-                return Main.result_single_object(aoc_api.workspace_info)
+                return Result::SingleObject.new(aoc_api.workspace_info)
               end
             when :profile
               case options.get_next_command(%i[show modify])
               when :show
-                return Main.result_single_object(aoc_api.current_user_info(exception: true))
+                return Result::SingleObject.new(aoc_api.current_user_info(exception: true))
               when :modify
                 aoc_api.update("users/#{aoc_api.current_user_info(exception: true)['id']}", options.get_next_argument('properties', validation: Hash))
-                return Main.result_status('modified')
+                return Result::Status.new('modified')
               end
             when :preferences, :notifications
               user_preferences_res = "users/#{aoc_api.current_user_info(exception: true)['id']}/#{user_cmd.eql?(:preferences) ? 'user_interaction_preferences' : 'notification_preferences'}"
               case options.get_next_command(%i[show modify])
               when :show
-                return Main.result_single_object(aoc_api.read(user_preferences_res))
+                return Result::SingleObject.new(aoc_api.read(user_preferences_res))
               when :modify
                 aoc_api.update(user_preferences_res, options.get_next_argument('properties', validation: Hash))
-                return Main.result_status('modified')
+                return Result::Status.new('modified')
               end
             end
           when :packages
@@ -1037,13 +1073,13 @@ module Aspera
                 workspace_id_hash(default_query, string: true)
                 return result_list('dropbox_memberships', fields: %w[dropbox_id dropbox.name], default_query: default_query)
               when :show
-                return Main.result_single_object(aoc_api.read(get_resource_path_from_args('dropboxes')))
+                return Result::SingleObject.new(aoc_api.read(get_resource_path_from_args('dropboxes')))
               when :short_link
                 # TODO: check name
                 return short_link_command(dropbox_id: get_resource_id_from_args('dropboxes'), name: '')
               end
             when :send
-              package_data = value_create_modify(command: package_command)
+              package_data = value_create_modify(command: package_command, schema: Schema::Registry.req_body(Schema::Registry::AOC, 'packages.post'))
               new_user_option = options.get_option(:new_user_option)
               option_validate = options.get_option(:validate_metadata)
               # Works for both normal user auth and link auth.
@@ -1058,9 +1094,9 @@ module Aspera
               package_data['encryption_at_rest'] = true if transfer.user_transfer_spec['content_protection'].eql?('encrypt')
               # transfer may raise an error
               created_package = aoc_api.create_package_simple(package_data, option_validate, new_user_option)
-              Main.result_transfer(transfer.start(created_package[:spec], rest_token: created_package[:node]))
+              Runner.result_transfer(transfer.start(created_package[:spec], rest_token: created_package[:node]))
               # return all info on package (especially package id)
-              return Main.result_single_object(created_package[:info])
+              return Result::SingleObject.new(created_package[:info])
             when :receive
               ids_to_download = nil
               if !aoc_api.public_link.nil?
@@ -1074,10 +1110,10 @@ module Aspera
               case ids_to_download
               when SpecialValues::INIT
                 all_packages = list_all_packages_with_query[:items]
-                Aspera.assert(skip_ids_persistency){'INIT requires option once_only'}
+                Aspera.assert(skip_ids_persistency, 'INIT requires option once_only')
                 skip_ids_persistency.data.clear.concat(all_packages.map{ |e| e['id']})
                 skip_ids_persistency.save
-                return Main.result_status("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
+                return Result::Status.new("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
               when SpecialValues::ALL
                 all_packages = list_all_packages_with_query[:items]
                 # remove from list the ones already downloaded
@@ -1115,25 +1151,25 @@ module Aspera
                   rest_token: package_node_api
                 )
                 File.write(File.join(dest_folder, "#{package_id}.info.json"), package_info.to_json) if save_metadata
-                result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
+                result_transfer.push({'package' => package_id, Runner::STATUS_FIELD => statuses})
                 # update skip list only if all transfer sessions completed
                 if skip_ids_persistency && TransferAgent.session_status(statuses).eql?(:success)
                   skip_ids_persistency.data.push(package_id)
                   skip_ids_persistency.save
                 end
               end
-              return Main.result_transfer_multiple(result_transfer)
+              return Runner.result_transfer_multiple(result_transfer)
             when :show
               package_id = options.instance_identifier
               package_info = aoc_api.read("packages/#{package_id}")
-              return Main.result_single_object(package_info)
+              return Result::SingleObject.new(package_info)
             when :list
               result = list_all_packages_with_query
               skip_ids_persistency = package_persistency
               reject_packages_from_persistency(result[:items], skip_ids_persistency)
               display_fields = PACKAGE_LIST_DEFAULT_FIELDS
               display_fields += ['workspace_id'] if aoc_api.workspace_info[:id].nil?
-              return Main.result_object_list(result[:items], fields: display_fields, total: result[:total])
+              return Result::ObjectList.new(result[:items], fields: display_fields, total: result[:total])
             when :delete
               return do_bulk_operation(command: package_command, values: options.instance_identifier) do |package_id|
                 Aspera.assert_type(package_id, String, Integer){'identifier'}
@@ -1143,7 +1179,7 @@ module Aspera
               package_id = options.instance_identifier
               package_data = value_create_modify(command: package_command)
               aoc_api.update("packages/#{package_id}", package_data)
-              return Main.result_status('modified')
+              return Result::Status.new('modified')
             when *Node::NODE4_READ_ACTIONS
               package_id = options.instance_identifier
               package_info = aoc_api.read("packages/#{package_id}")
@@ -1220,7 +1256,7 @@ module Aspera
               when :launch
                 wf_id = options.instance_identifier
                 data = automation_api.create("workflows/#{wf_id}/launch", {})
-                return Main.result_single_object(data)
+                return Result::SingleObject.new(data)
               when :action
                 # TODO: not complete
                 wf_id = options.instance_identifier
@@ -1231,7 +1267,7 @@ module Aspera
                 action = automation_api.create('actions', {'step_id' => step['id'], 'type' => 'manual'})
                 automation_api.update("steps/#{step['id']}", {'action_order' => [action['id']]})
                 wf = automation_api.read("workflows/#{wf_id}")
-                return Main.result_single_object(wf)
+                return Result::SingleObject.new(wf)
               end
             end
           when :admin
@@ -1241,10 +1277,10 @@ module Aspera
             parameters = value_create_modify(command: command, default: {}).symbolize_keys
             uri = URI.parse(parameters.delete(:url){WebServerSimple::DEFAULT_URL})
             server = WebServerSimple.new(uri, **parameters.slice(*WebServerSimple::PARAMS))
-            Aspera.assert(parameters.except(*WebServerSimple::PARAMS).empty?)
+            Aspera.assert(parameters.except(*WebServerSimple::PARAMS).empty?){"unexpected parameters: #{parameters.except(*WebServerSimple::PARAMS).keys}"}
             server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.workspace_info[:id])
             server.start
-            return Main.result_status('Gateway terminated')
+            return Result::Status.new('Gateway terminated')
           else Aspera.error_unreachable_line
           end
           Aspera.error_unreachable_line