morpheus-cli 2.12.5 → 3.1.0

data/lib/morpheus/api/{network_pools_interface.rb → image_builder_boot_scripts_interface.rb}

@@ -1,6 +1,6 @@
 require 'morpheus/api/api_client'
 
-class Morpheus::NetworkPoolsInterface < Morpheus::APIClient
+class Morpheus::ImageBuilderBootScriptsInterface < Morpheus::APIClient
   def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
     @access_token = access_token
     @refresh_token = refresh_token
@@ -10,35 +10,35 @@ class Morpheus::NetworkPoolsInterface < Morpheus::APIClient
 
   def get(id, params={})
     raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-    url = "#{@base_url}/api/networks/pools/#{id}"
+    url = "#{@base_url}/api/boot-scripts/#{id}"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def list(params={})
-    url = "#{@base_url}/api/networks/pools"
+    url = "#{@base_url}/api/boot-scripts"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def create(payload)
-    url = "#{@base_url}/api/networks/pools"
+    url = "#{@base_url}/api/boot-scripts"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
   def update(id, payload)
-    url = "#{@base_url}/api/networks/pools/#{id}"
+    url = "#{@base_url}/api/boot-scripts/#{id}"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
   def destroy(id, params={})
-    url = "#{@base_url}/api/networks/pools/#{id}"
+    url = "#{@base_url}/api/boot-scripts/#{id}"
     headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :delete, url: url, timeout: 30, headers: headers}
     execute(opts)

data/lib/morpheus/api/{policies_interface.rb → image_builder_image_builds_interface.rb}

@@ -1,7 +1,6 @@
 require 'morpheus/api/api_client'
-require 'uri'
-
-class Morpheus::PoliciesInterface < Morpheus::APIClient
+# this may change to just /api/image-builds
+class Morpheus::ImageBuilderImageBuildsInterface < Morpheus::APIClient
   def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
     @access_token = access_token
     @refresh_token = refresh_token
@@ -11,50 +10,56 @@ class Morpheus::PoliciesInterface < Morpheus::APIClient
 
   def get(id, params={})
     raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-    url = "#{@base_url}/api/policies/#{id}"
+    url = "#{@base_url}/api/image-builds/#{id}"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def list(params={})
-    url = "#{@base_url}/api/policies"
+    url = "#{@base_url}/api/image-builds"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def create(payload)
-    url = "#{@base_url}/api/policies"
+    url = "#{@base_url}/api/image-builds"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
+  # def validate_save(payload)
+  #   url = "#{@base_url}/api/image-builds/validate-save"
+  #   headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+  #   opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+  #   execute(opts)
+  # end
+
   def update(id, payload)
-    url = "#{@base_url}/api/policies/#{id}"
+    url = "#{@base_url}/api/image-builds/#{id}"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
   def destroy(id, params={})
-    url = "#{@base_url}/api/policies/#{id}"
+    url = "#{@base_url}/api/image-builds/#{id}"
     headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :delete, url: url, timeout: 30, headers: headers}
     execute(opts)
   end
 
-  def list_policy_types(params={})
-    url = "#{@base_url}/api/policy-types"
-    headers = { params: params, authorization: "Bearer #{@access_token}" }
-    opts = {method: :get, url: url, headers: headers}
+  def run(id, params={})
+    url = "#{@base_url}/api/image-builds/#{id}/run"
+    headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :post, url: url, timeout: 30, headers: headers}
     execute(opts)
   end
 
-  def get_policy_type(id, params={})
-    raise "#{self.class}.get_policy_type() passed a blank id!" if id.to_s == ''
-    url = "#{@base_url}/api/policy-types/#{URI.escape(id.to_s)}"
+  def list_executions(id, params={})
+    url = "#{@base_url}/api/image-builds/#{id}/list-executions"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)

data/lib/morpheus/api/image_builder_interface.rb

@@ -0,0 +1,26 @@
+require 'morpheus/api/api_client'
+require 'morpheus/api/image_builder_image_builds_interface'
+require 'morpheus/api/image_builder_preseed_scripts_interface'
+require 'morpheus/api/image_builder_boot_scripts_interface'
+
+class Morpheus::ImageBuilderInterface < Morpheus::APIClient
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
+
+  def image_builds
+    Morpheus::ImageBuilderImageBuildsInterface.new(@access_token, @refresh_token, @expires_at, @base_url)
+  end
+
+  def preseed_scripts
+    Morpheus::ImageBuilderPreseedScriptsInterface.new(@access_token, @refresh_token, @expires_at, @base_url)
+  end
+
+  def boot_scripts
+    Morpheus::ImageBuilderBootScriptsInterface.new(@access_token, @refresh_token, @expires_at, @base_url)
+  end
+  
+end

data/lib/morpheus/api/{network_proxies_interface.rb → image_builder_preseed_scripts_interface.rb}

@@ -1,6 +1,6 @@
 require 'morpheus/api/api_client'
 
-class Morpheus::NetworkProxiesInterface < Morpheus::APIClient
+class Morpheus::ImageBuilderPreseedScriptsInterface < Morpheus::APIClient
   def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
     @access_token = access_token
     @refresh_token = refresh_token
@@ -10,35 +10,35 @@ class Morpheus::NetworkProxiesInterface < Morpheus::APIClient
 
   def get(id, params={})
     raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-    url = "#{@base_url}/api/networks/proxies/#{id}"
+    url = "#{@base_url}/api/preseed-scripts/#{id}"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def list(params={})
-    url = "#{@base_url}/api/networks/proxies"
+    url = "#{@base_url}/api/preseed-scripts"
     headers = { params: params, authorization: "Bearer #{@access_token}" }
     opts = {method: :get, url: url, headers: headers}
     execute(opts)
   end
 
   def create(payload)
-    url = "#{@base_url}/api/networks/proxies"
+    url = "#{@base_url}/api/preseed-scripts"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
   def update(id, payload)
-    url = "#{@base_url}/api/networks/proxies/#{id}"
+    url = "#{@base_url}/api/preseed-scripts/#{id}"
     headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
     execute(opts)
   end
 
   def destroy(id, params={})
-    url = "#{@base_url}/api/networks/proxies/#{id}"
+    url = "#{@base_url}/api/preseed-scripts/#{id}"
     headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     opts = {method: :delete, url: url, timeout: 30, headers: headers}
     execute(opts)

data/lib/morpheus/cli.rb

@@ -29,7 +29,7 @@ module Morpheus
     def self.load!()
       # load interfaces
       require 'morpheus/api/api_client.rb'
-      Dir[File.dirname(__FILE__)  + "/api/*.rb"].each {|file| load file }
+      Dir[File.dirname(__FILE__)  + "/api/**/*.rb"].each {|file| load file }
 
       # load mixins
       Dir[File.dirname(__FILE__)  + "/cli/mixins/*.rb"].each {|file| load file }
@@ -94,14 +94,15 @@ module Morpheus
       load 'morpheus/cli/monitoring_contacts_command.rb'
       load 'morpheus/cli/monitoring_groups_command.rb'
       load 'morpheus/cli/monitoring_apps_command.rb'
-      load 'morpheus/cli/policies_command.rb'
-      load 'morpheus/cli/networks_command.rb'
-      load 'morpheus/cli/network_groups_command.rb'
-      load 'morpheus/cli/network_pools_command.rb'
-      load 'morpheus/cli/network_services_command.rb'
-      load 'morpheus/cli/network_pool_servers_command.rb'
-      load 'morpheus/cli/network_domains_command.rb'
-      load 'morpheus/cli/network_proxies_command.rb'
+
+      # maybe scope all of these to image-builder or something
+      load 'morpheus/cli/image_builder_command.rb'
+      # load 'morpheus/cli/image_builds_command.rb'
+      load 'morpheus/cli/preseed_scripts_command.rb'
+      load 'morpheus/cli/boot_scripts_command.rb'
+
+      load 'morpheus/cli/archives_command.rb'
+
       # nice to have commands
       load 'morpheus/cli/curl_command.rb'
       load 'morpheus/cli/set_prompt_command.rb'

data/lib/morpheus/cli/alias_command.rb

@@ -68,15 +68,14 @@ class Morpheus::Cli::AliasCommand
       exit 1
     end
     alias_definition = args[0]
-    alias_name, command_string = Morpheus::Cli::CliRegistry.parse_alias_definition(alias_definition)
 
-    if alias_name.empty? || command_string.empty?
-      print_red_alert "invalid alias syntax: #{alias_definition}"
-      return false
-    else
-      # config[:aliases] ||= []
-      # config[:aliases] << {name: alias_name, command: command_string}
+      
       begin
+        alias_name, command_string = Morpheus::Cli::CliRegistry.parse_alias_definition(alias_definition)
+        if alias_name.empty? || command_string.empty?
+          print_red_alert "invalid alias syntax: #{alias_definition}"
+          return false
+        end
         Morpheus::Cli::CliRegistry.instance.add_alias(alias_name, command_string)
         #print "registered alias #{alias_name}", "\n"
         if do_export
@@ -84,12 +83,14 @@ class Morpheus::Cli::AliasCommand
           morpheus_profile = Morpheus::Cli::DotFile.new(Morpheus::Cli::DotFile.morpheus_profile_filename)
           morpheus_profile.export_aliases({(alias_name) => command_string})
         end
+      rescue Morpheus::Cli::CliRegistry::BadAlias => err
+        print_red_alert "#{err.message}"
+        return false
       rescue => err
-        raise err
+        # raise err  
         print_red_alert "#{err.message}"
         return false
       end
-    end
 
     if Morpheus::Cli::Shell.instance
       Morpheus::Cli::Shell.instance.recalculate_auto_complete_commands()

data/lib/morpheus/cli/app_templates.rb

@@ -9,9 +9,21 @@ class Morpheus::Cli::AppTemplates
   include Morpheus::Cli::CliCommand
   include Morpheus::Cli::ProvisioningHelper
 
-  register_subcommands :list, :get, :add, :update, :remove, :'add-instance', :'remove-instance', :'connect-tiers', :'available-tiers', :'available-types'
-  alias_subcommand :details, :get
-  set_default_subcommand :list
+  #set_command_name :templates # instead of app-templates
+
+  register_subcommands :list, :get, :add, :update, :remove
+  register_subcommands :duplicate
+  register_subcommands :'upload-image' => :upload_image
+  register_subcommands :'available-tiers'
+  register_subcommands :'add-tier', :'update-tier', :'remove-tier', :'connect-tiers', :'disconnect-tiers'
+  register_subcommands :'add-instance'
+  #register_subcommands :'update-instance'
+  register_subcommands :'remove-instance'
+  register_subcommands :'add-instance-config'
+  #register_subcommands :'update-instance-config'
+  register_subcommands :'remove-instance-config'
+  # alias_subcommand :details, :get
+  # set_default_subcommand :list
   
   def initialize() 
     # @appliance_name, @appliance_url = Morpheus::Cli::Remote.active_appliance
@@ -33,9 +45,10 @@ class Morpheus::Cli::AppTemplates
 
   def list(args)
     options = {}
-    optparse = OptionParser.new do|opts|
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage()
       build_common_options(opts, options, [:list, :json, :dry_run])
+      opts.footer = "List app templates."
     end
     optparse.parse!(args)
     connect(options)
@@ -76,12 +89,14 @@ class Morpheus::Cli::AppTemplates
 
   def get(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name]")
-      opts.on( '-c', '--config', "Display Config Data" ) do |val|
-        options[:config] = true
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template]")
+      opts.on( '-c', '--config', "Display raw config only. Default is YAML. Combine with -j for JSON instead." ) do
+        options[:show_config] = true
       end
-      build_common_options(opts, options, [:json, :dry_run])
+      build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.footer = "Get details about an app template.\n" +
+                    "[template] is required. This is the name or id of an app template."
     end
     optparse.parse!(args)
     if args.count < 1
@@ -92,59 +107,59 @@ class Morpheus::Cli::AppTemplates
     begin
       if options[:dry_run]
         if args[0].to_s =~ /\A\d{1,}\Z/
-          print_dry_run @instances_interface.dry.get(args[0].to_i)
+          print_dry_run @app_templates_interface.dry.get(args[0].to_i)
         else
-          print_dry_run @instances_interface.dry.list({name:args[0]})
+          print_dry_run @app_templates_interface.dry.list({name:args[0]})
         end
         return
       end
       app_template = find_app_template_by_name_or_id(args[0])
       exit 1 if app_template.nil?
 
-      json_response = @app_templates_interface.get(app_template['id'])
+      json_response = {'appTemplate' => app_template}  # skip redundant request
+      #json_response = @app_templates_interface.get(app_template['id'])
       app_template = json_response['appTemplate']
 
-      if options[:json]
-        print JSON.pretty_generate(json_response)
-        print "\n"
-      else
-        print_h1 "App Template Details"
-        print cyan
-        description_cols = {
-          "ID" => 'id',
-          "Name" => 'name',
-          "Account" => lambda {|it| it['account'] ? it['account']['name'] : '' }
-        }
-        print_description_list(description_cols, app_template)
-
-        instance_type_names = (app_template['instanceTypes'] || []).collect {|it| it['name'] }
-        #puts "Instance Types: #{instance_type_names.join(', ')}"
-        config = app_template['config']['tierView']
-        tiers = config['nodes'].select {|node| node['data']['type'] == "tier" }
-        if tiers.empty?
-          puts yellow,"0 Tiers",reset
+      if options[:show_config]
+        #print_h2 "RAW"
+        if options[:json]
+          print cyan
+          print "// JSON config for Morpheus App Template: #{app_template['name']}","\n"
+          print reset
+          puts as_json(app_template["config"])
         else
-          tiers.each do |tier|
-            instances = config['nodes'].select {|node| node['data']['type'] == "instance" && node['data']['parent'] == tier['data']['id'] }.sort {|x,y| x['data']['index'].to_i <=> y['data']['index'].to_i }
-            print "\n"
-            print cyan, "=  #{tier['data']['name']}\n"
-            instances.each do |instance|
-              instance_id = instance['data']['id'].to_s.sub('newinstance-', '')
-              instance_name = instance['data']['instance.name'] || ''
-              print green, "    #{instance_name} - #{instance['data']['typeName']} (#{instance_id})\n",reset
-            end
-
-          end
+          print cyan
+          print "# YAML config for Morpheus App Template: #{app_template['name']}","\n"
+          print reset
+          puts as_yaml(app_template["config"])
         end
-        print cyan
+        return 0
+      end
 
-        if options[:config]
-          puts "\nConfig:"
-          puts JSON.pretty_generate(config)
+      if options[:json]
+        if options[:include_fields]
+          json_response = {"appTemplate" => filter_data(json_response["appTemplate"], options[:include_fields]) }
         end
-
-        print reset,"\n"
+        puts as_json(json_response, options)
+        return 0
+      elsif options[:yaml]
+        if options[:include_fields]
+          json_response = {"appTemplate" => filter_data(json_response["appTemplate"], options[:include_fields]) }
+        end
+        puts as_yaml(json_response, options)
+        return 0
+      end
+      if options[:csv]
+        puts records_as_csv([json_response['appTemplate']], options)
+        return 0
       end
+      
+      print_h1 "App Template Details"
+      
+      print_app_template_details(app_template)
+
+      print reset,"\n"
+      
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1
@@ -153,46 +168,58 @@ class Morpheus::Cli::AppTemplates
 
   def add(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage()
-      # opts.on( '-g', '--group GROUP', "Group Name" ) do |group|
-      #   options[:options] ||= {}
-      #   options[:options]['group'] = group
-      # end
-      build_option_type_options(opts, options, add_app_template_option_types(false))
-      opts.on( '-g', '--group GROUP', "Group Name or ID" ) do |val|
-        options[:options] ||= {}
-        options[:options]['group']
-        # options[:group] = val
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name] [options]")
+      opts.on('--config JSON', String, "App Template Config JSON") do |val|
+        options['config'] = JSON.parse(val.to_s)
+      end
+      opts.on('--config-yaml YAML', String, "App Template Config YAML") do |val|
+        options['config'] = YAML.load(val.to_s)
+      end
+      opts.on('--config-file FILE', String, "App Template Config from a local JSON or YAML file") do |val|
+        options['configFile'] = val.to_s
       end
+      build_option_type_options(opts, options, add_app_template_option_types(false))
       build_common_options(opts, options, [:options, :json, :dry_run])
+      opts.footer = "Create a new app template.\n" + 
+                    "[name] is optional and can be passed as --name or inside the config instead."
+                    "[--config] or [--config-file] can be used to define the app template."
     end
     optparse.parse!(args)
+    if args.count > 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} add expects 0-1 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      return 1
+    end
+    options[:options] ||= {}
+    if args[0] && !options[:options]['name']
+      options[:options]['name'] = args[0]
+    end
     connect(options)
     begin
-      options[:options] ||= {}
-      # use active group by default
-      options[:options]['group'] ||= @active_group_id
-      
-      params = Morpheus::Cli::OptionTypes.prompt(add_app_template_option_types, options[:options], @api_client, options[:params])
-      group = find_group_by_name_or_id_for_provisioning(params.delete('group'))
-
-      #puts "parsed params is : #{params.inspect}"
-      app_template_keys = ['name']
-      app_template_payload = params.select {|k,v| app_template_keys.include?(k) }
-
-      group = nil
-      if params['group'].to_s != ''
-        group = find_group_by_name(params['group'])
-        exit 1 if group.nil?
-        #app_template_payload['siteId'] = {id: group['id']}
+      request_payload = nil
+      config_payload = {}
+      if options['config']
+        config_payload = options['config']
+        request_payload = config_payload
+      elsif options['configFile']
+        config_file = File.expand_path(options['configFile'])
+        if !File.exists?(config_file) || !File.file?(config_file)
+          print_red_alert "File not found: #{config_file}"
+          return false
+        end
+        if config_file =~ /\.ya?ml\Z/
+          config_payload = YAML.load_file(config_file)
+        else
+          config_payload = JSON.parse(File.read(config_file))
+        end
+        request_payload = config_payload
+      else
+        params = Morpheus::Cli::OptionTypes.prompt(add_app_template_option_types, options[:options], @api_client, options[:params])
+        app_template_payload = params.select {|k,v| ['name', 'description', 'category'].include?(k) }
+        # expects no namespace, just the config
+        request_payload = app_template_payload
       end
-      config = {
-        nodes: []
-      }
-      request_payload = {appTemplate: app_template_payload}
-      request_payload['siteId'] = group['id'] if group
-      request_payload['config'] = config
 
       if options[:dry_run]
         print_dry_run @app_templates_interface.dry.create(request_payload)
@@ -205,9 +232,19 @@ class Morpheus::Cli::AppTemplates
         print JSON.pretty_generate(json_response)
         print "\n"
       else
-        print_green_success "Added app template #{app_template_payload['name']}"
-        details_options = [app_template_payload["name"]]
-        get(details_options)
+        app_template = json_response["appTemplate"]
+        print_green_success "Added app template #{app_template['name']}"
+        if !options[:no_prompt]
+          if ::Morpheus::Cli::OptionTypes::confirm("Would you like to add a tier now?", options.merge({default: false}))
+            add_tier([app_template['id']])
+            while ::Morpheus::Cli::OptionTypes::confirm("Add another tier?", options.merge({default: false})) do
+              add_tier([app_template['id']])
+            end
+          else
+            # print details
+            get([app_template['id']])
+          end
+        end
       end
 
     rescue RestClient::Exception => e
@@ -218,10 +255,23 @@ class Morpheus::Cli::AppTemplates
 
   def update(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name] [options]")
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [options]")
+      opts.on('--config JSON', String, "App Template Config JSON") do |val|
+        options['config'] = JSON.parse(val.to_s)
+      end
+      opts.on('--config-yaml YAML', String, "App Template Config YAML") do |val|
+        options['config'] = YAML.load(val.to_s)
+      end
+      opts.on('--config-file FILE', String, "App Template Config from a local JSON or YAML file") do |val|
+        options['configFile'] = val.to_s
+      end
       build_option_type_options(opts, options, update_app_template_option_types(false))
-      build_common_options(opts, options, [:options, :json, :dry_run])
+      build_common_options(opts, options, [:options, :json, :dry_run, :quiet])
+      opts.footer = "Update an app template.\n" + 
+                    "[template] is required. This is the name or id of an app template.\n" +
+                    "[options] Available options include --name and --description. This will update only the specified values.\n" +
+                    "[--config] or [--config-file] can be used to replace the entire app template."
     end
     optparse.parse!(args)
 
@@ -237,291 +287,1106 @@ class Morpheus::Cli::AppTemplates
       app_template = find_app_template_by_name_or_id(args[0])
       exit 1 if app_template.nil?
 
-      #params = Morpheus::Cli::OptionTypes.prompt(update_app_template_option_types, options[:options], @api_client, options[:params])
-      params = options[:options] || {}
+      request_payload = nil
+      config_payload = {}
+      if options['config']
+        config_payload = options['config']
+        request_payload = config_payload
+      elsif options['configFile']
+        config_file = options['configFile']
+        if !File.exists?(config_file)
+          print_red_alert "File not found: #{config_file}"
+          return false
+        end
+        if config_file =~ /\.ya?ml\Z/
+          config_payload = YAML.load_file(config_file)
+        else
+          config_payload = JSON.parse(File.read(config_file))
+        end
+        request_payload = config_payload
+      else
+        # update just name,description,category
+        # preserve all other attributes of the config..
 
-      if params.empty?
-        print_red_alert "Specify atleast one option to update"
-        puts optparse
-        exit 1
-      end
+        #params = Morpheus::Cli::OptionTypes.prompt(update_app_template_option_types, options[:options], @api_client, options[:params])
+        params = options[:options] || {}
 
-      #puts "parsed params is : #{params.inspect}"
-      app_template_keys = ['name']
-      app_template_payload = params.select {|k,v| app_template_keys.include?(k) }
+        if params.empty?
+          # print_red_alert "Specify atleast one option to update"
+          print_red_alert "Specify atleast one option to update.\nOr use --config or --config-file to replace the entire config."
+          puts optparse
+          exit 1
+        end
 
-      group = nil
-      if params['group'].to_s != ''
-        group = find_group_by_name(params['group'])
-        exit 1 if group.nil?
-        #app_template_payload['siteId'] = {id: group['id']}
+        #puts "parsed params is : #{params.inspect}"
+        app_template_payload = params.select {|k,v| ['name','description','category'].include?(k) }
+        # expects no namespace, just the config
+        # preserve all other attributes of the config.
+        request_payload = app_template["config"].merge(app_template_payload)
+        # todo maybe: put name, description and category at the front.
+        # request_payload = app_template_payload.merge(app_template["config"].merge(app_template_payload))
+      end
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return
       end
-      config = app_template['config'] # {}
-      request_payload = {appTemplate: app_template_payload}
-      if group
-        request_payload['siteId'] = group['id']
+
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        print JSON.pretty_generate(json_response)
+        print "\n"
       else
-        request_payload['siteId'] = app_template['config']['siteId']
+        unless options[:quiet]
+          app_template = json_response['appTemplate']
+          print_green_success "Updated app template #{app_template['name']}"
+          details_options = [app_template['id']]
+          get(details_options)
+        end
       end
-      # request_payload['config'] = config['tierView']
-      request_payload['config'] = config
 
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+
+  def upload_image(args)
+    image_type_name = nil
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [file]")
+      build_common_options(opts, options, [:json, :dry_run, :quiet, :remote])
+      opts.footer = "Upload an image file to be used as the icon for an app template.\n" + 
+                    "[template] is required. This is the name or id of an app template.\n" +
+                    "[file] is required. This is the local path of a file to upload [png|jpg|svg]."
+    end
+    optparse.parse!(args)
+    if args.count != 2
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} upload-image expects 2 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      return 1
+    end
+    app_template_name = args[0]
+    filename = File.expand_path(args[1].to_s)
+    image_file = nil
+    if filename && File.file?(filename)
+      # maybe validate it's an image file? [.png|jpg|svg]
+      image_file = File.new(filename, 'rb')
+    else
+      print_red_alert "File not found: #{filename}"
+      # print_error Morpheus::Terminal.angry_prompt
+      # puts_error  "bad argument [file] - File not found: #{filename}\n#{optparse}"
+      return 1
+    end
+    connect(options)
+    begin
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      exit 1 if app_template.nil?
       if options[:dry_run]
-        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        print_dry_run @app_templates_interface.dry.save_image(app_template['id'], image_file)
+        return 0
+      end
+      unless options[:quiet] || options[:json]
+        print cyan, "Uploading file #{filename} ...", reset, "\n"
+      end
+      json_response = @app_templates_interface.save_image(app_template['id'], image_file)
+      if options[:json]
+        print JSON.pretty_generate(json_response)
+      elsif !options[:quiet]
+        app_template = json_response['appTemplate']
+        new_image_url = app_template['image']
+        print cyan, "Updated app template #{app_template['name']} image.\nNew image url is: #{new_image_url}", reset, "\n\n"
+        get([app_template['id']])
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def duplicate(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [new name]")
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
+      opts.footer = "Duplicate an app template." + "\n" +
+                    "[template] is required. This is the name or id of an app template." + "\n" +
+                    "[new name] is required. This is the name for the clone."
+    end
+    optparse.parse!(args)
+
+    if args.count < 1
+      puts optparse
+      exit 1
+    end
+
+    request_payload = {"appTemplate" => {}}
+    if args[1]
+      request_payload["appTemplate"]["name"] = args[1]
+    end
+
+    connect(options)
+    begin
+      app_template = find_app_template_by_name_or_id(args[0])
+      exit 1 if app_template.nil?
+      # unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to duplicate the app template #{app_template['name']}?")
+      #   exit
+      # end
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.duplicate(app_template['id'], request_payload)
         return
       end
+      json_response = @app_templates_interface.duplicate(app_template['id'], request_payload)
 
-      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+      if options[:json]
+        print JSON.pretty_generate(json_response)
+        print "\n"
+      else
+        new_app_template = json_response["appTemplate"] || {}
+        print_green_success "Created duplicate app template '#{new_app_template['name']}'"
+        #get([new_app_template["id"]])
+      end
 
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def remove(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template]")
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
+      opts.footer = "Delete an app template." + "\n" +
+                    "[template] is required. This is the name or id of an app template."
+    end
+    optparse.parse!(args)
+
+    if args.count < 1
+      puts optparse
+      exit 1
+    end
+
+    connect(options)
+    begin
+      app_template = find_app_template_by_name_or_id(args[0])
+      exit 1 if app_template.nil?
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the app template #{app_template['name']}?")
+        exit
+      end
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.destroy(app_template['id'])
+        return
+      end
+      json_response = @app_templates_interface.destroy(app_template['id'])
 
       if options[:json]
         print JSON.pretty_generate(json_response)
         print "\n"
       else
-        print_green_success "Updated app template #{app_template_payload['name']}"
-        details_options = [app_template_payload["name"] || app_template['name']]
-        get(details_options)
+        print_green_success "Removed app template #{app_template['name']}"
+      end
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def add_instance(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier] [instance-type]")
+      # opts.on( '-g', '--group GROUP', "Group" ) do |val|
+      #   options[:group] = val
+      # end
+      # opts.on( '-c', '--cloud CLOUD', "Cloud" ) do |val|
+      #   options[:cloud] = val
+      # end
+      opts.on('--name VALUE', String, "Instance Name") do |val|
+        options[:instance_name] = val
+      end
+      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+      opts.footer = "Update an app template, adding an instance." + "\n" +
+                    "[template] is required. This is the name or id of an app template." + "\n" +
+                    "[tier] is required and will be prompted for. This is the name of the tier." + "\n" +
+                    "[instance-type] is required and will be prompted for. This is the type of instance."
+    end
+    optparse.parse!(args)
+
+    if args.count < 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} add-instance expects 3 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      return 1
+    end
+
+    connect(options)
+
+    begin
+      app_template_name = args[0]
+      tier_name = args[1]
+      instance_type_code = args[2]
+      # we also need consider when there is multiple instances of the same type in
+      # a template/tier.. so maybe split instance_type_code as [type-code]:[index].. or...errr
+
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+
+      if !tier_name
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'tierName', 'fieldLabel' => 'Tier Name', 'type' => 'text', 'required' => true, 'description' => 'Enter the name of the tier'}], options[:options])
+        tier_name = v_prompt['tierName']
+      end
+
+      if !instance_type_code
+        instance_type_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'type' => 'select', 'fieldLabel' => 'Type', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Select Instance Type.'}],options[:options],api_client,{})
+        instance_type_code = instance_type_prompt['type']
+      end
+      instance_type = find_instance_type_by_code(instance_type_code)
+      return 1 if instance_type.nil?
+      
+      tier_config = nil
+      instance_config = nil
+
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
+      tiers ||= {}
+      # tier identified by name, case sensitive...
+      if !tiers[tier_name]
+        tiers[tier_name] = {}
+      end
+      tier_config = tiers[tier_name]
+      
+      tier_config['instances'] ||= []
+      instance_config = tier_config['instances'].find {|it| it["instance"] && it["instance"]["type"] && it["instance"]["type"] == instance_type["code"] }
+      if !instance_config
+        instance_config = {'instance' => {'type' => instance_type['code']} }
+        tier_config['instances'].push(instance_config)
+      end
+      instance_config['instance'] ||= {}
+
+      # just prompts for Instance Name (optional)
+      instance_name = nil
+      if options[:instance_name]
+        instance_name = options[:instance_name]
+      else
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Instance Name', 'type' => 'text', 'defaultValue' => instance_config['instance']['name']}])
+        instance_name = v_prompt['name'] || ''
+      end
+      
+      if instance_name
+        if instance_name.to_s == 'null'
+          instance_config['instance'].delete('name')
+          # instance_config['instance']['name'] = ''
+        else
+          instance_config['instance']['name'] = instance_name
+        end
+      end
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return 0
+      end
+
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        puts JSON.pretty_generate(json_response)
+      elsif !options[:quiet]
+        print_green_success "Instance added to app template #{app_template['name']}"
+        # prompt for new instance
+        if !options[:no_prompt]
+          if ::Morpheus::Cli::OptionTypes::confirm("Would you like to add a config now?", options.merge({default: true}))
+            # todo: this needs to work by index, because you can have multiple instances of the same type
+            add_instance_config([app_template['id'], tier_name, instance_type['code']])
+            while ::Morpheus::Cli::OptionTypes::confirm("Add another config?", options.merge({default: false})) do
+              add_instance_config([app_template['id'], tier_name, instance_type['code']])
+            end
+          else
+            # print details
+            get([app_template['name']])
+          end
+        end
+      end
+      return 0
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+
+  end
+
+  def add_instance_config(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier] [instance]")
+      opts.on( '-g', '--group GROUP', "Group" ) do |val|
+        options[:group] = val
+      end
+      opts.on( '-c', '--cloud CLOUD', "Cloud" ) do |val|
+        options[:cloud] = val
+      end
+      opts.on( '-e', '--env ENVIRONMENT', "Environment" ) do |val|
+        options[:environment] = val
+      end
+      opts.on('--name VALUE', String, "Instance Name") do |val|
+        options[:instance_name] = val
+      end
+      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+      opts.footer = "Update an app template, adding an instance config." + "\n" +
+                    "[template] is required. This is the name or id of an app template." + "\n" +
+                    "[tier] is required. This is the name of the tier." + "\n" +
+                    "[instance] is required. This is the type of instance."
+    end
+    optparse.parse!(args)
+
+    if args.count < 3
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "Wrong number of arguments"
+      puts_error optparse
+      return 1
+    end
+
+    connect(options)
+
+    begin
+
+      app_template_name = args[0]
+      tier_name = args[1]
+      instance_type_code = args[2]
+      # we also need consider when there is multiple instances of the same type in
+      # a template/tier.. so maybe split instance_type_code as [type-code]:[index].. or...errr
+
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+
+      instance_type = find_instance_type_by_code(instance_type_code)
+      return 1 if instance_type.nil?
+      
+      tier_config = nil
+      instance_config = nil
+
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
+      tiers ||= {}
+      # tier identified by name, case sensitive...
+      if !tiers[tier_name]
+        tiers[tier_name] = {}
+      end
+      tier_config = tiers[tier_name]
+      
+      tier_config['instances'] ||= []
+      instance_config = tier_config['instances'].find {|it| it["instance"] && it["instance"]["type"] && it["instance"]["type"] == instance_type["code"] }
+      if !instance_config
+        instance_config = {'instance' => {'type' => instance_type['code']} }
+        tier_config['instances'].push(instance_config)
+      end
+      instance_config['instance'] ||= {}
+
+      # group prompt
+
+      # use active group by default
+      options[:group] ||= @active_group_id
+      
+
+      # available_groups = get_available_groups()
+      # group_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'group', 'fieldLabel' => 'Group', 'type' => 'select', 'selectOptions' => get_available_groups(), 'required' => true, 'defaultValue' => @active_group_id}],options[:options],@api_client,{})
+      
+      # group_id = group_prompt['group']
+      # the_group = find_group_by_name_or_id_for_provisioning(group_id)
+
+      # # cloud prompt
+      # cloud_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'cloud', 'type' => 'select', 'fieldLabel' => 'Cloud', 'optionSource' => 'clouds', 'required' => true, 'description' => 'Select Cloud.'}],options[:options],@api_client,{groupId: group_id})
+      # cloud_id = cloud_prompt['cloud']
+
+      # look for existing config for group + cloud
+
+      options[:name_required] = false
+      options[:instance_type_code] = instance_type["code"]
+      
+      #options[:options].deep_merge!(specific_config)
+      # this provisioning helper method handles all (most) of the parsing and prompting
+      instance_config_payload = prompt_new_instance(options)
+
+      # strip all empty string and nil, would be problematic for update()
+      instance_config_payload.deep_compact!
+      
+      # puts "INSTANCE CONFIG YAML:"
+      # puts as_yaml(instance_config_payload)
+      
+      selected_environment = instance_config_payload.delete('instanceContext') || instance_config_payload.delete('environment')
+      # groom provision instance payload for template purposes
+      selected_cloud_id = instance_config_payload.delete('zoneId')
+      selected_site = instance_config_payload['instance'].delete('site')
+      selected_site_id = selected_site['id']
+
+      selected_group = find_group_by_name_or_id_for_provisioning(selected_site_id)
+      selected_cloud = find_cloud_by_name_or_id_for_provisioning(selected_group['id'], selected_cloud_id)
+
+      # store config in environments => env => groups => groupname => clouds => cloudname => 
+      current_config = instance_config
+      if selected_environment.to_s != ''
+        instance_config['environments'] ||= {}
+        instance_config['environments'][selected_environment] ||= {}
+        current_config = instance_config['environments'][selected_environment]
+      end
+
+      current_config['groups'] ||= {}
+      current_config['groups'][selected_group['name']] ||= {}
+      current_config['groups'][selected_group['name']]['clouds'] ||= {}
+      current_config['groups'][selected_group['name']]['clouds'][selected_cloud['name']] = instance_config_payload
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return 0
+      end
+
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        puts JSON.pretty_generate(json_response)
+      else
+        print_green_success "Instance added to app template #{app_template['name']}"
+        get([app_template['name']])
+      end
+      return 0
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+
+  end
+
+  def remove_instance_config(args)
+    instance_index = nil
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier] [instance] -g GROUP -c CLOUD")
+      opts.on( '-g', '--group GROUP', "Group" ) do |val|
+        options[:group] = val
+      end
+      opts.on( '-c', '--cloud CLOUD', "Cloud" ) do |val|
+        options[:cloud] = val
+      end
+      opts.on( '-e', '--env ENV', "Environment" ) do |val|
+        options[:environment] = val
+      end
+      # opts.on( nil, '--index NUMBER', "The index of the instance to remove, starting with 0." ) do |val|
+      #   instance_index = val.to_i
+      # end
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
+      opts.footer = "Update an app template, removing a specified instance config." + "\n" +
+                    "[template] is required. This is the name or id of an app template." + "\n" +
+                    "[tier] is required. This is the name of the tier." + "\n" +
+                    "[instance] is required. This is the type of instance." + "\n" +
+                    "The config scope is specified with the -g GROUP, -c CLOUD and -e ENV. The -g and -c options are required."
+    end
+    optparse.parse!(args)
+    
+    if args.count < 3
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "Wrong number of arguments"
+      puts_error optparse
+      return 1
+    end
+    if !options[:group]
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "Missing required argument -g GROUP"
+      puts_error optparse
+      return 1
+    end
+    if !options[:cloud]
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "Missing required argument -g CLOUD"
+      puts_error optparse
+      return 1
+    end
+    connect(options)
+
+    begin
+
+      app_template_name = args[0]
+      tier_name = args[1]
+      instance_type_code = args[2]
+      # we also need consider when there is multiple instances of the same type in
+      # a template/tier.. so maybe split instance_type_code as [type-code]:[index].. or...errr
+
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+
+      instance_type = find_instance_type_by_code(instance_type_code)
+      return 1 if instance_type.nil?
+      
+      tier_config = nil
+      # instance_config = nil
+
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
+      tiers ||= {}
+      # tier identified by name, case sensitive...
+      if !tiers[tier_name]
+        print_red_alert "Tier not found by name #{tier_name}"
+        return 1
+      end
+      tier_config = tiers[tier_name]
+      
+      if !tier_config
+        print_red_alert "Tier not found by name #{tier1_name}!"
+        return 1
+      elsif tier_config['instances'].nil? || tier_config['instances'].empty?
+        print_red_alert "Tier #{tier_name} is empty!"
+        return 1
+      end
+
+      matching_indices = []
+      if tier_config['instances']
+        if instance_index
+          matching_indices = [instance_index].compact
+        else
+          tier_config['instances'].each_with_index do |instance_config, index|
+            is_match = instance_config['instance'] && instance_config['instance']['type'] == instance_type['code']
+            if is_match
+              matching_indices << index
+            end
+          end
+        end
+      end
+
+      if matching_indices.size == 0
+        print_red_alert "Instance not found by tier: #{tier_name}, type: #{instance_type_code}"
+        return 1
+      elsif matching_indices.size > 1
+        #print_error Morpheus::Terminal.angry_prompt
+        print_red_alert  "More than one instance found by tier: #{tier_name}, type: #{instance_type_code}"
+        puts_error "Try using the --index option to identify the instance you wish to remove."
+        puts_error optparse
+        return 1
+      end
+
+      # ok, find the specified config
+      instance_config = tier_config['instances'][matching_indices[0]]
+      parent_config = nil
+      current_config = instance_config
+      delete_key = nil
+
+      config_description = "type: #{instance_type['code']}"
+      config_description << " environment: #{options[:environment]}" if options[:environment]
+      config_description << " group: #{options[:group]}" if options[:group]
+      config_description << " cloud: #{options[:cloud]}" if options[:cloud]
+      config_description = config_description.strip
+
+      
+      # find config in environments => env => groups => groupname => clouds => cloudname => 
+      if options[:environment]
+        if current_config && current_config['environments'] && current_config['environments'][options[:environment]]
+          parent_config = current_config['environments']
+          delete_key  = options[:environment]
+          current_config = parent_config[delete_key]
+        else
+          print_red_alert "Instance config not found for scope #{config_description}"
+          return 1
+        end
+      end
+      if options[:group]
+        if current_config && current_config['groups'] && current_config['groups'][options[:group]]
+          parent_config = current_config['groups']
+          delete_key  = options[:group]
+          current_config = parent_config[delete_key]
+        else
+          print_red_alert "Instance config not found for scope #{config_description}"
+          return 1
+        end
+      end
+      if options[:cloud]
+        if current_config && current_config['clouds'] && current_config['clouds'][options[:cloud]]
+          parent_config = current_config['clouds']
+          delete_key  = options[:cloud]
+          current_config = parent_config[delete_key]
+        else
+          print_red_alert "Instance config not found for scope #{config_description}"
+          return 1
+        end
+      end
+      
+      # remove it
+      parent_config.delete(delete_key)
+      
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete this instance config #{config_description} ?")
+        return 9
+      end
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return
+      end
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        puts JSON.pretty_generate(json_response)
+      else
+        print_green_success "Removed instance from app template."
+        get([app_template['id']])
+      end
+      return 0
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def update_instance(args)
+    print_red_alert "NOT YET SUPPORTED"
+    return 5
+  end
+
+  def update_instance_config(args)
+    print_red_alert "NOT YET SUPPORTED"
+    return 5
+  end
+
+  def remove_instance(args)
+    instance_index = nil
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier] [instance]")
+      # opts.on('--index NUMBER', Number, "Identify Instance by index within tier, starting with 0." ) do |val|
+      #   instance_index = val.to_i
+      # end
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
+    end
+    optparse.parse!(args)
+    
+    if args.count < 3
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "Wrong number of arguments"
+      puts_error optparse
+      return 1
+    end
+
+    connect(options)
+
+    begin
+
+      app_template_name = args[0]
+      tier_name = args[1]
+      instance_identier = args[2]
+
+      # instance_type_code = args[2]
+      # we also need consider when there is multiple instances of the same type in
+      # a template/tier.. so maybe split instance_type_code as [type-code]:[index].. or...errr
+
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+
+      # instance_type = find_instance_type_by_code(instance_type_code)
+      # return 1 if instance_type.nil?
+      
+      tier_config = nil
+      # instance_config = nil
+
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
+      tiers ||= {}
+      # tier identified by name, case sensitive...
+      if !tiers[tier_name]
+        print_red_alert "Tier not found by name #{tier_name}"
+        return 1
+      end
+      tier_config = tiers[tier_name]
+      
+      if tier_config['instances'].nil? || tier_config['instances'].empty?
+        print_red_alert "Tier #{tier_name} is empty!"
+        return 1
+      end
+
+      # find instance
+      matching_indices = []
+      if tier_config['instances']
+        if instance_identier.to_s =~ /\A\d{1,}\Z/
+          matching_indices = [instance_identier.to_i].compact
+        else
+          tier_config['instances'].each_with_index do |instance_config, index|
+            if instance_config['instance'] && instance_config['instance']['type'] == instance_identier
+              matching_indices << index
+            elsif instance_config['instance'] && instance_config['instance']['name'] == instance_identier
+              matching_indices << index
+            end
+          end
+        end
+      end
+      if matching_indices.size == 0
+        print_red_alert "Instance not found by tier: #{tier_name}, instance: #{instance_identier}"
+        return 1
+      elsif matching_indices.size > 1
+        #print_error Morpheus::Terminal.angry_prompt
+        print_red_alert "More than one instance matched tier: #{tier_name}, instance: #{instance_identier}"
+        puts_error "Instance can be identified type, name or index within the tier."
+        puts_error optparse
+        return 1
+      end
+
+      # remove it
+      tier_config['instances'].delete_at(matching_indices[0])
+
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete this instance #{instance_type_code} instance from tier: #{tier_name}?")
+        return 9
+      end
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return
+      end
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        puts JSON.pretty_generate(json_response)
+      else
+        print_green_success "Removed instance from app template."
+        get([app_template['id']])
+      end
+      return 0
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def add_tier(args)
+    options = {}
+    boot_order = nil
+    linked_tiers = nil
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier]")
+      opts.on('--name VALUE', String, "Tier Name") do |val|
+        options[:name] = val
+      end
+      opts.on('--bootOrder NUMBER', String, "Boot Order" ) do |val|
+        boot_order = val
+      end
+      opts.on('--linkedTiers x,y,z', Array, "Connected Tiers.") do |val|
+        linked_tiers = val
+      end
+      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+    end
+    optparse.parse!(args)
+
+    if args.count < 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} add-tier requires argument: [template]\n#{optparse}"
+      # puts optparse
+      return 1
+    end
+    app_template_name = args[0]
+    tier_name = args[1]
+
+    connect(options)
+
+    begin
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+      
+      app_template["config"] ||= {}
+      app_template["config"]["tiers"] ||= {}
+      tiers = app_template["config"]["tiers"]
+
+      # prompt new tier
+      # Name
+      # {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1, 'description' => 'A unique name for the app template.'},
+      #   {'fieldName' => 'bootOrder', 'fieldLabel' => 'Boot Order', 'type' => 'text', 'required' => false, 'displayOrder' => 2, 'description' => 'Boot Order'}
+      if !tier_name
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Tier Name', 'type' => 'text', 'required' => true, 'description' => 'Enter the name of the tier'}], options[:options])
+        tier_name = v_prompt['name']
+      end
+      # case insensitive match
+      existing_tier_names = tiers.keys
+      matching_tier_name = existing_tier_names.find {|k| k.downcase == tier_name.downcase }
+      if matching_tier_name
+        # print_red_alert "Tier #{tier_name} already exists"
+        # return 1
+        print cyan,"Tier #{tier_name} already exists.",reset,"\n"
+        return 0
+      end
+      # idempotent
+      if !tiers[tier_name]
+        tiers[tier_name] = {'instances' => []}
+      end
+      tier = tiers[tier_name]
+      
+      # Boot Order
+      if !boot_order
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'bootOrder', 'fieldLabel' => 'Boot Order', 'type' => 'text', 'required' => false, 'description' => 'Sequence order for starting app instances by tier. 0-N', 'defaultValue' => tier['bootOrder']}], options[:options])
+        boot_order = v_prompt['bootOrder']
+      end
+      if boot_order.to_s == 'null'
+        tier.delete('bootOrder')
+      elsif boot_order.to_s != ''
+        tier['bootOrder'] = boot_order.to_i
+      end
+
+      # Connected Tiers
+      if !linked_tiers
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'linkedTiers', 'fieldLabel' => 'Connected Tiers', 'type' => 'text', 'required' => false, 'description' => 'Names of connected tiers, comma separated', 'defaultValue' => (linked_tiers ? linked_tiers.join(',') : nil)}], options[:options])
+        linked_tiers = v_prompt['linkedTiers'].to_s.split(',').collect {|it| it.strip }.select {|it| it != ''}
+      end
+      if linked_tiers && !linked_tiers.empty?
+        linked_tiers.each do |other_tier_name|
+          link_result = link_tiers(tiers, [tier_name, other_tier_name])
+          # could just re-prompt unless options[:no_prompt]
+          return 1 if !link_result
+        end
+      end
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = app_template["config"]
+      # request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return
+      end
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
+
+      if options[:json]
+        puts JSON.pretty_generate(json_response)
+      elsif !options[:quiet]
+        print_green_success "Added tier #{tier_name}"
+        # prompt for new instance
+        if !options[:no_prompt]
+          if ::Morpheus::Cli::OptionTypes::confirm("Would you like to add an instance now?", options.merge({default: true}))
+            add_instance([app_template['id'], tier_name])
+            while ::Morpheus::Cli::OptionTypes::confirm("Add another instance now?", options.merge({default: false})) do
+              add_instance([app_template['id'], tier_name])
+            end
+            # if !add_instance_result
+            # end
+          end
+        end
+        # print details
+        get([app_template['name']])
       end
-
+      return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1
     end
   end
 
-  def remove(args)
+  def update_tier(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name]")
-      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
+    new_tier_name = nil
+    boot_order = nil
+    linked_tiers = nil
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier]")
+      opts.on('--name VALUE', String, "Tier Name") do |val|
+        new_tier_name = val
+      end
+      opts.on('--bootOrder NUMBER', String, "Boot Order" ) do |val|
+        boot_order = val
+      end
+      opts.on('--linkedTiers x,y,z', Array, "Connected Tiers") do |val|
+        linked_tiers = val
+      end
+      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
     end
     optparse.parse!(args)
 
-    if args.count < 1
-      puts optparse
-      exit 1
+    if args.count != 2
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} update-tier expects 2 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      return 1
     end
+    app_template_name = args[0]
+    tier_name = args[1]
 
     connect(options)
+
     begin
-      app_template = find_app_template_by_name_or_id(args[0])
-      exit 1 if app_template.nil?
-      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the app template #{app_template['name']}?")
-        exit
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
+      
+      app_template["config"] ||= {}
+      app_template["config"]["tiers"] ||= {}
+      tiers = app_template["config"]["tiers"]
+      
+      if !tiers[tier_name]
+        print_red_alert "Tier not found by name #{tier_name}"
+        return 1
+      end
+      tier = tiers[tier_name]
+
+      
+      if options[:no_prompt]
+        if !(new_tier_name || boot_order || linked_tiers)
+          print_error Morpheus::Terminal.angry_prompt
+          puts_error  "#{command_name} update-tier requires an option to update.\n#{optparse}"
+          return 1
+        end
+      end
+
+      # prompt update tier
+      # Name
+      if !new_tier_name
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Tier Name', 'type' => 'text', 'required' => true, 'description' => 'Rename the tier', 'defaultValue' => tier_name}], options[:options])
+        new_tier_name = v_prompt['name']
+      end
+      if new_tier_name && new_tier_name != tier_name
+        old_tier_name = tier_name
+        if tiers[new_tier_name]
+          print_red_alert "A tier named #{tier_name} already exists."
+          return 1
+        end
+        tier = tiers.delete(tier_name)
+        tiers[new_tier_name] = tier
+        # Need to fix all the linkedTiers
+        tiers.each do |k, v|
+          if v['linkedTiers'] && v['linkedTiers'].include?(tier_name)
+            v['linkedTiers'] = v['linkedTiers'].map {|it| it == tier_name ? new_tier_name : it }
+          end
+        end
+        # old_tier_name = tier_name
+        tier_name = new_tier_name
       end
+
+      # Boot Order
+      if !boot_order
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'bootOrder', 'fieldLabel' => 'Boot Order', 'type' => 'text', 'required' => false, 'description' => 'Sequence order for starting app instances by tier. 0-N', 'defaultValue' => tier['bootOrder']}], options[:options])
+        boot_order = v_prompt['bootOrder']
+      end
+      if boot_order.to_s == 'null'
+        tier.delete('bootOrder')
+      elsif boot_order.to_s != ''
+        tier['bootOrder'] = boot_order.to_i
+      end
+
+      # Connected Tiers
+      if !linked_tiers
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'linkedTiers', 'fieldLabel' => 'Connected Tiers', 'type' => 'text', 'required' => false, 'description' => 'Names of connected tiers, comma separated', 'defaultValue' => (tier['linkedTiers'] ? tier['linkedTiers'].join(',') : nil)}], options[:options])
+        linked_tiers = v_prompt['linkedTiers'].to_s.split(',').collect {|it| it.strip }.select {|it| it != ''}
+      end
+      current_linked_tiers = tier['linkedTiers'] || []
+      if linked_tiers && linked_tiers != current_linked_tiers
+        remove_tiers = current_linked_tiers - linked_tiers
+        remove_tiers.each do |other_tier_name|
+          unlink_result = unlink_tiers(tiers, [tier_name, other_tier_name])
+          # could just re-prompt unless options[:no_prompt]
+          return 1 if !unlink_result
+        end
+        add_tiers = linked_tiers - current_linked_tiers
+        add_tiers.each do |other_tier_name|
+          link_result = link_tiers(tiers, [tier_name, other_tier_name])
+          # could just re-prompt unless options[:no_prompt]
+          return 1 if !link_result
+        end
+      end
+
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = app_template["config"]
+      # request_payload = {appTemplate: app_template}
+      
       if options[:dry_run]
-        print_dry_run @app_templates_interface.dry.destroy(app_template['id'])
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
         return
       end
-      json_response = @app_templates_interface.destroy(app_template['id'])
+      json_response = @app_templates_interface.update(app_template['id'], request_payload)
 
       if options[:json]
-        print JSON.pretty_generate(json_response)
-        print "\n"
-      else
-        print_green_success "App Template #{app_template['name']} removed"
+        puts JSON.pretty_generate(json_response)
+      elsif !options[:quiet]
+        print_green_success "Updated tier #{tier_name}"
+        get([app_template['id']])
       end
-
+      return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1
     end
   end
 
-  def add_instance(args)
+  def remove_tier(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name] [tier] [instance-type]")
-      # opts.on( '-g', '--group GROUP', "Group" ) do |val|
-      #   options[:group] = val
-      # end
-      # opts.on( '-c', '--cloud CLOUD', "Cloud" ) do |val|
-      #   options[:cloud] = val
-      # end
-      build_common_options(opts, options, [:json])
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [tier]")
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run])
     end
     optparse.parse!(args)
 
-    if args.count < 3
-      puts "\n#{optparse}\n\n"
-      exit 1
+    if args.count < 2
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} remove-tier expects 2 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      return 1
     end
-
-    connect(options)
-
     app_template_name = args[0]
     tier_name = args[1]
-    instance_type_code = args[2]
 
-    app_template = find_app_template_by_name_or_id(app_template_name)
-    exit 1 if app_template.nil?
-
-    instance_type = find_instance_type_by_code(instance_type_code)
-    if instance_type.nil?
-      exit 1
-    end
-
-    group_id = app_template['config']['siteId']
-
-    if group_id.nil?
-      #puts "Group not found or specified! \n #{optparse}"
-      print_red_alert("Group not found or specified for this template!")
-      puts "#{optparse}"
-      exit 1
-    end
-
-    cloud_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'cloud', 'type' => 'select', 'fieldLabel' => 'Cloud', 'optionSource' => 'clouds', 'required' => true, 'description' => 'Select Cloud.'}],options[:options],@api_client,{groupId: group_id})
-    cloud_id = cloud_prompt['cloud']
-
-
-    instance_option_types = [{'fieldName' => 'name', 'fieldLabel' => 'Instance Name', 'type' => 'text'}]
-    instance_option_values = Morpheus::Cli::OptionTypes.prompt(instance_option_types, options[:options], @api_client, options[:params])
-    instance_name = instance_option_values['name'] || ''
-
-    # copied from instances command, this payload isn't used
-    payload = {
-      :servicePlan => nil,
-      :zoneId => cloud_id,
-      :instance => {
-        :name => instance_name,
-        :site => {
-          :id => group_id
-        },
-        :instanceType => {
-          :code => instance_type_code
-        }
-      }
-    }
-
-    version_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'version', 'type' => 'select', 'fieldLabel' => 'Version', 'optionSource' => 'instanceVersions', 'required' => true, 'skipSingleOption' => true, 'description' => 'Select which version of the instance type to be provisioned.'}],options[:options],@api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})
-    layout_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'layout', 'type' => 'select', 'fieldLabel' => 'Layout', 'optionSource' => 'layoutsForCloud', 'required' => true, 'description' => 'Select which configuration of the instance type to be provisioned.'}],options[:options],@api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], version: version_prompt['version']})
-    layout_id = layout_prompt['layout']
-    layout = instance_type['instanceTypeLayouts'].find{ |lt| lt['id'].to_i == layout_id.to_i}
-    payload[:instance][:layout] = {id: layout['id']}
-
-    # prompt for service plan
-    service_plans_json = @instances_interface.service_plans({zoneId: cloud_id, layoutId: layout_id})
-    service_plans = service_plans_json["plans"]
-    service_plans_dropdown = service_plans.collect {|sp| {'name' => sp["name"], 'value' => sp["id"]} } # already sorted
-    plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'description' => 'Choose the appropriately sized plan for this instance'}],options[:options])
-    service_plan = service_plans.find {|sp| sp["id"] == plan_prompt['servicePlan'].to_i }
-    payload[:servicePlan] = service_plan["id"]
-
-
-    type_payload = {}
-    if !layout['optionTypes'].nil? && !layout['optionTypes'].empty?
-      type_payload = Morpheus::Cli::OptionTypes.prompt(layout['optionTypes'],options[:options],@api_client,{groupId: group_id, cloudId: cloud_id, zoneId: cloud_id, instanceTypeId: instance_type['id'], version: version_prompt['version']})
-    elsif !instance_type['optionTypes'].nil? && !instance_type['optionTypes'].empty?
-      type_payload = Morpheus::Cli::OptionTypes.prompt(instance_type['optionTypes'],options[:options],@api_client,{groupId: group_id, cloudId: cloud_id, zoneId: cloud_id, instanceTypeId: instance_type['id'], version: version_prompt['version']})
-    end
-    if !type_payload['config'].nil?
-      payload.merge!(type_payload['config'])
-    end
-
-    provision_payload = {}
-    if !layout['provisionType'].nil? && !layout['provisionType']['optionTypes'].nil? && !layout['provisionType']['optionTypes'].empty?
-      puts "Checking for option Types"
-      provision_payload = Morpheus::Cli::OptionTypes.prompt(layout['provisionType']['optionTypes'],options[:options],@api_client,{groupId: group_id, cloudId: cloud_id, zoneId: cloud_id, instanceTypeId: instance_type['id'], version: version_prompt['version']})
-    end
-
-    if !provision_payload.nil? && !provision_payload['config'].nil?
-      payload.merge!(provision_payload['config'])
-    end
-    # if !provision_payload.nil? && !provision_payload['server'].nil?
-    #   payload[:server] = provision_payload['server']
-    # end
-
-
-    config = app_template['config']['tierView']
-
-    config['nodes'] ||= []
-
-    tier = config['nodes'].find {|node|
-      node["data"] && node["data"]["type"] == "tier" && node["data"]["id"] == "newtier-#{tier_name}"
-    }
-    if !tier
-      tier = {
-        "classes"=>"tier newtier-#{tier_name}",
-        "data"=>{"id"=>"newtier-#{tier_name}", "name"=> tier_name, "type"=>"tier"},
-        "grabbable"=>true, "group"=>"nodes","locked"=>false,
-        #"position"=>{"x"=>-2.5, "y"=>-45},
-        "removed"=>false, "selectable"=>true, "selected"=>false
-      }
-      config['nodes'] << tier
-    end
-
-    instance_id = generate_id()
-
-    instance_type_node = {
-      "classes"=>"instance newinstance-#{instance_id} #{instance_type['code']}",
-      "data"=>{
-        "controlName" => "instance.layout.id",
-        "id"=>"newinstance-#{instance_id}",
-        "nodeId"=>["newinstance-#{instance_id}"], # not sure what this is for..
-        "index"=>nil,
-        "instance.layout.id"=>layout_id.to_s,
-        "instance.name"=>instance_name,
-        "instanceType"=>instance_type['code'],
-        "isPlaced"=>true,
-        "name"=> instance_name,
-        "parent"=>tier['data']['id'],
-        "type"=>"instance",
-        "typeName"=>instance_type['name'],
-        "servicePlan"=>plan_prompt['servicePlan'].to_s,
-        # "servicePlanOptions.maxCpu": "",
-        # "servicePlanOptions.maxCpuId": nil,
-        # "servicePlanOptions.maxMemory": "",
-        # "servicePlanOptions.maxMemoryId": nil,
-
-        # "volumes.datastoreId": nil,
-        # "volumes.name": "root",
-        # "volumes.rootVolume": "true",
-        # "volumes.size": "5",
-        # "volumes.sizeId": "5",
-        # "volumes.storageType": nil,
-
-        "version"=>version_prompt['version'],
-        "siteId"=>group_id.to_s,
-        "zoneId"=>cloud_id.to_s
-      },
-      "grabbable"=>true, "group"=>"nodes", "locked"=>false,
-      #"position"=>{"x"=>-79.83254449505226, "y"=>458.33806818181824},
-      "removed"=>false, "selectable"=>true, "selected"=>false
-    }
-
-    if !type_payload['config'].nil?
-      instance_type_node['data'].merge!(type_payload['config'])
-    end
+    connect(options)
 
-    if !provision_payload.nil? && !provision_payload['config'].nil?
-      instance_type_node['data'].merge!(provision_payload['config'])
-    end
+    begin
+      app_template = find_app_template_by_name_or_id(app_template_name)
+      return 1 if app_template.nil?
 
-    config['nodes'].push(instance_type_node)
+      app_template["config"] ||= {}
+      app_template["config"]["tiers"] ||= {}
+      tiers = app_template["config"]["tiers"]
 
-    # re-index nodes for this tier
-    tier_instances = config['nodes'].select {|node| node['data']['parent'] == tier['data']['id'] }
-    tier_instances.each_with_index do |node, idx|
-      node['data']['index'] = idx
-    end
+      if !tiers[tier_name]
+        # print_red_alert "Tier not found by name #{tier_name}"
+        # return 1
+        print cyan,"Tier #{tier_name} does not exist.",reset,"\n"
+        return 0
+      end
 
-    request_payload = {appTemplate: {} }
-    request_payload['siteId'] = app_template['config']['siteId']
-    # request_payload['config'] = config['tierView']
-    request_payload['config'] = config
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the tier #{tier_name}?")
+        exit
+      end
 
-    begin
+      # remove it
+      tiers.delete(tier_name)
+      
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = app_template["config"]
+      # request_payload = {appTemplate: app_template}
+      
       if options[:dry_run]
         print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
         return
       end
+
       json_response = @app_templates_interface.update(app_template['id'], request_payload)
 
+
       if options[:json]
         print JSON.pretty_generate(json_response)
         print "\n"
       else
-        print_green_success "Added instance type to app template #{app_template['name']}"
+        print_green_success "Removed tier #{tier_name}"
         get([app_template['name']])
       end
 
@@ -529,73 +1394,89 @@ class Morpheus::Cli::AppTemplates
       print_rest_exception(e, options)
       exit 1
     end
-
   end
 
-  def remove_instance(args)
+  def connect_tiers(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name] [instance-id]")
-      build_common_options(opts, options, [:auto_confirm, :json])
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [Tier1] [Tier2]")
+      build_common_options(opts, options, [:json, :dry_run])
     end
     optparse.parse!(args)
 
-    if args.count < 2
-      puts optparse
-      exit 1
+    if args.count < 3
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} connect-tiers expects 3 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      # puts optparse
+      return 1
     end
     app_template_name = args[0]
-    instance_id = args[1]
+    tier1_name = args[1]
+    tier2_name = args[2]
 
     connect(options)
 
     begin
-
       app_template = find_app_template_by_name_or_id(app_template_name)
-      exit 1 if app_template.nil?
-
-      config = app_template['config']['tierView']
-
-      config['nodes'] ||= []
+      return 1 if app_template.nil?
+
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
+
+      if !tiers || tiers.keys.size == 0
+        error_msg = "App Template #{app_template['name']} has no tiers."
+        # print_red_alert "App Template #{app_template['name']} has no tiers."
+        # raise_command_error "App Template #{app_template['name']} has no tiers."
+        print_error Morpheus::Terminal.angry_prompt
+        puts_error  "App Template #{app_template['name']} has no tiers."
+        return 1
+      end
 
-      instance_node = config['nodes'].find { |node|
-        node["data"] && node["data"]["type"] == "instance" && node["data"]["id"] == "newinstance-#{instance_id}"
-      }
+      connect_tiers = []
+      tier1 = tiers[tier1_name]
+      tier2 = tiers[tier2_name]
+      # uhh support N args
 
-      if instance_node.nil?
-        print_red_alert "Instance not found by id #{instance_id}"
-        exit 1
+      if tier1.nil?
+        print_red_alert "Tier not found by name #{tier1_name}!"
+        return 1
       end
 
-      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the app template #{instance_node['data']['typeName']} instance #{instance_id}?")
-        exit
+      if tier2.nil?
+        print_red_alert "Tier not found by name #{tier2_name}!"
+        return 1
       end
 
-      tier = config['nodes'].find {|node|
-        node["data"] && node["data"]["type"] == "tier" && node["data"]["id"] == instance_node['data']['parent']
-      }
+      tier1["linkedTiers"] = tier1["linkedTiers"] || []
+      tier2["linkedTiers"] = tier2["linkedTiers"] || []
 
-      if tier.nil?
-        print_red_alert "Parent Tier not found for instance id #{instance_id}!"
-        exit 1
+      found_edge = tier1["linkedTiers"].include?(tier2_name) || tier2["linkedTiers"].include?(tier1_name)
+
+      if found_edge
+        puts cyan,"Tiers #{tier1_name} and #{tier2_name} are already connected.",reset
+        return 0
       end
 
-      # remove the one node
-      config['nodes'] = config['nodes'].reject {|node|
-        node["data"] && node["data"]["type"] == "instance" && node["data"]["id"] == "newinstance-#{instance_id}"
-      }
+      # ok to be connect the tiers
+      # note: the ui doesn't hook up both sides eh?
 
+      if !tier1["linkedTiers"].include?(tier2_name)
+        tier1["linkedTiers"].push(tier2_name)
+      end
 
-      # re-index nodes for this tier
-      tier_instances = config['nodes'].select {|node| node['data']['parent'] == tier['data']['id'] }
-      tier_instances.each_with_index do |node, idx|
-        node['data']['index'] = idx
+      if !tier2["linkedTiers"].include?(tier1_name)
+        tier2["linkedTiers"].push(tier1_name)
       end
 
-      request_payload = {appTemplate: {} }
-      request_payload['siteId'] = app_template['config']['siteId']
-      # request_payload['config'] = config['tierView']
-      request_payload['config'] = config
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = app_template["config"]
+      # request_payload = {appTemplate: app_template}
+      
+      if options[:dry_run]
+        print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
+        return
+      end
       json_response = @app_templates_interface.update(app_template['id'], request_payload)
 
 
@@ -603,7 +1484,7 @@ class Morpheus::Cli::AppTemplates
         print JSON.pretty_generate(json_response)
         print "\n"
       else
-        print_green_success "Added instance type to app template #{app_template['name']}"
+        print_green_success "Connected 2 tiers for app template #{app_template['name']}"
         get([app_template['name']])
       end
 
@@ -613,17 +1494,19 @@ class Morpheus::Cli::AppTemplates
     end
   end
 
-  def connect_tiers(args)
+  def disconnect_tiers(args)
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("[name] [tier1] [tier2]")
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[template] [Tier1] [Tier2]")
       build_common_options(opts, options, [:json, :dry_run])
     end
     optparse.parse!(args)
 
     if args.count < 3
-      puts optparse
-      exit 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "#{command_name} disconnect-tiers expects 3 arguments and received #{args.count}: #{args.join(' ')}\n#{optparse}"
+      # puts optparse
+      return 1
     end
     app_template_name = args[0]
     tier1_name = args[1]
@@ -632,62 +1515,54 @@ class Morpheus::Cli::AppTemplates
     connect(options)
 
     begin
-
       app_template = find_app_template_by_name_or_id(app_template_name)
-      exit 1 if app_template.nil?
+      return 1 if app_template.nil?
 
-      config = app_template['config']['tierView']
+      app_template["config"] ||= {}
+      tiers = app_template["config"]["tiers"]
 
-      config['nodes'] ||= []
+      if !tiers || tiers.keys.size == 0
+        # print_red_alert "App Template #{app_template['name']} has no tiers."
+        # raise_command_error "App Template #{app_template['name']} has no tiers."
+        print_error Morpheus::Terminal.angry_prompt
+        puts_error  "App Template #{app_template['name']} has no tiers."
+        return 1
+      end
+
+      connect_tiers = []
+      tier1 = tiers[tier1_name]
+      tier2 = tiers[tier2_name]
+      # uhh support N args
 
-      tier1 = config['nodes'].find {|node|
-        node["data"] && node["data"]["type"] == "tier" && node["data"]["id"] == "newtier-#{tier1_name}"
-      }
       if tier1.nil?
         print_red_alert "Tier not found by name #{tier1_name}!"
-        exit 1
+        return 1
       end
 
-      tier2 = config['nodes'].find {|node|
-        node["data"] && node["data"]["type"] == "tier" && node["data"]["id"] == "newtier-#{tier2_name}"
-      }
       if tier2.nil?
         print_red_alert "Tier not found by name #{tier2_name}!"
-        exit 1
+        return 1
       end
 
-      config['edges'] ||= []
+      tier1["linkedTiers"] = tier1["linkedTiers"] || []
+      tier2["linkedTiers"] = tier2["linkedTiers"] || []
 
-      found_edge = config['edges'].find {|edge|
-        (edge['data']['source'] == "newtier-#{tier1_name}" && edge['data']['target'] == "newtier-#{tier2_name}") &&
-        (edge['data']['target'] == "newtier-#{tier2_name}" && edge['data']['source'] == "newtier-#{tier1_name}")
-      }
+      found_edge = tier1["linkedTiers"].include?(tier2_name) || tier2["linkedTiers"].include?(tier1_name)
 
       if found_edge
-        puts yellow,"Tiers #{tier1_name} and #{tier2_name} are already connected.",reset
-        exit
+        puts cyan,"Tiers #{tier1_name} and #{tier2_name} are not connected.",reset
+        return 0
       end
 
-      # not sure how this id is being generated in the ui exactly
-      new_edge_index = (1..999).find {|i|
-        !config['edges'].find {|edge| edge['data']['id'] == "ele#{i}" }
-      }
-      new_edge = {
-        "classes"=>"",
-        "data"=>{"id"=>"ele#{new_edge_index}", "source"=>tier1['data']['id'], "target"=>tier2['data']['id']},
-        "grabbable"=>true, "group"=>"edges", "locked"=>false,
-        #"position"=>{},
-        "removed"=>false, "selectable"=>true, "selected"=>false
-      }
-
-      config['edges'].push(new_edge)
-
-
-      request_payload = {appTemplate: {} }
-      request_payload['siteId'] = app_template['config']['siteId']
-      # request_payload['config'] = config['tierView']
-      request_payload['config'] = config
+      # remove links
+      tier1["linkedTiers"] = tier1["linkedTiers"].reject {|it| it == tier2_name }
+      tier2["linkedTiers"] = tier2["linkedTiers"].reject {|it| it == tier1_name }
 
+      # ok, make api request
+      app_template["config"]["tiers"] = tiers
+      request_payload = app_template["config"]
+      # request_payload = {appTemplate: app_template}
+      
       if options[:dry_run]
         print_dry_run @app_templates_interface.dry.update(app_template['id'], request_payload)
         return
@@ -699,7 +1574,7 @@ class Morpheus::Cli::AppTemplates
         print JSON.pretty_generate(json_response)
         print "\n"
       else
-        print_green_success "Connected tiers for app template #{app_template['name']}"
+        print_green_success "Connected 2 tiers for app template #{app_template['name']}"
         get([app_template['name']])
       end
 
@@ -711,7 +1586,7 @@ class Morpheus::Cli::AppTemplates
 
   def available_tiers(args)
     options = {}
-    optparse = OptionParser.new do|opts|
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage()
       build_common_options(opts, options, [:json, :dry_run])
     end
@@ -725,72 +1600,30 @@ class Morpheus::Cli::AppTemplates
         return
       end
       json_response = @app_templates_interface.list_tiers(params)
-      tiers = json_response['tiers']
+      tiers = json_response["tiers"] # just a list of names
       if options[:json]
-        print JSON.pretty_generate(json_response)
-        print "\n"
+        puts JSON.pretty_generate(json_response)
       else
         print_h1 "Available Tiers"
         if tiers.empty?
           print yellow,"No tiers found.",reset,"\n"
         else
-          rows = tiers.collect do |tier|
-            {
-              id: tier['id'],
-              name: tier['name'],
-            }
-          end
+          # rows = tiers.collect do |tier|
+          #   {
+          #     id: tier['id'],
+          #     name: tier['name'],
+          #   }
+          # end
+          # print cyan
+          # tp rows, [:name]
           print cyan
-          tp rows, [:name]
-          print reset
-        end
-        print reset,"\n"
-      end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
-    end
-
-  end
-
-  def available_types(args)
-    options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage()
-      build_common_options(opts, options, [:json])
-    end
-    optparse.parse!(args)
-    connect(options)
-    params = {}
-
-    begin
-      if options[:dry_run]
-        print_dry_run @app_templates_interface.dry.list_types(params)
-        return
-      end
-      json_response = @app_templates_interface.list_types(params)
-      instance_types = json_response['types']
-      if options[:json]
-        print JSON.pretty_generate(json_response)
-        print "\n"
-      else
-        print_h1 "Available Instance Types"
-        if instance_types.empty?
-          print yellow,"No instance types found.",reset,"\n"
-        else
-          rows = instance_types.collect do |instance_type|
-            {
-              id: instance_type['id'],
-              code: instance_type['code'],
-              name: instance_type['name'],
-            }
+          tiers.each do |tier_name|
+            puts tier_name
           end
-          print cyan
-          tp rows, [:code, :name]
-          print reset
         end
         print reset,"\n"
       end
+      return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1
@@ -804,7 +1637,9 @@ class Morpheus::Cli::AppTemplates
   def add_app_template_option_types(connected=true)
     [
       {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
-      {'fieldName' => 'group', 'fieldLabel' => 'Group', 'type' => 'select', 'selectOptions' => (connected ? get_available_groups() : []), 'required' => true}
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false, 'displayOrder' => 2},
+      {'fieldName' => 'category', 'fieldLabel' => 'Category', 'type' => 'text', 'required' => false, 'displayOrder' => 3},
+      #{'fieldName' => 'group', 'fieldLabel' => 'Group', 'type' => 'select', 'selectOptions' => (connected ? get_available_groups() : []), 'required' => true}
     ]
   end
 
@@ -874,25 +1709,38 @@ class Morpheus::Cli::AppTemplates
   def print_app_templates_table(app_templates, opts={})
     table_color = opts[:color] || cyan
     rows = app_templates.collect do |app_template|
-      instance_type_names = (app_template['instanceTypes'] || []).collect {|it| it['name'] }.join(', ')
+      #instance_type_names = (app_template['instanceTypes'] || []).collect {|it| it['name'] }.join(', ')
+      instance_type_names = []
+      # if app_template['config'] && app_template['config']["tiers"]
+      #   app_template['config']["tiers"]
+      # end
       {
         id: app_template['id'],
         name: app_template['name'],
-        #code: app_template['code'],
-        instance_types: instance_type_names,
-        account: app_template['account'] ? app_template['account']['name'] : nil,
-        #dateCreated: format_local_dt(app_template['dateCreated'])
+        description: app_template['description'],
+        category: app_template['category'],
+        tiers_summary: format_app_template_tiers_summary(app_template)
       }
     end
 
-    print table_color
-    tp rows, [
+    term_width = current_terminal_width()
+    tiers_col_width = 60
+    if term_width > 190
+      tiers_col_width += 130
+    end
+    columns = [
       :id,
       :name,
-      {:instance_types => {:display_name => "Instance Types"} },
-      :account,
-      #{:dateCreated => {:display_name => "Date Created"} }
+      :description,
+      :category,
+      {:tiers_summary => {:display_name => "TIERS", :max_width => tiers_col_width} }
     ]
+    # # custom pretty table columns ...
+    # if options[:include_fields]
+    #   columns = options[:include_fields]
+    # end
+    print table_color
+    print as_pretty_table(rows, columns, opts)
     print reset
   end
 
@@ -902,4 +1750,265 @@ class Morpheus::Cli::AppTemplates
     id
   end
 
+  def format_app_template_tiers_summary(app_template)
+    str = ""
+    if app_template["config"] && app_template["config"]["tiers"]
+      tier_descriptions = app_template["config"]["tiers"].collect do |tier_name, tier_config|
+        # maybe do Tier Name (instance, instance2)
+        instance_blurbs = []
+        if tier_config["instances"]
+          tier_config["instances"].each do |instance_config|
+            if instance_config["instance"] && instance_config["instance"]["type"]
+              # only have type: code in the config, rather not name fetch remotely right now..
+              # instance_blurbs << instance_config["instance"]["type"]
+              instance_name = instance_config["instance"]["name"] || ""
+              instance_type_code = instance_config["instance"]["type"]
+              instances_str = "#{green}#{instance_type_code}#{cyan}"
+              if instance_name.to_s != ""
+                instances_str << "#{green} - #{instance_name}#{cyan}"
+              end
+              begin
+                config_list = parse_scoped_instance_configs(instance_config)
+                if config_list.size == 0
+                  instances_str << " (No configs)"
+                elsif config_list.size == 1
+                  # configs_str = config_list.collect {|it| 
+                  #   str = ""
+                  #     it[:scope].to_s.inspect
+                  #   }.join(", ")
+                  the_config = config_list[0]
+                  scope_str = the_config[:scope].collect {|k,v| v.to_s }.join("/")
+                  instances_str << " (#{scope_str})"
+                else
+                  instances_str << " (#{config_list.size} configs)"
+                end
+              rescue => err
+                puts_error "Failed to parse instance scoped instance configs: #{err.class} #{err.message}"
+                raise err
+              end
+              instance_blurbs << instances_str
+            end
+          end
+        end
+        if instance_blurbs.size > 0
+          tier_name + ": #{instance_blurbs.join(', ')}" + cyan
+        else
+          tier_name + ": (empty)" + cyan
+        end
+      end
+      str += tier_descriptions.compact.join(", ")
+    end
+    str
+  end
+
+  def print_app_template_details(app_template)
+    print cyan
+    description_cols = {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Category" => 'category',
+      #"Image" => lambda {|it| it['config'] ? it['config']['image'] : '' },
+    }
+    if app_template["config"] && app_template["config"]["image"]
+      description_cols["Image"] = lambda {|it| app_template["config"]["image"] }
+    # else
+      # '/assets/apps/template.png'
+    end
+    print_description_list(description_cols, app_template)
+    # print_h2 "Tiers"
+    if app_template["config"] && app_template["config"]["tiers"] && app_template["config"]["tiers"].keys.size != 0
+      print cyan
+      #puts as_yaml(app_template["config"]["tiers"])
+      app_template["config"]["tiers"].each do |tier_name, tier_config|
+        # print_h2 "Tier: #{tier_name}"
+        print_h2 tier_name
+        # puts "  Instances:"
+        if tier_config['instances'] && tier_config['instances'].size != 0
+          # puts as_yaml(tier)
+          tier_config['instances'].each_with_index do |instance_config, instance_index|
+            instance_name = instance_config["instance"]["name"] || ""
+            instance_type_code = ""
+            if instance_config["instance"]["type"]
+              instance_type_code = instance_config["instance"]["type"]
+            end
+            instance_bullet = ""
+            # instance_bullet += "#{green}     - #{bold}#{instance_type_code}#{reset}"
+            instance_bullet += "     #{green}#{bold}#{instance_type_code}#{reset}"
+            if instance_name.to_s != ""
+              instance_bullet += "#{green} - #{instance_name}#{reset}"
+            end
+            puts instance_bullet
+            # print "\n"
+            begin
+              config_list = parse_scoped_instance_configs(instance_config)
+              print cyan
+              if config_list.size > 0
+                print "\n"
+                if config_list.size == 1
+                  puts "     Config:"
+                else
+                  puts "     Configs (#{config_list.size}):"
+                end
+                config_list.each do |config_obj| 
+                  # puts "     = #{config_obj[:scope].inspect}"
+                  config_scope = config_obj[:scope]
+                  scoped_instance_config = config_obj[:config]
+                  config_description = ""
+                  config_items = []
+                  if config_scope[:environment]
+                    config_items << {label: "Environment", value: config_scope[:environment]}
+                  end
+                  if config_scope[:group]
+                    config_items << {label: "Group", value: config_scope[:group]}
+                  end
+                  if config_scope[:cloud]
+                    config_items << {label: "Cloud", value: config_scope[:cloud]}
+                  end
+                  # if scoped_instance_config['plan'] && scoped_instance_config['plan']['code']
+                  #   config_items << {label: "Plan", value: scoped_instance_config['plan']['code']}
+                  # end
+                  config_description = config_items.collect {|item| "#{item[:label]}: #{item[:value]}"}.join(", ")
+                  puts "     * #{config_description}"
+                end
+              else
+                print white,"     Instance has no configs, see `app-templates add-instance-config \"#{app_template['name']}\" \"#{tier_name}\" \"#{instance_type_code}\"`",reset,"\n"
+              end
+            rescue => err
+              #puts_error "Failed to parse instance scoped instance configs for app template #{app_template['id']} #{app_template['name']} Exception: #{err.class} #{err.message}"
+            end
+            print "\n"
+            #puts as_yaml(instance_config)
+            # todo: iterate over 
+            #   instance_config["groups"][group_name]["clouds"][cloud_name]
+          end
+          
+          print cyan
+          if tier_config['bootOrder']
+            puts "  Boot Order: #{tier_config['bootOrder']}"
+          end
+          if tier_config['linkedTiers'] && !tier_config['linkedTiers'].empty?
+            puts "  Connected Tiers: #{tier_config['linkedTiers'].join(', ')}"
+          end  
+          
+        else
+          print white,"  Tier is empty, see `app-templates add-instance \"#{app_template['name']}\" \"#{tier_name}\"`",reset,"\n"
+        end
+        # print "\n"
+
+      end
+      # print "\n"
+
+    else
+      print white,"\nTemplate is empty, see `app-templates add-tier \"#{app_template['name']}\"`",reset,"\n"
+    end
+  end
+
+  # this parses the environments => groups => clouds tree structure
+  # and returns a list of objects like {scope: {group:'thegroup'}, config: Map}
+  # this would be be better as a recursive function, brute forced for now.
+  def parse_scoped_instance_configs(instance_config)
+    config_list = []
+    if instance_config['environments'] && instance_config['environments'].keys.size > 0
+      instance_config['environments'].each do |env_name, env_config|
+        if env_config['groups']
+          env_config['groups'].each do |group_name, group_config|
+            if group_config['clouds'] && !group_config['clouds'].empty?
+              group_config['clouds'].each do |cloud_name, cloud_config|
+                config_list << {config: cloud_config, scope: {environment: env_name, group: group_name, cloud: cloud_name}}
+              end
+            end
+            if (!group_config['clouds'] || group_config['clouds'].empty?)
+              config_list << {config: group_config, scope: {environment: env_name, group: group_name}}
+            end
+          end
+        end
+        if env_config['clouds'] && !env_config['clouds'].empty?
+          env_config['clouds'].each do |cloud_name, cloud_config|
+            config_list << {config: cloud_config, scope: {environment: env_name, cloud: cloud_name}}
+          end
+        end
+        if (!env_config['groups'] || env_config['groups'].empty?) && (!env_config['clouds'] || env_config['clouds'].empty?)
+          config_list << {config: env_config, scope: {environment: env_name}}
+        end
+      end
+    end
+    if instance_config['groups']
+      instance_config['groups'].each do |group_name, group_config|
+        if group_config['clouds'] && !group_config['clouds'].empty?
+          group_config['clouds'].each do |cloud_name, cloud_config|
+            config_list << {config: cloud_config, scope: {group: group_name, cloud: cloud_name}}
+          end
+        end
+        if (!group_config['clouds'] || group_config['clouds'].empty?)
+          config_list << {config: group_config, scope: {group: group_name}}
+        end
+      end
+    end
+    if instance_config['clouds']
+      instance_config['clouds'].each do |cloud_name, cloud_config|
+        config_list << {config: cloud_config, scope: {cloud: cloud_name}}
+      end
+    end
+    return config_list
+  end
+
+  def link_tiers(tiers, tier_names)
+    # tiers = app_template["config"]["tiers"]
+    tier_names = [tier_names].flatten.collect {|it| it }.compact.uniq
+    if !tiers
+      print_red_alert "No tiers found for template"
+      return false
+    end
+
+    existing_tier_names = tiers.keys
+    matching_tier_names = tier_names.map {|tier_name| 
+      existing_tier_names.find {|k| k.downcase == tier_name.downcase }
+    }.compact
+    if matching_tier_names.size != tier_names.size
+      print_red_alert "Template does not contain tiers: '#{tier_names}'"
+      return false
+    end
+    matching_tier_names.each do |tier_name|
+      tier = tiers[tier_name]
+      tier['linkedTiers'] ||= []
+      other_tier_names = matching_tier_names.select {|it| tier_name != it}
+      other_tier_names.each do |other_tier_name|
+        if !tier['linkedTiers'].include?(other_tier_name)
+          tier['linkedTiers'].push(other_tier_name)
+        end
+      end
+    end
+    return true
+  end
+
+  def unlink_tiers(tiers, tier_names)
+    # tiers = app_template["config"]["tiers"]
+    tier_names = [tier_names].flatten.collect {|it| it }.compact.uniq
+    if !tiers
+      print_red_alert "No tiers found for template"
+      return false
+    end
+
+    existing_tier_names = tiers.keys
+    matching_tier_names = tier_names.map {|tier_name| 
+      existing_tier_names.find {|k| k.downcase == tier_name.downcase }
+    }.compact
+    if matching_tier_names.size != tier_names.size
+      print_red_alert "Template does not contain tiers: '#{tier_names}'"
+      return false
+    end
+    matching_tier_names.each do |tier_name|
+      tier = tiers[tier_name]
+      tier['linkedTiers'] ||= []
+      other_tier_names = matching_tier_names.select {|it| tier_name != it}
+      other_tier_names.each do |other_tier_name|
+        if tier['linkedTiers'].include?(other_tier_name)
+          tier['linkedTiers'] = tier['linkedTiers'].reject {|it| it == other_tier_name }
+        end
+      end
+    end
+    return true
+  end
+
 end