aspera-cli 4.26.2 → 4.27.0

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

@@ -26,7 +26,7 @@ module Aspera
                 login_page = Rest
                   .new(base_url: url, redirect_max: 2)
                   .read('', headers: {'Accept'=>'text/html'})
-                raise 'not Shares' unless login_page.include?('aspera-Shares')
+                Aspera.assert(login_page.include?('aspera-Shares')){'not Shares'}
                 if (m = login_page.match(/\(v([0-9a-f\.]+)\)/))
                   version = m[1]
                   if (m = login_page.match(/Patch level ([0-9]+)/))
@@ -91,129 +91,323 @@ module Aspera
 
         def initialize(**_)
           super
+          @api_shares_admin = nil
         end
 
         SAML_IMPORT_MANDATORY = %w[id name_id].freeze
         SAML_IMPORT_ALLOWED = %w[email given_name surname].concat(SAML_IMPORT_MANDATORY).freeze
 
-        ACTIONS = %i[health info files admin].freeze
         # common to users and groups
         USR_GRP_SETTINGS = %i[transfer_settings app_authorizations share_permissions].freeze
 
-        def execute_action
-          command = options.get_next_command(ACTIONS, aliases: {repository: :files})
-          case command
-          when :health
-            nagios = Nagios.new
-            shares_url = options.get_option(:url, mandatory: true)
-            health = self.class.health_check(shares_url)
-            nagios.add_ok('version', health[:version]) if health[:version].is_a?(String)
-            if health[:ping].is_a?(String)
-              nagios.add_ok('ping', health[:ping])
-            else
-              nagios.add_critical('ping', health[:ping].to_s)
+        # --- DSL ---
+
+        command :health,   description: 'Check Shares health'
+        command :info,     description: 'Show server information', action: ->{Result::SingleObject.new(basic_auth_api(NODE_API_PATH).read('info', headers: {'Content-Type'=>'application/json'}))}
+        command :files,    description: 'Browse and transfer files on Shares', aliases: [:repository], setup: :setup_shares_node
+        command :admin,    description: 'Administer Shares', setup: :setup_admin
+
+        commands_under(:admin) do
+          entity_command :node, api: :@api_shares_admin, entity: 'data/nodes'
+          command :share,             description: 'Manage shares'
+          command :transfer_settings, description: 'Manage transfer settings'
+          command :user,              description: 'Manage users'
+          command :group,             description: 'Manage groups'
+        end
+
+        # admin > user / group: sub-commands per location, generated for both entity types
+        %i[user group].each do |entity_type|
+          commands_under([:admin, entity_type]) do
+            command :all,   description: "#{entity_type.capitalize}s from all sources"
+            command :local, description: "Local #{entity_type}s"
+            command :ldap,  description: "LDAP #{entity_type}s"
+            command :saml,  description: "SAML #{entity_type}s"
+          end
+
+          # all: list/show/delete + USR_GRP_SETTINGS [+ users for group]
+          commands_under([:admin, entity_type, :all]) do
+            (Operations::ALL - [:create]).each do |op|
+              command(op, description: "#{op.capitalize} #{entity_type}(s)")
             end
-            if health[:api].is_a?(String)
-              nagios.add_ok('API', health[:api])
-            else
-              nagios.add_critical('API', health[:api].to_s)
+            USR_GRP_SETTINGS.each do |setting|
+              setting_ops = setting.eql?(:share_permissions) ? Operations::ALL : %i[show modify]
+              lookup_method = :"lookup_shares_#{entity_type}_all_id"
+              command(
+                setting, description: "Manage #{setting} for a #{entity_type}",
+                arguments: [{name: :entity_id, type: :identifier, lookup: lookup_method}]
+              )
+              commands_under([:admin, entity_type, :all, setting]) do
+                setting_ops.each do |op|
+                  command(op, description: "#{op.capitalize} #{setting} for a #{entity_type}")
+                end
+              end
             end
-            Result::ObjectList.new(nagios.status_list)
-          when :info
-            return Result::SingleObject.new(basic_auth_api(NODE_API_PATH).read('info', headers: {'Content-Type'=>'application/json'}))
-          when :files
-            api_shares_node = basic_auth_api(NODE_API_PATH)
-            repo_command = options.get_next_command(Node::COMMANDS_SHARES)
-            return Node
-                .new(context: context, api: api_shares_node)
-                .execute_action(repo_command)
-          when :admin
-            api_shares_admin = basic_auth_api(ADMIN_API_PATH)
-            admin_command = options.get_next_command(%i[node share transfer_settings user group].freeze)
-            lookup_share = ->(field, value){RestList.lookup_entity_generic(entity: 'share', field: field, value: value){api_shares_admin.read('data/shares')}['id']}
-            case admin_command
-            when :node
-              return entity_execute(api: api_shares_admin, entity: 'data/nodes')
-            when :share
-              share_command = options.get_next_command(%i[user_permissions group_permissions].concat(Operations::ALL))
-              case share_command
-              when *Operations::ALL
-                return entity_execute(
-                  api:            api_shares_admin,
-                  entity:         'data/shares',
-                  command:        share_command,
-                  display_fields: %w[id name node_id directory percent_free],
-                  &lookup_share
-                )
-              when :user_permissions, :group_permissions
-                share_id = options.instance_identifier(&lookup_share)
-                return entity_execute(api: api_shares_admin, entity: "data/shares/#{share_id}/#{share_command}")
+            if entity_type.eql?(:group)
+              command(
+                :users, description: 'Manage users of a group',
+                arguments: [{name: :group_id, type: :identifier}]
+              )
+              commands_under([:admin, entity_type, :all, :users]) do
+                Operations::ALL.each do |op|
+                  command(op, description: "#{op.capitalize} users of a group")
+                end
               end
-            when :transfer_settings
-              xfer_settings_command = options.get_next_command(%i[show modify])
-              return entity_execute(
-                api: api_shares_admin,
-                entity: 'data/transfer_settings',
-                command: xfer_settings_command,
-                is_singleton: true
+            end
+          end
+
+          # local: list/show/delete/create/modify [+ users for group]
+          commands_under([:admin, entity_type, :local]) do
+            Operations::ALL.each do |op|
+              command(op, description: "#{op.capitalize} #{entity_type}(s)")
+            end
+            USR_GRP_SETTINGS.each do |setting|
+              setting_ops = setting.eql?(:share_permissions) ? Operations::ALL : %i[show modify]
+              lookup_method = :"lookup_shares_#{entity_type}_local_id"
+              command(
+                setting, description: "Manage #{setting} for a #{entity_type}",
+                arguments: [{name: :entity_id, type: :identifier, lookup: lookup_method}]
               )
-            when :user, :group
-              entity_type = admin_command
-              entities_location = options.get_next_command(%i[all local ldap saml])
-              entities_prefix = entities_location.eql?(:all) ? '' : "#{entities_location}_"
-              entities_path = "data/#{entities_prefix}#{entity_type}s"
-              entity_commands = nil
-              case entities_location
-              when :all
-                entity_commands = %i[list show delete]
-                entity_commands.concat(USR_GRP_SETTINGS)
-                entity_commands.push(:users) if entity_type.eql?(:group)
-                entity_commands.freeze
-              when :local
-                entity_commands = %i[list show delete create modify]
-                entity_commands.push(:users) if entity_type.eql?(:group)
-                entity_commands.freeze
-              when :ldap
-                entity_commands = %i[add].freeze
-              when :saml
-                entity_commands = %i[import].freeze
+              commands_under([:admin, entity_type, :local, setting]) do
+                setting_ops.each do |op|
+                  command(op, description: "#{op.capitalize} #{setting} for a #{entity_type}")
+                end
               end
-              entity_verb = options.get_next_command(entity_commands)
-              lookup_block = ->(field, value){RestList.lookup_entity_generic(entity: entity_type, field: field, value: value){api_shares_admin.read(entities_path)}['id']}
-              case entity_verb
-              when *Operations::ALL
-                display_fields = entity_type.eql?(:user) ? %w[id user_id username first_name last_name email] : nil
-                display_fields.push('directory_user') if entity_type.eql?(:user) && entities_location.eql?(:all)
-                return entity_execute(
-                  api:            api_shares_admin,
-                  entity:         entities_path,
-                  command:        entity_verb,
-                  display_fields: display_fields,
-                  &lookup_block
-                )
-              when *USR_GRP_SETTINGS # transfer_settings, app_authorizations, share_permissions
-                group_id = options.instance_identifier(&lookup_block)
-                entities_path = "#{entities_path}/#{group_id}/#{entity_verb}"
-                return entity_execute(api: api_shares_admin, entity: entities_path, is_singleton: !entity_verb.eql?(:share_permissions), &lookup_share)
-              when :import # saml
-                return do_bulk_operation(command: entity_verb, descr: 'user information') do |entity_parameters|
-                  entity_parameters = entity_parameters.transform_keys{ |k| k.gsub(/\s+/, '_').downcase}
-                  Aspera.assert_type(entity_parameters, Hash)
-                  SAML_IMPORT_MANDATORY.each{ |p| raise "missing mandatory field: #{p}" if entity_parameters[p].nil?}
-                  entity_parameters.each_key do |p|
-                    raise "unsupported field: #{p}, use: #{SAML_IMPORT_ALLOWED.join(',')}" unless SAML_IMPORT_ALLOWED.include?(p)
-                  end
-                  api_shares_admin.create("#{entities_path}/import", entity_parameters)
+            end
+            if entity_type.eql?(:group)
+              command(
+                :users, description: 'Manage users of a group',
+                arguments: [{name: :group_id, type: :identifier}]
+              )
+              commands_under([:admin, entity_type, :local, :users]) do
+                Operations::ALL.each do |op|
+                  command(op, description: "#{op.capitalize} users of a group")
                 end
-              when :add # ldap
-                return do_bulk_operation(command: entity_verb, descr: "#{entity_type} name", values: String) do |entity_name|
-                  api_shares_admin.create(entities_path, {entity_type=>entity_name})
+              end
+            end
+          end
+
+          # ldap: add only
+          commands_under([:admin, entity_type, :ldap]) do
+            command :add, description: "Add a LDAP #{entity_type}",
+              arguments: [{name: :entity_name, type: String, bulk: true}]
+          end
+
+          # saml: import only
+          commands_under([:admin, entity_type, :saml]) do
+            command :import, description: "Import a SAML #{entity_type}",
+              arguments: [{name: :entity_parameters, type: Hash, bulk: true}]
+          end
+        end
+
+        ENTITY_LOCATIONS = %i[all local].freeze
+        SHARE_DISPLAY_FIELDS = %w[id name node_id directory percent_free].freeze
+        private_constant :ENTITY_LOCATIONS, :SHARE_DISPLAY_FIELDS
+
+        # Lookup methods used by arguments:(:identifier, lookup:) on setting nodes.
+        # One method per entity_type/location combination; each returns the entity id.
+        %i[user group].each do |entity_type|
+          ENTITY_LOCATIONS.each do |location|
+            lookup_method = :"lookup_shares_#{entity_type}_#{location}_id"
+            define_method(lookup_method) do |field, value, **|
+              path = admin_entity_path(entity_type, location)
+              RestList.lookup_entity_generic(entity: entity_type, field: field, value: value){@api_shares_admin.read(path)}['id']
+            end
+            private lookup_method
+          end
+        end
+
+        commands_under(%i[admin share]) do
+          Operations::ALL.each do |op|
+            command(op, description: "#{op.capitalize} share(s)", action: lambda do
+              entity_execute(
+                api: @api_shares_admin, entity: 'data/shares', command: op,
+                display_fields: SHARE_DISPLAY_FIELDS
+              ){ |f, v| lookup_share_id(f, v)}
+            end)
+          end
+          command(
+            :user_permissions, description: 'Manage user permissions on a share',
+            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}]
+          )
+          command(
+            :group_permissions, description: 'Manage group permissions on a share',
+            arguments: [{name: :share_id, type: :identifier, lookup: :lookup_share_id}]
+          )
+        end
+
+        %i[user_permissions group_permissions].each do |perm_type|
+          commands_under([:admin, :share, perm_type]) do
+            Operations::ALL.each do |op|
+              command(op, description: "#{op.capitalize} #{perm_type}")
+            end
+          end
+        end
+
+        commands_under(%i[admin transfer_settings]) do
+          entity_command :show,   description: 'Show transfer settings',   api: :@api_shares_admin, entity: 'data/transfer_settings', command: :show,   is_singleton: true
+          entity_command :modify, description: 'Modify transfer settings', api: :@api_shares_admin, entity: 'data/transfer_settings', command: :modify, is_singleton: true
+        end
+
+        # --- setup ---
+
+        # Build the Shares node API plugin and inject into ctx.
+        # @return [Hash] context hash containing :shares_node_plugin
+        def setup_shares_node(**)
+          api_shares_node = basic_auth_api(NODE_API_PATH)
+          {shares_node_plugin: Node.new(context: context, api: api_shares_node)}
+        end
+
+        # Build the admin REST API and store in ivar.
+        # @return [Hash] empty ctx (state stored in @api_shares_admin)
+        def setup_admin(**)
+          @api_shares_admin = basic_auth_api(ADMIN_API_PATH)
+          {}
+        end
+
+        # Lookup a share id by field/value using the admin API.
+        def lookup_share_id(field, value, **)
+          RestList.lookup_entity_generic(entity: 'share', field: field, value: value){@api_shares_admin.read('data/shares')}['id']
+        end
+
+        # --- health ---
+
+        def action_health
+          nagios = Nagios.new
+          shares_url = options.get_option(:url, mandatory: true)
+          health = self.class.health_check(shares_url)
+          nagios.add_ok('version', health[:version]) if health[:version].is_a?(String)
+          if health[:ping].is_a?(String)
+            nagios.add_ok('ping', health[:ping])
+          else
+            nagios.add_critical('ping', health[:ping].to_s)
+          end
+          if health[:api].is_a?(String)
+            nagios.add_ok('API', health[:api])
+          else
+            nagios.add_critical('API', health[:api].to_s)
+          end
+          Result::ObjectList.new(nagios.status_list)
+        end
+
+        # --- files sub-commands (restricted to COMMANDS_SHARES, delegated to Node) ---
+
+        commands_under(:files) do
+          Node::COMMANDS_SHARES.each do |cmd|
+            command(cmd, description: "Node #{cmd} command")
+          end
+        end
+
+        # One handler per COMMANDS_SHARES command.
+        Node::COMMANDS_SHARES.each do |cmd|
+          define_action_method([:files, cmd]) do |shares_node_plugin:|
+            shares_node_plugin.dispatch_v3_command(cmd)
+          end
+        end
+
+        private
+
+        # @return [String] admin API path for the given entity_type and location
+        def admin_entity_path(entity_type, location)
+          prefix = location.eql?(:all) ? '' : "#{location}_"
+          "data/#{prefix}#{entity_type}s"
+        end
+
+        # --- admin > user|group handlers ---
+
+        # Shared handler for list/show/delete/create/modify on user or group.
+        # @param entity_type [Symbol] :user or :group
+        # @param location    [Symbol] :all or :local
+        # @param op          [Symbol] CRUD operation
+        def action_admin_entity_crud(entity_type, location, op)
+          path = admin_entity_path(entity_type, location)
+          lookup = ->(f, v){RestList.lookup_entity_generic(entity: entity_type, field: f, value: v){@api_shares_admin.read(path)}['id']}
+          display_fields = entity_type.eql?(:user) ? %w[id user_id username first_name last_name email] : nil
+          display_fields&.push('directory_user') if entity_type.eql?(:user) && location.eql?(:all)
+          entity_execute(api: @api_shares_admin, entity: path, command: op, display_fields: display_fields, &lookup)
+        end
+
+        # Shared handler for USR_GRP_SETTINGS (transfer_settings, app_authorizations, share_permissions)
+        # @param entity_type [Symbol] :user or :group
+        # @param location    [Symbol] :all or :local
+        # @param setting     [Symbol] one of USR_GRP_SETTINGS
+        # @param op          [Symbol] CRUD operation
+        # entity_id: resolved by Phase A via arguments:(:identifier) on the setting node
+        def action_admin_entity_setting(entity_type, location, setting, op, entity_id:, **)
+          path = admin_entity_path(entity_type, location)
+          entity_execute(
+            api:          @api_shares_admin,
+            entity:       "#{path}/#{entity_id}/#{setting}",
+            command:      op,
+            is_singleton: !setting.eql?(:share_permissions)
+          ){ |f, v| lookup_share_id(f, v)}
+        end
+
+        # Shared handler for :users (group only)
+        # group_id: resolved by Phase A via arguments:(:identifier) on the :users node
+        def action_admin_entity_users(entity_type, location, op, group_id:, **)
+          path = admin_entity_path(entity_type, location)
+          prefix = location.eql?(:all) ? '' : "#{location}_"
+          entity_execute(api: @api_shares_admin, entity: "#{path}/#{group_id}/#{prefix}users", command: op)
+        end
+
+        # Generate action_admin_<user|group>_<location>_<verb> for all combinations
+        %i[user group].each do |entity_type|
+          # all + local: CRUD + USR_GRP_SETTINGS [+ users for group]
+          ENTITY_LOCATIONS.each do |location|
+            ops = location.eql?(:all) ? (Operations::ALL - [:create]) : Operations::ALL
+            ops.each do |op|
+              define_action_method([:admin, entity_type, location, op]) do
+                action_admin_entity_crud(entity_type, location, op)
+              end
+            end
+            USR_GRP_SETTINGS.each do |setting|
+              setting_ops = setting.eql?(:share_permissions) ? Operations::ALL : %i[show modify]
+              setting_ops.each do |op|
+                define_action_method([:admin, entity_type, location, setting, op]) do |entity_id:, **|
+                  action_admin_entity_setting(entity_type, location, setting, op, entity_id: entity_id)
                 end
-              when :users # group
-                return entity_execute(api: api_shares_admin, entity: "#{entities_path}/#{options.instance_identifier(&lookup_block)}/#{entities_prefix}users")
-              else Aspera.error_unexpected_value(entity_verb)
               end
             end
+            next unless entity_type.eql?(:group)
+            Operations::ALL.each do |op|
+              define_action_method([:admin, entity_type, location, :users, op]) do |group_id:, **|
+                action_admin_entity_users(entity_type, location, op, group_id: group_id)
+              end
+            end
+          end
+
+          # ldap: add
+          define_action_method([:admin, entity_type, :ldap, :add]) do |entity_name:, **|
+            path = admin_entity_path(entity_type, :ldap)
+            is_bulk = options.get_option(:bulk)
+            Result.bulk(entity_name, is_bulk: is_bulk, command: :add, id_result: entity_type.to_s, bfail: options.get_option(:bfail)) do |entity_name|
+              @api_shares_admin.create(path, {entity_type => entity_name})
+            end
+          end
+
+          # saml: import
+          define_action_method([:admin, entity_type, :saml, :import]) do |entity_parameters:, **|
+            path = admin_entity_path(entity_type, :saml)
+            is_bulk = options.get_option(:bulk)
+            Result.bulk(entity_parameters, is_bulk: is_bulk, command: :import, bfail: options.get_option(:bfail)) do |entity_parameters|
+              entity_parameters = entity_parameters.transform_keys{ |k| k.gsub(/\s+/, '_').downcase}
+              Aspera.assert_type(entity_parameters, Hash)
+              SAML_IMPORT_MANDATORY.each{ |p| raise "missing mandatory field: #{p}" if entity_parameters[p].nil?}
+              entity_parameters.each_key do |p|
+                Aspera.assert_values(p, SAML_IMPORT_ALLOWED){'SAML field'}
+              end
+              @api_shares_admin.create("#{path}/import", entity_parameters)
+            end
+          end
+        end
+
+        # Handlers for admin > share > user_permissions|group_permissions > op
+        # share_id: resolved by Phase A via arguments:(:identifier, lookup: :lookup_share_id) on the perm_type node
+        %i[user_permissions group_permissions].each do |perm_type|
+          Operations::ALL.each do |op|
+            define_action_method([:admin, :share, perm_type, op]) do |share_id:, **|
+              entity_execute(api: @api_shares_admin, entity: "data/shares/#{share_id}/#{perm_type}", command: op)
+            end
           end
         end
       end

data/lib/aspera/cli/preset_actions.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+
+module Aspera
+  module Cli
+    # Mixin for Config plugin: preset CRUD actions
+    module PresetActions
+      # Used to identify the global default preset keyword
+      GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
+      # Display columns for preset overview
+      CONF_OVERVIEW_KEYS = %w[preset parameter value].freeze
+
+      def action_preset_list(**)
+        Result::ValueList.new(presets.config_presets.keys, name: 'name')
+      end
+
+      def action_preset_overview(**)
+        cp = presets.config_presets
+        # Display process modifies the value (hide secrets): we do not want to save removed secrets
+        data = PresetManager.deep_clone(cp)
+        formatter.hide_secrets(data)
+        result = []
+        data.each do |config, preset|
+          preset.each do |parameter, value|
+            result.push(CONF_OVERVIEW_KEYS.zip([config, parameter, value]).to_h)
+          end
+        end
+        Result::ObjectList.new(result, fields: CONF_OVERVIEW_KEYS)
+      end
+
+      def action_preset_lookup(**)
+        Plugins::BasicAuth.declare_options(options)
+        url = options.get_option(:url, mandatory: true)
+        user = options.get_option(:username, mandatory: true)
+        result = presets.lookup_preset(url: url, username: user)
+        Aspera.assert(!result.nil?, type: Error){'no such config found'}
+        Result::SingleObject.new(result)
+      end
+
+      def action_preset_secure(config_name: nil, **)
+        cp = presets.config_presets
+        preset_names = config_name.nil? ? cp.keys : [config_name]
+        secret_keywords = %w[password secret].freeze
+        preset_names.each do |preset_name|
+          preset = cp[preset_name]
+          next unless preset.is_a?(Hash)
+          preset.each_key do |option_name|
+            secret_keywords.each do |keyword|
+              next unless option_name.end_with?(keyword)
+              vault_label = preset_name
+              incr = 0
+              until vault.get(label: vault_label, exception: false).nil?
+                vault_label = "#{preset_name}#{incr}"
+                incr += 1
+              end
+              to_set = {label: vault_label, password: preset[option_name]}
+              puts "need to encode #{preset_name}.#{option_name} -> #{vault_label} -> #{to_set}"
+              vault.set(to_set)
+              preset[option_name] = "@vault:#{vault_label}.password"
+            end
+          end
+        end
+        Result::Status.new('Secrets secured in vault: Make sure to save the vault password securely.')
+      end
+
+      def action_preset_show(name:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        raise "no such preset: #{name}" unless cp.key?(name)
+        Result::SingleObject.new(PresetManager.deep_clone(cp[name]))
+      end
+
+      def action_preset_delete(name:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        raise "no such preset: #{name}" unless cp.key?(name)
+        cp.delete(name)
+        Result::Status.new("Deleted: #{name}")
+      end
+
+      def action_preset_get(name:, param_name:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        raise "no such preset: #{name}" unless cp.key?(name)
+        value = cp[name][param_name]
+        raise "no such option in preset #{name} : #{param_name}" if value.nil?
+        case value
+        when Numeric, String then return Result::Text.new(ExtendedValue.instance.evaluate(value.to_s, context: 'preset'))
+        end
+        Result::SingleObject.new(value)
+      end
+
+      def action_preset_unset(name:, param_name:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        raise "no such preset: #{name}" unless cp.key?(name)
+        cp[name].delete(param_name)
+        Result::Status.new("Removed: #{name}: #{param_name}")
+      end
+
+      def action_preset_set(name:, param_name:, param_value:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        param_name = Parser.option_line_to_name(param_name)
+        presets.set_key(name, param_name, param_value)
+        Result::Nothing.new
+      end
+
+      def action_preset_initialize(name:, config_value:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        Log.log.warn{"configuration already exists: #{name}, overwriting"} if cp.key?(name)
+        cp[name] = config_value
+        Result::Status.new("Modified: #{@option_config_file}")
+      end
+
+      def action_preset_update(name:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        unprocessed_options = options.unprocessed_options_with_value
+        Log.log.debug{"opts=#{unprocessed_options}"}
+        cp = presets.config_presets
+        cp[name] ||= {}
+        cp[name].merge!(unprocessed_options)
+        Result::Status.new("Updated: #{name}")
+      end
+
+      def action_preset_ask(name:, option_names:, **)
+        name = presets.global_default_preset if name.eql?(GLOBAL_DEFAULT_KEYWORD)
+        cp = presets.config_presets
+        cp[name] ||= {}
+        option_names.each do |option_name|
+          option_value = options.get_interactive(option_name, check_option: true)
+          cp[name][option_name] = option_value
+        end
+        Result::Status.new("Updated: #{name}")
+      end
+    end
+  end
+end