aspera-cli 4.27.3 → 4.27.5

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

@@ -24,7 +24,7 @@ using Rainbow
 module Aspera
   module Cli
     module Plugins
-      class Aoc < Oauth # rubocop:disable Metrics/ClassLength
+      class Aoc < Oauth
         # default redirect for AoC web auth
         REDIRECT_LOCALHOST = 'http://localhost:12345'
         # admin objects that can be manipulated
@@ -140,44 +140,46 @@ module Aspera
             }
           end
 
-          # DSL helper: register the 5 short_link leaf commands under the given parent path
-          # and define the corresponding action methods on `base`.
-          # @param base        [Class]         the plugin class
-          # @param parent_path [Array<Symbol>] full path ending with :short_link
-          def register_short_link_commands(base, parent_path)
-            base.commands_under(parent_path) do
-              base.command(
-                :create, description: base.operation_description(:create, 'short link'),
-                arguments: [{name: :short_link, type: Hash, mandatory: false, default: {}}]
+          # Optional `Hash` argument of short link create and modify, merged into the request body
+          # @param endpoint [String] endpoint of the request body schema, e.g. `short_links.post`
+          # @return [Hash] argument declaration
+          def short_link_argument(endpoint)
+            {
+              name: :short_link, type: Hash, mandatory: false, default: {},
+              description: 'Merged into the request body, and: `password` (link password), `access_levels` (shared folder only)',
+              schema: Schema::Registry.req_body(Schema::Registry::AOC, endpoint)
+            }
+          end
+
+          # DSL class method: declare the 5 short link leaf commands under the given node.
+          # The node itself is declared by the caller, with its arguments and setup.
+          # @param parent [Symbol, Array<Symbol>] path relative to current scope, e.g. :short_link
+          def short_link_commands(parent)
+            commands_under(parent) do
+              command(
+                :create, description: operation_description(:create, 'short link'),
+                arguments: [short_link_argument('short_links.post')],
+                action: ->(short_link: {}, **ctx) { short_link_create(short_link, **ctx) }
               )
-              base.command(
-                :modify, description: base.operation_description(:modify, 'short link'),
-                arguments: [{name: :short_link_id, type: :identifier}, {name: :short_link, type: Hash, mandatory: false, default: {}}]
+              command(
+                :modify, description: operation_description(:modify, 'short link'),
+                arguments: [{name: :short_link_id, type: :identifier}, short_link_argument('short_links/{id}.put')],
+                action: ->(short_link: {}, **ctx) { short_link_modify(short_link, **short_link_fetch_list(**ctx), **ctx) }
               )
-              base.command(:list, description: base.operation_description(:list, 'short link'))
-              base.command(
-                :show, description: base.operation_description(:show, 'short link'),
-                arguments: [{name: :short_link_id, type: :identifier}]
+              command(
+                :list, description: operation_description(:list, 'short link'), query_schema: SHORT_LINK_QUERY_SCHEMA,
+                action: ->(**ctx) { short_link_list(**short_link_fetch_list(**ctx)) }
               )
-              base.command(
-                :delete, description: base.operation_description(:delete, 'short link'),
-                arguments: [{name: :short_link_id, type: :identifier}]
+              command(
+                :show, description: operation_description(:show, 'short link'),
+                arguments: [{name: :short_link_id, type: :identifier}],
+                action: ->(**ctx) { short_link_show(**short_link_fetch_list(**ctx), **ctx) }
+              )
+              command(
+                :delete, description: operation_description(:delete, 'short link'),
+                arguments: [{name: :short_link_id, type: :identifier}],
+                action: ->(**ctx) { short_link_delete(**short_link_fetch_list(**ctx), **ctx) }
               )
-            end
-            base.define_action_method(parent_path + [:create]) do |short_link: {}, **ctx|
-              sl_exec_create(short_link, **ctx)
-            end
-            base.define_action_method(parent_path + [:list]) do |**ctx|
-              sl_exec_list(**sl_fetch_list(**ctx))
-            end
-            base.define_action_method(parent_path + [:show]) do |**ctx|
-              sl_exec_show(**sl_fetch_list(**ctx))
-            end
-            base.define_action_method(parent_path + [:delete]) do |**ctx|
-              sl_exec_delete(**sl_fetch_list(**ctx), **ctx)
-            end
-            base.define_action_method(parent_path + [:modify]) do |short_link: {}, **ctx|
-              sl_exec_modify(short_link, **sl_fetch_list(**ctx), **ctx)
             end
           end
         end
@@ -474,13 +476,10 @@ module Aspera
           )))
         end
 
-        # Execute an action on admin resources
-        # @param resource_type [Symbol] One of ADMIN_OBJECTS
         # Per-resource configuration for admin CRUD resources.
         # Keys: path, list_fields, id_result, require_ws_id, create_schema, extra_ops, singleton, op_setup, op_mount, op_descriptions
-        # op_setup: Hash of op => setup method name, used for ops that require consuming an instance identifier.
-        #   For Operations::INSTANCE ops (show/modify/delete), use the auto-generated :setup_admin_<res>_instance.
-        #   For extra_ops that are instance ops, specify explicitly (or rely on the auto-generated one).
+        # Ops other than `create` and `list` read the identifier `<res>_id` (argument of the op node).
+        # op_setup: Hash of op => setup method name, for ops that need context derived from the identifier.
         # op_mount: Hash of op => mount: of that op's node.
         # op_descriptions: Hash of op => description, for ops other than standard ones.
         ADMIN_OBJECT_CONFIG = {
@@ -515,7 +514,6 @@ module Aspera
           user:                      {
             list_fields:     %w[id name email],
             extra_ops:       %i[preferences notifications],
-            op_setup:        {preferences: :setup_admin_user_instance, notifications: :setup_admin_user_instance},
             op_descriptions: {preferences: 'Manage user preferences', notifications: 'Manage user notification preferences'}
           },
           workspace:                 {
@@ -544,37 +542,24 @@ module Aspera
           }))
         end
 
-        # Compute short-link purposes from shared_data keys and link_type.
-        # @param shared_data [Hash] :dropbox_id + :name or :file_id + :node_id
-        # @param link_type [Symbol] :public or :private
-        # @return [Array(String,String)] [token_purpose, short_link_purpose]
-        def short_link_purposes(shared_data, link_type)
-          if shared_data.keys.sort == %i[dropbox_id name]
-            token_purpose = 'send_package_to_dropbox'
-            short_link_purpose = link_type.eql?(:public) ? 'send_package_to_dropbox' : 'shared_folder_auth_link'
-          elsif shared_data.keys.sort == %i[file_id node_id]
-            token_purpose = 'view_shared_file'
-            short_link_purpose = link_type.eql?(:public) ? 'token_auth_redirection' : 'shared_folder_auth_link'
-          else
-            Aspera.error_unexpected_value(shared_data.keys)
-          end
-          [token_purpose, short_link_purpose]
-        end
+        # Purpose of a short link, by link type (the purpose of its URL token depends on the shared resource)
+        SHORT_LINK_PURPOSES = {public: 'token_auth_redirection', private: 'shared_folder_auth_link'}.freeze
+        # Query parameters of short link list
+        SHORT_LINK_QUERY_SCHEMA = Schema::Registry.query_params(Schema::Registry::AOC, 'short_links')
 
         # Build the list_params hash used by delete/list/show/modify short link operations.
         # @return [Hash]
-        def short_link_list_params(shared_data:, link_type:, token_purpose:, short_link_purpose:, **)
+        def short_link_list_params(shared_data:, link_type:, token_purpose:, short_link_purpose:, **ctx)
           query = if link_type.eql?(:private)
             shared_data
           else
             {url_token_data: {data: shared_data, purpose: token_purpose}}
           end
-          {
-            json_query:  query.to_json,
-            purpose:     short_link_purpose,
-            edit_access: true,
-            sort:        '-created_at'
-          }
+          # String keys: the user's `--query` overrides them
+          list_params = {'json_query' => query.to_json, 'purpose' => short_link_purpose, 'sort' => '-created_at'}
+          # `edit_access` requires `file_id` and `node_id`: shared folder links only
+          list_params['edit_access'] = true if ctx.key?(:shared_apifid)
+          list_params
         end
 
         # @return [PersistencyActionOnce, nil] persistency object if option `once_only` is used.
@@ -926,22 +911,20 @@ module Aspera
             arguments: [{name: :dropbox_id, type: :identifier, lookup: :lookup_aoc_dropbox_id}],
             action: ->(dropbox_id:, **) { Result::SingleObject.new(aoc_api.read("dropboxes/#{dropbox_id}")) }
           command :short_link, description: 'Manage shared inbox short links',
-            arguments: [{name: :link_type, allowed: %i[public private]}, {name: :dropbox_id, type: :identifier, lookup: :lookup_aoc_dropbox_id}],
+            arguments: [{name: :link_type, allowed: %i[public]}, {name: :dropbox_id, type: :identifier, lookup: :lookup_aoc_dropbox_id}],
             setup: :setup_packages_short_link
+          short_link_commands :short_link
         end
-        # packages > shared_inboxes > short_link sub-commands
-        register_short_link_commands(self, %i[packages shared_inboxes short_link])
 
         # files sub-commands: Gen4 commands are mounted, plus AoC-specific commands
         commands_under :files do
           command :short_link, description: 'Manage file short link',
             arguments: [{name: :folder}, {name: :link_type, allowed: %i[public private]}],
             setup: :setup_files_short_link
+          short_link_commands :short_link
           command :transfer, description: 'Transfer files (node-to-node)', arguments: TRANSFER_ARGS,
             action: ->(direction:, source_folder:, **) { nodegen4_transfer(aoc_api.home[:node_id], file_id: aoc_api.home[:file_id], scope: Api::Node::Scope::USER, direction: direction, source_folder: source_folder) }
         end
-        # files > short_link sub-commands
-        register_short_link_commands(self, %i[files short_link])
 
         # automation sub-commands
         # Automation API: a workflow has ordered steps (step_order), a step has ordered actions (action_order)
@@ -1156,8 +1139,8 @@ module Aspera
         end
 
         # setup: files > short_link
-        # Resolves the target folder, consumes link_type argument, computes purposes.
-        # @return [Hash] ctx keys: sl_shared_data, sl_link_type, sl_token_purpose, sl_short_link_purpose, sl_perm_block, sl_shared_apifid, sl_folder_dest
+        # Resolves the target folder, sets purposes.
+        # @return [Hash] ctx keys: shared_data, token_purpose, short_link_purpose, shared_apifid
         def setup_files_short_link(folder:, link_type:, **)
           home_node_api = aoc_api.node_api_from(
             node_id: aoc_api.home[:node_id],
@@ -1168,77 +1151,75 @@ module Aspera
             node_id: shared_apifid.node_api.app_info.node_info['id'],
             file_id: shared_apifid.file_id
           }
-          token_purpose, short_link_purpose = short_link_purposes(shared_data, link_type)
-          perm_block = lambda do |op, id, access_levels|
-            case op
-            when :create
-              perm_data = {
-                'file_id'       => shared_apifid.file_id,
-                'access_id'     => id,
-                'access_type'   => 'user',
-                'access_levels' => Api::AoC.expand_access_levels(access_levels),
-                'tags'          => {
-                  'url_token'        => true,
-                  'folder_name'      => File.basename(folder),
-                  'created_by_name'  => aoc_api.current_user_info['name'],
-                  'created_by_email' => aoc_api.current_user_info['email'],
-                  '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_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
-              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) }
-              Aspera.assert(!found.nil?, type: Error) { "Short link not found: #{id}" }
-              shared_apifid.node_api.update("permissions/#{found['id']}", {access_levels: Api::AoC.expand_access_levels(access_levels)})
-            when :delete
-              found = shared_apifid.node_api.read('permissions', {file_id: shared_apifid.file_id, inherited: false, access_type: 'user', access_id: id}).first
-              Aspera.assert(!found.nil?, type: Error) { "Short link not found: #{id}" }
-              shared_apifid.node_api.delete("permissions/#{found['id']}")
-            else Aspera.error_unexpected_value(op)
-            end
-          end
           {
-            sl_shared_data:        shared_data,
-            sl_link_type:          link_type,
-            sl_token_purpose:      token_purpose,
-            sl_short_link_purpose: short_link_purpose,
-            sl_perm_block:         perm_block
+            shared_data:        shared_data,
+            token_purpose:      'view_shared_file',
+            short_link_purpose: SHORT_LINK_PURPOSES[link_type],
+            shared_apifid:      shared_apifid
           }
         end
 
+        # Node permission of a public short link on the shared folder (files > short_link only)
+        # @param op            [Symbol]             :create, :update or :delete
+        # @param id            [String]             Short link resource id: access_id of the permission
+        # @param access_levels [String, Array, nil] Access levels for :create and :update
+        def short_link_permission(op, id, access_levels, shared_apifid:, folder:, **)
+          case op
+          when :create
+            perm_data = {
+              'file_id'       => shared_apifid.file_id,
+              'access_id'     => id,
+              'access_type'   => 'user',
+              'access_levels' => Api::AoC.expand_access_levels(access_levels),
+              'tags'          => {
+                'url_token'        => true,
+                'folder_name'      => File.basename(folder),
+                'created_by_name'  => aoc_api.current_user_info['name'],
+                'created_by_email' => aoc_api.current_user_info['email'],
+                '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_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
+            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) }
+            Aspera.assert(!found.nil?, type: Error) { "Short link not found: #{id}" }
+            shared_apifid.node_api.update("permissions/#{found['id']}", {access_levels: Api::AoC.expand_access_levels(access_levels)})
+          when :delete
+            found = shared_apifid.node_api.read('permissions', {file_id: shared_apifid.file_id, inherited: false, access_type: 'user', access_id: id}).first
+            Aspera.assert(!found.nil?, type: Error) { "Short link not found: #{id}" }
+            shared_apifid.node_api.delete("permissions/#{found['id']}")
+          else Aspera.error_unexpected_value(op)
+          end
+        end
+
         # setup: packages > shared_inboxes > short_link
-        # link_type: and dropbox_id: resolved via arguments: on the node, computes purposes.
-        # @return [Hash] ctx keys: sl_shared_data, sl_link_type, sl_token_purpose, sl_short_link_purpose
+        # link_type: and dropbox_id: resolved via arguments: on the node, sets purposes.
+        # @return [Hash] ctx keys: shared_data, token_purpose, short_link_purpose
         def setup_packages_short_link(link_type:, dropbox_id:, **)
-          shared_data = {dropbox_id: dropbox_id, name: ''}
-          token_purpose, short_link_purpose = short_link_purposes(shared_data, link_type)
           {
-            sl_shared_data:        shared_data,
-            sl_link_type:          link_type,
-            sl_token_purpose:      token_purpose,
-            sl_short_link_purpose: short_link_purpose,
-            sl_perm_block:         nil
+            shared_data:        {dropbox_id: dropbox_id, name: ''},
+            token_purpose:      'send_package_to_dropbox',
+            short_link_purpose: SHORT_LINK_PURPOSES[link_type]
           }
         end
 
         # Shared implementation for short_link > create
-        def sl_exec_create(custom_data = {}, sl_shared_data:, sl_link_type:, sl_token_purpose:, sl_short_link_purpose:, sl_perm_block:, **)
-          shared_data = sl_shared_data.dup
-          workspace_id_hash(shared_data)
-          create_payload = {purpose: sl_short_link_purpose, user_selected_name: nil}
-          case sl_link_type
+        def short_link_create(custom_data = {}, shared_data:, link_type:, token_purpose:, short_link_purpose:, **ctx)
+          ws_shared_data = workspace_id_hash(shared_data.dup)
+          create_payload = {purpose: short_link_purpose, user_selected_name: nil}
+          case link_type
           when :private
-            create_payload[:data] = shared_data
+            create_payload[:data] = ws_shared_data
           when :public
             create_payload[:expires_at]       = nil
             create_payload[:password_enabled] = false
-            shared_data[:name] = ''
+            ws_shared_data[:name] = ''
             create_payload[:data] = {
               aoc:            true,
-              url_token_data: {data: shared_data, purpose: sl_token_purpose}
+              url_token_data: {data: ws_shared_data, purpose: token_purpose}
             }
           end
           custom_data = custom_data.dup
@@ -1249,66 +1230,65 @@ module Aspera
           end
           create_payload.deep_merge!(custom_data)
           result_create_short_link = aoc_api.create('short_links', create_payload)
-          sl_perm_block&.call(:create, result_create_short_link['resource_id'], access_levels) if sl_link_type.eql?(:public)
+          short_link_permission(:create, result_create_short_link['resource_id'], access_levels, **ctx) if link_type.eql?(:public) && ctx.key?(:shared_apifid)
           Result::SingleObject.new(result_create_short_link)
         end
 
         # Shared implementation for short_link > delete|list|show|modify: fetch the short_list
-        def sl_fetch_list(sl_shared_data:, sl_link_type:, sl_token_purpose:, sl_short_link_purpose:, **)
-          shared_data = sl_shared_data.dup
-          workspace_id_hash(shared_data)
-          list_params = short_link_list_params(
-            shared_data: shared_data, link_type: sl_link_type,
-            token_purpose: sl_token_purpose, short_link_purpose: sl_short_link_purpose
-          )
+        def short_link_fetch_list(shared_data:, **ctx)
+          ws_shared_data = workspace_id_hash(shared_data.dup)
+          list_params = short_link_list_params(shared_data: ws_shared_data, **ctx)
           {
-            sl_short_list:     aoc_api.read_with_paging('short_links', list_params.merge(query_read_delete(default: {})).compact),
-            sl_shared_data_ws: shared_data
+            short_list:     aoc_api.read_with_paging('short_links', list_params.merge(query_read_delete(default: {}, schema: SHORT_LINK_QUERY_SCHEMA)).compact),
+            ws_shared_data: ws_shared_data
           }
         end
 
         # Shared implementation for short_link > delete
-        def sl_exec_delete(sl_shared_data_ws:, sl_short_list:, sl_link_type:, sl_perm_block:, short_link_id: nil, **)
+        def short_link_delete(ws_shared_data:, short_list:, link_type:, short_link_id: nil, **ctx)
           one_id = short_link_id
-          if sl_link_type.eql?(:public)
-            found = sl_short_list[:items].find { |item| item['id'].eql?(one_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?
-            sl_perm_block&.call(:delete, found['resource_id'], nil)
+            short_link_permission(:delete, found['resource_id'], nil, **ctx) if ctx.key?(:shared_apifid)
           end
-          aoc_api.delete("short_links/#{one_id}", {edit_access: true, json_query: sl_shared_data_ws.to_json})
+          # `edit_access` requires `file_id` and `node_id`: shared folder links only
+          aoc_api.delete("short_links/#{one_id}", ({edit_access: true, json_query: ws_shared_data.to_json} if ctx.key?(:shared_apifid)))
           Result::Status.new('deleted')
         end
 
         # Shared implementation for short_link > list
-        def sl_exec_list(sl_short_list:, **)
-          Result::ObjectList.new(sl_short_list[:items], fields: Formatter.all_but('data'), total: sl_short_list[:total])
+        def short_link_list(short_list:, **)
+          Result::ObjectList.new(short_list[:items], fields: Formatter.all_but('data'), total: short_list[:total])
         end
 
         # Shared implementation for short_link > show
-        def sl_exec_show(sl_short_list:, short_link_id: nil, **)
+        def short_link_show(short_list:, short_link_id: nil, **)
           one_id = short_link_id
-          found = sl_short_list[:items].find { |item| item['id'].eql?(one_id) }
+          found = short_list[:items].find { |item| item['id'].eql?(one_id) }
           raise BadIdentifier.new('Short link', one_id) if found.nil?
           Result::SingleObject.new(found, fields: Formatter.all_but('data'))
         end
 
         # Shared implementation for short_link > modify
-        def sl_exec_modify(custom_data = {}, sl_shared_data:, sl_short_list:, sl_link_type:, sl_perm_block:, short_link_id: nil, **)
-          Aspera.assert_values(sl_link_type, [:public], type: Cli::BadArgument) { 'link_type' }
+        def short_link_modify(custom_data = {}, shared_data:, short_list:, link_type:, short_link_id: nil, **ctx)
+          Aspera.assert_values(link_type, [:public], type: Cli::BadArgument) { 'link_type' }
           one_id = short_link_id
-          node_file = sl_shared_data.slice(:node_id, :file_id)
-          modify_payload = {edit_access: true, json_query: node_file}
+          # Identifies the shared resource: `node_id` and `file_id`, or `dropbox_id`
+          token_data = shared_data.except(:name)
+          # `edit_access` requires `file_id` and `node_id`: shared folder links only
+          modify_payload = ctx.key?(:shared_apifid) ? {edit_access: true, json_query: token_data} : {}
           custom_data = custom_data.dup
           if (pass = custom_data.delete('password'))
             modify_payload[:password_enabled] = true
-            modify_payload[:data] = {url_token_data: {password: pass, data: node_file}}
+            modify_payload[:data] = {url_token_data: {password: pass, data: token_data}}
           else
             modify_payload[:password_enabled] = false
           end
-          if custom_data.delete('access_levels')
-            found = sl_short_list[:items].find { |item| item['id'].eql?(one_id) }
+          if (access_levels = custom_data.delete('access_levels'))
+            found = short_list[:items].find { |item| item['id'].eql?(one_id) }
             raise BadIdentifier.new('Short link', one_id) if found.nil?
-            sl_perm_block&.call(:update, found['resource_id'], nil)
+            short_link_permission(:update, found['resource_id'], access_levels, **ctx) if ctx.key?(:shared_apifid)
           end
           modify_payload.deep_merge!(custom_data)
           aoc_api.update("short_links/#{one_id}", modify_payload)
@@ -1544,9 +1524,6 @@ module Aspera
           Ats.new(context: context, api: ats_api)
         end
 
-        # admin > node > do | bearer_token — setup reuses the generic instance setup
-        # (setup_admin_node_instance is auto-generated above, providing res_id:)
-
         # admin > node > do - mount target: Gen4 commands on the node, admin scope
         def admin_node_do_plugin(node_id:, **)
           nodegen4_plugin(node_id, scope: Api::Node::Scope::ADMIN)
@@ -1617,7 +1594,7 @@ module Aspera
         end
 
         # admin > user > preferences|notifications > show|modify
-        # (setup_admin_user_instance is auto-generated, providing res_id:)
+        # (user_id: argument of the preferences|notifications node)
         %i[preferences notifications].each do |pref|
           pref_path = pref.eql?(:preferences) ? 'user_interaction_preferences' : 'notification_preferences'
           define_action_method([:admin, :user, pref, :show]) do |user_id:, **|

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

@@ -229,12 +229,6 @@ module Aspera
           [Node.new(context: context, api: api_node), {do_root_file_id: ak_data['root_file_id']}]
         end
 
-        def action_api_key_instances
-          instances = ats_api_v2_auth_ibm.read('instances')
-          Log.log.warn { "more instances remaining: #{instances['remaining']}" } unless instances['remaining'].to_i.eql?(0)
-          Result::ValueList.new(instances['data'], name: 'instance')
-        end
-
         def action_access_key_cluster(access_key_id:, **)
           ats_url = ats_api.base_url
           api_ak_auth = Rest::Client.new(
@@ -255,7 +249,7 @@ module Aspera
         def build_ats_ibm_api_with_instance
           instance = options.get_option(:instance)
           if instance.nil?
-            instance = ats_api_v2_auth_ibm.read('instances')['data'].first
+            instance = ats_api_v2_auth_ibm.read('instances')['data']&.first
             formatter.display_status("using first instance: #{instance}")
           end
           ats_api_v2_auth_ibm({'X-ATS-Service-Instance-Id' => instance})

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

@@ -6,6 +6,7 @@ require 'aspera/assert'
 require 'aspera/cli/result'
 require 'aspera/cli/command_registry'
 require 'aspera/cli/option_declarator'
+require 'aspera/cli/special_values'
 require 'aspera/schema/registry'
 
 module Aspera
@@ -26,16 +27,18 @@ module Aspera
         class << self
           include OptionDeclarator
 
-          # Option sources added with `use_options`.
-          # @return [Array<Class, Module>]
+          # Option sources added with `use_options`, with their `on_set` target.
+          # @return [Hash{Class, Module => Proc, nil}]
           def used_option_sources
-            @used_option_sources ||= []
+            @used_option_sources ||= {}
           end
 
           # Include options from another plugin or OptionDeclarator module.
           # @param source [Class, Module]
-          def use_options(source)
-            used_option_sources << source unless used_option_sources.include?(source)
+          # @param target [Proc, nil] Executed on the plugin instance, returns the object for Symbol and Proc `on_set` callbacks
+          #                           of `source` (e.g. `-> { http_config }`); nil: the plugin instance
+          def use_options(source, target: nil)
+            used_option_sources[source] = target unless used_option_sources.key?(source)
           end
 
           # Per-class DSL registry (not inherited: each subclass gets its own instance).
@@ -218,15 +221,15 @@ module Aspera
 
           # Classes and modules whose options apply to this plugin:
           # this class, its plugin ancestors and sources added via `use_options`.
-          # @return [Array<Class, Module>] each responds to `option_specs`
+          # @return [Hash{Class, Module => Proc, nil}] key responds to `option_specs`, value: `on_set` target (see `use_options`)
           def option_sources
-            sources = []
+            sources = {}
             ancestors.each do |klass|
               next unless klass.is_a?(Class) && klass <= Base
-              sources << klass if klass.instance_variable_defined?(:@command_registry)
-              sources.concat(klass.used_option_sources)
+              sources[klass] = nil if klass.instance_variable_defined?(:@command_registry) && !sources.key?(klass)
+              klass.used_option_sources.each { |src, src_target| sources[src] = src_target unless sources.key?(src) }
             end
-            sources.uniq
+            sources
           end
 
           # Declare all options of `option_sources` onto a Parser instance.
@@ -235,9 +238,10 @@ module Aspera
           # @param target  [Base, nil] plugin instance for Symbol and Proc `on_set` callbacks; nil: such callbacks are not bound
           # @param parse   [Boolean] whether to call parse_options! after declaring
           def declare_options(options, target: nil, parse: false)
-            option_sources.each do |src|
+            option_sources.each do |src, src_target|
+              src_target = src_target.nil? ? target : target&.instance_exec(&src_target)
               src.option_specs.each_value do |spec|
-                spec.declare_on(options, target: target) unless options.option_declared?(spec.name)
+                spec.declare_on(options, target: src_target) unless options.option_declared?(spec.name)
               end
             end
             options.parse_options! if parse
@@ -312,11 +316,6 @@ module Aspera
         # @return [Aspera::Cli::TransferProgress, nil]
         def progress_bar; @context.progress_bar; end
 
-        def add_manual_header(_has_options = true)
-          # No-op: the group is set at the start of initialize.
-          # Kept for compatibility with Config, which calls add_manual_header(false) from Runner.
-        end
-
         # Entry point for all DSL-based plugins.
         def execute_action
           @help_path = nil
@@ -390,7 +389,8 @@ module Aspera
           # (mounted children are only walked here for --help, see below).
           # With --help, conditions are not evaluated: they may need the API, which is not built for help.
           available = children.reject { |id, c| c.condition && !@context.help_requested && registry.local?(current_path + [id]) && !send(c.condition) }
-          aliases   = children.values.each_with_object({}) do |c, h|
+          # Aliases of available commands only: an alias must not bypass the condition of its command
+          aliases   = available.values.each_with_object({}) do |c, h|
             Array(c.aliases).each { |a| h[a] = c.id } if c.aliases
           end
 
@@ -485,14 +485,19 @@ module Aspera
         end
 
         # Resolve positional arguments from the CLI argument stream, in order.
-        # Arguments already present in `ctx` are not read again.
+        # Arguments already present in `ctx` (e.g. injected by a setup method) are not read from the command line.
+        # If the next CLI argument is that same value, or `ALL`, it is skipped, so that it is not mistaken for a later argument
+        # (e.g. `faspex5 packages receive ALL` with a public link to a package).
         # For type: :identifier, the percent-selector lookup receives the ctx accumulated so far.
         # @param arg_specs [Array<ArgumentSpec>]
         # @param ctx       [Hash] accumulated context
         # @return [Hash] ctx merged with the resolved arguments
         def resolve_arguments(arg_specs, ctx)
           arg_specs.each do |arg_spec|
-            next if ctx.key?(arg_spec.name)
+            if ctx.key?(arg_spec.name)
+              options.get_next_argument(arg_spec.name.to_s, mandatory: false) if options.next_argument_in?([ctx[arg_spec.name].to_s, SpecialValues::ALL])
+              next
+            end
             lookup_cb = arg_spec.lookup if arg_spec.type.eql?(:identifier)
             current = ctx
             block =
@@ -508,6 +513,7 @@ module Aspera
 
         # Resolve a single positional argument from the CLI argument stream.
         # When arg_spec.bulk is true, always returns an Array (normalized to [value] when non-bulk).
+        # Only such arguments are read as a list with `--bulk=yes`: others (e.g. the id of a parent node) are single values.
         # For type: :identifier, an optional block provides the percent-selector lookup.
         # @param arg_spec [ArgumentSpec]
         # @yieldparam field [String]  field name from a percent-selector (%field:value)
@@ -518,7 +524,7 @@ module Aspera
           if arg_spec.bulk
             is_bulk = options.get_option(:bulk)
             if arg_spec.type.eql?(:identifier)
-              val = options.instance_identifier(description: arg_spec.name.to_s, &block)
+              val = options.instance_identifier(description: arg_spec.name.to_s, multiple: is_bulk, &block)
             else
               val = options.get_next_argument(
                 arg_spec.name.to_s,
@@ -539,19 +545,19 @@ module Aspera
               options.instance_identifier(description: arg_spec.name.to_s, &block)
             else
               # Class or Array<Class> -> pass as validation type
-              # When interactive: true, set ask_missing_mandatory so that get_interactive is triggered
-              # when no CLI arguments are provided (mandatory is forced to true for the same reason:
-              # a non-nil default would short-circuit get_interactive before it is ever called).
-              options.ask_missing_mandatory = true if arg_spec.interactive
-              options.get_next_argument(
-                arg_spec.name.to_s,
-                mandatory:   arg_spec.interactive ? true : arg_spec.mandatory,
-                multiple:    arg_spec.multiple || false,
-                validation:  arg_spec.type,
-                accept_list: arg_spec.allowed,
-                default:     arg_spec.interactive ? nil : arg_spec.default,
-                schema:      arg_spec.schema
-              )
+              # When interactive: true, prompt for this argument only when no CLI argument is provided
+              # (mandatory is forced to true and default ignored: a non-nil default would short-circuit the prompt).
+              options.with_interactive(enabled: arg_spec.interactive) do
+                options.get_next_argument(
+                  arg_spec.name.to_s,
+                  mandatory:   arg_spec.interactive ? true : arg_spec.mandatory,
+                  multiple:    arg_spec.multiple || false,
+                  validation:  arg_spec.type,
+                  accept_list: arg_spec.allowed,
+                  default:     arg_spec.interactive ? nil : arg_spec.default,
+                  schema:      arg_spec.schema
+                )
+              end
             end
           end
         end