morpheus-cli 4.2.22 → 5.2.1

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

@@ -596,12 +596,12 @@ 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 (used to be called tags)
+    if options[:labels]
+      payload['instance']['labels'] = 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])
-      payload['instance']['tags'] = v_prompt['tags'].split(',').collect {|it| it.to_s.strip }.compact.uniq if !v_prompt['tags'].empty?
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false}], options[:options])
+      payload['instance']['labels'] = v_prompt['labels'].split(',').collect {|it| it.to_s.strip }.compact.uniq if !v_prompt['labels'].empty?
     end
 
     # Version and Layout
@@ -976,6 +976,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
@@ -1688,6 +1691,15 @@ module Morpheus::Cli::ProvisioningHelper
           row = {}
           row['name'] = metadata_pair[0].to_s.strip
           row['value'] = metadata_pair[1].to_s.strip
+          # hacky way to set masked flag to true of false to (masked) in the value itself
+          if(row['value'].include?("(masked)"))
+            row['value'] = row['value'].gsub("(masked)", "").strip
+            row['masked'] = true
+          end
+          if(row['value'].include?("(unmasked)"))
+            row['value'] = row['value'].gsub("(unmasked)", "").strip
+            row['masked'] = false
+          end
           row
         end
         metadata = metadata_list
@@ -2175,6 +2187,82 @@ module Morpheus::Cli::ProvisioningHelper
     return ports
   end
 
+  def format_instance_status(instance, return_color=cyan)
+    out = ""
+    status_string = instance['status'].to_s
+    if status_string == 'running'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'provisioning'
+      out << "#{cyan}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'stopped' or status_string == 'failed'
+      out << "#{red}#{status_string.upcase}#{return_color}"
+    else
+      out << "#{yellow}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+
+  def format_instance_connection_string(instance)
+    if !instance['connectionInfo'].nil? && instance['connectionInfo'].empty? == false
+      connection_string = "#{instance['connectionInfo'][0]['ip']}:#{instance['connectionInfo'][0]['port']}"
+    end
+  end
+
+  def format_app_status(app, return_color=cyan)
+    out = ""
+    status_string = app['status'] || app['appStatus'] || ''
+    if status_string == 'running'
+      out = "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'provisioning'
+      out = "#{cyan}#{status_string.upcase}#{cyan}"
+    elsif status_string == 'stopped' or status_string == 'failed'
+      out = "#{red}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'unknown'
+      out = "#{yellow}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'warning' && app['instanceCount'].to_i == 0
+      # show this instead of WARNING
+      out =  "#{cyan}EMPTY#{return_color}"
+    else
+      out =  "#{yellow}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+  
+  def format_container_status(container, return_color=cyan)
+    out = ""
+    status_string = container['status'].to_s
+    if status_string == 'running'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'provisioning'
+      out << "#{cyan}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'stopped' or status_string == 'failed'
+      out << "#{red}#{status_string.upcase}#{return_color}"
+    else
+      out << "#{yellow}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+
+  def format_container_connection_string(container)
+    if !container['ports'].nil? && container['ports'].empty? == false
+      connection_string = "#{container['ip']}:#{container['ports'][0]['external']}"
+    else
+      # eh? more logic needed here i think, see taglib morph:containerLocationMenu
+      connection_string = "#{container['ip']}"
+    end
+  end
+  
+  def format_instance_container_display_name(instance, plural=false)
+    #<span class="info-label">${[null,'docker'].contains(instance.layout?.provisionType?.code) ? 'Containers' : 'Virtual Machines'}:</span> <span class="info-value">${instance.containers?.size()}</span>
+    v = plural ? "Containers" : "Container"
+    if instance && instance['layout'] && instance['layout'].key?("provisionTypeCode")
+      if [nil, 'docker'].include?(instance['layout']["provisionTypeCode"])
+        v = plural ? "Virtual Machines" : "Virtual Machine"
+      end
+    end
+    return v
+  end
+
   def format_blueprint_type(type_code)
     return type_code.to_s # just show it as is
     if type_code.to_s.empty?
@@ -2200,4 +2288,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/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,22 +137,32 @@ 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
             elsif option_type['type'] == 'select'
-              value = select_prompt(option_type.merge({'defaultValue' => value, 'defaultInputValue' => input_value}), api_client, (api_params || {}).merge(results), true)
+              value = select_prompt(option_type.merge({'defaultValue' => value, 'defaultInputValue' => input_value}), api_client, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), true)
             elsif option_type['type'] == 'multiSelect'
               # 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 << select_prompt(option_type.merge({'defaultValue' => v, 'defaultInputValue' => input_value_list[i]}), api_client, (api_params || {}).merge(results), true)
+                select_value_list << select_prompt(option_type.merge({'defaultValue' => v, 'defaultInputValue' => input_value_list[i]}), api_client, (option_type['noParams'] ? {} : (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, (option_type['noParams'] ? {} : (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, (option_type['noParams'] ? {} : (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
@@ -155,7 +187,11 @@ module Morpheus
                 # select type is special because it supports skipSingleOption
                 # and prints the available options on error
                 if ['select', 'multiSelect'].include?(option_type['type'])
-                  value = select_prompt(option_type, api_client, (api_params || {}).merge(results), true)
+                  value = select_prompt(option_type, api_client, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), true)
+                  value_found = !!value
+                end
+                if ['typeahead', 'multiTypeahead'].include?(option_type['type'])
+                  value = typeahead_prompt(option_type, api_client, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), true)
                   value_found = !!value
                 end
                 if !value_found
@@ -192,11 +228,23 @@ module Morpheus
               # I suppose the entered value should take precedence
               # api_params = api_params.merge(options) # this might be good enough
               # dup it
-              value = select_prompt(option_type, api_client, (api_params || {}).merge(results), options[:no_prompt], nil, paging_enabled)
+              value = select_prompt(option_type, api_client, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), options[:no_prompt], nil, paging_enabled)
               if value && option_type['type'] == 'multiSelect'
                 value = [value]
                 while self.confirm("Add another #{option_type['fieldLabel']}?", {:default => false}) do
-                  if addn_value = select_prompt(option_type, api_client, (api_params || {}).merge(results), options[:no_prompt], nil, paging_enabled)
+                  if addn_value = select_prompt(option_type, api_client, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), options[:no_prompt], nil, paging_enabled)
+                    value << addn_value
+                  else
+                    break
+                  end
+                end
+              end
+            elsif ['typeahead', 'multiTypeahead'].include?(option_type['type'])
+              value = typeahead_prompt(option_type, api_client, (option_type['noParams'] ? {} : (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, (option_type['noParams'] ? {} : (api_params || {}).merge(results)), options[:no_prompt], nil, paging_enabled)
                     value << addn_value
                   else
                     break
@@ -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={})