aspera-cli 4.27.0 → 4.27.1

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # cspell:ignore snid fnid bidi ssync asyncs rund asnodeadmin mkfile mklink asperabrowser asperabrowserurl watchfolders watchfolderd entsrv
+require 'aspera/schema/registry'
 require 'aspera/cli/plugins/basic_auth'
 require 'aspera/cli/sync_actions'
 require 'aspera/cli/special_values'
@@ -22,30 +23,6 @@ module Aspera
       class Node < BasicAuth
         include SyncActions
 
-        # Processing of paths in arguments and results
-        # Used only by Faspex4 to browse packages
-        class NodePathPrefix
-          def initialize(path)
-            @root = path
-          end
-
-          # get next path argument from command line, and add prefix
-          def add_to_path(path_arg)
-            File.join(@root, path_arg)
-          end
-
-          # get remaining path arguments from command line, and add prefix
-          def add_to_paths!(path_args)
-            path_args.map!{ |p| add_to_path(p)}
-          end
-
-          def remove_in_object_list!(obj_list)
-            obj_list.each do |item|
-              item['path'] = item['path'].delete_prefix(@root) if item['path'].start_with?(@root)
-            end
-          end
-        end
-
         application_name 'HSTS Node API'
 
         SESSION_TIME_FIELDS = %i[start end].freeze
@@ -82,31 +59,12 @@ module Aspera
               }
             rescue StandardError => e
               error = e
-              Log.log.debug{"detect error: #{e}"}
+              Log.log.debug { "detect error: #{e}" }
             end
             raise error if error
             return
           end
 
-          # Called by non-Node plugins (Ats, Cos, Aoc) to declare Node options on their
-          # own options object. The DSL registry is walked so descriptions stay in one place.
-          def declare_options(options)
-            return if options.option_declared?(:root_id)
-            command_registry.option_specs.each_value do |spec|
-              next if options.option_declared?(spec.name)
-              options.declare(
-                spec.name,
-                description: spec.description,
-                short:       spec.short,
-                allowed:     spec.allowed,
-                default:     spec.default,
-                handler:     spec.handler,
-                schema:      spec.schema
-              )
-            end
-            options.parse_options!
-          end
-
           # Using /files/browse: is it a folder (node and shares)
           def gen3_entry_folder?(entry)
             FOLDER_TYPES.include?(entry['type'])
@@ -114,7 +72,7 @@ module Aspera
         end
 
         # DSL option declarations - at class level, picked up by Base#initialize via ancestor chain.
-        # Also exposed via Node.declare_options for non-Node plugins (Ats, Cos, Aoc).
+        # Included by other plugins (Ats, Cos, Aoc) via `use_options Node`.
         option :validator,        description: 'Identifier of validator (optional for central)'
         option :asperabrowserurl, description: 'URL for simple aspera web ui', default: 'https://asperabrowser.mybluemix.net'
         option :node_api,         description: 'Gen4: standard_ports: Use standard FASP ports (true) or get from node API (false). cache: Set to false to force actual file system read',
@@ -149,37 +107,83 @@ module Aspera
         SEARCH_REMOVE_FIELDS = %w[basename permissions].freeze
 
         # Actions in execute_command_gen3
-        COMMANDS_GEN3 = %i[search space mkdir mklink mkfile rename delete browse upload download cat sync transport spec]
-
-        BASE_ACTIONS = %i[api_details].concat(COMMANDS_GEN3).freeze
+        COMMANDS_GEN3 = %i[search space mkdir mklink mkfile rename delete ls upload download cat sync transport spec]
+
+        # Shared DSL metadata for Gen3 commands (description:, arguments:, transfer_paths:, aliases:).
+        # Consumed by commands_under(:files) in shares.rb and commands_under %i[source node]) in faspex.rb.
+        # :sync is excluded (intermediate node with sub-commands, handled separately).
+        # action: entries are node-specific and intentionally omitted.
+        COMMANDS_GEN3_SPEC = {
+          search:      {description: 'Search for files',             arguments: [{name: :search_root, type: String}]},
+          space:       {description: 'Show space information',       arguments: [{name: :path_list, multiple: true}]},
+          mkdir:       {description: 'Create a folder (Gen3)',       arguments: [{name: :path_list, multiple: true}]},
+          mklink:      {description: 'Create a symbolic link (Gen3)', arguments: [{name: :target, type: String}, {name: :link_path, type: String}]},
+          mkfile:      {description: 'Create a file (Gen3)', arguments: [{name: :file_path, type: String}, {name: :contents, mandatory: false, default: nil}]},
+          rename:      {description: 'Rename a file or folder (Gen3)', arguments: [{name: :path_base, type: String}, {name: :path_src, type: String}, {name: :path_dst, type: String}]},
+          delete:      {description: 'Delete files or folders (Gen3)', arguments: [{name: :paths, multiple: true}]},
+          ls:          {description: 'List files (Gen3)',            arguments: [{name: :path, type: String}], aliases: [:browse]},
+          upload:      {description: 'Upload files (Gen3)',          transfer_paths: :send},
+          download:    {description: 'Download files (Gen3)',        transfer_paths: :receive},
+          cat:         {description: 'Show file contents (Gen3)',    arguments: [{name: :remote_path, type: String}]},
+          transport:   {description: 'Show transport parameters'},
+          spec:        {description: 'Show transfer spec base'},
+          api_details: {description: 'Show API details'},
+          health:      {description: 'Check node health'},
+          events:      {description: 'List events'},
+          info:        {description: 'Show node info'},
+          slash:       {description: 'Show root info'},
+          license:     {description: 'Show license'},
+          access_keys: {description: 'Manage access keys'}
+        }.freeze
+
+        BASE_ACTIONS = (%i[api_details] + COMMANDS_GEN3).freeze
 
         SPECIAL_ACTIONS = %i[health events info slash license].freeze
 
         # commands for : `execute_simple_common`: actions used commonly when a node is involved
-        COMMON_ACTIONS = %i[access_keys].concat(BASE_ACTIONS).concat(SPECIAL_ACTIONS).freeze
+        COMMON_ACTIONS = (%i[access_keys] + BASE_ACTIONS + SPECIAL_ACTIONS).freeze
 
         private_constant :CENTRAL_SOAP_API_TEST, :SEARCH_REMOVE_FIELDS, :BASE_ACTIONS, :SPECIAL_ACTIONS, :COMMON_ACTIONS
 
         # used in aoc
-        NODE4_READ_ACTIONS = %i[bearer_token_node node_info browse find].freeze
+        NODE4_READ_ACTIONS = %i[bearer_token_node node_info ls find].freeze
 
         # commands for execute_command_gen4
-        COMMANDS_GEN4 = %i[mkdir mklink mkfile rename delete upload download sync cat show modify permission thumbnail v3].concat(NODE4_READ_ACTIONS).freeze
+        COMMANDS_GEN4 = (%i[mkdir mklink mkfile rename delete upload download sync cat show modify permission thumbnail v3] + NODE4_READ_ACTIONS).freeze
+
+        # Shared DSL metadata for all Gen4 commands (description:, arguments:, transfer_paths:, aliases:).
+        # Consumed by commands_under %i[access_keys do]) in node.rb and by aoc.rb.
+        # :sync and :permission are excluded: they are intermediate nodes handled separately.
+        SINGLE_PATH_ARG = [{name: :path, type: String}].freeze
+        COMMANDS_GEN4_SPEC = {
+          mkdir:             {description: 'Create folder',                  arguments: SINGLE_PATH_ARG},
+          mklink:            {description: 'Create symbolic link',           arguments: SINGLE_PATH_ARG},
+          mkfile:            {description: 'Create file',                    arguments: [{name: :path, type: String}, {name: :contents, mandatory: false, default: nil}]},
+          rename:            {description: 'Rename entry',                   arguments: [{name: :source_path, type: String}, {name: :new_name, type: String}]},
+          delete:            {description: 'Delete entry',                   arguments: [{name: :paths, type: String, bulk: true}]},
+          upload:            {description: 'Upload files',                   transfer_paths: :send},
+          download:          {description: 'Download files',                 transfer_paths: :receive},
+          modify:            {description: 'Modify file',                    arguments: [{name: :path, type: String}, {name: :update_value, type: Hash, schema: 'node:components.schemas.files-id-put-request'}]},
+          cat:               {description: 'Show file contents',             arguments: SINGLE_PATH_ARG},
+          show:              {description: 'Show file info',                 arguments: SINGLE_PATH_ARG},
+          thumbnail:         {description: 'Show file thumbnail',            arguments: SINGLE_PATH_ARG},
+          bearer_token_node: {description: 'Show bearer token for file node', arguments: SINGLE_PATH_ARG},
+          node_info:         {description: 'Show node info for file',        arguments: SINGLE_PATH_ARG},
+          ls:                {description: 'List files',                     arguments: SINGLE_PATH_ARG, aliases: [:browse]},
+          find:              {description: 'Find files',                     arguments: SINGLE_PATH_ARG + FILTER_ARGS},
+          v3:                {description: 'Legacy v3 commands on files'}
+        }.freeze
+        private_constant :SINGLE_PATH_ARG
 
         # commands supported in ATS for COS
         COMMANDS_COS = %i[upload download info access_keys api_details transfer].freeze
         COMMANDS_SHARES = (BASE_ACTIONS - %i[search]).freeze
-        COMMANDS_FASPEX = COMMON_ACTIONS
-
         # `browse` display fields for gen4
         GEN4_LS_FIELDS = %w[name type recursive_size size modified_time access_level].freeze
 
         # @param api [Rest] an existing API object for the Node API
-        # @param prefix_path [String,nil] for Faspex 4, allows browsing a package without full path in node (removes storage prefix)
-        def initialize(context:, api: nil, prefix_path: nil)
-          @node_path_prefix = prefix_path ? NodePathPrefix.new(prefix_path) : nil
+        def initialize(context:, api: nil)
           super(context: context, basic_options: api.nil?)
-          Node.declare_options(options)
           return if context.only_manual?
           @api_node =
             if !api.nil?
@@ -207,7 +211,7 @@ module Aspera
         # Gen3 API
         # @param path [String] starting path
         def browse_gen3(path)
-          folders_to_process = @node_path_prefix.nil? ? path : @node_path_prefix.add_to_path(path)
+          folders_to_process = path
           folders_to_process = [folders_to_process]
           query = options.get_option(:query) || {}
           # special parameter: max number of entries in result
@@ -220,7 +224,7 @@ module Aspera
           single_call = query.key?('skip')
           # API default is 100, so use 1000 for default
           query['count'] ||= 1000
-          Aspera.assert(!(recursive && single_call), type: Cli::BadArgument){'options `recursive` and `skip` cannot be used together'}
+          Aspera.assert(!(recursive && single_call), type: Cli::BadArgument) { 'options `recursive` and `skip` cannot be used together' }
           all_items = []
           until folders_to_process.empty?
             path = folders_to_process.shift
@@ -231,10 +235,7 @@ module Aspera
               # example: send_result={'items'=>[{'file'=>"filename1","permissions"=>[{'name'=>'read'},{'name'=>'write'}]}]}
               response = @api_node.create('files/browse', query)
               # 'file','symbolic_link'
-              if !Node.gen3_entry_folder?(response['self']) || only_path
-                @node_path_prefix&.remove_in_object_list!([response['self']])
-                return Result::SingleObject.new(response['self'])
-              end
+              return Result::SingleObject.new(response['self']) if !Node.gen3_entry_folder?(response['self']) || only_path
               items = response['items']
               total_count ||= response['total_count']
               all_items.concat(items)
@@ -242,7 +243,7 @@ module Aspera
                 formatter.display_item_count(response['item_count'], total_count)
                 break
               end
-              folders_to_process.concat(items.select{ |i| Node.gen3_entry_folder?(i)}.map{ |i| i['path']}) if recursive
+              folders_to_process.concat(items.select { |i| Node.gen3_entry_folder?(i) }.map { |i| i['path'] }) if recursive
               if !max_items.nil? && (all_items.count >= max_items)
                 all_items = all_items.slice(0, max_items) if all_items.count > max_items
                 break
@@ -254,7 +255,6 @@ module Aspera
             end
             query.delete('skip')
           end
-          @node_path_prefix&.remove_in_object_list!(all_items)
           return Result::ObjectList.new(all_items)
         ensure
           RestParameters.instance.spinner_cb.call(action: :success)
@@ -297,7 +297,7 @@ module Aspera
         # @param path        [String] plain path or %id:<file_id> selector
         def apifid_from_path(top_file_id, path)
           if (m = Parser.percent_selector(path))
-            Aspera.assert_values(m[:field], ['id'], type: BadArgument){'file id'}
+            Aspera.assert_values(m[:field], ['id'], type: BadArgument) { 'file id' }
             val = m[:value]
             return Api::NodeFileId.new(@api_node, val.nil? || val.empty? ? top_file_id : val)
           end
@@ -309,7 +309,7 @@ module Aspera
         # (intermediate nodes whose path cannot yet be injected via execute_leaf).
         def apifid_from_next_arg(top_file_id)
           file_path = options.instance_identifier(description: 'path or %id:<id> or %id:') do |attribute, value|
-            Aspera.assert_values(attribute, ['id'], type: BadArgument){'file id'}
+            Aspera.assert_values(attribute, ['id'], type: BadArgument) { 'file id' }
             return Api::NodeFileId.new(@api_node, value.nil? || value.empty? ? top_file_id : value)
           end
           @api_node.resolve_api_fid(top_file_id, file_path)
@@ -321,21 +321,30 @@ module Aspera
         # @return [Integer] id of the sync
         # @raise [Cli::BadArgument] if no such sync, or not by name
         def async_lookup(field, value)
-          Aspera.assert_values(field, ['name'], type: Cli::BadArgument){'search field'}
+          Aspera.assert_values(field, ['name'], type: Cli::BadArgument) { 'search field' }
           async_ids = @api_node.read('async/list')['sync_ids']
           summaries = @api_node.create('async/summary', {'syncs' => async_ids})['sync_summaries']
-          selected = summaries.find{ |s| s['name'].eql?(value)}
+          selected = summaries.find { |s| s['name'].eql?(value) }
           raise Cli::BadIdentifier.new('sync', value, field: field) if selected.nil?
           return selected['snid']
         end
 
+        # Lookup for access_keys: only supports %id:self selector.
+        # @param field [String] must be 'id'
+        # @param value [String] must be 'self'
+        # @return [String] the resolved access key id
+        def lookup_access_key_self_id(field, value, **)
+          Aspera.assert(field.eql?('id') && value.eql?('self'), type: BadArgument) { 'only selector: %id:self' }
+          @api_node.read('access_keys/self')['id']
+        end
+
         # Search /asyncs by name
         # @param field [String] name of the field to search
         # @param value [String] value of the field to search
         # @return [Integer] id of the sync
         # @raise [Cli::BadArgument] if no such sync, or not by name
         def ssync_lookup(field, value)
-          Aspera.assert_values(field, ['name'], type: Cli::BadArgument){'search field'}
+          Aspera.assert_values(field, ['name'], type: Cli::BadArgument) { 'search field' }
           @api_node.read('asyncs')['ids'].each do |id|
             sync_info = @api_node.read("asyncs/#{id}")['configuration']
             # name is unique, so we can return
@@ -346,106 +355,77 @@ module Aspera
 
         # --- DSL command declarations ---
 
-        # Gen3 leaf commands
-        command :search,      description: 'Search for files',
-          arguments: [{name: :search_root, type: String}]
-        command :space,       description: 'Show space information',
-          arguments: [{name: :path_list, multiple: true}]
-        command :mkdir,       description: 'Create a folder (Gen3)',
-          arguments: [{name: :path_list, multiple: true}]
-        command :mklink,      description: 'Create a symbolic link (Gen3)',
-          arguments: [{name: :target, type: String}, {name: :link_path, type: String}]
-        command :mkfile,      description: 'Create a file (Gen3)',
-          arguments: [{name: :file_path, type: String}, {name: :contents, mandatory: false, default: nil}]
-        command :rename,      description: 'Rename a file or folder (Gen3)',
-          arguments: [{name: :path_base, type: String}, {name: :path_src, type: String}, {name: :path_dst, type: String}]
-        command :delete,      description: 'Delete files or folders (Gen3)',
-          arguments: [{name: :paths, multiple: true}]
-        command :browse,      description: 'Browse files (Gen3)',
-          arguments: [{name: :path, type: String}],
-          action: ->(path:, **){browse_gen3(path)}
-        command :upload,      description: 'Upload files (Gen3)',   transfer_paths: :send
-        command :download,    description: 'Download files (Gen3)', transfer_paths: :receive
-        command :cat,         description: 'Show file contents (Gen3)',
-          arguments: [{name: :remote_path, type: String}]
-        command :sync,        description: 'Synchronize folders (Gen3)'
-        commands_under(:sync) do
+        # Gen3 leaf commands — metadata from COMMANDS_GEN3_SPEC; action: added where node-specific.
+        # :sync is declared separately (intermediate node with sub-commands).
+        GEN3_NODE_ACTIONS = {
+          ls:          ->(path:, **) { browse_gen3(path) },
+          transport:   ->(**) { Result::SingleObject.new(@api_node.transport_params) },
+          spec:        ->(**) { Result::SingleObject.new(@api_node.base_spec, fields: Formatter.all_but(Transfer::Spec::SPECIFIC)) },
+          api_details: ->(**) { Result::SingleObject.new({base_url: @api_node.base_url}.merge(@api_node.params)) },
+          events:      ->(**) { Result::ObjectList.new(@api_node.read('events', query_read_delete(schema: Schema::Registry.query_params(Schema::Registry::NODE, 'events'))), fields: ->(f) { !f.start_with?('data') }) },
+          info:        ->(**) { Result::SingleObject.new(@api_node.read('info')) },
+          slash:       ->(**) { Result::SingleObject.new(@api_node.read('')) },
+          license:     ->(**) { Result::SingleObject.new(@api_node.read('license')) }
+        }.freeze
+        private_constant :GEN3_NODE_ACTIONS
+        COMMANDS_GEN3_SPEC.each do |cmd, spec|
+          next if cmd.eql?(:sync)        # intermediate node with sub-commands
+          next if cmd.eql?(:access_keys) # intermediate node declared separately below
+          action = GEN3_NODE_ACTIONS[cmd]
+          command cmd, **spec, **(action ? {action: action} : {})
+        end
+        command :sync, description: 'Synchronize folders (Gen3)'
+        commands_under :sync do
           Sync::Operations::DIRECTIONS.each do |dir|
-            command(dir, description: "#{dir.capitalize}-sync (Gen3)", transfer_paths: :send)
+            command dir, description: "#{dir.capitalize}-sync (Gen3)", transfer_paths: :send, arguments: SyncActions::PATH_AND_INFO_ARGS
           end
           command :admin, description: 'Manage sync database (admin operations)'
-          SyncActions.register_sync_admin_commands(self, %i[sync admin])
-        end
-        command :transport,   description: 'Show transport parameters',
-          action: ->{Result::SingleObject.new(@api_node.transport_params)}
-        command :spec,        description: 'Show transfer spec base',
-          action: ->{Result::SingleObject.new(@api_node.base_spec, fields: Formatter.all_but(Transfer::Spec::SPECIFIC))}
-        # Other common leaf commands
-        command :api_details, description: 'Show API details',
-          action: ->{Result::SingleObject.new({base_url: @api_node.base_url}.merge(@api_node.params))}
-        command :health,      description: 'Check node health'
-        command :events,      description: 'List events',
-          action: ->{Result::ObjectList.new(@api_node.read('events', query_read_delete), fields: ->(f){!f.start_with?('data')})}
-        command :info,        description: 'Show node info',
-          action: ->{Result::SingleObject.new(@api_node.read('info'))}
-        command :slash,       description: 'Show root info',
-          action: ->{Result::SingleObject.new(@api_node.read(''))}
-        command :license,     description: 'Show license',
-          action: ->{Result::SingleObject.new(@api_node.read('license'))}
+          SyncActions.register_sync_admin_commands(self, :admin)
+        end
         # access_keys sub-tree
         command :access_keys, description: 'Manage access keys'
-        commands_under(:access_keys) do
+        commands_under :access_keys do
           command :do, description: 'Execute Gen4 command via access key',
             arguments: [{name: :access_key_id, type: :identifier}],
             setup: :setup_access_key_do
           command :set_bearer_key, description: 'Set bearer key on access key',
             arguments: [{name: :access_key_id}, {name: :bearer_key_pem, type: String}]
-          Operations::ALL.each{ |op| command(op, description: "#{op.capitalize} access key(s)")}
-        end
-
-        # Commands requiring a single path argument (Gen4)
-        COMMANDS_GEN4_SINGLE_PATH = %i[mkdir mklink browse cat show find thumbnail bearer_token_node node_info].freeze
-        private_constant :COMMANDS_GEN4_SINGLE_PATH
-
-        commands_under(%i[access_keys do]) do
-          COMMANDS_GEN4.each do |cmd|
-            next if cmd.eql?(:sync) # sync is an intermediate node declared below
-            kwargs = {description: "Gen4 #{cmd} command"}
-            kwargs[:setup] = :setup_access_key_do_permission if cmd.eql?(:permission)
-            kwargs[:arguments] = [{name: :source_path, type: String}, {name: :new_name, type: String}] if cmd.eql?(:rename)
-            kwargs[:arguments] = [{name: :paths, type: String, bulk: true}] if cmd.eql?(:delete)
-            kwargs[:arguments] = [{name: :path, type: String}, {name: :contents, mandatory: false, default: nil}] if cmd.eql?(:mkfile)
-            kwargs[:arguments] = [{name: :path, type: String}, {name: :update_value, type: Hash}] if cmd.eql?(:modify)
-            kwargs[:arguments] = [{name: :path, type: String}] if COMMANDS_GEN4_SINGLE_PATH.include?(cmd)
-            kwargs[:transfer_paths] = :send     if cmd.eql?(:upload)
-            kwargs[:transfer_paths] = :receive  if cmd.eql?(:download)
-            command(cmd, **kwargs)
+          crud_commands entity: 'access_keys',
+            api:            :@api_node,
+
+            body_component: Schema::Registry::NODE,
+            lookup:         :lookup_access_key_self_id
+        end
+
+        commands_under %i[access_keys do] do
+          COMMANDS_GEN4_SPEC.each do |cmd, spec|
+            command cmd, **spec
           end
-          command :sync, description: 'Synchronize folders (Gen4)'
-          commands_under(%i[access_keys do sync]) do
+          command :permission, description: 'Manage permissions', setup: :setup_access_key_do_permission
+          command :sync, description: 'Synchronize folders'
+          commands_under :sync do
             Sync::Operations::DIRECTIONS.each do |dir|
-              command(dir, description: "#{dir.capitalize}-sync (Gen4)", transfer_paths: :send)
+              command dir, description: "#{dir.capitalize}-sync", transfer_paths: :send, arguments: SyncActions::PATH_AND_INFO_ARGS
             end
             command :admin, description: 'Manage sync database (admin operations)'
-            SyncActions.register_sync_admin_commands(self, %i[access_keys do sync admin])
+            SyncActions.register_sync_admin_commands(self, :admin)
           end
         end
-        commands_under(%i[access_keys do permission]) do
+        commands_under %i[access_keys do permission] do
           command :list,   description: 'List permissions on a file'
           command :show,   description: 'Show a permission',
             arguments: [{name: :perm_id, type: :identifier}],
-            action: ->(apifid:, perm_id:, **){Result::SingleObject.new(apifid.node_api.read("permissions/#{perm_id}"))}
+            action: ->(apifid:, perm_id:, **) { Result::SingleObject.new(apifid.node_api.read("permissions/#{perm_id}")) }
           command :create, description: 'Create a permission',
-            arguments: [{name: :data, type: Hash}]
+            arguments: [{name: :data, type: Hash, schema: 'node:components.schemas.permissions-post-request'}]
           command :modify, description: 'Modify a permission',
-            arguments: [{name: :perm_id, type: :identifier}, {name: :data, type: Hash}]
-          command :delete, description: 'Delete permission(s)',
+            arguments: [{name: :perm_id, type: :identifier}, {name: :data, type: Hash, schema: 'node:components.schemas.permissions-id-put-request'}]
+          command :delete, description: 'Delete permissions',
             arguments: [{name: :perm_id, bulk: true}]
         end
         # async (legacy /async)
-        command :async, description: 'Manage async operations (legacy /async)'
-        commands_under(:async) do
-          command :list,      description: 'List async sync IDs', action: ->{Result::ValueList.new(@api_node.read('async/list')['sync_ids'])}
+        commands_under :async, description: 'synchronization (legacy /async)' do
+          command :list,      description: 'List async sync IDs', action: -> { Result::ValueList.new(@api_node.read('async/list')['sync_ids']) }
           command :show,      description: 'Show async summary',
             arguments: [{name: :async_id, type: :identifier, lookup: :async_lookup}]
           command :delete,    description: 'Delete async',
@@ -458,73 +438,70 @@ module Aspera
             arguments: [{name: :async_id, type: :identifier, lookup: :async_lookup}]
         end
         # ssync (/asyncs)
-        command :ssync, description: 'Manage sync operations (/asyncs)'
-        commands_under(:ssync) do
-          command :create,    description: 'Create ssync',         action: ->{entity_execute(api: @api_node, entity: :asyncs, command: :create, items_key: 'ids'){ |f, v| ssync_lookup(f, v)}}
-          command :list,      description: 'List ssync',           action: ->{entity_execute(api: @api_node, entity: :asyncs, command: :list,   items_key: 'ids'){ |f, v| ssync_lookup(f, v)}}
-          command :show,      description: 'Show ssync',
-            arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}"))}
-          command :delete,    description: 'Delete ssync',
-            arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: :action_ssync_delete
-          command :start,     description: 'Start a sync',
+        # command :ssync, description: 'Manage sync operations (/asyncs)'
+        commands_under :ssync, description: 'synchronization (/asyncs)' do
+          crud_commands entity: 'asyncs',
+            api: :@api_node,
+            operations: %i[create list show delete],
+            items_key: 'ids',
+            lookup: :ssync_lookup
+          command :start, description: 'Start a sync',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
             action: :action_ssync_start
-          command :stop,      description: 'Stop a sync',
+          command :stop, description: 'Stop a sync',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
             action: :action_ssync_stop
           command :bandwidth, description: 'Show sync bandwidth',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/bandwidth", options.get_option(:query) || {}))}
-          command :counters,  description: 'Show sync counters',
+            action: ->(ssync_id:, **) { Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/bandwidth", options.get_option(:query) || {})) }
+          command :counters, description: 'Show sync counters',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/counters", options.get_option(:query) || {}))}
-          command :files,     description: 'List sync files',
+            action: ->(ssync_id:, **) { Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/counters", options.get_option(:query) || {})) }
+          command :files, description: 'List sync files',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/files", options.get_option(:query) || {}))}
-          command :state,     description: 'Show sync state',
+            action: ->(ssync_id:, **) { Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/files", options.get_option(:query) || {})) }
+          command :state, description: 'Show sync state',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/state"))}
-          command :summary,   description: 'Show sync summary',
+            action: ->(ssync_id:, **) { Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/state")) }
+          command :summary, description: 'Show sync summary',
             arguments: [{name: :ssync_id, type: :identifier, lookup: :ssync_lookup}],
-            action: ->(ssync_id:, **){Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/summary"))}
+            action: ->(ssync_id:, **) { Result::SingleObject.new(@api_node.read("asyncs/#{ssync_id}/summary")) }
         end
         # stream
         command :stream, description: 'Manage stream operations'
-        commands_under(:stream) do
-          command :list,   description: 'List streams', action: ->{Result::ObjectList.new(@api_node.read('ops/transfers', query_read_delete), fields: %w[id status])}
+        commands_under :stream do
+          command :list,   description: 'List streams', action: -> { Result::ObjectList.new(@api_node.read('ops/transfers', query_read_delete), fields: %w[id status]) }
           command :create, description: 'Create a stream',
-            arguments: [{name: :data, type: Hash}],
-            action: ->(data:, **){Result::SingleObject.new(@api_node.create('streams', data))}
+            arguments: [{name: :data, type: Hash, schema: 'node:components.schemas.transferPostRequest'}],
+            action: ->(data:, **) { Result::SingleObject.new(@api_node.create('streams', data)) }
           command :show,   description: 'Show a stream',
             arguments: [{name: :transfer_id, type: :identifier}],
-            action: ->(transfer_id:, **){Result::SingleObject.new(@api_node.read("ops/transfers/#{transfer_id}"))}
+            action: ->(transfer_id:, **) { Result::SingleObject.new(@api_node.read("ops/transfers/#{transfer_id}")) }
           command :modify, description: 'Modify a stream',
-            arguments: [{name: :transfer_id, type: :identifier}, {name: :data, type: Hash}],
-            action: ->(data:, transfer_id:, **){Result::SingleObject.new(@api_node.update("streams/#{transfer_id}", data))}
+            arguments: [{name: :transfer_id, type: :identifier}, {name: :data, type: Hash, schema: 'node:components.schemas.transferPutRequest'}],
+            action: ->(data:, transfer_id:, **) { Result::SingleObject.new(@api_node.update("streams/#{transfer_id}", data)) }
           command :cancel, description: 'Cancel a stream',
             arguments: [{name: :transfer_id, type: :identifier}],
-            action: ->(transfer_id:, **){Result::SingleObject.new(@api_node.cancel("streams/#{transfer_id}"))}
+            action: ->(transfer_id:, **) { Result::SingleObject.new(@api_node.cancel("streams/#{transfer_id}")) }
         end
         # transfer
         command :transfer, description: 'Manage transfer operations'
-        commands_under(:transfer) do
-          command :list,              description: 'List transfers'
-          command :cancel,            description: 'Cancel a transfer',
+        commands_under :transfer do
+          command :list, description: 'List transfers'
+          command :cancel, description: 'Cancel a transfer',
             arguments: [{name: :transfer_id, type: :identifier}]
-          command :show,              description: 'Show a transfer',
+          command :show, description: 'Show a transfer',
             arguments: [{name: :transfer_id, type: :identifier}],
-            action: ->(transfer_id:, **){Result::SingleObject.new(@api_node.read("ops/transfers/#{transfer_id}"))}
+            action: ->(transfer_id:, **) { Result::SingleObject.new(@api_node.read("ops/transfers/#{transfer_id}")) }
           command :modify,            description: 'Modify a transfer',
-            arguments: [{name: :transfer_id, type: :identifier}, {name: :update_value, type: Hash}]
+            arguments: [{name: :transfer_id, type: :identifier}, {name: :update_value, type: Hash, schema: 'node:components.schemas.transferPutRequest'}]
           command :bandwidth_average, description: 'Show average bandwidth per period'
           command :sessions,          description: 'List transfer sessions'
         end
         # service
         command :service, description: 'Manage services'
-        commands_under(:service) do
-          command :list,   description: 'List services', action: ->{Result::ObjectList.new(@api_node.read('rund/services')['services'])}
+        commands_under :service do
+          command :list,   description: 'List services', action: -> { Result::ObjectList.new(@api_node.read('rund/services')['services']) }
           command :create, description: 'Create a service',
             arguments: [{name: :creation_data, type: Hash}]
           command :delete, description: 'Delete a service',
@@ -532,34 +509,34 @@ module Aspera
         end
         # watch_folder
         command :watch_folder, description: 'Manage watch folders', setup: :setup_watch_folder
-        commands_under(:watch_folder) do
+        commands_under :watch_folder do
           command :create, description: 'Create a watch folder',
             arguments: [{name: :data, type: Hash}],
-            action: ->(data:, **){Result::Status.new("#{@api_node.create('v3/watchfolders', data)['id']} created")}
+            action: ->(data:, **) { Result::Status.new("#{@api_node.create('v3/watchfolders', data)['id']} created") }
           command :list,   description: 'List watch folders',
-            action: ->{Result::ValueList.new(@api_node.read('v3/watchfolders', query_read_delete)['ids'])}
+            action: -> { Result::ValueList.new(@api_node.read('v3/watchfolders', query_read_delete)['ids']) }
           command :show,   description: 'Show a watch folder',
-            arguments: [{name: :res_id, type: :identifier}],
-            action: ->(res_id:, **){Result::SingleObject.new(@api_node.read("v3/watchfolders/#{res_id}"))}
+            arguments: [{name: :watch_folder_id, type: :identifier}],
+            action: ->(watch_folder_id:, **) { Result::SingleObject.new(@api_node.read("v3/watchfolders/#{watch_folder_id}")) }
           command :modify, description: 'Modify a watch folder',
-            arguments: [{name: :res_id, type: :identifier}, {name: :data, type: Hash}]
+            arguments: [{name: :watch_folder_id, type: :identifier}, {name: :data, type: Hash}]
           command :delete, description: 'Delete a watch folder',
-            arguments: [{name: :res_id, type: :identifier}]
+            arguments: [{name: :watch_folder_id, type: :identifier}]
           command :state,  description: 'Show watch folder state',
-            arguments: [{name: :res_id, type: :identifier}],
-            action: ->(res_id:, **){Result::SingleObject.new(@api_node.read("v3/watchfolders/#{res_id}/state"))}
+            arguments: [{name: :watch_folder_id, type: :identifier}],
+            action: ->(watch_folder_id:, **) { Result::SingleObject.new(@api_node.read("v3/watchfolders/#{watch_folder_id}/state")) }
         end
         # central
         command :central, description: 'Query Central service'
-        commands_under(:central) do
+        commands_under :central do
           command :session, description: 'Query sessions'
           command :file,    description: 'Query files'
         end
-        commands_under(%i[central session]) do
+        commands_under %i[central session] do
           command :list, description: 'List sessions',
             arguments: [{name: :request_data, type: Hash, mandatory: false, default: nil}]
         end
-        commands_under(%i[central file]) do
+        commands_under %i[central file] do
           command :list,   description: 'List file transfers',
             arguments: [{name: :request_data, type: Hash, mandatory: false, default: nil}]
           command :modify, description: 'Modify file transfer validation',
@@ -567,72 +544,60 @@ module Aspera
         end
         # Standalone leaf commands
         command :asperabrowser, description: 'Open Aspera browser'
-        command :basic_token,   description: 'Generate basic auth token', action: ->{Result::Text.new(Rest.basic_authorization(options.get_option(:username, mandatory: true), options.get_option(:password, mandatory: true)))}
+        command :basic_token,   description: 'Generate basic auth token', action: -> { Result::Text.new(Rest.basic_authorization(options.get_option(:username, mandatory: true), options.get_option(:password, mandatory: true))) }
         command :bearer_token, description: 'Generate bearer token',
-          arguments: [{name: :private_key_pem, type: String}, {name: :user_group_id, type: Hash}]
+          arguments: [{name: :private_key_pem, type: String}, {name: :user_group_id, type: Hash, schema: 'opts:components.schemas.NodeBearerTokenOptions'}]
         command :simulator,     description: 'Start node simulator',
-          arguments: [{name: :parameters, type: Hash, mandatory: false, default: {}}]
+          arguments: [{name: :parameters, type: Hash, mandatory: false, default: {}, schema: 'opts:components.schemas.NodeSimulatorOptions'}]
         command :telemetry,     description: 'Report telemetry to external system',
-          arguments: [{name: :parameters, type: Hash, mandatory: false, default: {}}]
+          arguments: [{name: :parameters, type: Hash, mandatory: false, default: {}, schema: 'opts:components.schemas.NodeTelemetryOptions'}]
 
         # --- Handler methods (Gen3) ---
 
         def action_delete(paths:, **)
           # TODO: add query for recursive
           paths_to_delete = Array(paths)
-          @node_path_prefix&.add_to_paths!(paths_to_delete)
-          resp = @api_node.create('files/delete', {paths: paths_to_delete.map{ |i| {'path' => i.start_with?('/') ? i : "/#{i}"}}})
+          resp = @api_node.create('files/delete', {paths: paths_to_delete.map { |i| {'path' => i.start_with?('/') ? i : "/#{i}"} }})
           cli_result_from_paths_response(resp, 'file deleted')
         end
 
         def action_search(search_root:, **)
-          search_root = @node_path_prefix.nil? ? search_root : @node_path_prefix.add_to_path(search_root)
           parameters = {'path' => search_root}
           other_options = options.get_option(:query)
           parameters.merge!(other_options) unless other_options.nil?
           resp = @api_node.create('files/search', parameters)
           return Result::Empty.new if resp['items'].empty?
-          fields = resp['items'].first.keys.reject{ |i| SEARCH_REMOVE_FIELDS.include?(i)}
+          fields = resp['items'].first.keys.reject { |i| SEARCH_REMOVE_FIELDS.include?(i) }
           formatter.display_item_count(resp['item_count'], resp['total_count'])
-          formatter.display_status("params: #{resp['parameters'].keys.map{ |k| "#{k}:#{resp['parameters'][k]}"}.join(',')}")
-          @node_path_prefix&.remove_in_object_list!(resp['items'])
+          formatter.display_status("params: #{resp['parameters'].keys.map { |k| "#{k}:#{resp['parameters'][k]}" }.join(',')}")
           Result::ObjectList.new(resp['items'], fields: fields)
         end
 
         def action_space(path_list:, **)
           path_list = Array(path_list)
-          @node_path_prefix&.add_to_paths!(path_list)
-          resp = @api_node.create('space', {'paths' => path_list.map{ |i| {path: i}}})
-          @node_path_prefix&.remove_in_object_list!(resp['paths'])
+          resp = @api_node.create('space', {'paths' => path_list.map { |i| {path: i} }})
           Result::ObjectList.new(resp['paths'])
         end
 
         def action_mkdir(path_list:, **)
           path_list = Array(path_list)
-          @node_path_prefix&.add_to_paths!(path_list)
-          resp = @api_node.create('files/create', {'paths' => path_list.map{ |i| {type: :directory, path: i}}})
+          resp = @api_node.create('files/create', {'paths' => path_list.map { |i| {type: :directory, path: i} }})
           cli_result_from_paths_response(resp, 'folder created')
         end
 
         def action_mklink(target:, link_path:, **)
-          target    = @node_path_prefix.nil? ? target : @node_path_prefix.add_to_path(target)
-          one_path  = @node_path_prefix.nil? ? link_path : @node_path_prefix.add_to_path(link_path)
-          resp = @api_node.create('files/create', {'paths' => [{type: :symbolic_link, path: one_path, target: {path: target}}]})
+          resp = @api_node.create('files/create', {'paths' => [{type: :symbolic_link, path: link_path, target: {path: target}}]})
           cli_result_from_paths_response(resp, 'link created')
         end
 
         def action_mkfile(file_path:, contents:, **)
-          one_path = @node_path_prefix.nil? ? file_path : @node_path_prefix.add_to_path(file_path)
           contents64 = contents.nil? ? '' : Base64.strict_encode64(contents)
-          resp = @api_node.create('files/create', {'paths' => [{type: :file, path: one_path, contents: contents64}]})
+          resp = @api_node.create('files/create', {'paths' => [{type: :file, path: file_path, contents: contents64}]})
           cli_result_from_paths_response(resp, 'file created')
         end
 
         def action_rename(path_base:, path_src:, path_dst:, **)
           # TODO: multiple ?
-          path_base = @node_path_prefix.nil? ? path_base : @node_path_prefix.add_to_path(path_base)
-          path_src  = @node_path_prefix.nil? ? path_src  : @node_path_prefix.add_to_path(path_src)
-          path_dst  = @node_path_prefix.nil? ? path_dst  : @node_path_prefix.add_to_path(path_dst)
           resp = @api_node.create('files/rename', {'paths' => [{'path' => path_base, 'source' => path_src, 'destination' => path_dst}]})
           cli_result_from_paths_response(resp, 'entry moved')
         end
@@ -646,14 +611,14 @@ module Aspera
               'files/sync_setup',
               {transfer_requests: [{transfer_request: request_transfer_spec}]}
             )['transfer_specs'].first['transfer_spec']
-            transfer_spec.delete_if{ |_k, v| v.nil?}
+            transfer_spec.delete_if { |_k, v| v.nil? }
             Log.dump(:ts, transfer_spec)
             transfer_spec
           end
         end
 
         Sync::Operations::DIRECTIONS.each do |dir|
-          define_method(:"action_sync_#{dir}"){ |**| run_sync_transfer(dir, &sync_gen3_block)}
+          define_method(:"action_sync_#{dir}") { |path:, sync_info: {}, **| run_sync_transfer(dir, path: path, sync_info: sync_info, &sync_gen3_block) }
         end
 
         def action_upload
@@ -684,7 +649,6 @@ module Aspera
         end
 
         def action_cat(remote_path:, **)
-          remote_path = @node_path_prefix.nil? ? remote_path : @node_path_prefix.add_to_path(remote_path)
           http = @api_node.read("files/#{URI.encode_www_form_component(remote_path)}/contents", ret: :resp)
           Result::Text.new(http.body)
         end
@@ -727,24 +691,14 @@ module Aspera
           Result::Status.new('Updated')
         end
 
-        def action_watch_folder_modify(data:, res_id:, **)
-          @api_node.update("v3/watchfolders/#{res_id}", data)
-          Result::Status.new("#{res_id} updated")
+        def action_watch_folder_modify(data:, watch_folder_id:, **)
+          @api_node.update("v3/watchfolders/#{watch_folder_id}", data)
+          Result::Status.new("#{watch_folder_id} updated")
         end
 
-        def action_watch_folder_delete(res_id:, **)
-          @api_node.delete("v3/watchfolders/#{res_id}")
-          Result::Status.new("#{res_id} deleted")
-        end
-
-        # access_keys > CRUD
-        Operations::ALL.each do |op|
-          define_action_method([:access_keys, op]) do
-            entity_execute(api: @api_node, entity: 'access_keys', command: op) do |field, value|
-              Aspera.assert(field.eql?('id') && value.eql?('self'), type: BadArgument){'only selector: %id:self'}
-              @api_node.read('access_keys/self')['id']
-            end
-          end
+        def action_watch_folder_delete(watch_folder_id:, **)
+          @api_node.delete("v3/watchfolders/#{watch_folder_id}")
+          Result::Status.new("#{watch_folder_id} deleted")
         end
 
         # access_keys > do - setup: resolve access key and root file id
@@ -756,7 +710,7 @@ module Aspera
             ak_info = @api_node.read("access_keys/#{access_key_id}")
             ak_secret = context.secret_finder.lookup(url: @api_node.base_url, username: ak_info['id'])
             if !access_key_id.eql?('self')
-              Aspera.assert(ak_secret, type: Cli::MissingArgument){"Please provide secret for #{ak_info['id']} using option: secret or by setting a preset for #{ak_info['id']}@#{@api_node.base_url}."}
+              Aspera.assert(ak_secret, type: Cli::MissingArgument) { "Please provide secret for #{ak_info['id']} using option: secret or by setting a preset for #{ak_info['id']}@#{@api_node.base_url}." }
               @api_node.auth_params[:username] = ak_info['id']
               @api_node.auth_params[:password] = ak_secret
             end
@@ -772,8 +726,8 @@ module Aspera
           {apifid: apifid_from_next_arg(@do_root_file_id)}
         end
 
-        # access_keys > do > browse
-        def action_access_keys_do_browse(path:, do_root_file_id:, **)
+        # access_keys > do > ls
+        def action_access_keys_do_ls(path:, do_root_file_id:, **)
           apifid = apifid_from_path(do_root_file_id, path)
           file_info = apifid.node_api.read("files/#{apifid.file_id}", headers: Api::Node.add_cache_control)
           return Result::ObjectList.new([file_info], fields: GEN4_LS_FIELDS) unless file_info['type'].eql?('folder')
@@ -781,9 +735,9 @@ module Aspera
         end
 
         # access_keys > do > find
-        def action_access_keys_do_find(path:, do_root_file_id:, **)
+        def action_access_keys_do_find(path:, filter: nil, do_root_file_id:, **)
           apifid = apifid_from_path(do_root_file_id, path)
-          Result::ObjectList.new(@api_node.find_files(apifid.file_id, Api::Node.file_matcher_from_argument(options)), fields: ['path'])
+          Result::ObjectList.new(@api_node.find_files(apifid.file_id, Base.file_matcher(filter)), fields: ['path'])
         end
 
         # access_keys > do > cat
@@ -820,8 +774,7 @@ module Aspera
 
         # access_keys > do > delete
         def action_access_keys_do_delete(paths:, do_root_file_id:, **)
-          is_bulk = options.get_option(:bulk)
-          Result.bulk(paths, is_bulk: is_bulk, command: :delete, id_result: 'path', bfail: options.get_option(:bfail)) do |l_path|
+          bulk_result(paths, command: :delete, id_result: 'path') do |l_path|
             apifid = if (m = Parser.percent_selector(l_path))
               Aspera.assert_values(m[:field], ['id'], type: BadIdentifier)
               Api::NodeFileId.new(@api_node, m[:value])
@@ -843,8 +796,8 @@ module Aspera
         end
 
         Sync::Operations::DIRECTIONS.each do |dir|
-          define_method(:"action_access_keys_do_sync_#{dir}") do |do_root_file_id:, **|
-            run_sync_transfer(dir, &sync_gen4_block(do_root_file_id))
+          define_method(:"action_access_keys_do_sync_#{dir}") do |path:, sync_info: {}, do_root_file_id:, **|
+            run_sync_transfer(dir, path: path, sync_info: sync_info, &sync_gen4_block(do_root_file_id))
           end
         end
 
@@ -884,7 +837,7 @@ module Aspera
           when :oauth2
             result[:username] = apifid.node_api.params[:headers][Api::Node::HEADER_X_ASPERA_ACCESS_KEY]
             result[:password] = apifid.node_api.oauth.authorization
-          else Aspera.error_unexpected_value(apifid.node_api.auth_params[:type]){'Node API Auth type'}
+          else Aspera.error_unexpected_value(apifid.node_api.auth_params[:type]) { 'Node API Auth type' }
           end
           [apifid, result]
         end
@@ -897,7 +850,7 @@ module Aspera
         def action_access_keys_do_bearer_token_node(path:, do_root_file_id:, **)
           apifid, result = gen4_apifid_info(do_root_file_id, path)
           Log.dump(:result, result)
-          Aspera.assert(apifid.node_api.auth_params[:type].eql?(:oauth2), type: BadArgument){"Cannot get bearer token if authenticating with secret (#{apifid.node_api.auth_params[:type]})"}
+          Aspera.assert(apifid.node_api.auth_params[:type].eql?(:oauth2), type: BadArgument) { "Cannot get bearer token if authenticating with secret (#{apifid.node_api.auth_params[:type]})" }
           Aspera.assert(OAuth::Factory.bearer_auth?(result[:password]), 'Not using bearer token auth')
           Result::Text.new(result[:password])
         end
@@ -924,8 +877,8 @@ module Aspera
           if check_exists
             folder_content = apifid.node_api.read("files/#{apifid.file_id}/files")
             link_name = ".#{new_item}.asp-lnk"
-            found = folder_content.find{ |i| i['name'].eql?(new_item) || i['name'].eql?(link_name)}
-            Aspera.assert(!found, type: Cli::Error){"A #{found['type']} already exists with name #{new_item}"}
+            found = folder_content.find { |i| i['name'].eql?(new_item) || i['name'].eql?(link_name) }
+            Aspera.assert(!found, type: Cli::Error) { "A #{found['type']} already exists with name #{new_item}" }
           end
           [apifid, payload]
         end
@@ -961,9 +914,7 @@ module Aspera
         end
 
         def action_access_keys_do_permission_delete(perm_id:, apifid:, **)
-          is_bulk = options.get_option(:bulk)
-          items = perm_id.is_a?(Array) ? perm_id : [perm_id]
-          Result.bulk(items, is_bulk: is_bulk, command: :delete, bfail: options.get_option(:bfail)) do |one_id|
+          bulk_result(perm_id, command: :delete) do |one_id|
             apifid.node_api.delete("permissions/#{one_id}")
             the_app = apifid.node_api.app_info
             the_app&.api&.permissions_send_event(event_data: {}, app_info: the_app, types: ['permission.deleted'])
@@ -973,7 +924,7 @@ module Aspera
 
         def action_access_keys_do_permission_create(data:, apifid:, **)
           create_param = data
-          Aspera.assert(!create_param.key?('file_id'), type: Cli::BadArgument){'no file_id'}
+          Aspera.assert(!create_param.key?('file_id'), type: Cli::BadArgument) { 'no file_id' }
           create_param['file_id'] = apifid.file_id
           create_param['access_levels'] = Api::Node::ACCESS_LEVELS unless create_param.key?('access_levels')
           the_app = apifid.node_api.app_info
@@ -1036,7 +987,7 @@ module Aspera
               data:    iteration_data,
               id:      IdGenerator.from_list('sync_files', options.get_option(:url, mandatory: true), options.get_option(:username, mandatory: true), async_id)
             )
-            data.select!{ |l| l['fnid'].to_i > iteration_data.first} unless iteration_data.first.nil?
+            data.select! { |l| l['fnid'].to_i > iteration_data.first } unless iteration_data.first.nil?
             iteration_data[0] = data.last['fnid'].to_i unless data.empty?
           end
           return Result::Empty.new if data.empty?
@@ -1051,15 +1002,6 @@ module Aspera
           Result::SingleObject.new(resp)
         end
 
-        def action_ssync_delete(ssync_id:, **)
-          is_bulk = options.get_option(:bulk)
-          items = ssync_id.is_a?(Array) ? ssync_id : [ssync_id]
-          Result.bulk(items, is_bulk: is_bulk, command: :delete, bfail: options.get_option(:bfail)) do |one_id|
-            @api_node.delete("asyncs/#{one_id}", query_read_delete)
-            {'id' => one_id}
-          end
-        end
-
         def action_ssync_start(ssync_id:, **)
           @api_node.call(operation: 'POST', subpath: "asyncs/#{ssync_id}/start", content_type: Mime::TEXT, body: '', ret: :resp).body
           Result::Status.new('Done')
@@ -1072,7 +1014,7 @@ module Aspera
 
         # transfer sub-commands
         def action_transfer_list
-          transfer_filter = query_read_delete(default: {})
+          transfer_filter = query_read_delete(default: {}, schema: Schema::Registry.query_params(Schema::Registry::NODE, 'ops/transfers'))
           iteration_persistency = nil
           if options.get_option(:once_only, mandatory: true)
             iteration_persistency = PersistencyActionOnce.new(
@@ -1094,8 +1036,8 @@ module Aspera
         end
 
         def action_transfer_sessions
-          transfers_data = @api_node.read('ops/transfers', query_read_delete)
-          sessions = transfers_data.flat_map{ |t| t['sessions']}
+          transfers_data = @api_node.read('ops/transfers', query_read_delete(schema: Schema::Registry.query_params(Schema::Registry::NODE, 'ops/transfers')))
+          sessions = transfers_data.flat_map { |t| t['sessions'] }
           sessions.each do |session|
             SESSION_TIME_FIELDS.each do |what|
               session["#{what}_time"] = session["#{what}_time_usec"] ? Time.at(session["#{what}_time_usec"] / 1_000_000.0).utc.iso8601(0) : nil
@@ -1115,7 +1057,7 @@ module Aspera
         end
 
         def action_transfer_bandwidth_average
-          transfers_data = @api_node.read('ops/transfers', query_read_delete)
+          transfers_data = @api_node.read('ops/transfers', query_read_delete(schema: Schema::Registry.query_params(Schema::Registry::NODE, 'ops/transfers')))
           bandwidth_period = {}
           dir_info = %i[avg_kbps sessions].freeze
           transfers_data.each do |t|
@@ -1129,7 +1071,7 @@ module Aspera
             end_date = all_dates[index + 1]
             break if end_date.nil?
             period_bandwidth = Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).to_h do |dir|
-              [dir, dir_info.to_h{ |k2| [k2, 0]}]
+              [dir, dir_info.to_h { |k2| [k2, 0] }]
             end
             transfers_data.each do |t|
               next if t['avg_rate_kbps'].zero?
@@ -1138,7 +1080,7 @@ module Aspera
               info[:avg_kbps] += t['avg_rate_kbps']
               info[:sessions] += 1
             end
-            next if Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).all?{ |dir| period_bandwidth[dir][:sessions].zero?}
+            next if Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).all? { |dir| period_bandwidth[dir][:sessions].zero? }
             result.push({start: Time.at(start_date / 1_000_000), end: Time.at(end_date / 1_000_000)}.merge(period_bandwidth))
           end
           Result::ObjectList.new(result)
@@ -1211,7 +1153,7 @@ module Aspera
         def action_simulator(parameters: {}, **)
           require 'aspera/node_simulator'
           parameters = parameters.symbolize_keys
-          uri = URI.parse(parameters.delete(:url){WebServerSimple::DEFAULT_URL})
+          uri = URI.parse(parameters.delete(:url) { WebServerSimple::DEFAULT_URL })
           server = WebServerSimple.new(uri, **parameters.slice(*WebServerSimple::PARAMS))
           server.mount(uri.path, NodeSimulatorServlet, parameters.except(*WebServerSimple::PARAMS), NodeSimulator.new)
           server.start
@@ -1221,13 +1163,13 @@ module Aspera
         def action_telemetry(parameters: {}, **)
           parameters = parameters.symbolize_keys
           %i[url key].each do |psym|
-            Aspera.assert(parameters.key?(psym), type: Cli::BadArgument){"Missing parameter: #{psym}"}
+            Aspera.assert(parameters.key?(psym), type: Cli::BadArgument) { "Missing parameter: #{psym}" }
           end
           require 'socket'
           parameters[:interval] = 10 unless parameters.key?(:interval)
           parameters[:hostname] = Socket.gethostname unless parameters.key?(:hostname)
           interval = parameters[:interval].to_f
-          Aspera.assert(interval > 0, type: Cli::BadArgument){'Interval must be a positive number in seconds'}
+          Aspera.assert(interval > 0, type: Cli::BadArgument) { 'Interval must be a positive number in seconds' }
           otel_api = Rest.new(
             base_url: "#{parameters[:url]}/v1",
             headers: {
@@ -1294,16 +1236,19 @@ module Aspera
           end
         end
 
-        # Dispatch a command that has already been read from the argument stream.
-        # Used when a new Node instance is created and the command was already consumed
-        # (e.g., :v3 delegation, shares, cos, faspex).
-        # Re-enters the DSL registry for all commands so Proc handlers and sub-trees
+        # Dispatch a Gen3 command that has already been read from the argument stream.
+        # Used when a new Node instance is created by an external plugin (shares, faspex, cos, :v3)
+        # and the command symbol was already consumed before the Node was instantiated.
+        # Re-enters the DSL registry so Proc actions and intermediate nodes (sync, access_keys)
         # are resolved normally.
+        # Pre-resolved CLI arguments (e.g. path:) can be forwarded via +ctx+ to avoid
+        # re-consuming tokens that were already resolved by the calling plugin's DSL.
         # @param command [Symbol] command already consumed from the argument stream
+        # @param ctx     [Hash]   pre-resolved context (keyword args forwarded to dispatch)
         # @return [Object] CLI result
-        def dispatch_v3_command(command)
-          Aspera.assert_values(command, COMMANDS_GEN3 + %i[health events info slash license api_details access_keys transfer]){'v3 command'}
-          dispatch_from_registry([command], {})
+        def dispatch_v3_command(command, **ctx)
+          Aspera.assert_values(command, COMMANDS_GEN3 + %i[health events info slash license api_details access_keys transfer]) { 'v3 command' }
+          dispatch_from_registry([command], ctx)
         end
 
         private
@@ -1317,21 +1262,20 @@ module Aspera
           response['paths'].each do |p|
             result = success_msg
             if p.key?('error')
-              Log.log.error{"#{p['error']['user_message']} : #{p['path']}"}
+              Log.log.error { "#{p['error']['user_message']} : #{p['path']}" }
               result = p['error']['user_message']
               errors.push([p['path'], p['error']['user_message']])
             end
             obj_list.push({'path' => p['path'], 'result' => result})
           end
           # one error make all fail
-          raise errors.map{ |i| "#{i.first}: #{i.last}"}.join(', ') unless errors.empty?
+          raise errors.map { |i| "#{i.first}: #{i.last}" }.join(', ') unless errors.empty?
           obj_list
         end
 
         # Translates paths results into CLI result, and removes prefix
         def cli_result_from_paths_response(response, success_msg)
           obj_list = response_to_result(response, success_msg)
-          @node_path_prefix&.remove_in_object_list!(obj_list)
           return Result::ObjectList.new(obj_list, fields: %w[path result])
         end
       end