bolt 1.29.0 → 1.29.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8594a6349cae9dc7c45446a40f0f15c7093a2b706361f48a938b6a21471a7ae4
-  data.tar.gz: 0a4954a8df306277da739d1ae33849719f0071db2ef9ba337ca3a7e045a2861f
+  metadata.gz: 319eb2a2f42911eed9c4a7e9aa8e9bd351146f7ab3cdf69b34c9e364a2fbf574
+  data.tar.gz: ad22b5b96fc923b68d7109fdeba19f4a1046b327d0dcb0a1934bfc7a774425f6
 SHA512:
-  metadata.gz: 63d35051226313b40df680787dd026922fc829480e5cc7e73e34f882ab494a0a7bfb746a2cb561c34ad63f35d382226fd165c45783c2249f23e15763065ba07d
-  data.tar.gz: 9702e0fe3b12e5f7b7b5531d4dee87a5bd12a39070946c7ea9da678aa8db5d018195c34a1b7f4109c470ef34d98ec6831167cd254c50375df89a8d6dd0a51cb0
+  metadata.gz: a2e9e0277e1b7ee2cb7eb86120250e62a2ef91068893e7d86e7fb8ce542b3eaf016f0f7ca8a8245202a6c1c64a4a3d1af82c6e10fd826d5bec8df0f9f42c8d65
+  data.tar.gz: 64d7965e9e75abee048a0c251bcaaf2ce6f9a592ac86bc8f73fc330dba77ff847acaf4574ebdd194c6747d90b3d8496ae85c34658d3c0831c85befbe3a8b0aa9

data/lib/bolt/transport/docker.rb

@@ -8,7 +8,7 @@ module Bolt
   module Transport
     class Docker < Base
       def self.options
-        %w[host service-url service-options tmpdir interpreters shell-command tty]
+        %w[host service-url tmpdir interpreters shell-command tty]
       end
 
       def provided_features
@@ -21,12 +21,6 @@ module Bolt
             raise Bolt::ValidationError, 'service-url must be a string'
           end
         end
-
-        if (opts = options['service-options'])
-          unless opts.instance_of?(Hash)
-            raise Bolt::ValidationError, 'service-options must be a hash'
-          end
-        end
       end
 
       def with_connection(target)
@@ -57,9 +51,8 @@ module Bolt
       end
 
       def run_command(target, command, options = {})
-        if target.options['tty']
-          options[:Tty] = true
-        end
+        options[:tty] = target.options['tty']
+
         if target.options['shell-command'] && !target.options['shell-command'].empty?
           # escape any double quotes in command
           command = command.gsub('"', '\"')

data/lib/bolt/transport/docker/connection.rb

@@ -8,21 +8,24 @@ module Bolt
     class Docker < Base
       class Connection
         def initialize(target)
-          # lazy-load expensive gem code
-          require 'docker'
-
           raise Bolt::ValidationError, "Target #{target.name} does not have a host" unless target.host
-
           @target = target
           @logger = Logging.logger[target.host]
+          @docker_host = @target.options['service-url']
         end
 
         def connect
-          # Explicitly create the new Connection to avoid relying on global state in the Docker module.
-          url = @target.options['service-url'] || ::Docker.url
-          options = ::Docker.options.merge(@target.options['service-options'] || {})
-          @container = ::Docker::Container.get(@target.host, {}, ::Docker::Connection.new(url, options))
+          # We don't actually have a connection, but we do need to
+          # check that the container exists and is running.
+          output = execute_local_docker_json_command('ps')
+          index = output.find_index { |item| item["ID"] == @target.host || item["Names"] == @target.host }
+          raise "Could not find a container with name or ID matching '#{@target.host}'" if index.nil?
+          # Now find the indepth container information
+          output = execute_local_docker_json_command('inspect', [output[index]["ID"]])
+          # Store the container information for later
+          @container_info = output[0]
           @logger.debug { "Opened session" }
+          true
         rescue StandardError => e
           raise Bolt::Node::ConnectError.new(
             "Failed to connect to #{@target.uri}: #{e.message}",
@@ -30,38 +33,61 @@ module Bolt
           )
         end
 
+        # Executes a command inside the target container
+        #
+        # @param command [Array] The command to run, expressed as an array of strings
+        # @param options [Hash] command specific options
+        # @option opts [String] :interpreter statements that are prefixed to the command e.g `/bin/bash` or `cmd.exe /c`
+        # @option opts [Hash] :environment A hash of environment variables that will be injected into the command
+        # @option opts [IO] :stdin An IO object that will be used to redirect STDIN for the docker command
         def execute(*command, options)
           command.unshift(options[:interpreter]) if options[:interpreter]
+          # Build the `--env` parameters
+          envs = []
           if options[:environment]
-            envs = options[:environment].map { |env, val| "#{env}=#{val}" }
-            command = ['env'] + envs + command
+            options[:environment].each { |env, val| envs.concat(['--env', "#{env}=#{val}"]) }
           end
 
-          @logger.debug { "Executing: #{command}" }
-          result = @container.exec(command, options) { |stream, chunk| @logger.debug("#{stream}: #{chunk}") }
-          if result[2] == 0
+          command_options = []
+          # Need to be interactive if redirecting STDIN
+          command_options << '--interactive' unless options[:stdin].nil?
+          command_options << '--tty' if options[:tty]
+          command_options.concat(envs) unless envs.empty?
+          command_options << container_id
+          command_options.concat(command)
+
+          @logger.debug { "Executing: exec #{command_options}" }
+
+          stdout_str, stderr_str, status = execute_local_docker_command('exec', command_options, options[:stdin])
+
+          # The actual result is the exitstatus not the process object
+          status = status.nil? ? -32768 : status.exitstatus
+          if status == 0
             @logger.debug { "Command returned successfully" }
           else
-            @logger.info { "Command failed with exit code #{result[2]}" }
+            @logger.info { "Command failed with exit code #{status}" }
           end
-          result[0] = result[0].join.force_encoding('UTF-8')
-          result[1] = result[1].join.force_encoding('UTF-8')
-          result
+          stdout_str.force_encoding(Encoding::UTF_8)
+          stderr_str.force_encoding(Encoding::UTF_8)
+          # Normalise line endings
+          stdout_str.gsub!("\r\n", "\n")
+          stderr_str.gsub!("\r\n", "\n")
+          [stdout_str, stderr_str, status]
         rescue StandardError
           @logger.debug { "Command aborted" }
           raise
         end
 
         def write_remote_file(source, destination)
-          @container.store_file(destination, File.binread(source))
+          _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
+          raise "Error writing file to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
         def write_remote_directory(source, destination)
-          tar = ::Docker::Util.create_dir_tar(source)
-          mkdirs([destination])
-          @container.archive_in_stream(destination) { tar.read(Excon.defaults[:chunk_size]).to_s }
+          _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
+          raise "Error writing directory to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
@@ -75,7 +101,7 @@ module Bolt
         end
 
         def make_tempdir
-          tmpdir = @target.options.fetch('tmpdir', '/tmp')
+          tmpdir = @target.options.fetch('tmpdir', container_tmpdir)
           tmppath = "#{tmpdir}/#{SecureRandom.uuid}"
 
           stdout, stderr, exitcode = execute('mkdir', '-m', '700', tmppath, {})
@@ -112,6 +138,70 @@ module Bolt
             raise Bolt::Node::FileError.new(message, 'CHMOD_ERROR')
           end
         end
+
+        private
+
+        # Converts the JSON encoded STDOUT string from the docker cli into ruby objects
+        #
+        # @param stdout_string [String] The string to convert
+        # @return [Object] Ruby object representation of the JSON string
+        def extract_json(stdout_string)
+          # The output from the docker format command is a JSON string per line.
+          # We can't do a direct convert but this helper method will convert it into
+          # an array of Objects
+          stdout_string.split("\n")
+                       .reject { |str| str.strip.empty? }
+                       .map { |str| JSON.parse(str) }
+        end
+
+        # rubocop:disable Metrics/LineLength
+        # Executes a Docker CLI command
+        #
+        # @param subcommand [String] The docker subcommand to run e.g. 'inspect' for `docker inspect`
+        # @param command_options [Array] Additional command options e.g. ['--size'] for `docker inspect --size`
+        # @param redir_stdin [IO] IO object which will be use to as STDIN in the docker command. Default is nil, which does not perform redirection
+        # @return [String, String, Process::Status] The output of the command:  STDOUT, STDERR, Process Status
+        # rubocop:enable Metrics/LineLength
+        def execute_local_docker_command(subcommand, command_options = [], redir_stdin = nil)
+          env_hash = {}
+          # Set the DOCKER_HOST if we are using a non-default service-url
+          env_hash['DOCKER_HOST'] = @docker_host unless @docker_host.nil?
+
+          command_options = [] if command_options.nil?
+          docker_command = [subcommand].concat(command_options)
+
+          # Always use binary mode for any text data
+          capture_options = { binmode: true }
+          capture_options[:stdin_data] = redir_stdin unless redir_stdin.nil?
+          stdout_str, stderr_str, status = Open3.capture3(env_hash, 'docker', *docker_command, capture_options)
+          [stdout_str, stderr_str, status]
+        end
+
+        # Executes a Docker CLI command and parses the output in JSON format
+        #
+        # @param subcommand [String] The docker subcommand to run e.g. 'inspect' for `docker inspect`
+        # @param command_options [Array] Additional command options e.g. ['--size'] for `docker inspect --size`
+        # @return [Object] Ruby object representation of the JSON string
+        def execute_local_docker_json_command(subcommand, command_options = [])
+          command_options = [] if command_options.nil?
+          command_options = ['--format', '{{json .}}'].concat(command_options)
+          stdout_str, _stderr_str, _status = execute_local_docker_command(subcommand, command_options)
+          extract_json(stdout_str)
+        end
+
+        # The full ID of the target container
+        #
+        # @return [String] The full ID of the target container
+        def container_id
+          @container_info["Id"]
+        end
+
+        # The temp path inside the target container
+        #
+        # @return [String] The absolute path to the temp directory
+        def container_tmpdir
+          '/tmp'
+        end
       end
     end
   end

data/lib/bolt/transport/local/shell.rb

@@ -20,17 +20,18 @@ module Bolt
           @user = ENV['USER'] || Etc.getlogin
           @run_as = target.options['run-as']
           @logger = Logging.logger[self]
+          @sudo_id = SecureRandom.uuid
         end
 
         # If prompted for sudo password, send password to stdin and return an
         # empty string. Otherwise, check for sudo errors and raise Bolt error.
+        # If sudo_id is detected, that means the task needs to have stdin written.
         # If error is not sudo-related, return the stderr string to be added to
         # node output
-        def handle_sudo(stdin, err, pid)
+        def handle_sudo(stdin, err, pid, sudo_stdin)
           if err.include?(Sudoable.sudo_prompt)
             # A wild sudo prompt has appeared!
             if @target.options['sudo-password']
-              # Hopefully no one's sudo-password is > 64kb
               stdin.write("#{@target.options['sudo-password']}\n")
               ''
             else
@@ -39,6 +40,12 @@ module Bolt
                 'NO_PASSWORD'
               )
             end
+          elsif err =~ /^#{@sudo_id}/
+            if sudo_stdin
+              stdin.write("#{sudo_stdin}\n")
+              stdin.close
+            end
+            ''
           else
             handle_sudo_errors(err, pid)
           end
@@ -96,12 +103,12 @@ module Bolt
 
         # See if there's a sudo prompt in the output
         # If not, return the output
-        def check_sudo(out, inp, pid)
+        def check_sudo(out, inp, pid, stdin)
           buffer = out.readpartial(CHUNK_SIZE)
           # Split on newlines, including the newline
           lines = buffer.split(/(?<=[\n])/)
           # handle_sudo will return the line if it is not a sudo prompt or error
-          lines.map! { |line| handle_sudo(inp, line, pid) }
+          lines.map! { |line| handle_sudo(inp, line, pid, stdin) }
           lines.join("")
         # If stream has reached EOF, no password prompt is expected
         # return an empty string
@@ -114,33 +121,25 @@ module Bolt
           escalate = sudoable && run_as && @user != run_as
           use_sudo = escalate && @target.options['run-as-command'].nil?
 
-          if options[:interpreter]
-            if command.is_a?(Array)
-              command.unshift(options[:interpreter])
-            else
-              command = [options[:interpreter], command]
-            end
-          end
-
-          command_str = command.is_a?(String) ? command : Shellwords.shelljoin(command)
+          command_str = inject_interpreter(options[:interpreter], command)
 
           if escalate
             if use_sudo
               sudo_flags = ["sudo", "-k", "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
               sudo_flags += ["-E"] if options[:environment]
               sudo_str = Shellwords.shelljoin(sudo_flags)
-              command_str = "#{sudo_str} #{command_str}"
             else
-              run_as_str = Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
-              command_str = "#{run_as_str} #{command_str}"
+              sudo_str = Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
             end
+            command_str = build_sudoable_command_str(command_str, sudo_str, @sudo_id, options)
           end
 
           command_arr = options[:environment].nil? ? [command_str] : [options[:environment], command_str]
 
           # Prepare the variables!
           result_output = Bolt::Node::Output.new
-          in_buffer = options[:stdin] || ''
+          # Sudo handler will pass stdin if needed.
+          in_buffer = !use_sudo && options[:stdin] ? options[:stdin] : ''
           # Chunks of this size will be read in one iteration
           index = 0
           timeout = 0.1
@@ -153,7 +152,7 @@ module Bolt
           # See if there's a sudo prompt
           if use_sudo
             ready_read = select([err], nil, nil, timeout * 5)
-            read_streams[err] << check_sudo(err, inp, t.pid) if ready_read
+            read_streams[err] << check_sudo(err, inp, t.pid, options[:stdin]) if ready_read
           end
 
           # True while the process is running or waiting for IO input
@@ -166,7 +165,7 @@ module Bolt
               begin
                 # Check for sudo prompt
                 read_streams[stream] << if use_sudo
-                                          check_sudo(stream, inp, t.pid)
+                                          check_sudo(stream, inp, t.pid, options[:stdin])
                                         else
                                           stream.readpartial(CHUNK_SIZE)
                                         end

data/lib/bolt/transport/local_windows.rb

@@ -201,5 +201,3 @@ module Bolt
     end
   end
 end
-
-require 'bolt/transport/local/shell'

data/lib/bolt/transport/ssh/connection.rb

@@ -20,6 +20,7 @@ module Bolt
           require 'net/ssh/proxy/jump'
 
           raise Bolt::ValidationError, "Target #{target.name} does not have a host" unless target.host
+          @sudo_id = SecureRandom.uuid
 
           @target = target
           @load_config = target.options['load-config']
@@ -139,10 +140,10 @@ module Bolt
           end
         end
 
-        def handled_sudo(channel, data)
+        def handled_sudo(channel, data, stdin)
           if data.lines.include?(Sudoable.sudo_prompt)
             if target.options['sudo-password']
-              channel.send_data "#{target.options['sudo-password']}\n"
+              channel.send_data("#{target.options['sudo-password']}\n")
               channel.wait
               return true
             else
@@ -153,6 +154,12 @@ module Bolt
                 'NO_PASSWORD'
               )
             end
+          elsif data =~ /^#{@sudo_id}/
+            if stdin
+              channel.send_data(stdin)
+              channel.eof!
+            end
+            return true
           elsif data =~ /^#{@user} is not in the sudoers file\./
             @logger.debug { data }
             raise Bolt::Node::EscalateError.new(
@@ -175,21 +182,17 @@ module Bolt
           escalate = sudoable && run_as && @user != run_as
           use_sudo = escalate && @target.options['run-as-command'].nil?
 
-          if options[:interpreter]
-            command.is_a?(Array) ? command.unshift(options[:interpreter]) : [options[:interpreter], command]
-          end
+          command_str = inject_interpreter(options[:interpreter], command)
 
-          command_str = command.is_a?(String) ? command : Shellwords.shelljoin(command)
           if escalate
             if use_sudo
               sudo_flags = ["sudo", "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
               sudo_flags += ["-E"] if options[:environment]
               sudo_str = Shellwords.shelljoin(sudo_flags)
-              command_str = "#{sudo_str} #{command_str}"
             else
-              run_as_str = Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
-              command_str = "#{run_as_str} #{command_str}"
+              sudo_str = Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
             end
+            command_str = build_sudoable_command_str(command_str, sudo_str, @sudo_id, options)
           end
 
           # Including the environment declarations in the shelljoin will escape
@@ -216,14 +219,14 @@ module Bolt
               end
 
               channel.on_data do |_, data|
-                unless use_sudo && handled_sudo(channel, data)
+                unless use_sudo && handled_sudo(channel, data, options[:stdin])
                   result_output.stdout << data
                 end
                 @logger.debug { "stdout: #{data.strip}" }
               end
 
               channel.on_extended_data do |_, _, data|
-                unless use_sudo && handled_sudo(channel, data)
+                unless use_sudo && handled_sudo(channel, data, options[:stdin])
                   result_output.stderr << data
                 end
                 @logger.debug { "stderr: #{data.strip}" }
@@ -232,8 +235,8 @@ module Bolt
               channel.on_request("exit-status") do |_, data|
                 result_output.exit_code = data.read_long
               end
-
-              if options[:stdin]
+              # A wrapper is used to direct stdin when elevating privilage or using tty
+              if options[:stdin] && !use_sudo && !options[:wrapper]
                 channel.send_data(options[:stdin])
                 channel.eof!
               end

data/lib/bolt/transport/sudoable.rb

@@ -79,7 +79,6 @@ module Bolt
         with_connection(target) do |conn|
           conn.running_as(options['_run_as']) do
             stdin, output = nil
-            command = []
             execute_options = {}
             execute_options[:interpreter] = select_interpreter(executable, target.options['interpreters'])
             interpreter_debug = if execute_options[:interpreter]
@@ -103,8 +102,6 @@ module Bolt
                 end
               end
 
-              remote_task_path = conn.write_executable(task_dir, executable)
-
               if STDIN_METHODS.include?(input_method)
                 stdin = JSON.dump(arguments)
               end
@@ -113,20 +110,22 @@ module Bolt
                 execute_options[:environment] = envify_params(arguments)
               end
 
-              if conn.run_as && stdin
-                # Inject interpreter in to wrapper script and remove from execute options
+              remote_task_path = conn.write_executable(task_dir, executable)
+
+              # Avoid the horrors of passing data on stdin via a tty on multiple platforms
+              # by writing a wrapper script that directs stdin to the task.
+              if stdin && target.options['tty']
                 wrapper = make_wrapper_stringio(remote_task_path, stdin, execute_options[:interpreter])
                 execute_options.delete(:interpreter)
-                remote_wrapper_path = conn.write_executable(dir, wrapper, 'wrapper.sh')
-                command << remote_wrapper_path
-              else
-                command << remote_task_path
-                execute_options[:stdin] = stdin
+                execute_options[:wrapper] = true
+                remote_task_path = conn.write_executable(dir, wrapper, 'wrapper.sh')
               end
+
               dir.chown(conn.run_as)
 
+              execute_options[:stdin] = stdin
               execute_options[:sudoable] = true if conn.run_as
-              output = conn.execute(command, execute_options)
+              output = conn.execute(remote_task_path, execute_options)
             end
             Bolt::Result.for_task(target, output.stdout.string,
                                   output.stderr.string,

data/lib/bolt/transport/sudoable/connection.rb

@@ -70,6 +70,39 @@ module Bolt
           message = "#{self.class.name} must implement #{method} to execute commands"
           raise NotImplementedError, message
         end
+
+        # In the case where a task is run with elevated privilege and needs stdin
+        # a random string is echoed to stderr indicating that the stdin is available
+        # for task input data because the sudo password has already either been
+        # provided on stdin or was not needed.
+        def prepend_sudo_success(sudo_id, command_str)
+          "sh -c 'echo #{sudo_id} 1>&2; #{command_str}'"
+        end
+
+        # A helper to build up a single string that contains all of the options for
+        # privilege escalation. A wrapper script is used to direct task input to stdin
+        # when a tty is allocated and thus we do not need to prepend_sudo_success when
+        # using the wrapper or when the task does not require stdin data.
+        def build_sudoable_command_str(command_str, sudo_str, sudo_id, options)
+          if options[:stdin] && !options[:wrapper]
+            "#{sudo_str} #{prepend_sudo_success(sudo_id, command_str)}"
+          else
+            "#{sudo_str} #{command_str}"
+          end
+        end
+
+        # Returns string with the interpreter conditionally prepended
+        def inject_interpreter(interpreter, command)
+          if interpreter
+            if command.is_a?(Array)
+              command.unshift(interpreter)
+            else
+              command = [interpreter, command]
+            end
+          end
+
+          command.is_a?(String) ? command : Shellwords.shelljoin(command)
+        end
       end
     end
   end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.29.0'
+  VERSION = '1.29.1'
 end

data/lib/bolt_server/schemas/action-run_command.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "run_command request",
+  "description": "POST <transport>/run_command request schema",
+  "type": "object",
+  "properties": {
+    "command": { "type": "string" },
+    "target": { "$ref": "partial:target-any" }
+  },
+  "required": ["command", "target"],
+  "additionalProperties": false
+}

data/lib/bolt_server/transport_app.rb

@@ -19,7 +19,7 @@ module BoltServer
     PARTIAL_SCHEMAS = %w[target-any target-ssh target-winrm task].freeze
 
     # These schemas combine shared schemas to describe client requests
-    REQUEST_SCHEMAS = %w[action-run_task transport-ssh transport-winrm].freeze
+    REQUEST_SCHEMAS = %w[action-run_task action-run_command transport-ssh transport-winrm].freeze
 
     def initialize(config)
       @config = config
@@ -65,6 +65,14 @@ module BoltServer
       @executor.run_task(target, task, parameters)
     end
 
+    def run_command(target, body)
+      error = validate_schema(@schemas["action-run_command"], body)
+      return [400, error.to_json] unless error.nil?
+
+      command = body['command']
+      @executor.run_command(target, command)
+    end
+
     get '/' do
       200
     end
@@ -84,7 +92,7 @@ module BoltServer
       raise 'Unexpected error'
     end
 
-    ACTIONS = %w[run_task].freeze
+    ACTIONS = %w[run_task run_command].freeze
 
     post '/ssh/:action' do
       not_found unless ACTIONS.include?(params[:action])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.29.0
+  version: 1.29.1
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: docker-api
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.34'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.34'
 - !ruby/object:Gem::Dependency
   name: hiera-eyaml
   requirement: !ruby/object:Gem::Requirement
@@ -454,6 +440,7 @@ files:
 - lib/bolt_server/base_config.rb
 - lib/bolt_server/config.rb
 - lib/bolt_server/file_cache.rb
+- lib/bolt_server/schemas/action-run_command.json
 - lib/bolt_server/schemas/action-run_task.json
 - lib/bolt_server/schemas/partials/target-any.json
 - lib/bolt_server/schemas/partials/target-ssh.json
@@ -509,8 +496,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Execute commands remotely over SSH and WinRM