opswalrus 1.0.16 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6d990ac1fac1a918ebca3eac342377ee61702f0864e635e378ad8e69d7ec0d5
-  data.tar.gz: 900661d04774a42b0a960624fd7fc51b9690c23ad15fba5aaf94f8a3e1241de6
+  metadata.gz: f2ce759171a0342644a1e3e2c94555299b093095b1684a69e11142fe29292da4
+  data.tar.gz: 75f4cab88e00038c73df02d69718b5cd067f3ed69150c192335894128ef912d0
 SHA512:
-  metadata.gz: 88e94b27da26afb8b925f1b363c6ccf889f3e105d28e3f7d2ccfd1d2d8fe1b61d443d64dc1829c42b8644216e19bad1c4e384757246414b62dc18104421cb8fe
-  data.tar.gz: 3e5b2b2062a592102bed054b7bae779a66b676ca8d47beb42cbab0a6cc6096e191129b3fd9a2c6fc815f8964bf78270b15687cbba99787c0323fb51c87e82c9c
+  metadata.gz: 6d47f83ae4dde1c9007f0d4591da7d6d9501218b15dfed542bdf9eda8538cfca14e22baa0d0a9e7dd244ef0db3fc683f862f296e296f713f500a3b084de02dac
+  data.tar.gz: 96877f5975e10dd6415194f5f130f3b7b31fcee66199c354cee93386116b4c0e918749c4158ec6da4a9fe64d9414410032c47d5c78c41caf2a36683cab259a03

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opswalrus (1.0.16)
+    opswalrus (1.0.17)
       amazing_print (~> 1.5)
       bcrypt_pbkdf (~> 1.1)
       citrus (~> 3.0)
@@ -9,8 +9,10 @@ PATH
       git (~> 1.18)
       gli (~> 2.21)
       ougai (~> 2.0)
+      pastel (~> 0.8)
       rubyzip (~> 2.3)
       sshkit (~> 1.21)
+      tty-editor (~> 0.7)
 
 GEM
   remote: https://rubygems.org/
@@ -32,6 +34,8 @@ GEM
     oj (3.16.0)
     ougai (2.0.0)
       oj (~> 3.10)
+    pastel (0.8.0)
+      tty-color (~> 0.5)
     public_suffix (5.0.3)
     rake (13.0.6)
     rchardet (1.8.0)
@@ -52,6 +56,19 @@ GEM
     sshkit (1.21.5)
       net-scp (>= 1.1.2)
       net-ssh (>= 2.8.0)
+    tty-color (0.6.0)
+    tty-cursor (0.7.1)
+    tty-editor (0.7.0)
+      tty-prompt (~> 0.22)
+    tty-prompt (0.23.1)
+      pastel (~> 0.8)
+      tty-reader (~> 0.8)
+    tty-reader (0.9.0)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      wisper (~> 2.0)
+    tty-screen (0.8.1)
+    wisper (2.0.1)
 
 PLATFORMS
   x86_64-linux

data/lib/opswalrus/app.rb

@@ -4,11 +4,12 @@ require "json"
 # require "logger"
 require "random/formatter"
 require "ougai"
+require "pastel"
+require "pathname"
 require "shellwords"
 require "socket"
 require "stringio"
 require "yaml"
-require "pathname"
 require_relative "errors"
 require_relative "patches"
 require_relative "git"
@@ -21,6 +22,8 @@ require_relative "version"
 
 
 module OpsWalrus
+  Style = Pastel.new(enabled: $stdout.tty?)
+
   class App
     def self.instance(*args)
       @instance ||= new(*args)
@@ -32,9 +35,14 @@ module OpsWalrus
     attr_reader :local_hostname
 
     def initialize(pwd = Dir.pwd)
-      @logger = Ougai::Logger.new($stdout, level: Logger::INFO)    # Logger.new($stdout, level: Logger::INFO)
+      @logger = Ougai::Logger.new($stdout)    # Logger.new($stdout, level: Logger::INFO)
+      @logger.level = :info    # , :trace or 'trace'
       @logger.formatter = Ougai::Formatters::Readable.new
 
+      # @logger.warn Style.yellow("warn"), foo: "bar", baz: {qux: "quux"}
+      # @logger.info Style.yellow("info"), foo: "bar", baz: {qux: "quux"}
+      # @logger.debug Style.yellow("debug"), foo: "bar", baz: {qux: "quux"}
+      # @logger.trace Style.yellow("trace"), foo: "bar", baz: {qux: "quux"}
 
       @verbose = false
       @sudo_user = nil
@@ -46,6 +54,7 @@ module OpsWalrus
       @bundler = Bundler.new(@pwd)
       @local_hostname = "localhost"
       @mode = :report     # :report | :script
+      @dry_run = false
     end
 
     def to_s
@@ -68,6 +77,14 @@ module OpsWalrus
       @mode == :script
     end
 
+    def dry_run?
+      @dry_run
+    end
+
+    def dry_run!
+      @dry_run = true
+    end
+
     def set_local_hostname(hostname)
       hostname = hostname.strip
       @local_hostname = hostname.empty? ? "localhost" : hostname
@@ -91,37 +108,54 @@ module OpsWalrus
       @bundler.bundle_dir
     end
 
-    def set_verbose(verbose)
-      @verbose = verbose
-      @logger.debug! if verbose?
+    # log_level = :fatal, :error, :warn, :info, :debug, :trace
+    # irb(main):018:0> Ougai::Logger::TRACE
+    # => -1
+    # irb(main):019:0> Ougai::Logger::DEBUG
+    # => 0
+    # irb(main):020:0> Ougai::Logger::INFO
+    # => 1
+    # irb(main):021:0> Ougai::Logger::WARN
+    # => 2
+    # irb(main):022:0> Ougai::Logger::ERROR
+    # => 3
+    # irb(main):023:0> Ougai::Logger::FATAL
+    # => 4
+    def set_log_level(log_level)
+      @logger.level = log_level
     end
 
     def verbose?
-      @verbose
+      @logger.level <= 1
     end
 
     def debug?
-      @verbose == 2
+      @logger.level <= 0
+    end
+
+    def fatal(*args)
+      @logger.fatal(*args)
     end
 
-    def error(msg)
-      @logger.error(msg)
+    def error(*args)
+      @logger.error(*args)
     end
 
-    def warn(msg)
-      @logger.warn(msg)
+    def warn(*args)
+      @logger.warn(*args)
     end
 
-    def log(msg)
-      @logger.info(msg)
+    def log(*args)
+      @logger.info(*args)
     end
+    alias_method :info, :log
 
-    def debug(msg)
-      @logger.debug(msg)
+    def debug(*args)
+      @logger.debug(*args)
     end
 
-    def trace(msg)
-      @logger.trace(msg)
+    def trace(*args)
+      @logger.trace(*args)
     end
 
     def set_pwd(pwd)

data/lib/opswalrus/bootstrap.sh

@@ -9,6 +9,7 @@ if [ -x "$(command -v /home/linuxbrew/.linuxbrew/bin/brew)" ]; then
     echo 'Ruby is already installed.' >&2
 
     # make sure the latest opswalrus gem is installed
+    # todo: figure out how to install this differently, so that test versions will work
     gem install opswalrus
 
     exit 0

data/lib/opswalrus/bundler.rb

@@ -26,6 +26,10 @@ module OpsWalrus
       FileUtils.mkdir_p(@bundle_dir) unless @bundle_dir.exist?
     end
 
+    def delete_pwd_bundle_directory
+      FileUtils.remove_dir(@bundle_dir) if @bundle_dir.exist?
+    end
+
     # # returns the OpsFile within the bundle directory that represents the given ops_file (which is outside of the bundle directory)
     # def build_bundle_for_ops_file(ops_file)
     #   if ops_file.package_file   # ops_file is part of larger package
@@ -50,6 +54,7 @@ module OpsWalrus
     # end
 
     def update
+      delete_pwd_bundle_directory
       ensure_pwd_bundle_directory_exists
 
       package_yaml_files = pwd.glob("./**/package.yaml") - pwd.glob("./**/#{BUNDLE_DIR}/**/package.yaml")
@@ -110,36 +115,16 @@ module OpsWalrus
       version = package_reference.version
 
       destination_package_path = @bundle_dir.join(package_reference.import_resolution_dirname)
-      FileUtils.remove_dir(destination_package_path) if destination_package_path.exist?
+
+      # we return early here under the assumption that an already downloaded package/version combo will not
+      # differ if we download it again multiple times to the same location
+      if destination_package_path.exist?
+        App.instance.log("Skipping #{package_reference} referenced in #{package_file.package_file_path} since it already has been downloaded to #{destination_package_path}")
+        return destination_package_path
+      end
+      # FileUtils.remove_dir(destination_package_path) if destination_package_path.exist?
 
       download_package_contents(package_file, local_name, package_url, version, destination_package_path)
-      # case
-      # when package_url =~ /\.git/                               # git reference
-      #   download_git_package(package_url, version, destination_package_path)
-      # when package_url.start_with?("file://")                   # local path
-      #   path = package_url.sub("file://", "")
-      #   path = path.to_pathname
-      #   package_path_to_download = if path.relative?            # relative path
-      #     package_file.containing_directory.join(path)
-      #   else                                                    # absolute path
-      #     path.realpath
-      #   end
-
-      #   raise Error, "Package not found: #{package_path_to_download}" unless package_path_to_download.exist?
-      #   FileUtils.cp_r(package_path_to_download, destination_package_path)
-      # when package_url.to_pathname.exist? || package_file.containing_directory.join(package_url).exist?     # local path
-      #   path = package_url.to_pathname
-      #   package_path_to_download = if path.relative?            # relative path
-      #     package_file.containing_directory.join(path)
-      #   else                                                    # absolute path
-      #     path.realpath
-      #   end
-
-      #   raise Error, "Package not found: #{package_path_to_download}" unless File.exist?(package_path_to_download)
-      #   FileUtils.cp_r(package_path_to_download, destination_package_path)
-      # else                                                      # git reference
-      #   download_git_package(package_url, version, destination_package_path)
-      # end
 
       destination_package_path
     end
@@ -147,10 +132,12 @@ module OpsWalrus
     def download_package_contents(package_file, local_name, package_url, version, destination_package_path)
       package_path = package_url.to_pathname
       package_path = package_path.to_s.gsub(/^~/, Dir.home).to_pathname
+      App.instance.trace("download_package_contents #{package_path}")
       if package_path.absolute? && package_path.exist?                                   # absolute path reference
         return case
         when package_path.directory?
           package_path_to_download = package_path.realpath
+          App.instance.debug("Copying #{package_path_to_download} to #{destination_package_path}")
           FileUtils.cp_r(package_path_to_download, destination_package_path)
         when package_path.file?
           raise Error, "Package reference must be a directory, not a file:: #{local_name}: #{package_path}"
@@ -163,6 +150,7 @@ module OpsWalrus
         if rebased_path.exist?
           return case
           when rebased_path.directory?
+            App.instance.debug("Copying #{package_path_to_download} to #{destination_package_path}")
             package_path_to_download = rebased_path.realpath
             FileUtils.cp_r(package_path_to_download, destination_package_path)
           when rebased_path.file?
@@ -174,6 +162,7 @@ module OpsWalrus
       end
 
       if package_uri = Git.repo?(package_url)                                                          # git repo
+        App.instance.debug("Cloning repo #{package_uri} into #{destination_package_path}")
         download_git_package(package_uri, version, destination_package_path)
       end
     end
@@ -195,15 +184,10 @@ module OpsWalrus
     end
 
     def dynamic_package_path_for_git_package(package_url, version = nil)
-      package_reference_dirname = sanitize_path(package_url)
+      package_reference_dirname = DynamicPackageReference.import_resolution_dirname(package_url, version)
       bundle_dir.join(package_reference_dirname)
     end
 
-    def sanitize_path(path)
-      # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
-      path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
-    end
-
     # returns the directory that the zip file is unzipped into
     def unzip(zip_bundle_file, output_dir = nil)
       if zip_bundle_file.to_pathname.exist?

data/lib/opswalrus/cli.rb

@@ -9,7 +9,7 @@ module OpsWalrus
 
     pre do |global_options, command, options, args|
       $app = App.instance(Dir.pwd)
-      $app.set_local_hostname(ENV["WALRUS_LOCAL_HOSTNAME"]) if ENV["WALRUS_LOCAL_HOSTNAME"]
+      $app.set_local_hostname(ENV["OPSWALRUS_LOCAL_HOSTNAME"]) if ENV["OPSWALRUS_LOCAL_HOSTNAME"]
       true
     end
 
@@ -31,6 +31,10 @@ module OpsWalrus
     desc 'Turn on debug mode'
     switch [:d, :debug]
 
+    switch :noop, desc: "Perform a dry run"
+    switch :dryrun, desc: "Perform a dry run"
+    switch :dry_run, desc: "Perform a dry run"
+
     flag [:h, :hosts], multiple: true, desc: "Specify the hosts.yaml file"
     flag [:t, :tags], multiple: true, desc: "Specify a set of tags to filter the hosts by"
 
@@ -48,7 +52,8 @@ module OpsWalrus
         hosts = global_options[:hosts]
         tags = global_options[:tags]
 
-        $app.set_verbose(global_options[:debug] || global_options[:verbose])
+        log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
+        $app.set_log_level(log_level)
 
         $app.report_inventory(hosts, tags: tags)
       end
@@ -63,28 +68,31 @@ module OpsWalrus
       c.flag [:p, :params], desc: "JSON string that represents the input parameters for the operation. The JSON string must conform to the params schema for the operation."
       c.switch :script, desc: "Script mode"
 
+      # dry run
+      c.switch :noop, desc: "Perform a dry run"
+      c.switch :dryrun, desc: "Perform a dry run"
+      c.switch :dry_run, desc: "Perform a dry run"
+
       c.action do |global_options, options, args|
+        log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
+        $app.set_log_level(log_level)
+
         hosts = global_options[:hosts] || []
         tags = global_options[:tags] || []
 
         $app.set_inventory_hosts(hosts)
         $app.set_inventory_tags(tags)
 
-        verbose = case
-        when global_options[:debug]
-          2
-        when global_options[:verbose]
-          1
-        end
-
         user = options[:user]
         params = options[:params]
 
-        $app.set_verbose(verbose)
         $app.set_params(params)
 
         $app.set_sudo_user(user) if user
 
+        dry_run = [:noop, :dryrun, :dry_run].any? {|sym| global_options[sym] || options[sym] }
+        $app.dry_run! if dry_run
+
         if options[:pass]
           $app.prompt_sudo_password
         end
@@ -107,6 +115,9 @@ module OpsWalrus
       long_desc 'Download and bundle the latest versions of dependencies for the current package'
       c.command :update do |update|
         update.action do |global_options, options, args|
+          log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
+          $app.set_log_level(log_level)
+
           $app.bundle_update
         end
       end
@@ -125,6 +136,9 @@ module OpsWalrus
         unzip.flag [:o, :output], desc: "Specify the output directory"
 
         unzip.action do |global_options, options, args|
+          log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
+          $app.set_log_level(log_level)
+
           output_dir = options[:output]
           zip_file_path = args.first
 

data/lib/opswalrus/host.rb

@@ -26,12 +26,12 @@ module OpsWalrus
             # we know we're dealing with a package dependency reference, so we want to run an ops file contained within the bundle directory,
             # therefore, we want to reference the specified ops file with respect to the bundle dir
             when PackageDependencyReference
-              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, true)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, true, prompt_for_sudo_password: !!ssh_password)
 
             # we know we're dealing with a directory reference or OpsFile reference outside of the bundle dir, so we want to reference
             # the specified ops file with respect to the root directory, and not with respect to the bundle dir
             when DirectoryReference, OpsFileReference
-              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, prompt_for_sudo_password: !!ssh_password)
             end
 
             invocation_context._invoke(*args, **kwargs)
@@ -49,7 +49,7 @@ module OpsWalrus
         unless methods_defined.include? symbol_name
           # puts "2. defining: #{symbol_name}(...)"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            invocation_context = RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false)
+            invocation_context = RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, prompt_for_sudo_password: !!ssh_password)
             invocation_context._invoke(*args, **kwargs)
           end
           methods_defined << symbol_name
@@ -107,13 +107,14 @@ module OpsWalrus
       #cmd = Shellwords.escape(cmd)
 
       if App.instance.report_mode?
+        puts Style.green("*" * 80)
         if self.alias
-          print "[#{self.alias} | #{host}] "
+          print "[#{Style.blue(self.alias)} | #{Style.blue(host)}] "
         else
-          print "[#{host}] "
+          print "[#{Style.blue(host)}] "
         end
         print "#{description}: " if description
-        puts cmd
+        puts Style.yellow(cmd)
       end
 
       return unless cmd && !cmd.strip.empty?
@@ -122,9 +123,12 @@ module OpsWalrus
       # puts "shell: #{cmd.inspect}"
       # puts "sudo_password: #{sudo_password}"
 
-      sshkit_cmd = execute_cmd(cmd, input: input)
-
-      [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
+      if App.instance.dry_run?
+        ["", "", 0]
+      else
+        sshkit_cmd = execute_cmd(cmd, input: input)
+        [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
+      end
     end
 
     # def init_brew
@@ -137,7 +141,13 @@ module OpsWalrus
       # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops run echo.ops args:foo args:bar
 
       # cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
-      cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
+      local_hostname_for_remote_host = if self.alias
+        "#{self.alias} | #{host}"
+      else
+        host
+      end
+
+      cmd = "OPSWALRUS_LOCAL_HOSTNAME='#{local_hostname_for_remote_host}'; /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
       cmd << " -v" if verbose
       cmd << " #{ops_command.to_s}"
       cmd << " #{ops_command_options.to_s}" if ops_command_options

data/lib/opswalrus/interaction_handlers.rb

@@ -5,6 +5,7 @@ module OpsWalrus
   class ScopedMappingInteractionHandler
     attr_accessor :input_mappings   # Hash[ String | Regex => String ]
 
+    # log_level is one of: :fatal, :error, :warn, :info, :debug, :trace
     def initialize(mapping, log_level = nil)
       @log_level = log_level
       @input_mappings = mapping
@@ -21,11 +22,10 @@ module OpsWalrus
     # end
 
     # sudo_password : String
-    def mapping_for_sudo_password(sudo_password)
+    def self.mapping_for_sudo_password(sudo_password)
       {
         /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
         App::LOCAL_SUDO_PASSWORD_PROMPT => "#{sudo_password}\n",
-        # /\s+/ => nil,     # unnecessary
       }
     end
 
@@ -39,7 +39,7 @@ module OpsWalrus
       raise ArgumentError.new("mapping must be a Hash") unless mapping.is_a?(Hash)
 
       if sudo_password
-        mapping.merge!(mapping_for_sudo_password(sudo_password))
+        mapping.merge!(ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password))
       end
 
       if mapping.empty?
@@ -57,17 +57,16 @@ module OpsWalrus
     end
 
     def on_data(_command, stream_name, data, channel)
-      log("Looking up response for #{stream_name} message #{data.inspect}")
-
       response_data = begin
         first_matching_key_value_pair = @input_mappings.find {|k, _v| k === data }
         first_matching_key_value_pair&.last
       end
 
       if response_data.nil?
-        log("Unable to find interaction handler mapping for #{stream_name}: #{data.inspect} so no response was sent")
+        trace(Style.red("No interaction handler mapping for #{stream_name}: #{data} so no response was sent"))
       else
-        log("Sending #{response_data.inspect}")
+        debug(Style.cyan("Handling #{stream_name} message #{data}"))
+        debug(Style.cyan("Sending response #{response_data}"))
         if channel.respond_to?(:send_data)  # Net SSH Channel
           channel.send_data(response_data)
         elsif channel.respond_to?(:write)   # Local IO
@@ -80,16 +79,21 @@ module OpsWalrus
 
     private
 
-    def log(message)
-      # puts message
-      SSHKit.config.output.send(@log_level, message) unless @log_level.nil?
+    def trace(message)
+      App.instance.trace(message)
+    end
+
+    def debug(message)
+      App.instance.debug(message)
+      if [:fatal, :error, :warn, :info, :debug, :trace].include? @log_level
+        SSHKit.config.output.send(@log_level, message)
+      end
     end
 
   end
 
   class PasswdInteractionHandler
     def on_data(command, stream_name, data, channel)
-      # puts data
       case data
       when '(current) UNIX password: '
         channel.send_data("old_pw\n")
@@ -118,8 +122,6 @@ module OpsWalrus
 
   class SudoPromptInteractionHandler
     def on_data(command, stream_name, data, channel)
-      # puts "0" * 80
-      # puts data.inspect
       case data
       when /\[sudo\] password for/
         if channel.respond_to?(:send_data)  # Net::SSH channel
@@ -128,12 +130,11 @@ module OpsWalrus
           channel.write("conquer\n")
         end
       when /\s+/
-        puts 'space, do nothing'
+        nil
       else
         raise "Unexpected prompt: #{data} on stream #{stream_name} and channel #{channel.inspect}"
-    end
+      end
     end
   end
 
-
 end

data/lib/opswalrus/invocation.rb

@@ -13,10 +13,18 @@ module OpsWalrus
     def method_missing(name, *args, **kwargs, &block)
       raise "Not implemented in base class"
     end
+
+    def _bang_method?(name)
+      name.to_s.end_with?("!")
+    end
+
+    def _non_bang_method(name)
+      name.to_s.sub(/!$/, '')
+    end
   end
 
   class RemoteImportInvocationContext < ImportInvocationContext
-    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false)
+    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false, prompt_for_sudo_password: nil)
       @runtime_env = runtime_env
       @host_proxy = host_proxy
       @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
@@ -24,12 +32,46 @@ module OpsWalrus
 
       initial_method_name = @namespace_or_ops_file.dirname.basename
       @method_chain = [initial_method_name]
+      @prompt_for_sudo_password = prompt_for_sudo_password
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
+    end
+
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      if _bang_method?(name)      # foo! is an attempt to invoke the module's default entrypoint
+        method_name = _non_bang_method(name)
+
+        @method_chain << method_name
+
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(method_name)
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      else
+        @method_chain << name.to_s
+
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+        _invoke(*args, **kwargs)
+      end
+    end
+
+    # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
+    # method invokes the OpsFile of that same name and returns the result;
+    # otherwise we return this namespace object
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+      method_name = @namespace_or_ops_file.dirname.basename
+      resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
+      if resolved_symbol.is_a? OpsFile
+        _resolve_method_and_invoke(method_name)
+      else
+        self
+      end
     end
 
     def _invoke(*args, **kwargs)
       case @namespace_or_ops_file
       when Namespace
-        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+        self
       when OpsFile
         _invoke_remote(*args, **kwargs)
       end
@@ -59,32 +101,13 @@ module OpsWalrus
         end.join(" ")
       end
 
-      @host_proxy.run_ops(:run, "--script", remote_run_command_args)
-    end
-
-    # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
-    # method invokes the OpsFile of that same name and returns the result;
-    # otherwise we return this namespace object
-    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
-      method_name = @namespace_or_ops_file.dirname.basename
-      resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
-      if resolved_symbol.is_a? OpsFile
-        _resolve_method_and_invoke(method_name)
+      # @host_proxy.run_ops(:run, "--script", remote_run_command_args)
+      if @prompt_for_sudo_password
+        @host_proxy.run_ops(:run, "--pass", remote_run_command_args)
       else
-        self
+        @host_proxy.run_ops(:run, remote_run_command_args)
       end
     end
-
-    def _resolve_method_and_invoke(name, *args, **kwargs)
-      @method_chain << name.to_s
-
-      @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
-      _invoke(*args, **kwargs)
-    end
-
-    def method_missing(name, *args, **kwargs, &block)
-      _resolve_method_and_invoke(name, *args, **kwargs)
-    end
   end
 
   class LocalImportInvocationContext < ImportInvocationContext
@@ -93,24 +116,25 @@ module OpsWalrus
       @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
     end
 
-    def _invoke(*args, **kwargs)
-      case @namespace_or_ops_file
-      when Namespace
-        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
-      when OpsFile
-        _invoke_local(*args, **kwargs)
-      end
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
     end
 
-    def _invoke_local(*args, **kwargs)
-      params_hash = @namespace_or_ops_file.build_params_hash(*args, **kwargs)
-      @namespace_or_ops_file.invoke(@runtime_env, params_hash)
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      if _bang_method?(name)      # foo! is an attempt to invoke the module's default entrypoint
+        method_name = _non_bang_method(name)
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(method_name)
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      else
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+        _invoke(*args, **kwargs)
+      end
     end
 
     # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
     # method invokes the OpsFile of that same name and returns the result;
     # otherwise we return this namespace object
-    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
       method_name = @namespace_or_ops_file.dirname.basename
       resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
       if resolved_symbol.is_a? OpsFile
@@ -121,14 +145,20 @@ module OpsWalrus
       end
     end
 
-    def _resolve_method_and_invoke(name, *args, **kwargs)
-      @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
-      _invoke(*args, **kwargs)
+    def _invoke(*args, **kwargs)
+      case @namespace_or_ops_file
+      when Namespace
+        self
+      when OpsFile
+        _invoke_local(*args, **kwargs)
+      end
     end
 
-    def method_missing(name, *args, **kwargs, &block)
-      _resolve_method_and_invoke(name, *args, **kwargs)
+    def _invoke_local(*args, **kwargs)
+      params_hash = @namespace_or_ops_file.build_params_hash(*args, **kwargs)
+      @namespace_or_ops_file.invoke(@runtime_env, params_hash)
     end
+
   end
 
 end

data/lib/opswalrus/local_non_blocking_backend.rb

@@ -112,7 +112,6 @@ module SSHKit
         buffer || ""
       end
 
-
       def handle_data_for_stderr(output, cmd, buffer, stdin, is_blocked)
         # we're blocked on reading, so let's process the buffer
         lines, buffer = split_buffer(buffer)

data/lib/opswalrus/operation_runner.rb

@@ -28,24 +28,39 @@ module OpsWalrus
       @app.sudo_password
     end
 
-    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg2:val2", ...]
-    # params_json_hash is a Hash representation of a JSON string
-    def run(runtime_kv_args, params_json_hash: nil)
-      params_hash = runtime_kv_args.reduce(params_json_hash || {}) do |memo, kv_pair_string|
-        str_key, str_value = kv_pair_string.split(":", 2)
-        if pre_existing_value = memo[str_key]
-          array = pre_existing_value.is_a?(Array) ? pre_existing_value : [pre_existing_value]
-          array << str_value
-          memo[str_key] = array
+    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg1:val2", ...]
+    # irb(main):057:0> build_params_hash(["names:foo", "names:bar", "names:baz", "age:5", "profile:name:corge", "profile:language:en", "height:5ft8in"])
+    # => {"names"=>["foo", "bar", "baz"], "age"=>"5", "profile"=>{"name"=>"corge", "language"=>"en"}, "height"=>"5ft8in"}
+    def build_params_hash(runtime_kv_args, params_json_hash: nil)
+      runtime_kv_args.reduce(params_json_hash || {}) do |memo, kv_pair_string|
+        param_name, str_value = kv_pair_string.split(":", 2)
+        key, value = str_value.split(":", 2)
+        if pre_existing_value = memo[param_name]
+          memo[param_name] = if value    # we're dealing with a Hash parameter value
+                               pre_existing_value.merge(key => value)
+                             else        # we're dealing with an Array parameter value or a scalar parameter value
+                               array = pre_existing_value.is_a?(Array) ? pre_existing_value : [pre_existing_value]
+                               array << str_value
+                             end
         else
-          memo[str_key] = str_value
+          memo[param_name] = if value    # we're dealing with a Hash parameter value
+                               {key => value}
+                             else        # we're dealing with an Array parameter value or a scalar parameter value
+                               str_value
+                             end
         end
         memo
       end
+    end
+
+    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg1:val2", ...]
+    # params_json_hash is a Hash representation of a JSON string
+    def run(runtime_kv_args, params_json_hash: nil)
+      params_hash = build_params_hash(runtime_kv_args, params_json_hash: params_json_hash)
 
       if app.debug?
-        puts "Script:"
-        puts @entry_point_ops_file.script
+        App.instance.trace "Script:"
+        App.instance.trace @entry_point_ops_file.script
       end
 
       result = begin
@@ -61,14 +76,14 @@ module OpsWalrus
         App.instance.error "[!] Command failed: #{e.message}"
       rescue Error => e
         App.instance.error "Error: Ops script crashed."
-        App.instance.error e.message
-        App.instance.error e.backtrace.take(5).join("\n")
+        App.instance.error e
+        # App.instance.error e.backtrace.take(5).join("\n")
         Invocation::Error.new(e)
       rescue => e
         App.instance.error "Unhandled Error: Ops script crashed."
         App.instance.error e.class
-        App.instance.error e.message
-        App.instance.error e.backtrace.take(10).join("\n")
+        App.instance.error e
+        # App.instance.error e.backtrace.take(10).join("\n")
         Invocation::Error.new(e)
       end
 
@@ -76,7 +91,7 @@ module OpsWalrus
         App.instance.debug "Ops script error details:"
         App.instance.debug "Error: #{result.value}"
         App.instance.debug "Status code: #{result.exit_status}"
-        App.instance.debug @entry_point_ops_file.script
+        App.instance.debug @entry_point_ops_file.script.to_s
       end
 
       result

data/lib/opswalrus/ops_file.rb

@@ -173,8 +173,9 @@ module OpsWalrus
       raise Error, "Unknown import reference: #{local_name}: #{import_str.inspect}"
     end
 
-    def invoke(runtime_env, params_hash)
-      script._invoke(runtime_env, params_hash)
+    def invoke(runtime_env, hashlike_params)
+      # this invokes the dynamically generated _invoke method that is defined at runtime within OpsFileScript.define_for(...)
+      script._invoke(runtime_env, hashlike_params)
     end
 
     def build_params_hash(*args, **kwargs)

data/lib/opswalrus/ops_file_script.rb

@@ -1,9 +1,80 @@
+require 'forwardable'
 require 'set'
 require_relative 'invocation'
 require_relative 'ops_file_script_dsl'
 
 module OpsWalrus
 
+  class ArrayOrHashNavigationProxy
+    extend Forwardable
+
+    def initialize(array_or_hash)
+      @obj = array_or_hash
+    end
+
+    def_delegators :@obj, :to_s, :inspect, :hash, :===, :eql?, :kind_of?, :is_a?, :instance_of?, :respond_to?, :<=>
+
+    def [](index, *args, **kwargs, &block)
+      @obj.method(:[]).call(index, *args, **kwargs, &block)
+    end
+    def respond_to_missing?(method, *)
+      @obj.is_a?(Hash) && @obj.respond_to?(method)
+    end
+    def method_missing(name, *args, **kwargs, &block)
+      case @obj
+      when Array
+        @obj.method(name).call(*args, **kwargs, &block)
+      when Hash
+        if @obj.respond_to?(name)
+          @obj.method(name).call(*args, **kwargs, &block)
+        else
+          value = self[name.to_s]
+          case value
+          when Array, Hash
+            ArrayOrHashNavigationProxy.new(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+
+  class InvocationParams
+    # @params : Hash
+
+    # params : Hash | ArrayOrHashNavigationProxy
+    def initialize(hashlike_params)
+      # this doesn't seem to make any difference
+      @params = hashlike_params.to_h
+      # @params = hashlike_params
+    end
+
+    def [](key)
+      key = key.to_s if key.is_a? Symbol
+      @params[key]
+    end
+
+    def dig(*keys)
+      # keys = keys.map {|key| key.is_a?(Integer) ? key : key.to_s }
+      @params.dig(*keys)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      if @params.respond_to?(name)
+        @params.method(name).call(*args, **kwargs, &block)
+      else
+        value = self[name]
+        case value
+        when Array, Hash
+          ArrayOrHashNavigationProxy.new(value)
+        else
+          value
+        end
+      end
+    end
+  end
+
   class OpsFileScript
 
     def self.define_for(ops_file, ruby_script)
@@ -14,11 +85,11 @@ module OpsWalrus
       # define methods for the OpsFile's local_symbol_table: local imports and private lib directory
       ops_file.local_symbol_table.each do |symbol_name, import_reference|
         unless methods_defined.include? symbol_name
-          App.instance.debug "defining method for local symbol table entry: #{symbol_name}"
+          App.instance.trace "defining method for local symbol table entry: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            App.instance.debug "resolving local symbol table entry: #{symbol_name}"
+            App.instance.trace "resolving local symbol table entry: #{symbol_name}"
             namespace_or_ops_file = @runtime_env.resolve_import_reference(ops_file, import_reference)
-            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+            App.instance.trace "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
 
             invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
             invocation_context._invoke(*args, **kwargs)
@@ -33,14 +104,14 @@ module OpsWalrus
       sibling_symbol_table_names |= ops_file.dirname.glob("*.ops").map {|ops_file_path| ops_file_path.basename(".ops").to_s }   # OpsFiles
       sibling_symbol_table_names |= ops_file.dirname.glob("*").select(&:directory?).map {|dir_path| dir_path.basename.to_s }    # Namespaces
       # puts "sibling_symbol_table_names=#{sibling_symbol_table_names}"
-      App.instance.debug "methods_defined=#{methods_defined}"
+      App.instance.trace "methods_defined=#{methods_defined}"
       sibling_symbol_table_names.each do |symbol_name|
         unless methods_defined.include? symbol_name
-          App.instance.debug "defining method for implicit imports: #{symbol_name}"
+          App.instance.trace "defining method for implicit imports: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            App.instance.debug "resolving implicit import: #{symbol_name}"
+            App.instance.trace "resolving implicit import: #{symbol_name}"
             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(ops_file, symbol_name)
-            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+            App.instance.trace "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
 
             invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
             invocation_context._invoke(*args, **kwargs)
@@ -60,9 +131,9 @@ module OpsWalrus
       # - #verbose?
       # - all the dynamically defined methods in the subclass of Invocation
       invoke_method_definition = <<~INVOKE_METHOD
-        def _invoke(runtime_env, params_hash)
+        def _invoke(runtime_env, hashlike_params)
           @runtime_env = runtime_env
-          @params = InvocationParams.new(params_hash)
+          @params = InvocationParams.new(hashlike_params)
           #{ruby_script}
         end
       INVOKE_METHOD
@@ -101,7 +172,7 @@ module OpsWalrus
     end
 
     # The _invoke method is dynamically defined as part of OpsFileScript.define_for
-    def _invoke(runtime_env, params_hash)
+    def _invoke(runtime_env, hashlike_params)
       raise "Not implemented in base class."
     end
 

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -12,67 +12,6 @@ require_relative 'walrus_lang'
 
 module OpsWalrus
 
-  class ArrayOrHashNavigationProxy
-    def initialize(array_or_hash)
-      @obj = array_or_hash
-    end
-    def [](index, *args, **kwargs, &block)
-      @obj.method(:[]).call(index, *args, **kwargs, &block)
-    end
-    def respond_to_missing?(method, *)
-      @obj.is_a?(Hash) && @obj.respond_to?(method)
-    end
-    def method_missing(name, *args, **kwargs, &block)
-      case @obj
-      when Array
-        @obj.method(name).call(*args, **kwargs, &block)
-      when Hash
-        if @obj.respond_to?(name)
-          @obj.method(name).call(*args, **kwargs, &block)
-        else
-          value = self[name.to_s]
-          case value
-          when Array, Hash
-            ArrayOrHashNavigationProxy.new(value)
-          else
-            value
-          end
-        end
-      end
-    end
-  end
-
-  class InvocationParams
-    # params : Hash
-    def initialize(params)
-      @params = params
-    end
-
-    def [](key)
-      key = key.to_s if key.is_a? Symbol
-      @params[key]
-    end
-
-    def dig(*keys)
-      # keys = keys.map {|key| key.is_a?(Integer) ? key : key.to_s }
-      @params.dig(*keys)
-    end
-
-    def method_missing(name, *args, **kwargs, &block)
-      if @params.respond_to?(name)
-        @params.method(name).call(*args, **kwargs, &block)
-      else
-        value = self[name]
-        case value
-        when Array, Hash
-          ArrayOrHashNavigationProxy.new(value)
-        else
-          value
-        end
-      end
-    end
-  end
-
   module Invocation
     class Result
       attr_accessor :value
@@ -157,7 +96,7 @@ module OpsWalrus
 
           # puts retval.inspect
 
-          # cleanup
+          # todo: cleanup
           # if tmp_bundle_root_dir =~ /tmp/   # sanity check the temp path before we blow away something we don't intend
           #   host.execute(:rm, "-rf", "tmpopsbootstrap.sh", "tmpops.zip", tmp_bundle_root_dir)
           # else
@@ -275,19 +214,23 @@ module OpsWalrus
       # puts "shell! self: #{self.inspect}"
 
       if App.instance.report_mode?
-        print "[#{@runtime_env.local_hostname}] "
+        puts Style.green("*" * 80)
+        print "[#{Style.blue(@runtime_env.local_hostname)}] "
         print "#{description}: " if description
-        puts cmd
+        puts Style.yellow(cmd)
       end
 
       return unless cmd && !cmd.strip.empty?
 
-      sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
-        # self is a Module instance that is serving as the evaluation context in an instance of a subclass of an Invocation; see Invocation#evaluate
-        backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+      if App.instance.dry_run?
+        ["", "", 0]
+      else
+        sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
+          # self is a Module instance that is serving as the evaluation context in an instance of a subclass of an Invocation; see Invocation#evaluate
+          backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+        end
+        [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
       end
-
-      [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
     end
 
     # def init_brew

data/lib/opswalrus/package_file.rb

@@ -15,15 +15,6 @@ module OpsWalrus
       @local_name, @package_uri, @version = local_name, package_uri, version
     end
 
-    def sanitized_package_uri
-      sanitize_path(@package_uri)
-    end
-
-    def sanitize_path(path)
-      # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
-      path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
-    end
-
     # important: the import_resolution_dirname implemented as the local_name is critical because Bundler#download_package downloads
     # package dependencies to the name that this method returns, which must match the package reference's local name
     # so that later, when the package is being looked up on the load path (in LoadPath#resolve_import_reference),
@@ -34,7 +25,7 @@ module OpsWalrus
     # change in order for the three things to reconcile with respect to one another, since all three bits of logic are
     # what make bundling package dependencies and loading them function properly.
     def import_resolution_dirname
-      local_name
+      "pkg_#{local_name}_version_#{version}"
     end
 
     def to_s
@@ -53,8 +44,17 @@ module OpsWalrus
   # these are dynamic package references defined at runtime when an OpsFile's imports are being evaluated.
   # this will usually be the case when an ops file does not belong to a package
   class DynamicPackageReference < PackageReference
+    def self.import_resolution_dirname(package_uri, version)
+      sanitized_package_uri = sanitize_path(package_uri || raise(Error, "Unspecified package reference"))
+      sanitized_version = sanitize_path(version || "")
+      "pkg_#{sanitized_package_uri}_version_#{sanitized_version}"
+    end
+    def self.sanitize_path(path)
+      # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
+      path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
+    end
     def import_resolution_dirname
-      sanitized_package_uri
+      DynamicPackageReference.import_resolution_dirname(@package_uri, @version)
     end
   end
 

data/lib/opswalrus/runtime_environment.rb

@@ -90,7 +90,7 @@ module OpsWalrus
       str = "Namespace: #{@dirname.to_s}\n"
       @symbol_table.each do |k, v|
         if v.is_a? Namespace
-          str << "#{'  ' * (indent)}|- #{k} : #{v.to_s(indent + 1)}\n"
+          str << "#{'  ' * (indent)}|- #{k} : #{v.to_s(indent + 1)}"
         else
           str << "#{'  ' * (indent)}|- #{k} : #{v.to_s}\n"
         end
@@ -106,31 +106,6 @@ module OpsWalrus
       @symbol_table[symbol_name.to_s]
     end
 
-    # # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
-    # # method invokes the OpsFile of that same name and returns the result;
-    # # otherwise we return this namespace object
-    # def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
-    #   resolved_symbol = resolve_symbol(@dirname.basename)
-    #   if resolved_symbol.is_a? OpsFile
-    #     params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
-    #     resolved_symbol.invoke(runtime_env, params_hash)
-    #   else
-    #     self
-    #   end
-    # end
-
-    # def method_missing(name, *args, **kwargs, &block)
-    #   # puts "method_missing: #{name}"
-    #   # puts caller
-    #   resolved_symbol = resolve_symbol(name)
-    #   case resolved_symbol
-    #   when Namespace
-    #     resolved_symbol._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
-    #   when OpsFile
-    #     params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
-    #     resolved_symbol.invoke(runtime_env, params_hash)
-    #   end
-    # end
   end
 
   # the assumption is that we have a bundle directory with all the packages in it
@@ -147,16 +122,13 @@ module OpsWalrus
       @root_namespace = build_symbol_resolution_tree(@dir)
       @path_map = build_path_map(@root_namespace)
 
-      # puts "*" * 80
-      # puts "load path for #{@dir}"
-      # puts "-" * 80
-      # puts 'root namespace'
-      # puts @root_namespace.to_s
-      # puts "-" * 80
-      # puts 'path map'
-      # @path_map.each do |k,v|
-      #   puts "#{k.to_s}: #{v.to_s}"
-      # end
+      App.instance.trace "LoadPath for #{@dir} ************************************************************"
+      App.instance.trace 'root namespace ******************************************************************'
+      App.instance.trace @root_namespace.to_s
+      App.instance.trace 'path map ************************************************************************'
+      @path_map.each do |k,v|
+        App.instance.trace "#{k.to_s}: #{v.to_s}"
+      end
 
       @dynamic_package_additions_memo = {}
     end
@@ -268,9 +240,16 @@ module OpsWalrus
       @bundle_load_path = LoadPath.new(self, @app.bundle_dir)
       @app_load_path = LoadPath.new(self, @app.pwd)
 
-      @interaction_handler = ScopedMappingInteractionHandler.new({
-        /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
-      })
+      # we include this sudo password mapping by default because if a bundled script is being run on a remote host,
+      # then the remote command invocation will include the --pass flag when being run on the remote host, which will
+      # interactively prompt for a sudo password, and that will be the only opportunity for the command host
+      # that is running the bundled script on the remote host to interactively enter a sudo password for the remote context
+      # since the remote ops command will be running within a PTY, and the interactive prompts running on the remote
+      # host will be managed by the local ScopedMappingInteractionHandler running within the instance of the ops command
+      # process on the remote host, and the command host will not have any further opportunity to interactively enter
+      # any prompts on the remote host
+      interaction_handler_mapping_for_sudo_password = ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password)
+      @interaction_handler = ScopedMappingInteractionHandler.new(interaction_handler_mapping_for_sudo_password)
 
       configure_sshkit
     end
@@ -291,6 +270,7 @@ module OpsWalrus
         # SSHKit.config.use_format :simpletext
         SSHKit.config.output_verbosity = :debug
       elsif app.verbose?
+        SSHKit.config.use_format :pretty
         # SSHKit.config.use_format :dot
         SSHKit.config.output_verbosity = :info
       end
@@ -344,8 +324,8 @@ module OpsWalrus
       end.run
     end
 
-    def invoke(ops_file, params_hash)
-      ops_file.invoke(self, params_hash)
+    def invoke(ops_file, hashlike_params)
+      ops_file.invoke(self, hashlike_params)
     end
 
     def find_load_path_that_includes_path(path)

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.16"
+  VERSION = "1.0.17"
 end

data/lib/opswalrus.rb

@@ -6,5 +6,5 @@ require_relative 'opswalrus/app'
 require_relative 'opswalrus/cli'
 require_relative 'opswalrus/version'
 
-module OpsWalrusWalrus
+module OpsWalrus
 end

data/opswalrus.gemspec

@@ -14,11 +14,11 @@ Gem::Specification.new do |spec|
   spec.license               = "EPL-2.0"
   spec.required_ruby_version = ">= 2.6.0"
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server - https://example.com"
+  # spec.metadata["allowed_push_host"] = "Set to your gem server - https://example.com"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/opswalrus/opswalrus"
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # spec.metadata["changelog_uri"] = "Put your gem's CHANGELOG.md URL here."
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -37,7 +37,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "gli", "~> 2.21"
   spec.add_dependency "git", "~> 1.18"
   spec.add_dependency "ougai", "~> 2.0"
+  spec.add_dependency "pastel", "~> 0.8"
   spec.add_dependency "rubyzip", "~> 2.3"
+  spec.add_dependency "tty-editor", "~> 0.7"
 
   spec.add_dependency "bcrypt_pbkdf", "~> 1.1"
   spec.add_dependency "ed25519", "~> 1.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.16
+  version: 1.0.17
 platform: ruby
 authors:
 - David Ellis
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: tty-editor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
   requirement: !ruby/object:Gem::Requirement