opswalrus 1.0.16 → 1.0.18

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
@@ -187,7 +126,7 @@ module OpsWalrus
         rescue => e
           puts e.class
           puts e.message
-          # puts e.backtrace.join("\n")
+          puts e.backtrace.join("\n")
         ensure
           host.clear_ssh_session
         end
@@ -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.18"
 end