morpheus-cli 4.2.20 → 5.0.2

data/lib/morpheus/cli/mixins/option_source_helper.rb

@@ -75,7 +75,7 @@ module Morpheus::Cli::OptionSourceHelper
 
   def get_cloud_options(refresh=false, api_params={})
     if !@available_cloud_options || refresh
-      option_results = options_interface.options_for_source('clouds', api_params.mege({'default' => 'false'}))
+      option_results = options_interface.options_for_source('clouds', api_params.merge({'default' => 'false'}))
         @available_cloud_options = option_results['data'].collect {|it|
           {"name" => it["name"], "value" => it["value"], "id" => it["value"]}
         }

data/lib/morpheus/cli/mixins/print_helper.rb

@@ -1151,27 +1151,6 @@ module Morpheus::Cli::PrintHelper
     out
   end
 
-  def format_list(items, conjunction="and", limit=nil)
-    items = items ? items.clone : []
-    if limit
-      items = items.first(limit)
-    end
-    last_item = items.pop
-    if items.empty?
-      return "#{last_item}"
-    else
-      return items.join(", ") + (conjunction.to_s.empty? ? ", " : " #{conjunction} ") + "#{last_item}" + ((limit && limit < (items.size+1)) ? " ..." : "")
-    end
-  end
-
-  def anded_list(items, limit=nil)
-    format_list(items, "and", limit)
-  end
-
-  def ored_list(items, limit=nil)
-    format_list(items, "or", limit)
-  end
-
   def sleep_with_dots(sleep_seconds, dots=3, dot_chr=".")
     dot_interval = (sleep_seconds.to_f / dots.to_i)
     dots.to_i.times do |dot_index|
@@ -1285,4 +1264,50 @@ module Morpheus::Cli::PrintHelper
     end
   end
 
+  # convert JSON or YAML string to a map
+  def parse_json_or_yaml(config, parsers = [:json, :yaml])
+    rtn = {success: false, data: nil, err: nil}
+    err = nil
+    config = config.strip
+    if config[0..2] == "---"
+      parsers = [:yaml]
+    end
+    # ok only parse json for strings that start with {, consolidated yaml can look like json and cause issues}
+    if config[0] && config[0].chr == "{" && config[-1] && config[-1].chr == "}"
+      parsers = [:json]
+    end
+    parsers.each do |parser|
+      if parser == :yaml
+        begin
+          # todo: one method to parse and return Hash
+          # load does not raise an exception, it just returns the bad string
+          #YAML.parse(config)
+          config_map = YAML.load(config)
+          if !config_map.is_a?(Hash)
+            raise "Failed to parse config as YAML"
+          end
+          rtn[:data] = config_map
+          rtn[:success] = true
+          break
+        rescue => ex
+          rtn[:err] = ex if rtn[:err].nil?
+        end
+      elsif parser == :json
+        begin
+          config_map = JSON.parse(config)
+          rtn[:data] = config_map
+          rtn[:success] = true
+          break
+        rescue => ex
+          rtn[:err] = ex if rtn[:err].nil?
+        end
+      end
+    end
+    return rtn
+  end
+
+  def parse_yaml_or_json(config, parsers = [:yaml, :json])
+    parse_json_or_yaml(config, parsers)
+  end
+
 end

data/lib/morpheus/cli/mixins/provisioning_helper.rb

@@ -596,11 +596,13 @@ module Morpheus::Cli::ProvisioningHelper
     v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'environment', 'fieldLabel' => 'Environment', 'type' => 'select', 'required' => false, 'selectOptions' => get_available_environments()}], options[:options])
     payload['instance']['instanceContext'] = v_prompt['environment'] if !v_prompt['environment'].empty?
 
-    # Labels (tags)
-    if options[:tags]
-      payload['instance']['tags'] = options[:tags].is_a?(Array) ? options[:tags] : options[:tags].to_s.split(',').collect {|it| it.to_s.strip }.compact.uniq
+    # Labels (Provisioning API still refers to these as tags)
+    # and tags (metadata tags) is called metadata.
+    # todo: switch this from 'tags' to labels' when the api changes
+    if options[:labels]
+      payload['instance']['tags'] = options[:labels].is_a?(Array) ? options[:labels] : options[:labels].to_s.split(',').collect {|it| it.to_s.strip }.compact.uniq
     else
-      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'tags', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false}], options[:options])
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false}], options[:options])
       payload['instance']['tags'] = v_prompt['tags'].split(',').collect {|it| it.to_s.strip }.compact.uniq if !v_prompt['tags'].empty?
     end
 
@@ -976,6 +978,9 @@ module Morpheus::Cli::ProvisioningHelper
         metadata_list = options[:metadata].split(",").select {|it| !it.to_s.empty? }
         metadata_list = metadata_list.collect do |it|
           metadata_pair = it.split(":")
+          if metadata_pair.size < 2 && it.include?("=")
+            metadata_pair = it.split("=")
+          end
           row = {}
           row['name'] = metadata_pair[0].to_s.strip
           row['value'] = metadata_pair[1].to_s.strip
@@ -2200,4 +2205,19 @@ module Morpheus::Cli::ProvisioningHelper
       return type_code.to_s.downcase
     end
   end
+
+  def format_snapshot_status(snapshot, return_color=cyan)
+    out = ""
+    status_string = snapshot['status'].to_s
+    if status_string == 'complete'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'creating'
+      out << "#{cyan}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'failed'
+      out << "#{red}#{status_string.upcase}#{return_color}"
+    else
+      out << "#{yellow}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
 end

data/lib/morpheus/cli/network_pools_command.rb

@@ -596,22 +596,28 @@ class Morpheus::Cli::NetworkPoolsCommand
   def add_ip(args)
     options = {}
     params = {}
+    next_free_ip = false
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage("[network-pool] [ip]")
+      opts.banner = subcommand_usage("[network-pool] [ip] [--next]")
       opts.on('--ip-address VALUE', String, "IP Address for this network pool IP") do |val|
         options[:options]['ipAddress'] = val
       end
+      opts.on('--next-free-ip', '--next-free-ip', "Use the next available ip address. This can be used instead of specifying an ip address") do
+        next_free_ip = true
+      end
       opts.on('--hostname VALUE', String, "Hostname for this network pool IP") do |val|
         options[:options]['hostname'] = val
       end
       build_common_options(opts, options, [:options, :payload, :json, :dry_run, :quiet, :remote])
       opts.footer = "Create a new network pool IP." + "\n" +
                     "[network-pool] is required. This is the name or id of a network pool.\n" +
-                    "[ip] is required and can be passed as --ip-address instead."
+                    "[ip] is required or --next-free-ip to use the next available address instead."
     end
     optparse.parse!(args)
-    if args.count < 1 || args.count > 2
-      raise_command_error "wrong number of arguments, expected 1-2 and got (#{args.count}) #{args}\n#{optparse}"
+    if next_free_ip
+      verify_args!(args:args, count:1, optparse:optparse)
+    else
+      verify_args!(args:args, min:1, max:2, optparse:optparse)
     end
     connect(options)
     begin
@@ -639,8 +645,10 @@ class Morpheus::Cli::NetworkPoolsCommand
         payload['networkPoolIp'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
 
         # IP Address
-        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'ipAddress', 'fieldLabel' => 'IP Address', 'type' => 'text', 'required' => true, 'description' => 'IP Address for this network pool IP.'}], options[:options])
-        payload['networkPoolIp']['ipAddress'] = v_prompt['ipAddress'] unless v_prompt['ipAddress'].to_s.empty?
+        unless next_free_ip
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'ipAddress', 'fieldLabel' => 'IP Address', 'type' => 'text', 'required' => true, 'description' => 'IP Address for this network pool IP.'}], options[:options])
+          payload['networkPoolIp']['ipAddress'] = v_prompt['ipAddress'] unless v_prompt['ipAddress'].to_s.empty?
+        end
 
         # Hostname
         v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'hostname', 'fieldLabel' => 'Hostname', 'type' => 'text', 'required' => true, 'description' => 'Hostname for this network pool IP.'}], options[:options])

data/lib/morpheus/cli/option_types.rb

@@ -5,6 +5,7 @@ module Morpheus
   module Cli
     module OptionTypes
       include Term::ANSIColor
+      # include Morpheus::Cli::PrintHelper
 
       def self.confirm(message,options={})
         if options[:yes] == true
@@ -72,9 +73,15 @@ module Morpheus
           field_name = namespaces.pop
 
           # respect optionType.dependsOnCode
-          if option_type['dependsOnCode'] && option_type['dependsOnCode'] != ""
+          # i guess this switched to visibleOnCode, respect one or the other
+          visible_option_check_value = option_type['dependsOnCode']
+          if !option_type['visibleOnCode'].to_s.empty?
+            visible_option_check_value = option_type['visibleOnCode']
+          end
+          if !visible_option_check_value.to_s.empty?
             # support formats code=value or code:value OR code:(value|value2|value3)
-            parts = option_type['dependsOnCode'].include?("=") ? option_type['dependsOnCode'].split("=") : option_type['dependsOnCode'].split(":")
+            # OR fieldContext.fieldName=value
+            parts = visible_option_check_value.include?("=") ? visible_option_check_value.split("=") : visible_option_check_value.split(":")
             depends_on_code = parts[0]
             depends_on_value = parts[1].to_s.strip
             depends_on_values = []
@@ -87,14 +94,29 @@ module Morpheus
               depends_on_values = depends_on_value.split("|").collect { |it| it.strip }
             end
             depends_on_option_type = option_types.find {|it| it["code"] == depends_on_code }
-            # could not find the dependent option type, proceed and prompt
-            if !depends_on_option_type.nil?
+            if !depends_on_option_type
+              depends_on_option_type = option_types.find {|it| 
+                (it['fieldContext'] ? "#{it['fieldContext']}.#{it['fieldName']}" : it['fieldName']) == depends_on_code
+              }
+            end
+            if depends_on_option_type
               # dependent option type has a different value
               depends_on_field_key = depends_on_option_type['fieldContext'] ? "#{depends_on_option_type['fieldContext']}.#{depends_on_option_type['fieldName']}" : "#{depends_on_option_type['fieldName']}"
               found_dep_value = get_object_value(results, depends_on_field_key) || get_object_value(options, depends_on_field_key)
-              if depends_on_values.size > 0 && !depends_on_values.include?(found_dep_value)
-                next
+              if depends_on_values.size > 0
+                # must be in the specified values
+                # todo: uhh this actually needs to change to parse regex
+                if !depends_on_values.include?(found_dep_value)
+                  next
+                end
+              else
+                # no value found
+                if found_dep_value.to_s.empty?
+                  next
+                end
               end
+            else
+              # could not find the dependent option type, proceed and prompt
             end
           end
 
@@ -115,7 +137,7 @@ module Morpheus
           # use the value passed in the options map
           if cur_namespace.respond_to?('key?') && cur_namespace.key?(field_name)
             value = cur_namespace[field_name]
-            input_value = ['select', 'multiSelect'].include?(option_type['type']) && option_type['fieldInput'] ? cur_namespace[option_type['fieldInput']] : nil
+            input_value = ['select', 'multiSelect','typeahead', 'multiTypeahead'].include?(option_type['type']) && option_type['fieldInput'] ? cur_namespace[option_type['fieldInput']] : nil
             if option_type['type'] == 'number'
               value = value.to_s.include?('.') ? value.to_f : value.to_i
             # these select prompts should just fall down through below, with the extra params no_prompt, use_value
@@ -130,7 +152,17 @@ module Morpheus
                 select_value_list << select_prompt(option_type.merge({'defaultValue' => v, 'defaultInputValue' => input_value_list[i]}), api_client, (api_params || {}).merge(results), true)
               end
               value = select_value_list
-              
+            elsif option_type['type'] == 'typeahead'
+              value = typeahead_prompt(option_type.merge({'defaultValue' => value, 'defaultInputValue' => input_value}), api_client, (api_params || {}).merge(results), true)
+            elsif option_type['type'] == 'multiTypeahead'
+              # support value as csv like "thing1, thing2"
+              value_list = value.is_a?(String) ? value.parse_csv.collect {|v| v ? v.to_s.strip : v } : [value].flatten
+              input_value_list = input_value.is_a?(String) ? input_value.parse_csv.collect {|v| v ? v.to_s.strip : v } : [input_value].flatten
+              select_value_list = []
+              value_list.each_with_index do |v, i|
+                select_value_list << typeahead_prompt(option_type.merge({'defaultValue' => v, 'defaultInputValue' => input_value_list[i]}), api_client, (api_params || {}).merge(results), true)
+              end
+              value = select_value_list
             end
             if options[:always_prompt] != true
               value_found = true
@@ -147,7 +179,7 @@ module Morpheus
           no_prompt = no_prompt || options[:no_prompt]
           if no_prompt
             if !value_found
-              if option_type['defaultValue'] != nil && !['select', 'multiSelect'].include?(option_type['type'])
+              if option_type['defaultValue'] != nil && !['select', 'multiSelect','typeahead','multiTypeahead'].include?(option_type['type'])
                 value = option_type['defaultValue']
                 value_found = true
               end
@@ -158,6 +190,10 @@ module Morpheus
                   value = select_prompt(option_type, api_client, (api_params || {}).merge(results), true)
                   value_found = !!value
                 end
+                if ['typeahead', 'multiTypeahead'].include?(option_type['type'])
+                  value = typeahead_prompt(option_type, api_client, (api_params || {}).merge(results), true)
+                  value_found = !!value
+                end
                 if !value_found
                   if option_type['required']
                     print Term::ANSIColor.red, "\nMissing Required Option\n\n", Term::ANSIColor.reset
@@ -203,6 +239,18 @@ module Morpheus
                   end
                 end
               end
+            elsif ['typeahead', 'multiTypeahead'].include?(option_type['type'])
+              value = typeahead_prompt(option_type, api_client, (api_params || {}).merge(results), options[:no_prompt], nil, paging_enabled)
+              if value && option_type['type'] == 'multiTypeahead'
+                value = [value]
+                while self.confirm("Add another #{option_type['fieldLabel']}?", {:default => false}) do
+                  if addn_value = typeahead_prompt(option_type, api_client, (api_params || {}).merge(results), options[:no_prompt], nil, paging_enabled)
+                    value << addn_value
+                  else
+                    break
+                  end
+                end
+              end
             elsif option_type['type'] == 'hidden'
               value = option_type['defaultValue']
               input = value
@@ -310,11 +358,12 @@ module Morpheus
         value_field = (option_type['config'] ? option_type['config']['valueField'] : nil) || 'value'
         default_value = option_type['defaultValue']
         default_value = default_value['id'] if default_value && default_value.is_a?(Hash) && !default_value['id'].nil?
+        api_params ||= {}
         # local array of options
         if option_type['selectOptions']
           # calculate from inline lambda
           if option_type['selectOptions'].is_a?(Proc)
-            select_options = option_type['selectOptions'].call()
+            select_options = option_type['selectOptions'].call(api_client, grails_params(api_params || {}))
           else
             # todo: better type validation
             select_options = option_type['selectOptions']
@@ -325,7 +374,7 @@ module Morpheus
             select_options = option_type['optionSource'].call(api_client, grails_params(api_params || {}))
           elsif option_type['optionSource'] == 'list'
             # /api/options/list is a special action for custom OptionTypeLists, just need to pass the optionTypeId parameter
-            select_options = load_source_options(option_type['optionSource'], api_client, {'optionTypeId' => option_type['id']})
+            select_options = load_source_options(option_type['optionSource'], api_client, grails_params(api_params || {}).merge({'optionTypeId' => option_type['id']}))
           else
             # remote optionSource aka /api/options/$optionSource?
             select_options = load_source_options(option_type['optionSource'], api_client, grails_params(api_params || {}))
@@ -345,7 +394,7 @@ module Morpheus
             print Term::ANSIColor.red, "  * #{option_type['fieldLabel']} [-O #{option_type['fieldContext'] ? (option_type['fieldContext']+'.') : ''}#{option_type['fieldName']}=] - #{option_type['description']}\n", Term::ANSIColor.reset
             if select_options && select_options.size > 10
               display_select_options(option_type, select_options.first(10))
-              puts " (#{select_options.size-1} more)"
+              puts " (#{select_options.size-10} more)"
             else
               display_select_options(option_type, select_options)
             end
@@ -388,7 +437,7 @@ module Morpheus
               print Term::ANSIColor.red, "  * #{option_type['fieldLabel']} [-O #{help_field_key}=] - #{option_type['description']}\n", Term::ANSIColor.reset
               if select_options && select_options.size > 10
                 display_select_options(option_type, select_options.first(10))
-                puts " (#{select_options.size-1} more)"
+                puts " (#{select_options.size-10} more)"
               else
                 display_select_options(option_type, select_options)
               end
@@ -458,6 +507,154 @@ module Morpheus
         value
       end
 
+      # this works like select_prompt, but refreshes options with ?query=value between inputs
+      # paging_enabled is ignored right now
+      def self.typeahead_prompt(option_type,api_client, api_params={}, no_prompt=false, use_value=nil, paging_enabled=false)
+        select_options = []
+        field_key = [option_type['fieldContext'], option_type['fieldName']].select {|it| it && it != '' }.join('.')
+        help_field_key = option_type[:help_field_prefix] ? "#{option_type[:help_field_prefix]}.#{field_key}" : field_key
+        input = ""
+        value_found = false
+        value = nil
+        value_field = (option_type['config'] ? option_type['config']['valueField'] : nil) || 'value'
+        default_value = option_type['defaultValue']
+        default_value = default_value['id'] if default_value && default_value.is_a?(Hash) && !default_value['id'].nil?
+
+        while !value_found do
+          # ok get input, refresh options and see if it matches
+          # if matches one, cool otherwise print matches and reprompt or error
+          if use_value
+            input = use_value
+          elsif no_prompt
+            input = default_value
+          else
+            Readline.completion_append_character = ""
+            Readline.basic_word_break_characters = ''
+            Readline.completion_proc = proc {|s| 
+              matches = []
+              available_options = (select_options || [])
+              available_options.each{|option| 
+                if option['name'] && option['name'] =~ /^#{Regexp.escape(s)}/
+                  matches << option['name']
+                # elsif option['id'] && option['id'].to_s =~ /^#{Regexp.escape(s)}/
+                elsif option[value_field] && option[value_field].to_s == s
+                  matches << option['name']
+                end
+              }
+              matches
+            }
+            # prompt for typeahead input value
+            input = Readline.readline("#{option_type['fieldLabel']}#{option_type['fieldAddOn'] ? ('(' + option_type['fieldAddOn'] + ') ') : '' }#{!option_type['required'] ? ' (optional)' : ''}#{!default_value.to_s.empty? ? ' ['+default_value.to_s+']' : ''} ['?' for options]: ", false).to_s
+            input = input.chomp.strip
+          end
+
+          # just hit enter, use [default] if set
+          if input.empty? && default_value
+            input = default_value.to_s
+          end
+          
+          # not required and no value? ok proceed
+          if input.to_s == "" && option_type['required'] != true
+            value_found = true
+            value = nil # or "" # hmm
+            #next
+            break
+          end
+
+          # required and no value? you need help
+          # if input.to_s == "" && option_type['required'] == true
+          #   help_prompt(option_type)
+          #   display_select_options(option_type, select_options) unless select_options.empty?
+          #   next
+          # end
+
+          # looking for help with this input
+          if input == '?'
+            help_prompt(option_type)
+            display_select_options(option_type, select_options) unless select_options.empty?
+            next
+          end
+
+          # just hit enter? scram
+          # looking for help with this input
+          # if input == ""
+          #   help_prompt(option_type)
+          #   display_select_options(option_type, select_options)
+          #   next
+          # end
+
+          # this is how typeahead works, it keeps refreshing the options with a new ?query={value}
+          # query_value = (value || use_value || default_value || '')
+          query_value = (input || '')
+          api_params ||= {}
+          api_params['query'] = query_value
+          # skip refresh if you just hit enter
+          if !query_value.empty?
+            select_options = load_options(option_type, api_client, api_params, query_value)
+          end
+
+          # match input to option name or value
+          # actually that is redundant, it should already be filtered to matches
+          # and can just do this:
+          # select_option = select_options.size == 1 ? select_options[0] : nil
+          select_option = select_options.find{|b| (b[value_field] && (b[value_field].to_s == input.to_s)) || ((b[value_field].nil? || b[value_field].empty?) && (input == "")) }
+          if select_option.nil?
+            select_option = select_options.find{|b| b['name'] && b['name'] == input }
+          end
+
+          # found matching value, else did not find a value, show matching options and prompt again or error
+          if select_option
+            value = select_option[value_field]
+            set_last_select(select_option)
+            value_found = true
+          else
+            if use_value || no_prompt
+              # todo: make this nicer
+              # help_prompt(option_type)
+              print Term::ANSIColor.red, "\nMissing Required Option\n\n", Term::ANSIColor.reset
+              print Term::ANSIColor.red, "  * #{option_type['fieldLabel']} [-O #{help_field_key}=] - #{option_type['description']}\n", Term::ANSIColor.reset
+              if select_options && select_options.size > 10
+                display_select_options(option_type, select_options.first(10))
+                puts " (#{select_options.size-10} more)"
+              else
+                display_select_options(option_type, select_options)
+              end
+              print "\n"
+              if select_options.empty?
+                print "The value '#{input}' matched 0 options.\n"
+                # print "Please try again.\n"
+              else
+                print "The value '#{input}' matched #{select_options.size()} options.\n"
+                print "Perhaps you meant one of these? #{ored_list(select_options.collect {|i|i['name']}, 3)}\n"
+                # print "Please try again.\n"
+              end
+              print "\n"
+              exit 1
+            else
+              #help_prompt(option_type)
+              display_select_options(option_type, select_options)
+              print "\n"
+              if select_options.empty?
+                print "The value '#{input}' matched 0 options.\n"
+                print "Please try again.\n"
+              else
+                print "The value '#{input}' matched #{select_options.size()} options.\n"
+                print "Perhaps you meant one of these? #{ored_list(select_options.collect {|i|i['name']}, 3)}\n"
+                print "Please try again.\n"
+              end
+              print "\n"
+              # reprompting now...
+            end
+          end
+        end # end while !value_found
+
+        # wrap in object when using fieldInput
+        if value && !option_type['fieldInput'].nil?
+          value = {option_type['fieldName'].split('.').last => value, option_type['fieldInput'] => (no_prompt ? option_type['defaultInputValue'] : field_input_prompt(option_type))}
+        end
+        value
+      end
+
       # this is a funky one, the user is prompted for yes/no
       # but the return value is 'on','off',nil
       # todo: maybe make this easier to use, and have the api's be flexible too..
@@ -544,6 +741,9 @@ module Morpheus
           # value = input.empty? ? option_type['defaultValue'] : input
           if input == '?' && value.nil?
             help_prompt(option_type)
+          elsif input.chomp == '' && value.nil?
+            # just hit enter right away to skip this
+            value_found = true
           elsif input.chomp == 'EOF'
             value_found = true
           else
@@ -682,6 +882,42 @@ module Morpheus
         return file_params
       end
 
+      def self.load_options(option_type, api_client, api_params, query_value=nil)
+        select_options = []
+        # local array of options
+        if option_type['selectOptions']
+          # calculate from inline lambda
+          if option_type['selectOptions'].is_a?(Proc)
+            select_options = option_type['selectOptions'].call(api_client, grails_params(api_params || {}))
+          else
+            select_options = option_type['selectOptions']
+          end
+          # filter options ourselves
+          if query_value.to_s != ""
+            filtered_options = select_options.select { |it| it['value'].to_s == query_value.to_s }
+            if filtered_options.empty?
+              filtered_options = select_options.select { |it| it['name'].to_s == query_value.to_s }
+            end
+            select_options = filtered_options
+          end
+        elsif option_type['optionSource']
+          # calculate from inline lambda
+          if option_type['optionSource'].is_a?(Proc)
+            select_options = option_type['optionSource'].call(api_client, grails_params(api_params || {}))
+          elsif option_type['optionSource'] == 'list'
+            # /api/options/list is a special action for custom OptionTypeLists, just need to pass the optionTypeId parameter
+            select_options = load_source_options(option_type['optionSource'], api_client, grails_params(api_params || {}).merge({'optionTypeId' => option_type['id']}))
+          else
+            # remote optionSource aka /api/options/$optionSource?
+            select_options = load_source_options(option_type['optionSource'], api_client, grails_params(api_params || {}))
+          end
+        else
+          raise "option '#{field_key}' is type: 'typeahead' and missing selectOptions or optionSource!"
+        end
+
+        return select_options
+      end
+
       def self.help_prompt(option_type)
         field_key = [option_type['fieldContext'], option_type['fieldName']].select {|it| it && it != '' }.join('.')
         help_field_key = option_type[:help_field_prefix] ? "#{option_type[:help_field_prefix]}.#{field_key}" : field_key
@@ -691,6 +927,11 @@ module Morpheus
         else
           print Term::ANSIColor.green,"  * #{option_type['fieldLabel']} [-O #{help_field_key}=] - ", Term::ANSIColor.reset , "#{option_type['description']}\n"
         end
+        if option_type['type'].to_s == 'typeahead'
+          print "This is a typeahead input. Enter the name or value of an option.\n"
+          print "If the specified input matches more than one option, they will be printed and you will be prompted again.\n"
+          print "the matching options will be shown and you can try again.\n"
+        end
       end
 
 
@@ -698,7 +939,8 @@ module Morpheus
         api_client.options.options_for_source(source,params)['data']
       end
 
-      def self.display_select_options(opt, select_options = [], paging = nil)
+      def self.format_select_options_help(opt, select_options = [], paging = nil)
+        out = ""
         header = opt['fieldLabel'] ? "#{opt['fieldLabel']} Options" : "Options"
         if paging
           offset = paging[:cur_page] * paging[:page_size]
@@ -706,11 +948,18 @@ module Morpheus
           header = "#{header} (#{offset+1}-#{limit+1} of #{paging[:total]})"
           select_options = select_options[(offset)..(limit)]
         end
-        puts "\n#{header}"
-        puts "==============="
+        out = ""
+        out << "\n"
+        out << "#{header}\n"
+        out << "===============\n"
         select_options.each do |option|
-          puts " * #{option['name']} [#{option['value']}]"
+          out << " * #{option['name']} [#{option['value']}]\n"
         end
+        return out
+      end
+
+      def self.display_select_options(opt, select_options = [], paging = nil)
+        puts format_select_options_help(opt, select_options, paging)
       end
 
       def self.format_option_types_help(option_types, opts={})