aspera-cli 4.25.6 → 4.26.1

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

@@ -24,26 +24,25 @@ module Aspera
         REDIRECT_LOCALHOST = 'http://localhost:12345'
         # admin objects that can be manipulated
         ADMIN_OBJECTS = %i[
-          self
-          organization
-          user
-          group
-          group_membership
           client
+          client_access_key
+          client_registration_token
           contact
           dropbox
+          dropbox_membership
+          group
+          group_membership
+          kms_profile
           node
           operation
+          organization
           package
           saml_configuration
+          self
+          short_link
+          user
           workspace
           workspace_membership
-          dropbox_membership
-          short_link
-          application
-          client_registration_token
-          client_access_key
-          kms_profile
         ].freeze
         # query to list fully received packages
         PACKAGE_RECEIVED_BASE_QUERY = {
@@ -53,10 +52,8 @@ module Aspera
           'completed'   => true
         }.freeze
         PACKAGE_LIST_DEFAULT_FIELDS = %w[id name created_at files_completed bytes_transferred].freeze
-        # options and parameters for Api::AoC.new
-        OPTIONS_NEW = %i[url auth client_id client_secret scope redirect_uri private_key passphrase username password workspace].freeze
 
-        private_constant :REDIRECT_LOCALHOST, :ADMIN_OBJECTS, :PACKAGE_RECEIVED_BASE_QUERY, :OPTIONS_NEW, :PACKAGE_LIST_DEFAULT_FIELDS
+        private_constant :REDIRECT_LOCALHOST, :ADMIN_OBJECTS, :PACKAGE_RECEIVED_BASE_QUERY, :PACKAGE_LIST_DEFAULT_FIELDS
         class << self
           def application_name
             'Aspera on Cloud'
@@ -220,21 +217,36 @@ module Aspera
         # Change API scope for subsequent calls, re-instantiate API object
         # @param new_scope [String] New scope
         def change_api_scope(new_scope)
+          # Discard cache
           @cache_api_aoc = nil
           @scope = new_scope
+          nil
         end
 
         # Create an API object with the options from CLI, but with a different subpath
-        # @param aoc_base_path [String] New subpath
+        # @param base_path [String] Base path for APIs.
         # @return [Api::AoC] API object for AoC (is Rest)
-        def api_from_options(aoc_base_path)
-          return Api::AoC.new(**Oauth.args_from_options(
-            options,
-            defaults:      {workspace: nil},
+        def api_from_options(base_path)
+          # Get all existing OAuth kwargs from `options`.
+          api = Api::AoC.new(
             scope:         @scope,
-            subpath:       aoc_base_path,
-            secret_finder: config
-          ))
+            subpath:       base_path,
+            secret_finder: config,
+            **Oauth.kwargs_from_options(options)
+          )
+          # User set a workspace ?
+          # @type [String, nil]
+          workspace = options.get_option(:workspace)
+          if !workspace.nil? && (m = Manager.percent_selector(workspace))
+            case m[:field]
+            when 'name' then api.ws_ids[:name] = m[:value]
+            when 'id' then api.ws_ids[:id] = m[:value]
+            else Aspera.error_unexpected_value(m[:field]){'workspace selector: only `name` or `id`'}
+            end
+          else
+            api.ws_ids[:name] = workspace
+          end
+          api
         end
 
         # AoC Rest object
@@ -260,7 +272,7 @@ module Aspera
         #   * `workspace_name` [String] (optional) the name, included if +name+ is true.
         # @note The key type (String or Symbol) depends on the +string+ parameter.
         def workspace_id_hash(hash = nil, string: false, name: false)
-          info = aoc_api.workspace
+          info = aoc_api.workspace_info
           hash = {} if hash.nil?
           fields = %i[id]
           fields.push(:name) if name
@@ -276,9 +288,9 @@ module Aspera
         # @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|
+          return options.instance_identifier do |field, value|
             Aspera.assert(field.eql?('name'), type: BadArgument){'only selection by name is supported'}
-            aoc_api.lookup_by_name(resource_class_path, value)['id']
+            aoc_api.lookup_with_q(resource_class_path, value: value)['id']
           end
         end
 
@@ -292,7 +304,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)
@@ -309,7 +321,7 @@ module Aspera
             # convenience: specify name instead of id
             raise BadArgument, 'Use field dropbox_name or dropbox_id, not both' 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.delete('dropbox_name'))['id']
+            query['dropbox_id'] = aoc_api.lookup_with_q('dropboxes', value: query.delete('dropbox_name'))['id']
           end
           workspace_id_hash(query, string: true)
           # by default show dropbox packages only for dropboxes
@@ -327,11 +339,10 @@ module Aspera
           return aoc_api.read_with_paging('packages', query.compact)
         end
 
-        NODE4_EXT_COMMANDS = %i[transfer].concat(Node::COMMANDS_GEN4).freeze
-        private_constant :NODE4_EXT_COMMANDS
+        FILES_COMMANDS = (Node::COMMANDS_GEN4 + %i[transfer]).freeze
 
-        # Execute a node gen4 command
-        # @param command_repo [Symbol] command to execute
+        # Execute a node gen4 command starting at given node and file IDs
+        # @param command_repo [Symbol] Command to execute
         # @param node_id [String] Node identifier
         # @param file_id [String] Root file id for the operation (can be AK root, or other, e.g. package, or link). If `nil` use AK root file id.
         # @param scope [String] node scope (Node::SCOPE_<USER|ADMIN>), or nil (requires secret)
@@ -341,7 +352,7 @@ module Aspera
             scope:          scope,
             **workspace_id_hash(name: true)
           )
-          file_id = top_node_api.read("access_keys/#{top_node_api.app_info[:node_info]['access_key']}")['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(context: context, api: top_node_api)
           case command_repo
           when *Node::COMMANDS_GEN4
@@ -363,23 +374,23 @@ module Aspera
               server_folder = source_folder
             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)
+            client_apifid = top_node_api.resolve_api_fid(file_id, client_folder)
+            server_apifid = top_node_api.resolve_api_fid(file_id, server_folder)
             # force node as transfer agent
             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.authorization,
-              root_id:  client_apfid[:file_id]
+              url:      client_apifid.node_api.base_url,
+              username: client_apifid.node_api.app_info.node_info['access_key'],
+              password: client_apifid.node_api.oauth.authorization,
+              root_id:  client_apifid.file_id
             )
             # additional node to node TS info
             add_ts = {
-              'remote_access_key'   => server_apfid[:api].app_info[:node_info]['access_key'],
-              'destination_root_id' => server_apfid[:file_id],
-              'source_root_id'      => client_apfid[:file_id]
+              'remote_access_key'   => server_apifid.node_api.app_info.node_info['access_key'],
+              'destination_root_id' => server_apifid.file_id,
+              'source_root_id'      => client_apifid.file_id
             }
-            return Main.result_transfer(transfer.start(server_apfid[:api].transfer_spec_gen4(
-              server_apfid[:file_id],
+            return Main.result_transfer(transfer.start(server_apifid.node_api.transfer_spec_gen4(
+              server_apifid.file_id,
               client_direction,
               add_ts
             )))
@@ -388,70 +399,90 @@ module Aspera
           Aspera.error_unreachable_line
         end
 
+        # Execute an action on admin resources
         # @param resource_type [Symbol] One of ADMIN_OBJECTS
         def execute_resource_action(resource_type)
-          # get path on API, resource type is singular, but api is plural
-          resource_class_path =
-            case resource_type
-            # special cases: singleton, in admin, with x
-            when :self, :organization then resource_type
-            when :client_registration_token, :client_access_key then "admin/#{resource_type}s"
-            when :application then 'admin/apps_new'
-            when :dropbox then "#{resource_type}es"
-            when :kms_profile then "integrations/#{resource_type}s"
-            else "#{resource_type}s"
-            end
-          # build list of supported operations
-          singleton_object = %i[self organization].include?(resource_type)
-          global_operations =  %i[create list]
-          supported_operations = %i[show modify]
-          supported_operations.push(:delete, *global_operations) unless singleton_object
-          supported_operations.push(:do, :bearer_token) if resource_type.eql?(:node)
-          supported_operations.push(:set_pub_key) if resource_type.eql?(:client)
-          supported_operations.push(:shared_folder, :dropbox) if resource_type.eql?(:workspace)
+          # 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"
+          # 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 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 :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 = %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
+          when :short_link
+            list_default_fields = %w[id short_url data.url_token_data.purpose password_enabled password_protected updated_by_user_id updated_at]
+          when :user
+            list_default_fields = %w[id name email]
+            supported_operations += %i[preferences notifications]
+          when :workspace
+            supported_operations += %i[shared_folder dropbox]
+          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 !singleton_object && !global_operations.include?(command)
+          # Require identifier for non global commands
+          if (supported_operations != Operations::SINGLETON) && !Operations::GLOBAL.include?(command)
             res_id = get_resource_id_from_args(resource_class_path)
             resource_instance_path = "#{resource_class_path}/#{res_id}"
           end
-          resource_instance_path = resource_class_path if singleton_object
           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')
-            return do_bulk_operation(command: command, descr: 'creation data', id_result: id_result) do |params|
+            workspace_id = aoc_api.workspace_info[:id] if require_workspace_id
+            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
           when :list
-            default_fields = ['id']
-            default_query = {}
-            case resource_type
-            when :application
-              default_query = {organization_apps: true}
-              default_fields.push('app_type', 'app_name', 'available', 'direct_authorizations_allowed', 'workspace_authorizations_allowed')
-            when :client, :client_access_key, :dropbox, :group, :package, :saml_configuration, :workspace then default_fields.push('name')
-            when :client_registration_token then default_fields.push('value', 'data.client_subject_scopes', 'created_at')
-            when :contact
-              default_fields = %w[source_type source_id name email]
-              default_query = {'include_only_user_personal_contacts' => true} if @scope == Api::AoC::Scope::USER
-            when :node then default_fields.push('name', 'host', 'access_key')
-            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('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)
+            return result_list(resource_class_path, fields: list_default_fields, default_query: list_default_query)
           when :show
-            object = aoc_api.read(resource_instance_path)
-            # default: show all, but certificate
-            fields = object.keys.reject{ |k| k.eql?('certificate')}
-            return Main.result_single_object(object, fields: fields)
+            object = aoc_api.read(resource_instance_path, query_read_delete)
+            return Main.result_single_object(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}
@@ -468,7 +499,7 @@ module Aspera
             aoc_api.update(resource_instance_path, {jwt_grant_enabled: true, public_key: the_public_key})
             return Main.result_success
           when :do
-            command_repo = options.get_next_command(NODE4_EXT_COMMANDS)
+            command_repo = options.get_next_command(FILES_COMMANDS)
             return execute_nodegen4_command(command_repo, res_id, scope: Api::Node::Scope::ADMIN)
           when :bearer_token
             node_api = aoc_api.node_api_from(
@@ -488,12 +519,18 @@ module Aspera
             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])
+            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)
+              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 = 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)
               command_shared_member = options.get_next_command(%i[list])
@@ -524,11 +561,75 @@ module Aspera
                 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])
               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))
+            when :modify
+              aoc_api.update(user_preferences_res, options.get_next_argument('properties', validation: Hash))
+              return Main.result_status('modified')
+            end
           else Aspera.error_unexpected_value(command)
           end
         end
 
-        ADMIN_ACTIONS = %i[ats bearer_token resource usage_reports analytics subscription auth_providers].concat(ADMIN_OBJECTS).freeze
+        def execute_application_action
+          apps_info = aoc_api.read('admin/apps')
+          all_app_types = 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)
+          when :settings
+            app_type = options.get_next_command(all_app_types)
+            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))
+            when :modify
+              aoc_api.update(cmd_path, options.get_next_argument('properties', validation: Hash))
+              return Main.result_status('modified')
+            end
+          when :instance
+            list_default_query = {workspace_id: aoc_api.workspace_info[:id]}
+            list_default_fields = %w[id app_type available workspace_id]
+            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)
+              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))
+            when :modify
+              aoc_api.update(resource_path, options.get_next_argument('properties', validation: Hash))
+              return Main.result_status('modified')
+            end
+          when :membership
+            resource_path = 'apps/app_memberships'
+            command_app_member = options.get_next_command(%i[create list show delete])
+            resource_path = "#{resource_path}/#{options.instance_identifier(description: 'membership id')}" unless Operations::GLOBAL.include?(command_app_member)
+            case command_app_member
+            when :list
+              return result_list(resource_path)
+            when :delete
+              aoc_api.delete("#{resource_path}}")
+              return Main.result_status('deleted')
+            when :show
+              return Main.result_single_object(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')
+            end
+          end
+        end
+
+        ADMIN_ACTIONS = %i[bearer_token application ats usage_reports analytics subscription auth_providers].concat(ADMIN_OBJECTS).freeze
 
         def execute_admin_action
           # change scope to admin
@@ -537,11 +638,10 @@ module Aspera
           case command_admin
           when :bearer_token
             return Main.result_text(aoc_api.oauth.authorization)
-          when :resource
-            Log.log.warn('resource command is deprecated (4.18), directly use the specific command instead')
-            return execute_resource_action(options.get_next_argument('resource', accept_list: ADMIN_OBJECTS))
           when *ADMIN_OBJECTS
             return execute_resource_action(command_admin)
+          when :application
+            return execute_application_action
           when :auth_providers
             command_auth_prov = options.get_next_command(%i[list update])
             case command_auth_prov
@@ -699,7 +799,7 @@ module Aspera
                   id: IdGenerator.from_list(
                     'aoc_ana_date',
                     options.get_option(:url, mandatory: true),
-                    aoc_api.workspace[:name],
+                    aoc_api.workspace_info[:name],
                     event_resource_type.to_s,
                     event_resource_id
                   )
@@ -721,7 +821,7 @@ module Aspera
             when :files
               event_type = command_analytics.to_s
               event_resource_type = options.get_next_argument('resource', accept_list: %i[organizations users nodes])
-              event_resource_id = instance_identifier(description: "#{event_resource_type} identifier")
+              event_resource_id = options.instance_identifier(description: "#{event_resource_type} identifier")
               event_resource_id =
                 case event_resource_type
                 when :organizations then aoc_api.current_user_info['organization_id']
@@ -729,7 +829,7 @@ module Aspera
                 when :nodes then aoc_api.current_user_info['read_only_home_node_id']
                 else Aspera.error_unreachable_line
                 end if event_resource_id.empty?
-              event_uuid = instance_identifier(description: 'event uuid')
+              event_uuid = options.instance_identifier(description: 'event uuid')
               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]
@@ -747,7 +847,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]
@@ -818,7 +921,7 @@ module Aspera
             short_list = aoc_api.read_with_paging('short_links', list_params.merge(query_read_delete(default: {})).compact)
             case command
             when :delete
-              one_id = instance_identifier(description: 'short link id')
+              one_id = options.instance_identifier(description: 'short link id')
               if link_type.eql?(:public)
                 found = short_list[:items].find{ |item| item['id'].eql?(one_id)}
                 raise BadIdentifier.new('Short link', one_id) if found.nil?
@@ -832,12 +935,12 @@ module Aspera
             when :list
               return Main.result_object_list(short_list[:items], fields: Formatter.all_but('data'), total: short_list[:total])
             when :show
-              one_id = instance_identifier(description: 'short link id')
+              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'))
             when :modify
-              one_id = instance_identifier(description: 'short link id')
+              one_id = options.instance_identifier(description: 'short link id')
               node_file = shared_data.slice(:node_id, :file_id)
               modify_payload = {
                 edit_access: true,
@@ -879,7 +982,7 @@ module Aspera
             id: IdGenerator.from_list(
               'aoc_recv',
               options.get_option(:url, mandatory: true),
-              aoc_api.workspace[:id],
+              aoc_api.workspace_info[:id],
               aoc_api.additional_persistence_ids
             )
           )
@@ -897,8 +1000,7 @@ module Aspera
         def execute_action
           command = options.get_next_command(ACTIONS)
           if %i[files packages].include?(command)
-            default_flag = ' (default)' if options.get_option(:workspace).eql?(:default)
-            formatter.display_status("Workspace: #{aoc_api.workspace[:name].to_s.red}#{default_flag}")
+            formatter.display_status("Workspace: #{aoc_api.workspace_info[:name].to_s.red}#{' (default)' if aoc_api.default_workspace?}")
             if !aoc_api.private_link.nil?
               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}")
@@ -919,7 +1021,8 @@ module Aspera
           when :tier_restrictions
             return Main.result_single_object(aoc_api.read('tier_restrictions'))
           when :user
-            case options.get_next_command(%i[workspaces profile preferences contacts])
+            user_cmd = options.get_next_command(%i[workspaces profile preferences notifications contacts])
+            case user_cmd
             when :contacts
               return execute_resource_action(:contact)
             # when :settings
@@ -929,7 +1032,7 @@ module Aspera
               when :list
                 return result_list('workspaces', fields: %w[id name])
               when :current
-                return Main.result_single_object(aoc_api.workspace)
+                return Main.result_single_object(aoc_api.workspace_info)
               end
             when :profile
               case options.get_next_command(%i[show modify])
@@ -939,8 +1042,8 @@ module Aspera
                 aoc_api.update("users/#{aoc_api.current_user_info(exception: true)['id']}", options.get_next_argument('properties', validation: Hash))
                 return Main.result_status('modified')
               end
-            when :preferences
-              user_preferences_res = "users/#{aoc_api.current_user_info(exception: true)['id']}/user_interaction_preferences"
+            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))
@@ -965,7 +1068,7 @@ module Aspera
                 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.
@@ -991,7 +1094,7 @@ module Aspera
                 ids_to_download = aoc_api.public_link['data']['package_id']
               end
               # Get from command line unless it was a public link
-              ids_to_download ||= instance_identifier
+              ids_to_download ||= options.instance_identifier
               skip_ids_persistency = package_persistency
               case ids_to_download
               when SpecialValues::INIT
@@ -1046,7 +1149,7 @@ module Aspera
               end
               return Main.result_transfer_multiple(result_transfer)
             when :show
-              package_id = instance_identifier
+              package_id = options.instance_identifier
               package_info = aoc_api.read("packages/#{package_id}")
               return Main.result_single_object(package_info)
             when :list
@@ -1054,27 +1157,27 @@ module Aspera
               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[:id].nil?
+              display_fields += ['workspace_id'] if aoc_api.workspace_info[:id].nil?
               return Main.result_object_list(result[:items], fields: display_fields, total: result[:total])
             when :delete
-              return do_bulk_operation(command: package_command, values: instance_identifier) do |id|
-                Aspera.assert_type(id, String, Integer){'identifier'}
-                aoc_api.delete("packages/#{id}")
+              return do_bulk_operation(command: package_command, values: options.instance_identifier) do |package_id|
+                Aspera.assert_type(package_id, String, Integer){'identifier'}
+                aoc_api.delete("packages/#{package_id}")
               end
             when :modify
-              id = instance_identifier
+              package_id = options.instance_identifier
               package_data = value_create_modify(command: package_command)
-              aoc_api.update("packages/#{id}", package_data)
+              aoc_api.update("packages/#{package_id}", package_data)
               return Main.result_status('modified')
             when *Node::NODE4_READ_ACTIONS
-              package_id = instance_identifier
+              package_id = options.instance_identifier
               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))
+            command_repo = options.get_next_command([:short_link].concat(FILES_COMMANDS))
             case command_repo
-            when *NODE4_EXT_COMMANDS
+            when *FILES_COMMANDS
               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
               folder_dest = options.get_next_argument('path', validation: String)
@@ -1082,16 +1185,16 @@ module Aspera
                 node_id: aoc_api.home[:node_id],
                 **workspace_id_hash(name: true)
               )
-              shared_apfid = home_node_api.resolve_api_fid(aoc_api.home[:file_id], folder_dest)
+              shared_apifid = home_node_api.resolve_api_fid(aoc_api.home[:file_id], folder_dest)
               return short_link_command(
-                node_id:        shared_apfid[:api].app_info[:node_info]['id'],
-                file_id:        shared_apfid[:file_id]
+                node_id:        shared_apifid.node_api.app_info.node_info['id'],
+                file_id:        shared_apifid.file_id
               ) do |op, id, access_levels|
                 case op
                 when :create
                   # `id` is the resource id
                   perm_data = {
-                    'file_id'       => shared_apfid[:file_id],
+                    'file_id'       => shared_apifid.file_id,
                     'access_id'     => id,
                     'access_type'   => 'user',
                     'access_levels' => Api::AoC.expand_access_levels(access_levels),
@@ -1100,23 +1203,23 @@ module Aspera
                       '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]['name'],
+                      'access_key'       => shared_apifid.node_api.app_info.node_info['access_key'],
+                      'node'             => shared_apifid.node_api.app_info.node_info['name'],
                       **workspace_id_hash(string: true, name: true)
                     }
                   }
-                  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)
+                  created_data = shared_apifid.node_api.create('permissions', perm_data)
+                  aoc_api.permissions_send_event(event_data: created_data, app_info: shared_apifid.node_api.app_info)
                 when :update
                   # `id` is the permission_id
-                  found = shared_apfid[:api].read('permissions', {file_id: shared_apfid[:file_id], inherited: false, access_type: 'user', access_id: id}).find{ |i| i['access_id'].eql?(id)}
-                  raise Error, 'Short link not found: #{id}' if found.nil?
-                  shared_apfid[:api].update("permissions/#{found['id']}", {access_levels: Api::AoC.expand_access_levels(access_levels)})
+                  found = shared_apifid.node_api.read('permissions', {file_id: shared_apifid.file_id, inherited: false, access_type: 'user', access_id: id}).find{ |i| i['access_id'].eql?(id)}
+                  raise Error, "Short link not found: #{id}" if found.nil?
+                  shared_apifid.node_api.update("permissions/#{found['id']}", {access_levels: Api::AoC.expand_access_levels(access_levels)})
                 when :delete
                   # `id` is the resource id, i.e. `access_id`
-                  found = shared_apfid[:api].read('permissions', {file_id: shared_apfid[:file_id], inherited: false, access_type: 'user', access_id: id}).first
-                  raise Error, 'Short link not found: #{id}' if found.nil?
-                  shared_apfid[:api].delete("permissions/#{found['id']}")
+                  found = shared_apifid.node_api.read('permissions', {file_id: shared_apifid.file_id, inherited: false, access_type: 'user', access_id: id}).first
+                  raise Error, "Short link not found: #{id}" if found.nil?
+                  shared_apifid.node_api.delete("permissions/#{found['id']}")
                 else Aspera.error_unexpected_value(op)
                 end
               end
@@ -1131,21 +1234,21 @@ module Aspera
             when :instances
               return entity_execute(api: aoc_api, entity: 'workflow_instances')
             when :workflows
-              wf_command = options.get_next_command(%i[action launch].concat(ALL_OPS))
+              wf_command = options.get_next_command(%i[action launch].concat(Operations::ALL))
               case wf_command
-              when *ALL_OPS
+              when *Operations::ALL
                 return entity_execute(
                   api: automation_api,
                   entity: 'workflows',
                   command: wf_command
                 )
               when :launch
-                wf_id = instance_identifier
+                wf_id = options.instance_identifier
                 data = automation_api.create("workflows/#{wf_id}/launch", {})
                 return Main.result_single_object(data)
               when :action
                 # TODO: not complete
-                wf_id = instance_identifier
+                wf_id = options.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})
@@ -1164,7 +1267,7 @@ module Aspera
             uri = URI.parse(parameters.delete(:url){WebServerSimple::DEFAULT_URL})
             server = WebServerSimple.new(uri, **parameters.slice(*WebServerSimple::PARAMS))
             Aspera.assert(parameters.except(*WebServerSimple::PARAMS).empty?)
-            server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.workspace[:id])
+            server.mount(uri.path, Faspex4GWServlet, aoc_api, aoc_api.workspace_info[:id])
             server.start
             return Main.result_status('Gateway terminated')
           else Aspera.error_unreachable_line