aspera-cli 4.19.0 → 4.21.1

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

@@ -63,17 +63,17 @@ 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}.#{Api::SAAS_DOMAIN_PROD}" unless base_url.include?('.')
+            base_url = "#{base_url}.#{Api::AoC::SAAS_DOMAIN_PROD}" unless base_url.include?('.')
             # AoC is only https
             return nil unless base_url.start_with?('https://')
-            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?(Api::SAAS_DOMAIN_PROD)
-            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')
+            res_http = Rest.new(base_url: base_url, redirect_max: 0).call(operation: 'GET', subpath: 'auth/ping', return_error: true)[:http]
+            return nil if res_http['Location'].nil?
+            redirect_uri = URI.parse(res_http['Location'])
+            od = Api::AoC.split_org_domain(URI.parse(base_url))
+            return nil unless redirect_uri.path.end_with?("oauth2/#{od[:organization]}/login")
             # either in standard domain, or product name in page
             return {
-              version: 'SaaS',
+              version: Api::AoC.saas_url?(base_url) ? 'SaaS' : 'Self-managed',
               url:     base_url
             }
           end
@@ -92,13 +92,11 @@ module Aspera
             # set vars to look like object
             options = object.options
             formatter = object.formatter
-            options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: true)
-            options.parse_options!
             instance_url = options.get_option(:url, mandatory: true)
             pub_link_info = Api::AoC.link_info(instance_url)
             if !pub_link_info[:token].nil?
               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]
+              pub_info = pub_api.read('env/url_token_check', {token: pub_link_info[:token]})
               preset_value = {
                 link: instance_url
               }
@@ -108,6 +106,8 @@ module Aspera
                 test_args:    'organization'
               }
             end
+            options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: Api::AoC.saas_url?(instance_url))
+            options.parse_options!
             # make username mandatory for jwt, this triggers interactive input
             wiz_username = options.get_option(:username, mandatory: true)
             raise "Username shall be an email in AoC: #{wiz_username}" if !(wiz_username =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i)
@@ -133,15 +133,15 @@ module Aspera
                 formatter.display_status('Please login to your Aspera on Cloud instance.'.red)
                 formatter.display_status('Navigate to: 𓃑  → Admin → Integrations → API Clients')
                 formatter.display_status('Check or create in integration:')
-                formatter.display_status("- name: #{@info[:name]}")
+                formatter.display_status('- name: cli')
                 formatter.display_status("- redirect uri: #{REDIRECT_LOCALHOST}")
                 formatter.display_status('- origin: localhost')
                 formatter.display_status('Use the generated client id and secret in the following prompts.'.red)
               end
-              Environment.instance.open_uri("#{instance_url}/admin/api-clients")
+              Environment.instance.open_uri("#{instance_url}/admin/integrations/api-clients")
               options.get_option(:client_id, mandatory: true)
               options.get_option(:client_secret, mandatory: true)
-              use_browser_authentication = true
+              # use_browser_authentication = true
             end
             if use_browser_authentication
               formatter.display_status('We will use web authentication to bootstrap.')
@@ -152,7 +152,7 @@ module Aspera
               # 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]
+            myself = object.aoc_api.read('self')
             if auto_set_pub_key
               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.')
@@ -214,7 +214,7 @@ module Aspera
         def aoc_api
           if @cache_api_aoc.nil?
             @cache_api_aoc = api_from_options(Api::AoC::API_V1)
-            organization = @cache_api_aoc.read('organization')[:data]
+            organization = @cache_api_aoc.read('organization')
             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']
@@ -223,7 +223,8 @@ module Aspera
           return @cache_api_aoc
         end
 
-        # get identifier or name from command line
+        # Get resource identifier from command line, either directly or from name.
+        # @param resource_class_path url path for resource
         # @return identifier
         def get_resource_id_from_args(resource_class_path)
           return instance_identifier do |field, value|
@@ -232,11 +233,13 @@ module Aspera
           end
         end
 
+        # Get resource path from command line
         def get_resource_path_from_args(resource_class_path)
           return "#{resource_class_path}/#{get_resource_id_from_args(resource_class_path)}"
         end
 
         # Call block with same query using paging and response information
+        # block must return a hash with :data and :http keys
         # @return [Hash] {data: , total: }
         def api_call_paging(base_query={})
           Aspera.assert_type(base_query, Hash){'query'}
@@ -254,6 +257,8 @@ module Aspera
             query = base_query.clone
             query['page'] = current_page
             result = yield(query)
+            Aspera.assert(result[:data])
+            Aspera.assert(result[:http])
             total_count = result[:http]['X-Total-Count']
             page_count += 1
             current_page += 1
@@ -272,18 +277,22 @@ module Aspera
         # @return [Hash] {data: , total: }
         def api_read_all(resource_class_path, base_query={})
           return api_call_paging(base_query) do |query|
-            aoc_api.read(resource_class_path, query)
+            aoc_api.call(operation: 'GET', subpath: resource_class_path, headers: {'Accept' => 'application/json'}, query: query)
           end
         end
 
         # list all entities, given additional, default and user's queries
+        # @param resource_class_path path to query on API
+        # @param fields fields to display
+        # @param base_query a query applied always
+        # @param default_query default query unless overriden by user
         def result_list(resource_class_path, fields: nil, base_query: {}, default_query: {})
           Aspera.assert_type(base_query, Hash)
           Aspera.assert_type(default_query, Hash)
           user_query = query_read_delete(default: default_query)
           # caller may add specific modifications or checks
           yield(user_query) if block_given?
-          return {type: :object_list, fields: fields}.merge(api_read_all(resource_class_path, base_query.merge(user_query)))
+          return {type: :object_list, fields: fields}.merge(api_read_all(resource_class_path, base_query.merge(user_query).compact))
         end
 
         def resolve_dropbox_name_default_ws_id(query)
@@ -294,7 +303,7 @@ module Aspera
             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['workspace_id'] ||= aoc_api.workspace[:id] unless aoc_api.workspace[:id].eql?(:undefined)
           # by default show dropbox packages only for dropboxes
           query['exclude_dropbox_packages'] = !query.key?('dropbox_id') unless query.key?('exclude_dropbox_packages')
         end
@@ -307,11 +316,11 @@ module Aspera
         def execute_nodegen4_command(command_repo, node_id, file_id: nil, scope: nil)
           top_node_api = aoc_api.node_api_from(
             node_id:        node_id,
-            workspace_id:   aoc_api.context[:workspace_id],
-            workspace_name: aoc_api.context[:workspace_name],
+            workspace_id:   aoc_api.workspace[:id],
+            workspace_name: aoc_api.workspace[:name],
             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?
+          file_id = top_node_api.read("access_keys/#{top_node_api.app_info[:node_info]['access_key']}")['root_file_id'] if file_id.nil?
           node_plugin = Node.new(**init_params, api: top_node_api)
           case command_repo
           when *Node::COMMANDS_GEN4
@@ -321,7 +330,7 @@ module Aspera
             # server side is transfer server
             # in same workspace
             push_pull = options.get_next_argument('direction', accept_list: %i[push pull])
-            source_folder = options.get_next_argument('folder of source files', validation: String)
+            source_folder = options.get_next_argument('folder or source files', validation: String)
             case push_pull
             when :push
               client_direction = Transfer::Spec::DIRECTION_SEND
@@ -390,7 +399,7 @@ module Aspera
             # 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')
             return do_bulk_operation(command: command, descr: 'creation data', id_result: id_result) do |params|
-              aoc_api.create(resource_class_path, params)[:data]
+              aoc_api.create(resource_class_path, params)
             end
           when :list
             default_fields = ['id']
@@ -406,12 +415,12 @@ module Aspera
             when :operation then default_fields = nil
             when :short_link then default_fields.push('short_url', 'data.url_token_data.purpose')
             when :user then default_fields.push('name', 'email')
-            when :group_membership then default_fields.push(*%w[group_id member_type member_id])
-            when :workspace_membership then default_fields.push(*%w[workspace_id member_type member_id])
+            when :group_membership then default_fields.push('group_id', 'member_type', 'member_id')
+            when :workspace_membership then default_fields.push('workspace_id', 'member_type', 'member_id')
             end
             return result_list(resource_class_path, fields: default_fields, default_query: default_query)
           when :show
-            object = aoc_api.read(resource_instance_path)[:data]
+            object = aoc_api.read(resource_instance_path)
             # default: show all, but certificate
             fields = object.keys.reject{|k|k.eql?('certificate')}
             return { type: :single_object, data: object, fields: fields }
@@ -435,7 +444,7 @@ module Aspera
           when :do
             command_repo = options.get_next_command(NODE4_EXT_COMMANDS)
             # init context
-            aoc_api.context(:files)
+            aoc_api.context = :files
             return execute_nodegen4_command(command_repo, res_id)
           else Aspera.error_unexpected_value(command)
           end
@@ -462,59 +471,61 @@ module Aspera
               raise 'not implemented'
             end
           when :subscription
-            org = aoc_api.read('organization')[:data]
-            bss_api = api_from_options('bss/platform')
+            org = aoc_api.read('organization')
+            bss_graphql = api_from_options('bss/platform/graphql')
             # cspell:disable
-            graphql_query = "
-    query ($organization_id: ID!) {
-      aoc (organization_id: $organization_id) {
-        bssSubscription {
-          endDate
-          startDate
-          termMonths
-          plan
-          trial
-          termType
-          instances {
-            id
-            entitlements {
-              maxUsageMb
-            }
-          }
-          additionalStorageVolumeGb
-          additionalEgressVolumeGb
-          additionalUsers
-          term {
-            startDate
+            graphql_query = <<-GRAPHQL
+      query ($organization_id: ID!) {
+        aoc (organization_id: $organization_id) {
+          bssSubscription {
+            aocVersion
             endDate
-            transferVolumeGb
-            egressVolumeGb
-            storageVolumeGb
-          }
-          paygoRate {
-            rate
-            currency
-          }
-          aocPlanData {
-            tier
+            startDate
+            termMonths
+            plan
             trial
-            workspaces { max }
-            users {
-              planAmount
-              max
+            termType
+            aocOrganizations {
+              id
+            }
+            additionalStorageVolumeGb
+            additionalEgressVolumeGb
+            term {
+              startDate
+              endDate
+              transferVolumeGb
+              egressVolumeGb
+              storageVolumeGb
+              transferVolumeOffsetGb
+            }
+            paygoRate {
+              transferRate
+              storageRate
+              currency
+            }
+            aocPlanData {
+              tier
+              trial
+              workspaces { max }
+              users {
+                planAmount
+                max
+              }
+              samlIntegration
+              activity
+              sharedInboxes
+              uniqueUrls
+              support
+              watermarking
+              byok
+              automation { planAmount, max }
             }
-            samlIntegration
-            activity
-            sharedInboxes
-            uniqueUrls
-            support
           }
         }
       }
-    }
-  "
+            GRAPHQL
             # cspell:enable
-            result = bss_api.create('graphql', {'variables' => {'organization_id' => org['id']}, 'query' => graphql_query})[:data]['data']
+            result = bss_graphql.create(nil, {query: graphql_query, variables: {organization_id: org['id']}})['data']
             return {type: :single_object, data: result['aoc']['bssSubscription']}
           when :ats
             ats_api = Rest.new(**aoc_api.params.deep_merge({
@@ -531,7 +542,7 @@ module Aspera
             case command_analytics
             when :application_events
               event_type = command_analytics.to_s
-              events = analytics_api.read("organizations/#{aoc_api.current_user_info['organization_id']}/#{event_type}")[:data][event_type]
+              events = analytics_api.read("organizations/#{aoc_api.current_user_info['organization_id']}/#{event_type}")[event_type]
               return {type: :object_list, data: events}
             when :transfers
               event_type = command_analytics.to_s
@@ -546,6 +557,7 @@ module Aspera
               filter = options.get_option(:query) || {}
               filter['limit'] ||= 100
               if options.get_option(:once_only, mandatory: true)
+                aoc_api.context = :files
                 saved_date = []
                 start_date_persistency = PersistencyActionOnce.new(
                   manager: persistency,
@@ -553,7 +565,7 @@ module Aspera
                   id: IdGenerator.from_list([
                     'aoc_ana_date',
                     options.get_option(:url, mandatory: true),
-                    aoc_api.context(:files)[:workspace_name],
+                    aoc_api.workspace[:name],
                     filter_resource.to_s,
                     filter_id
                   ]))
@@ -565,7 +577,7 @@ module Aspera
                 filter['start_time'] = start_date_time unless start_date_time.nil?
                 filter['stop_time'] = stop_date_time
               end
-              events = analytics_api.read("#{filter_resource}/#{filter_id}/#{event_type}", query_read_delete(default: filter))[:data][event_type]
+              events = analytics_api.read("#{filter_resource}/#{filter_id}/#{event_type}", query_read_delete(default: filter))[event_type]
               start_date_persistency&.save
               if !options.get_option(:notify_to).nil?
                 events.each do |tr_event|
@@ -575,7 +587,83 @@ module Aspera
               return {type: :object_list, data: events}
             end
           when :usage_reports
-            return result_list('usage_reports', base_query: {workspace_id: aoc_api.context(:files)[:workspace_id]})
+            aoc_api.context = :files
+            return result_list('usage_reports', base_query: {workspace_id: aoc_api.workspace[:id]})
+          end
+        end
+
+        # Create a shared link for the given entity
+        # @param shared_data [Hash] information for shared data
+        # @param block [Proc] Optional: called on creation
+        def short_link_command(shared_data, purpose_public:)
+          link_type = options.get_next_argument('link type', accept_list: %i[public private])
+          purpose_local = case link_type
+          when :public
+            case purpose_public
+            when /package/ then 'send_package_to_dropbox'
+            when /shared/ then 'token_auth_redirection'
+            else raise 'error'
+            end
+          when :private then 'shared_folder_auth_link'
+          else Aspera.error_unreachable_line
+          end
+          case options.get_next_command(%i[create delete list])
+          when :create
+            creation_params = {
+              purpose:            purpose_local,
+              user_selected_name: nil
+            }
+            case link_type
+            when :private
+              creation_params[:data] = shared_data
+            when :public
+              creation_params[:expires_at]       = nil
+              creation_params[:password_enabled] = false
+              shared_data[:name] = ''
+              creation_params[:data] = {
+                aoc:            true,
+                url_token_data: {
+                  data:    shared_data,
+                  purpose: purpose_public
+                }
+              }
+            end
+            result_create_short_link = aoc_api.create('short_links', creation_params)
+            # public: Creation: permission on node
+            yield(result_create_short_link['resource_id']) if block_given? && link_type.eql?(:public)
+            return {type: :single_object, data: result_create_short_link}
+          when :list
+            query = if link_type.eql?(:private)
+              shared_data
+            else
+              {
+                url_token_data: {
+                  data:    shared_data,
+                  purpose: purpose_public
+                }
+              }
+            end
+            list_params = {
+              json_query:  query.to_json,
+              purpose:     purpose_local,
+              edit_access: true,
+              # embed: 'updated_by_user',
+              sort:        '-created_at'
+            }
+            return result_list('short_links', fields: Formatter.all_but('data'), base_query: list_params)
+          when :delete
+            one_id = instance_identifier
+            shared_data.delete(:workspace_id)
+            delete_params = {
+              edit_access: true,
+              json_query:  shared_data.to_json
+            }
+            aoc_api.delete("short_links/#{one_id}", delete_params)
+            if link_type.eql?(:public)
+              # TODO: get permission id..
+              # shared_apfid[:api].delete('permissions', {ids: })
+            end
+            return Main.result_status('deleted')
           end
         end
 
@@ -586,10 +674,10 @@ module Aspera
           command = options.get_next_command(ACTIONS)
           if %i[files packages].include?(command)
             default_flag = ' (default)' if options.get_option(:workspace).eql?(:default)
-            app_context = aoc_api.context(command)
-            formatter.display_status("Workspace: #{app_context[:workspace_name].to_s.red}#{default_flag}")
+            aoc_api.context = command
+            formatter.display_status("Workspace: #{aoc_api.workspace[:name].to_s.red}#{default_flag}")
             if !aoc_api.private_link.nil?
-              folder_name = aoc_api.node_api_from(node_id: app_context[:home_node_id]).read("files/#{app_context[:home_file_id]}")[:data]['name']
+              folder_name = aoc_api.node_api_from(node_id: aoc_api.home[:node_id]).read("files/#{aoc_api.home[:file_id]}")['name']
               formatter.display_status("Private Folder: #{folder_name}")
             end
           end
@@ -597,26 +685,27 @@ 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})[:data]
+            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}")
           when :servers
-            return {type: :object_list, data: Rest.new(base_url: "#{Api::AoC.api_base_url}/#{Api::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')}
           when :bearer_token
             return {type: :text, data: aoc_api.oauth.token}
           when :organization
-            return { type: :single_object, data: aoc_api.read('organization')[:data] }
+            return { type: :single_object, data: aoc_api.read('organization') }
           when :tier_restrictions
-            return { type: :single_object, data: aoc_api.read('tier_restrictions')[:data] }
+            return { type: :single_object, data: aoc_api.read('tier_restrictions') }
           when :user
             case options.get_next_command(%i[workspaces profile preferences])
             # when :settings
-            # return {type: :object_list,data: aoc_api.read('client_settings/')[:data]}
+            # return {type: :object_list,data: aoc_api.read('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 { type: :single_object, data: aoc_api.read("workspaces/#{aoc_api.context(:files)[:workspace_id]}")[:data] }
+                aoc_api.context = :files
+                return { type: :single_object, data: aoc_api.read("workspaces/#{aoc_api.workspace[:id]}") }
               end
             when :profile
               case options.get_next_command(%i[show modify])
@@ -630,7 +719,7 @@ module Aspera
               user_preferences_res = "users/#{aoc_api.current_user_info(exception: true)['id']}/user_interaction_preferences"
               case options.get_next_command(%i[show modify])
               when :show
-                return { type: :single_object, data: aoc_api.read(user_preferences_res)[:data] }
+                return { type: :single_object, data: 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')
@@ -640,20 +729,28 @@ module Aspera
             package_command = options.get_next_command(%i[shared_inboxes send receive list show delete].concat(Node::NODE4_READ_ACTIONS), aliases: {recv: :receive})
             case package_command
             when :shared_inboxes
-              case options.get_next_command(%i[list show])
+              case options.get_next_command(%i[list show short_link])
               when :list
                 default_query = {'embed[]' => 'dropbox', 'aggregate_permissions_by_dropbox' => true, 'sort' => 'dropbox_name'}
-                default_query['workspace_id'] = aoc_api.context[:workspace_id] unless aoc_api.context[:workspace_id].eql?(:undefined)
+                default_query['workspace_id'] = aoc_api.workspace[:id] unless aoc_api.workspace[:id].eql?(:undefined)
                 return result_list('dropbox_memberships', fields: %w[dropbox_id dropbox.name], default_query: default_query)
               when :show
-                return {type: :single_object, data: aoc_api.read(get_resource_path_from_args('dropboxes'), query)[:data]}
+                return {type: :single_object, data: aoc_api.read(get_resource_path_from_args('dropboxes'))}
+              when :short_link
+                return short_link_command(
+                  {
+                    workspace_id: aoc_api.workspace[:id],
+                    dropbox_id:   get_resource_id_from_args('dropboxes'),
+                    name:         ''
+                  },
+                  purpose_public: 'send_package_to_dropbox')
               end
             when :send
               package_data = value_create_modify(command: package_command)
               new_user_option = options.get_option(:new_user_option)
               option_validate = options.get_option(:validate_metadata)
               # works for both normal usr auth and link auth
-              package_data['workspace_id'] ||= aoc_api.context[:workspace_id]
+              package_data['workspace_id'] ||= aoc_api.workspace[:id]
 
               if !aoc_api.public_link.nil?
                 aoc_api.assert_public_link_types(%w[send_package_to_user send_package_to_dropbox])
@@ -687,7 +784,7 @@ module Aspera
                   id: IdGenerator.from_list(
                     ['aoc_recv',
                      options.get_option(:url, mandatory: true),
-                     aoc_api.context[:workspace_id]
+                     aoc_api.workspace[:id]
                     ].concat(aoc_api.additional_persistence_ids)))
               end
               case ids_to_download
@@ -708,22 +805,28 @@ module Aspera
               else
                 ids_to_download = [ids_to_download] unless ids_to_download.is_a?(Array)
               end
+              file_list =
+                begin
+                  transfer.source_list.map{|i|{'source'=>i}}
+                rescue Cli::BadArgument
+                  [{'source' => '.'}]
+                end
               # list here
               result_transfer = []
               formatter.display_status("found #{ids_to_download.length} package(s).")
               ids_to_download.each do |package_id|
-                package_info = aoc_api.read("packages/#{package_id}")[:data]
+                package_info = aoc_api.read("packages/#{package_id}")
                 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],
-                  workspace_name: aoc_api.context[:workspace_name],
+                  workspace_id: aoc_api.workspace[:id],
+                  workspace_name: aoc_api.workspace[:name],
                   package_info: package_info)
                 statuses = transfer.start(
                   package_node_api.transfer_spec_gen4(
                     package_info['contents_file_id'],
                     Transfer::Spec::DIRECTION_RECEIVE,
-                    {'paths'=> [{'source' => '.'}]}),
+                    {'paths'=> file_list}),
                   rest_token: package_node_api)
                 result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
                 # update skip list only if all transfer sessions completed
@@ -735,136 +838,70 @@ module Aspera
               return Main.result_transfer_multiple(result_transfer)
             when :show
               package_id = instance_identifier
-              package_info = aoc_api.read("packages/#{package_id}")[:data]
+              package_info = aoc_api.read("packages/#{package_id}")
               return { type: :single_object, data: package_info }
             when :list
               display_fields = %w[id name bytes_transferred]
-              display_fields.push('workspace_id') if aoc_api.context[:workspace_id].eql?(:undefined)
+              display_fields.push('workspace_id') if aoc_api.workspace[:id].eql?(:undefined)
               return result_list('packages', fields: display_fields, base_query: PACKAGE_RECEIVED_BASE_QUERY) do |query|
                        resolve_dropbox_name_default_ws_id(query)
                      end
             when :delete
-              return do_bulk_operation(command: package_command, descr: 'identifier', values: identifier) do |id|
+              return do_bulk_operation(command: package_command, descr: 'identifier', values: instance_identifier) do |id|
                 Aspera.assert_values(id.class, [String, Integer]){'identifier'}
-                aoc_api.delete("packages/#{id}")[:data]
+                aoc_api.delete("packages/#{id}")
               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: Api::Node::SCOPE_USER)
+              package_info = aoc_api.read("packages/#{package_id}")
+              return execute_nodegen4_command(package_command, package_info['node_id'], file_id: package_info['contents_file_id'], scope: Api::Node::SCOPE_USER)
             end
           when :files
             command_repo = options.get_next_command([:short_link].concat(NODE4_EXT_COMMANDS))
             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: Api::Node::SCOPE_USER)
+              return execute_nodegen4_command(command_repo, aoc_api.home[:node_id], file_id: aoc_api.home[:file_id], scope: Api::Node::SCOPE_USER)
             when :short_link
-              link_type = options.get_next_argument('link type', accept_list: %i[public private])
-              short_link_command = options.get_next_command(%i[create delete list])
               folder_dest = options.get_next_argument('path', validation: String)
               home_node_api = aoc_api.node_api_from(
-                node_id:        aoc_api.context[:home_node_id],
-                workspace_id:   aoc_api.context[:workspace_id],
-                workspace_name: aoc_api.context[:workspace_name])
-              shared_apfid = home_node_api.resolve_api_fid(aoc_api.context[:home_file_id], folder_dest)
-              folder_info = {
-                node_id:      shared_apfid[:api].app_info[:node_info]['id'],
-                file_id:      shared_apfid[:file_id],
-                workspace_id: aoc_api.context[:workspace_id]
-              }
-              purpose = case link_type
-              when :public  then 'token_auth_redirection'
-              when :private then 'shared_folder_auth_link'
-              else Aspera.error_unreachable_line
-              end
-              case short_link_command
-              when :delete
-                one_id = instance_identifier
-                folder_info.delete(:workspace_id)
-                delete_params = {
-                  edit_access: true,
-                  json_query:  folder_info.to_json
-                }
-                aoc_api.delete("short_links/#{one_id}", delete_params)
-                if link_type.eql?(:public)
-                  # TODO: get permission id..
-                  # shared_apfid[:api].delete('permissions', {ids: })[:data]
-                end
-                return Main.result_status('deleted')
-              when :list
-                query = if link_type.eql?(:private)
-                  folder_info
-                else
-                  {
-                    url_token_data: {
-                      data:    folder_info,
-                      purpose: 'view_shared_file'
-                    }
-                  }
-                end
-                list_params = {
-                  json_query:  query.to_json,
-                  purpose:     purpose,
-                  edit_access: true,
-                  # embed: 'updated_by_user',
-                  sort:        '-created_at'
-                }
-                return result_list('short_links', fields: Formatter.all_but('data'), base_query: list_params)
-              when :create
-                creation_params = {
-                  purpose:            purpose,
-                  user_selected_name: nil
-                }
-                case link_type
-                when :private
-                  creation_params[:data] = folder_info
-                when :public
-                  creation_params[:expires_at]       = nil
-                  creation_params[:password_enabled] = false
-                  folder_info[:name] = ''
-                  creation_params[:data] = {
-                    aoc:            true,
-                    url_token_data: {
-                      data:    folder_info,
-                      purpose: 'view_shared_file'
-                    }
-                  }
-                end
-                result_create_short_link = aoc_api.create('short_links', creation_params)[:data]
-                # public: Creation: permission on node
-                if link_type.eql?(:public)
-                  # TODO: merge with node permissions ?
-                  # TODO: access level as arg
-                  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],
-                    'access_id'     => result_create_short_link['resource_id'],
-                    'access_type'   => 'user',
-                    'access_levels' => access_levels,
-                    'tags'          => {
-                      'url_token'        => true,
-                      'workspace_id'     => aoc_api.context[:workspace_id],
-                      'workspace_name'   => aoc_api.context[:workspace_name],
-                      'folder_name'      => folder_name,
-                      'created_by_name'  => aoc_api.current_user_info['name'],
-                      'created_by_email' => aoc_api.current_user_info['email'],
-                      'access_key'       => shared_apfid[:api].app_info[:node_info]['access_key'],
-                      'node'             => shared_apfid[:api].app_info[:node_info]['host']
-                    }
-                  }
-                  created_data = shared_apfid[:api].create('permissions', perm_data)[:data]
-                  aoc_api.permissions_send_event(created_data: created_data, app_info: shared_apfid[:api].app_info)
-                  # TODO: event ?
-                end
-                return {type: :single_object, data: result_create_short_link}
-              end
+                node_id:        aoc_api.home[:node_id],
+                workspace_id:   aoc_api.workspace[:id],
+                workspace_name: aoc_api.workspace[:name])
+              shared_apfid = home_node_api.resolve_api_fid(aoc_api.home[:file_id], folder_dest)
+              return short_link_command(
+                {
+                  workspace_id: aoc_api.workspace[:id],
+                  node_id:      shared_apfid[:api].app_info[:node_info]['id'],
+                  file_id:      shared_apfid[:file_id]
+                }, purpose_public: 'view_shared_file') do |resource_id|
+                       # TODO: merge with node permissions ?
+                       # TODO: access level as arg
+                       access_levels = Api::Node::ACCESS_LEVELS # ['delete','list','mkdir','preview','read','rename','write']
+                       perm_data = {
+                         'file_id'       => shared_apfid[:file_id],
+                         'access_id'     => resource_id,
+                         'access_type'   => 'user',
+                         'access_levels' => access_levels,
+                         'tags'          => {
+                           # TODO: really just here ? not in tags.aspera.files.workspace ?
+                           'url_token'        => true,
+                           'workspace_id'     => aoc_api.workspace[:id],
+                           'workspace_name'   => aoc_api.workspace[:name],
+                           'folder_name'      => File.basename(folder_dest),
+                           'created_by_name'  => aoc_api.current_user_info['name'],
+                           'created_by_email' => aoc_api.current_user_info['email'],
+                           'access_key'       => shared_apfid[:api].app_info[:node_info]['access_key'],
+                           'node'             => shared_apfid[:api].app_info[:node_info]['host']
+                         }
+                       }
+                       created_data = shared_apfid[:api].create('permissions', perm_data)
+                       aoc_api.permissions_send_event(event_data: created_data, app_info: shared_apfid[:api].app_info)
+                     end
             end
-            raise 'Error: shall not reach this line'
           when :automation
             Log.log.warn('BETA: work under progress')
             # automation api is not in the same place
-            automation_api = Rest.new(**aoc_api.params.merge(base_url: aoc_api.base_url.gsub('/api/', '/automation/')))
+            automation_api = Rest.new(**aoc_api.params, base_url: aoc_api.base_url.gsub('/api/', '/automation/'))
             command_automation = options.get_next_command(%i[workflows instances])
             case command_automation
             when :instances
@@ -876,18 +913,18 @@ module Aspera
                 return entity_command(wf_command, automation_api, 'workflows')
               when :launch
                 wf_id = instance_identifier
-                data = automation_api.create("workflows/#{wf_id}/launch", {})[:data]
+                data = automation_api.create("workflows/#{wf_id}/launch", {})
                 return {type: :single_object, data: data}
               when :action
                 # TODO: not complete
                 wf_id = instance_identifier
                 wf_action_cmd = options.get_next_command(%i[list create show])
                 Log.log.warn{"Not implemented: #{wf_action_cmd}"}
-                step = automation_api.create('steps', {'workflow_id' => wf_id})[:data]
+                step = automation_api.create('steps', {'workflow_id' => wf_id})
                 automation_api.update("workflows/#{wf_id}", {'step_order' => [step['id']]})
-                action = automation_api.create('actions', {'step_id' => step['id'], 'type' => 'manual'})[:data]
+                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}")[:data]
+                wf = automation_api.read("workflows/#{wf_id}")
                 return {type: :single_object, data: wf}
               end
             end
@@ -898,7 +935,8 @@ module Aspera
             url = value_create_modify(command: command, type: String)
             uri = URI.parse(url)
             server = WebServerSimple.new(uri)
-            server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.context(:files)[:workspace_id])
+            aoc_api.context = :files
+            server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.workspace[:id])
             server.start
             return Main.result_status('Gateway terminated')
           else Aspera.error_unreachable_line