Merge lp:~logan/ubuntu/quantal/ruby-vmc/new-upstream into lp:ubuntu/quantal/ruby-vmc

[Logan Rosen]

[Michael Terry (mterry)]

Looks fine, thanks! Again, UNRELEASED->quantal.

review: Approve

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2011-06-17 13:38:56 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-modify-include-path
 
=== removed directory '.pc/modify-include-path'
=== removed directory '.pc/modify-include-path/bin'
=== removed file '.pc/modify-include-path/bin/vmc'
--- .pc/modify-include-path/bin/vmc	2011-06-17 13:38:56 +0000
+++ .pc/modify-include-path/bin/vmc	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/cli', __FILE__)
-
-VMC::Cli::Runner.run(ARGV.dup)
-
 
=== modified file 'README.md'
--- README.md	2011-06-17 13:38:56 +0000
+++ README.md	2012-06-13 01:37:18 +0000
@@ -31,7 +31,6 @@
       stop  <appname>                              Stop the application
       restart <appname>                            Restart the application
       delete <appname>                             Delete the application
-      rename <appname> <newname>                   Rename the application
 
     Application Updates
       update <appname> [--path]                    Update the application bits
@@ -62,6 +61,8 @@
       bind-service <servicename> <appname>         Bind a service to an application
       unbind-service <servicename> <appname>       Unbind service from the application
       clone-services <src-app> <dest-app>          Clone service bindings from <src-app> application to <dest-app>
+      tunnel <servicename> [--port]                Create a local tunnel to a service
+      tunnel <servicename> <clientcmd>             Create a local tunnel to a service and start a local client
 
     Administration
       user                                         Display user account information
@@ -74,6 +75,15 @@
       runtimes                                     Display the supported runtimes of the target system
       frameworks                                   Display the recognized frameworks of the target system
 
+    Micro Cloud Foundry
+      micro status                                 Display Micro Cloud Foundry VM status
+      mciro offline                                Configure Micro Cloud Foundry VM for offline mode
+      micro online                                 Configure Micro Cloud Foundry VM for online mode
+        [--vmx file]                               Path to micro.vmx
+        [--vmrun executable]                       Path to vmrun executable
+        [--password cleartext]                     Cleartext password for guest VM vcap user
+        [--save]                                   Save cleartext password in ~/.vmc_micro
+
     Misc
       aliases                                      List aliases
       alias <alias[=]command>                      Create an alias for a command
@@ -86,7 +96,7 @@
 
 ## Simple Story (for Ruby apps)
 
-    vmc target api.vcloudlabs.com
+    vmc target api.cloudfoundry.com
     vmc login
     bundle package
     vmc push
 
=== modified file 'Rakefile'
--- Rakefile	2011-06-17 13:38:56 +0000
+++ Rakefile	2012-06-13 01:37:18 +0000
@@ -2,8 +2,7 @@
 require 'spec/rake/spectask'
 
 desc "Run specs"
-task :spec do
-  sh('bundle install')
+task :spec => :build do
   Spec::Rake::SpecTask.new('spec') do |t|
     t.spec_opts = %w(-fs -c)
     t.spec_files = FileList['spec/**/*_spec.rb']
@@ -15,3 +14,88 @@
 desc "Synonym for spec"
 task :tests => :spec
 task :default => :spec
+
+def tests_path
+  if @tests_path == nil
+    @tests_path = File.join(Dir.pwd, "spec/assets/tests")
+  end
+  @tests_path
+end
+TESTS_PATH = tests_path
+
+BUILD_ARTIFACT = File.join(Dir.pwd, "spec/assets/.build")
+
+TESTS_TO_BUILD = ["#{TESTS_PATH}/java_web/java_tiny_app",
+#             "#{TESTS_PATH}/grails/guestbook",
+             "#{TESTS_PATH}/lift/hello_lift",
+             "#{TESTS_PATH}/spring/roo-guestbook",
+             "#{TESTS_PATH}/spring/spring-osgi-hello",
+             "#{TESTS_PATH}/standalone/java_app",
+             "#{TESTS_PATH}/standalone/python_app"
+            ]
+
+desc "Build the tests. If the git hash associated with the test assets has not changed, nothing is built. To force a build, invoke 'rake build[--force]'"
+task :build, [:force] do |t, args|
+  sh('bundle install')
+  sh('git submodule update --init')
+  puts "\nBuilding tests"
+  if build_required? args.force
+    ENV['MAVEN_OPTS']="-XX:MaxPermSize=256M"
+    TESTS_TO_BUILD.each do |test|
+      puts "\tBuilding '#{test}'"
+      Dir.chdir test do
+        sh('mvn package -DskipTests') do |success, exit_code|
+          unless success
+            clear_build_artifact
+            do_mvn_clean('-q')
+            fail "\tFailed to build #{test} - aborting build"
+          end
+        end
+      end
+      puts "\tCompleted building '#{test}'"
+    end
+    save_git_hash
+  else
+    puts "Built artifacts in sync with test assets - no build required"
+  end
+end
+
+desc "Clean the build artifacts"
+task :clean do
+  puts "\nCleaning tests"
+  clear_build_artifact
+  TESTS_TO_BUILD.each do |test|
+    puts "\tCleaning '#{test}'"
+    Dir.chdir test do
+      do_mvn_clean
+    end
+    puts "\tCompleted cleaning '#{test}'"
+  end
+end
+
+def build_required? (force_build=nil)
+  if File.exists?(BUILD_ARTIFACT) == false or (force_build and force_build == "--force")
+    return true
+  end
+  Dir.chdir(tests_path) do
+    saved_git_hash = IO.readlines(BUILD_ARTIFACT)[0].split[0]
+    git_hash = `git rev-parse --short=8 --verify HEAD`
+    saved_git_hash.to_s.strip != git_hash.to_s.strip
+  end
+end
+
+def save_git_hash
+  Dir.chdir(tests_path) do
+    git_hash = `git rev-parse --short=8 --verify HEAD`
+    File.open(BUILD_ARTIFACT, 'w') {|f| f.puts("#{git_hash}")}
+  end
+end
+
+def clear_build_artifact
+  puts "\tClearing build artifact #{BUILD_ARTIFACT}"
+  File.unlink BUILD_ARTIFACT if File.exists? BUILD_ARTIFACT
+end
+
+def do_mvn_clean options=nil
+  sh("mvn clean #{options}")
+end
 
=== modified file 'bin/vmc'
--- bin/vmc	2011-06-17 13:38:56 +0000
+++ bin/vmc	2012-06-13 01:37:18 +0000
@@ -1,6 +1,6 @@
-#!/usr/bin/ruby1.9.1
+#!/usr/bin/env ruby
 
-require File.expand_path('/usr/lib/ruby/vendor_ruby/cli', __FILE__)
+require File.expand_path('../../lib/cli', __FILE__)
 
 VMC::Cli::Runner.run(ARGV.dup)
 
 
=== added directory 'caldecott_helper'
=== added file 'caldecott_helper/Gemfile'
--- caldecott_helper/Gemfile	1970-01-01 00:00:00 +0000
+++ caldecott_helper/Gemfile	2012-06-13 01:37:18 +0000
@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem 'rack', '~> 1.2.0'
+gem 'caldecott', '= 0.0.3'
+gem 'bundler'
+gem 'em-websocket'
+gem 'async_sinatra'
+gem 'thin'
+gem 'json'
+gem 'uuidtools'
 
=== added file 'caldecott_helper/Gemfile.lock'
--- caldecott_helper/Gemfile.lock	1970-01-01 00:00:00 +0000
+++ caldecott_helper/Gemfile.lock	2012-06-13 01:37:18 +0000
@@ -0,0 +1,48 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    async_sinatra (0.5.0)
+      rack (>= 1.2.1)
+      sinatra (>= 1.0)
+    caldecott (0.0.3)
+      addressable (= 2.2.6)
+      async_sinatra (= 0.5.0)
+      em-http-request (= 0.3.0)
+      em-websocket (= 0.3.1)
+      json (= 1.6.1)
+      uuidtools (= 2.1.2)
+    daemons (1.1.4)
+    em-http-request (0.3.0)
+      addressable (>= 2.0.0)
+      escape_utils
+      eventmachine (>= 0.12.9)
+    em-websocket (0.3.1)
+      addressable (>= 2.1.1)
+      eventmachine (>= 0.12.9)
+    escape_utils (0.2.4)
+    eventmachine (0.12.10)
+    json (1.6.1)
+    rack (1.2.4)
+    sinatra (1.2.7)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    thin (1.2.11)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.3)
+    uuidtools (2.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  async_sinatra
+  bundler
+  caldecott (= 0.0.3)
+  em-websocket
+  json
+  rack (~> 1.2.0)
+  thin
+  uuidtools
 
=== added file 'caldecott_helper/server.rb'
--- caldecott_helper/server.rb	1970-01-01 00:00:00 +0000
+++ caldecott_helper/server.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2009-2011 VMware, Inc.
+$:.unshift(File.dirname(__FILE__) + '/lib')
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'caldecott'
+require 'sinatra'
+require 'json'
+require 'eventmachine'
+
+port = ENV['VMC_APP_PORT']
+port ||= 8081
+
+# add vcap specific stuff to Caldecott
+class VcapHttpTunnel < Caldecott::Server::HttpTunnel
+  get '/info' do
+    { "version" => '0.0.4' }.to_json
+  end
+
+  def self.get_tunnels
+    super
+  end
+
+  get '/services' do
+    services_env = ENV['VMC_SERVICES']
+    return "no services env" if services_env.nil? or services_env.empty?
+    services_env
+  end
+
+  get '/services/:service' do |service_name|
+    services_env = ENV['VMC_SERVICES']
+    not_found if services_env.nil?
+
+    services = JSON.parse(services_env)
+    service = services.find { |s| s["name"] == service_name }
+    not_found if service.nil?
+    service["options"].to_json
+  end
+end
+
+VcapHttpTunnel.run!(:port => port, :auth_token => ENV["CALDECOTT_AUTH"])
 
=== added directory 'config'
=== added file 'config/clients.yml'
--- config/clients.yml	1970-01-01 00:00:00 +0000
+++ config/clients.yml	2012-06-13 01:37:18 +0000
@@ -0,0 +1,17 @@
+redis:
+  redis-cli: -h ${host} -p ${port} -a ${password}
+
+mysql:
+  mysql: --protocol=TCP --host=${host} --port=${port} --user=${user} --password=${password} ${name}
+  mysqldump: --protocol=TCP --host=${host} --port=${port} --user=${user} --password=${password} ${name} > ${Output file}
+
+mongodb:
+  mongo: --host ${host} --port ${port} -u ${user} -p ${password} ${name}
+  mongodump: --host ${host} --port ${port} -u ${user} -p ${password} --db ${name}
+  mongorestore: --host ${host} --port ${port} -u ${user} -p ${password} --db ${name} ${Directory or filename to restore from}
+
+postgresql:
+  psql:
+    command: -h ${host} -p ${port} -d ${name} -U ${user} -w
+    environment:
+      - PGPASSWORD='${password}'
 
=== added directory 'config/micro'
=== added file 'config/micro/offline.conf'
--- config/micro/offline.conf	1970-01-01 00:00:00 +0000
+++ config/micro/offline.conf	2012-06-13 01:37:18 +0000
@@ -0,0 +1,2 @@
+no-resolv
+log-queries
 
=== added file 'config/micro/paths.yml'
--- config/micro/paths.yml	1970-01-01 00:00:00 +0000
+++ config/micro/paths.yml	2012-06-13 01:37:18 +0000
@@ -0,0 +1,22 @@
+darwin:
+  vmrun:
+  - "/Applications/VMware Fusion.app/Contents/Library/"
+  - "/Applications/Fusion.app/Contents/Library/"
+  vmx:
+  - "~/Documents/Virtual Machines.localized/"
+  - "~/Documents/Virtual Machines/"
+  - "~/Desktop/"
+
+linux:
+  vmrun:
+  - "/usr/bin/"
+  vmx:
+  - "~/"
+
+windows:
+  vmrun:
+  - "c:\\Program Files (x86)\\"
+  - "c:\\Program Files\\"
+  vmx:
+  - "~\\Documents\\"
+  - "~\\Desktop\\"
 
=== added file 'config/micro/refresh_ip.rb'
--- config/micro/refresh_ip.rb	1970-01-01 00:00:00 +0000
+++ config/micro/refresh_ip.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,20 @@
+#!/var/vcap/bosh/bin/ruby
+require 'socket'
+
+A_ROOT_SERVER = '198.41.0.4'
+
+begin
+retries ||= 0
+route ||= A_ROOT_SERVER
+orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+ip_address = UDPSocket.open {|s| s.connect(route, 1); s.addr.last }
+rescue Errno::ENETUNREACH
+  # happens on boot when dhcp hasn't completed when we get here
+   sleep 3
+   retries += 1
+   retry if retries < 10
+ensure
+   Socket.do_not_reverse_lookup = orig
+end
+
+File.open("/tmp/ip.txt", 'w') { |file| file.write(ip_address) }
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-08-09 14:45:42 +0000
+++ debian/changelog	2012-06-13 01:37:18 +0000
@@ -1,3 +1,9 @@
+ruby-vmc (0.3.18-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release (LP: #998111).
+
+ -- Logan Rosen <[e-mail]>  Tue, 12 Jun 2012 21:31:33 -0400
+
 ruby-vmc (0.3.10-0ubuntu10) oneiric; urgency=low
 
   [ Marc Cluet ]
 
=== modified file 'lib/cli.rb'
--- lib/cli.rb	2011-06-17 13:38:56 +0000
+++ lib/cli.rb	2012-06-13 01:37:18 +0000
@@ -1,25 +1,42 @@
+require "rbconfig"
 
 ROOT = File.expand_path(File.dirname(__FILE__))
+WINDOWS = !!(RbConfig::CONFIG['host_os'] =~ /mingw|mswin32|cygwin/)
 
 module VMC
-
   autoload :Client,           "#{ROOT}/vmc/client"
+  autoload :Micro,            "#{ROOT}/vmc/micro"
+
+  module Micro
+    module Switcher
+      autoload :Base,         "#{ROOT}/vmc/micro/switcher/base"
+      autoload :Darwin,       "#{ROOT}/vmc/micro/switcher/darwin"
+      autoload :Dummy,        "#{ROOT}/vmc/micro/switcher/dummy"
+      autoload :Linux,        "#{ROOT}/vmc/micro/switcher/linux"
+      autoload :Windows,      "#{ROOT}/vmc/micro/switcher/windows"
+    end
+    autoload :VMrun,          "#{ROOT}/vmc/micro/vmrun"
+  end
 
   module Cli
-
     autoload :Config,         "#{ROOT}/cli/config"
     autoload :Framework,      "#{ROOT}/cli/frameworks"
     autoload :Runner,         "#{ROOT}/cli/runner"
     autoload :ZipUtil,        "#{ROOT}/cli/zip_util"
     autoload :ServicesHelper, "#{ROOT}/cli/services_helper"
+    autoload :TunnelHelper,   "#{ROOT}/cli/tunnel_helper"
+    autoload :ManifestHelper, "#{ROOT}/cli/manifest_helper"
+    autoload :ConsoleHelper,  "#{ROOT}/cli/console_helper"
 
     module Command
       autoload :Base,         "#{ROOT}/cli/commands/base"
       autoload :Admin,        "#{ROOT}/cli/commands/admin"
       autoload :Apps,         "#{ROOT}/cli/commands/apps"
+      autoload :Micro,        "#{ROOT}/cli/commands/micro"
       autoload :Misc,         "#{ROOT}/cli/commands/misc"
       autoload :Services,     "#{ROOT}/cli/commands/services"
       autoload :User,         "#{ROOT}/cli/commands/user"
+      autoload :Manifest,     "#{ROOT}/cli/commands/manifest"
     end
 
   end
 
=== modified file 'lib/cli/commands/admin.rb'
--- lib/cli/commands/admin.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/admin.rb	2012-06-13 01:37:18 +0000
@@ -2,13 +2,32 @@
 
   class Admin < Base
 
+    def list_users
+      users = client.users
+      users.sort! {|a, b| a[:email] <=> b[:email] }
+      return display JSON.pretty_generate(users || []) if @options[:json]
+
+      display "\n"
+      return display "No Users" if users.nil? || users.empty?
+
+      users_table = table do |t|
+        t.headings = 'Email', 'Admin', 'Apps'
+        users.each do |user|
+          t << [user[:email], user[:admin], user[:apps].map {|x| x[:name]}.join(', ')]
+        end
+      end
+      display users_table
+    end
+
+    alias :users :list_users
+
     def add_user(email=nil)
-      email    = @options[:email] unless email
+      email ||= @options[:email]
+      email ||= ask("Email") unless no_prompt
       password = @options[:password]
-      email = ask("Email: ") unless no_prompt || email
       unless no_prompt || password
-        password = ask("Password: ") {|q| q.echo = '*'}
-        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
+        password = ask("Password", :echo => "*")
+        password2 = ask("Verify Password", :echo => "*")
         err "Passwords did not match, try again" if password != password2
       end
       err "Need a valid email" unless email
@@ -34,11 +53,14 @@
 
       if (apps && !apps.empty?)
         unless no_prompt
-          proceed = ask("\nDeployed applications and associated services will be DELETED, continue? [yN]: ")
-          err "Aborted" if proceed.upcase != 'Y'
+          proceed = ask(
+            "\nDeployed applications and associated services will be DELETED, continue?",
+            :default => false
+          )
+          err "Aborted" unless proceed
         end
-        cmd = Apps.new(@options)
-        apps.each { |app| cmd.delete_app(app[:name], true) }
+        cmd = Apps.new(@options.merge({ :force => true }))
+        apps.each { |app| cmd.delete(app[:name]) }
       end
 
       services = client.services
@@ -48,6 +70,7 @@
       end
 
       display 'Deleting User: ', false
+      client.proxy = nil
       client.delete_user(user_email)
       display 'OK'.green
     end
 
=== modified file 'lib/cli/commands/apps.rb'
--- lib/cli/commands/apps.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/apps.rb	2012-06-13 01:37:18 +0000
@@ -1,16 +1,23 @@
 require 'digest/sha1'
 require 'fileutils'
+require 'pathname'
 require 'tempfile'
 require 'tmpdir'
 require 'set'
+require "uuidtools"
+require 'socket'
 
 module VMC::Cli::Command
 
   class Apps < Base
     include VMC::Cli::ServicesHelper
+    include VMC::Cli::ManifestHelper
+    include VMC::Cli::TunnelHelper
+    include VMC::Cli::ConsoleHelper
 
     def list
       apps = client.apps
+      apps.sort! {|a, b| a[:name] <=> b[:name] }
       return display JSON.pretty_generate(apps || []) if @options[:json]
 
       display "\n"
@@ -35,108 +42,97 @@
     HEALTH_TICKS  = 5/SLEEP_TIME
     TAIL_TICKS    = 45/SLEEP_TIME
     GIVEUP_TICKS  = 120/SLEEP_TIME
-    YES_SET = Set.new(["y", "Y", "yes", "YES"])
-
-    def start(appname, push = false)
-      app = client.app_info(appname)
-
-      return display "Application '#{appname}' could not be found".red if app.nil?
-      return display "Application '#{appname}' already started".yellow if app[:state] == 'STARTED'
-
-      banner = 'Staging Application: '
-      display banner, false
-
-      t = Thread.new do
-        count = 0
-        while count < TAIL_TICKS do
-          display '.', false
-          sleep SLEEP_TIME
-          count += 1
-        end
-      end
-
-      app[:state] = 'STARTED'
-      client.update_app(appname, app)
-
-      Thread.kill(t)
-      clear(LINE_LENGTH)
-      display "#{banner}#{'OK'.green}"
-
-      banner = 'Starting Application: '
-      display banner, false
-
-      count = log_lines_displayed = 0
-      failed = false
-      start_time = Time.now.to_i
-
-      loop do
-        display '.', false unless count > TICKER_TICKS
-        sleep SLEEP_TIME
-        begin
-          break if app_started_properly(appname, count > HEALTH_TICKS)
-          if !crashes(appname, false, start_time).empty?
-            # Check for the existance of crashes
-            display "\nError: Application [#{appname}] failed to start, logs information below.\n".red
-            grab_crash_logs(appname, '0', true)
-            if push
-              display "\n"
-              should_delete = ask 'Should I delete the application? (Y/n)? ' unless no_prompt
-              delete_app(appname, false) unless no_prompt || should_delete.upcase == 'N'
-            end
-            failed = true
-            break
-          elsif count > TAIL_TICKS
-            log_lines_displayed = grab_startup_tail(appname, log_lines_displayed)
-          end
-        rescue => e
-          err(e.message, '')
-        end
-        count += 1
-        if count > GIVEUP_TICKS # 2 minutes
-          display "\nApplication is taking too long to start, check your logs".yellow
-          break
-        end
-      end
-      exit(false) if failed
-      clear(LINE_LENGTH)
-      display "#{banner}#{'OK'.green}"
-    end
-
-    def stop(appname)
-      app = client.app_info(appname)
-      return display "Application '#{appname}' already stopped".yellow if app[:state] == 'STOPPED'
-      display 'Stopping Application: ', false
-      app[:state] = 'STOPPED'
-      client.update_app(appname, app)
-      display 'OK'.green
-    end
-
-    def restart(appname)
+
+    def info(what, default=nil)
+      @options[what] || (@app_info && @app_info[what.to_s]) || default
+    end
+
+    def console(appname, interactive=true)
+      unless defined? Caldecott
+        display "To use `vmc rails-console', you must first install Caldecott:"
+        display ""
+        display "\tgem install caldecott"
+        display ""
+        display "Note that you'll need a C compiler. If you're on OS X, Xcode"
+        display "will provide one. If you're on Windows, try DevKit."
+        display ""
+        display "This manual step will be removed in the future."
+        display ""
+        err "Caldecott is not installed."
+      end
+
+      #Make sure there is a console we can connect to first
+      conn_info = console_connection_info appname
+
+      port = pick_tunnel_port(@options[:port] || 20000)
+
+      raise VMC::Client::AuthError unless client.logged_in?
+
+      if not tunnel_pushed?
+        display "Deploying tunnel application '#{tunnel_appname}'."
+        auth = UUIDTools::UUID.random_create.to_s
+        push_caldecott(auth)
+        start_caldecott
+      else
+        auth = tunnel_auth
+      end
+
+      if not tunnel_healthy?(auth)
+        display "Redeploying tunnel application '#{tunnel_appname}'."
+        # We don't expect caldecott not to be running, so take the
+        # most aggressive restart method.. delete/re-push
+        client.delete_app(tunnel_appname)
+        invalidate_tunnel_app_info
+        push_caldecott(auth)
+        start_caldecott
+      end
+
+      start_tunnel(port, conn_info, auth)
+      wait_for_tunnel_start(port)
+      start_local_console(port, appname) if interactive
+      port
+    end
+
+    def start(appname=nil, push=false)
+      if appname
+        do_start(appname, push)
+      else
+        each_app do |name|
+          do_start(name, push)
+        end
+      end
+    end
+
+    def stop(appname=nil)
+      if appname
+        do_stop(appname)
+      else
+        reversed = []
+        each_app do |name|
+          reversed.unshift name
+        end
+
+        reversed.each do |name|
+          do_stop(name)
+        end
+      end
+    end
+
+    def restart(appname=nil)
       stop(appname)
       start(appname)
     end
 
-    def rename(appname, newname)
-      app = client.app_info(appname)
-      app[:name] = newname
-      display 'Renaming Appliction: '
-      client.update_app(newname, app)
-      display 'OK'.green
-    end
-
     def mem(appname, memsize=nil)
       app = client.app_info(appname)
       mem = current_mem = mem_quota_to_choice(app[:resources][:memory])
       memsize = normalize_mem(memsize) if memsize
 
-      unless memsize
-        choose do |menu|
-          menu.layout = :one_line
-          menu.prompt = "Update Memory Reservation? [Current:#{current_mem}] "
-          menu.default = current_mem
-          mem_choices.each { |choice| menu.choice(choice) {  memsize = choice } }
-        end
-      end
+      memsize ||= ask(
+        "Update Memory Reservation?",
+        :default => current_mem,
+        :choices => mem_choices
+      )
 
       mem         = mem_choice_to_quota(mem)
       memsize     = mem_choice_to_quota(memsize)
@@ -165,7 +161,7 @@
       uris << url
       app[:uris] = uris
       client.update_app(appname, app)
-      display "Succesfully mapped url".green
+      display "Successfully mapped url".green
     end
 
     def unmap(appname, url)
@@ -176,18 +172,13 @@
       err "Invalid url" unless deleted
       app[:uris] = uris
       client.update_app(appname, app)
-      display "Succesfully unmapped url".green
-
+      display "Successfully unmapped url".green
     end
 
     def delete(appname=nil)
       force = @options[:force]
       if @options[:all]
-        should_delete = force && no_prompt ? 'Y' : 'N'
-        unless no_prompt || force
-          should_delete = ask 'Delete ALL Applications and Services? (y/N)? '
-        end
-        if should_delete.upcase == 'Y'
+        if no_prompt || force || ask("Delete ALL applications?", :default => false)
           apps = client.apps
           apps.each { |app| delete_app(app[:name], force) }
         end
@@ -197,48 +188,18 @@
       end
     end
 
-    def delete_app(appname, force)
-      app = client.app_info(appname)
-      services_to_delete = []
-      app_services = app[:services]
-      app_services.each { |service|
-        del_service = force && no_prompt ? 'Y' : 'N'
-        unless no_prompt || force
-          del_service = ask("Provisioned service [#{service}] detected, would you like to delete it? [yN]: ")
-        end
-        services_to_delete << service if del_service.upcase == 'Y'
-      }
-      display "Deleting application [#{appname}]: ", false
-      client.delete_app(appname)
-      display 'OK'.green
-
-      services_to_delete.each do |s|
-        display "Deleting service [#{s}]: ", false
-        client.delete_service(s)
-        display 'OK'.green
-      end
-    end
-
-    def all_files(appname, path)
-      instances_info_envelope = client.app_instances(appname)
-      return if instances_info_envelope.is_a?(Array)
-      instances_info = instances_info_envelope[:instances] || []
-      instances_info.each do |entry|
-        content = client.app_files(appname, path, entry[:index])
-        display_logfile(path, content, entry[:index], "====> [#{entry[:index]}: #{path}] <====\n".bold)
-      end
-    end
-
     def files(appname, path='/')
       return all_files(appname, path) if @options[:all] && !@options[:instance]
       instance = @options[:instance] || '0'
       content = client.app_files(appname, path, instance)
       display content
-    rescue VMC::Client::NotFound => e
+    rescue VMC::Client::NotFound, VMC::Client::TargetError
       err 'No such file or directory'
     end
 
     def logs(appname)
+      # Check if we have an app before progressing further
+      client.app_info(appname)
       return grab_all_logs(appname) if @options[:all] && !@options[:instance]
       instance = @options[:instance] || '0'
       grab_logs(appname, instance)
@@ -285,194 +246,67 @@
     end
 
     def instances(appname, num=nil)
-      if (num)
+      if num
         change_instances(appname, num)
       else
         get_instances(appname)
       end
     end
 
-    def stats(appname)
-      stats = client.app_stats(appname)
-      return display JSON.pretty_generate(stats) if @options[:json]
-
-      stats_table = table do |t|
-        t.headings = 'Instance', 'CPU (Cores)', 'Memory (limit)', 'Disk (limit)', 'Uptime'
-        stats.each do |entry|
-          index = entry[:instance]
-          stat = entry[:stats]
-          hp = "#{stat[:host]}:#{stat[:port]}"
-          uptime = uptime_string(stat[:uptime])
-          usage = stat[:usage]
-          if usage
-            cpu   = usage[:cpu]
-            mem   = (usage[:mem] * 1024) # mem comes in K's
-            disk  = usage[:disk]
-          end
-          mem_quota = stat[:mem_quota]
-          disk_quota = stat[:disk_quota]
-          mem  = "#{pretty_size(mem)} (#{pretty_size(mem_quota, 0)})"
-          disk = "#{pretty_size(disk)} (#{pretty_size(disk_quota, 0)})"
-          cpu = cpu ? cpu.to_s : 'NA'
-          cpu = "#{cpu}% (#{stat[:cores]})"
-          t << [index, cpu, mem, disk, uptime]
+    def stats(appname=nil)
+      if appname
+        display "\n", false
+        do_stats(appname)
+      else
+        each_app do |n|
+          display "\n#{n}:"
+          do_stats(n)
         end
       end
-      display "\n"
-      if stats.empty?
-        display "No running instances for [#{appname}]".yellow
-      else
-        display stats_table
-      end
     end
 
-    def update(appname)
-      app = client.app_info(appname)
-      if @options[:canary]
-        display "[--canary] is deprecated and will be removed in a future version".yellow
+    def update(appname=nil)
+      if appname
+        app = client.app_info(appname)
+        if @options[:canary]
+          display "[--canary] is deprecated and will be removed in a future version".yellow
+        end
+        upload_app_bits(appname, @path)
+        restart appname if app[:state] == 'STARTED'
+      else
+        each_app do |name|
+          display "Updating application '#{name}'..."
+
+          app = client.app_info(name)
+          upload_app_bits(name, @application)
+          restart name if app[:state] == 'STARTED'
+        end
       end
-      path = @options[:path] || '.'
-      upload_app_bits(appname, path)
-      restart appname if app[:state] == 'STARTED'
     end
 
     def push(appname=nil)
-      instances = @options[:instances] || 1
-      exec = @options[:exec] || 'thin start'
-      ignore_framework = @options[:noframework]
-      no_start = @options[:nostart]
-
-      path = @options[:path] || '.'
-      appname = @options[:name] unless appname
-      url = @options[:url]
-      mem, memswitch = nil, @options[:mem]
-      memswitch = normalize_mem(memswitch) if memswitch
-
-      # Check app existing upfront if we have appname
-      app_checked = false
-      if appname
-        err "Application '#{appname}' already exists, use update" if app_exists?(appname)
-        app_checked = true
-      else
-        raise VMC::Client::AuthError unless client.logged_in?
-      end
-
-      # check if we have hit our app limit
-      check_app_limit
-
-      # check memsize here for capacity
-      if memswitch && !no_start
-        check_has_capacity_for(mem_choice_to_quota(memswitch) * instances)
-      end
-
       unless no_prompt || @options[:path]
-        proceed = ask('Would you like to deploy from the current directory? [Yn]: ')
-        if proceed.upcase == 'N'
-          path = ask('Please enter in the deployment path: ')
-        end
-      end
-
-      path = File.expand_path(path)
-      check_deploy_directory(path)
-
-      appname = ask("Application Name: ") unless no_prompt || appname
-      err "Application Name required." if appname.nil? || appname.empty?
-
-      unless app_checked
-        err "Application '#{appname}' already exists, use update or delete." if app_exists?(appname)
-      end
-
-      unless no_prompt || url
-        url = ask("Application Deployed URL: '#{appname}.#{VMC::Cli::Config.suggest_url}'? ")
-
-        # common error case is for prompted users to answer y or Y or yes or YES to this ask() resulting in an
-        # unintended URL of y. Special case this common error
-        if YES_SET.member?(url)
-          #silently revert to the stock url
-          url = "#{appname}.#{VMC::Cli::Config.suggest_url}"
-        end
-      end
-
-      url = "#{appname}.#{VMC::Cli::Config.suggest_url}" if url.nil? || url.empty?
-
-      # Detect the appropriate framework.
-      framework = nil
-      unless ignore_framework
-        framework = VMC::Cli::Framework.detect(path)
-        framework_correct = ask("Detected a #{framework}, is this correct? [Yn]: ") if prompt_ok && framework
-        framework_correct ||= 'y'
-        if prompt_ok && (framework.nil? || framework_correct.upcase == 'N')
-          display "#{"[WARNING]".yellow} Can't determine the Application Type." unless framework
-          framework = nil if framework_correct.upcase == 'N'
-          choose do |menu|
-            menu.layout = :one_line
-            menu.prompt = "Select Application Type: "
-            menu.default = framework
-            VMC::Cli::Framework.known_frameworks.each do |f|
-              menu.choice(f) { framework = VMC::Cli::Framework.lookup(f) }
-            end
-          end
-          display "Selected #{framework}"
-        end
-        # Framework override, deprecated
-        exec = framework.exec if framework && framework.exec
-      else
-        framework = VMC::Cli::Framework.new
-      end
-
-      err "Application Type undetermined for path '#{path}'" unless framework
-      unless memswitch
-        mem = framework.memory
-        if prompt_ok
-          choose do |menu|
-            menu.layout = :one_line
-            menu.prompt = "Memory Reservation [Default:#{mem}] "
-            menu.default = mem
-            mem_choices.each { |choice| menu.choice(choice) {  mem = choice } }
-          end
-        end
-      else
-        mem = memswitch
-      end
-
-      # Set to MB number
-      mem_quota = mem_choice_to_quota(mem)
-
-      # check memsize here for capacity
-      check_has_capacity_for(mem_quota * instances) unless no_start
-
-      display 'Creating Application: ', false
-
-      manifest = {
-        :name => "#{appname}",
-        :staging => {
-           :framework => framework.name,
-           :runtime => @options[:runtime]
-        },
-        :uris => [url],
-        :instances => instances,
-        :resources => {
-          :memory => mem_quota
-        },
-      }
-
-      # Send the manifest to the cloud controller
-      client.create_app(appname, manifest)
-      display 'OK'.green
-
-      # Services check
-      unless no_prompt || @options[:noservices]
-        services = client.services_info
-        unless services.empty?
-          proceed = ask("Would you like to bind any services to '#{appname}'? [yN]: ")
-          bind_services(appname, services) if proceed.upcase == 'Y'
-        end
-      end
-
-      # Stage and upload the app bits.
-      upload_app_bits(appname, path)
-
-      start(appname, true) unless no_start
+        proceed = ask(
+          'Would you like to deploy from the current directory?',
+          :default => true
+        )
+
+        unless proceed
+          @path = ask('Deployment path')
+        end
+      end
+
+      pushed = false
+      each_app(false) do |name|
+        display "Pushing application '#{name}'..." if name
+        do_push(name)
+        pushed = true
+      end
+
+      unless pushed
+        @application = @path
+        do_push(appname)
+      end
     end
 
     def environment(appname)
@@ -483,7 +317,7 @@
       etable = table do |t|
         t.headings = 'Variable', 'Value'
         env.each do |e|
-          k,v = e.split('=')
+          k,v = e.split('=', 2)
           t << [k, v]
         end
       end
@@ -494,7 +328,7 @@
     def environment_add(appname, k, v=nil)
       app = client.app_info(appname)
       env = app[:env] || []
-      k,v = k.split('=') unless v
+      k,v = k.split('=', 2) unless v
       env << "#{k}=#{v}"
       display "Adding Environment Variable [#{k}=#{v}]: ", false
       app[:env] = env
@@ -537,11 +371,35 @@
 
     def check_deploy_directory(path)
       err 'Deployment path does not exist' unless File.exists? path
-      err 'Deployment path is not a directory' unless File.directory? path
       return if File.expand_path(Dir.tmpdir) != File.expand_path(path)
       err "Can't deploy applications from staging directory: [#{Dir.tmpdir}]"
     end
 
+    def check_unreachable_links(path)
+      files = Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
+
+      pwd = Pathname.pwd
+
+      abspath = File.expand_path(path)
+      unreachable = []
+      files.each do |f|
+        file = Pathname.new(f)
+        if file.symlink? && !file.realpath.to_s.start_with?(abspath)
+          unreachable << file.relative_path_from(pwd)
+        end
+      end
+
+      unless unreachable.empty?
+        root = Pathname.new(path).relative_path_from(pwd)
+        err "Can't deploy application containing links '#{unreachable}' that reach outside its root '#{root}'"
+      end
+    end
+
+    def find_sockets(path)
+      files = Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
+      files && files.select { |f| File.socket? f }
+    end
+
     def upload_app_bits(appname, path)
       display 'Uploading Application:'
 
@@ -551,147 +409,112 @@
       explode_dir = "#{Dir.tmpdir}/.vmc_#{appname}_files"
       FileUtils.rm_rf(explode_dir) # Make sure we didn't have anything left over..
 
-      Dir.chdir(path) do
-        # Stage the app appropriately and do the appropriate fingerprinting, etc.
-        if war_file = Dir.glob('*.war').first
-          VMC::Cli::ZipUtil.unpack(war_file, explode_dir)
-        else
-          FileUtils.mkdir(explode_dir)
-          files = Dir.glob('{*,.[^\.]*}')
-          FileUtils.cp_r(files, explode_dir)
-        end
-
-        # Send the resource list to the cloudcontroller, the response will tell us what it already has..
-        unless @options[:noresources]
-          display '  Checking for available resources: ', false
-          fingerprints = []
-          total_size = 0
-          resource_files = Dir.glob("#{explode_dir}/**/*", File::FNM_DOTMATCH)
-          resource_files.each do |filename|
-            next if (File.directory?(filename) || !File.exists?(filename))
-            fingerprints << {
-              :size => File.size(filename),
-              :sha1 => Digest::SHA1.file(filename).hexdigest,
-              :fn => filename
-            }
-            total_size += File.size(filename)
-          end
-
-          # Check to see if the resource check is worth the round trip
-          if (total_size > (64*1024)) # 64k for now
-            # Send resource fingerprints to the cloud controller
-            appcloud_resources = client.check_resources(fingerprints)
-          end
-          display 'OK'.green
-
-          if appcloud_resources
-            display '  Processing resources: ', false
-            # We can then delete what we do not need to send.
-            appcloud_resources.each do |resource|
-              FileUtils.rm_f resource[:fn]
-              # adjust filenames sans the explode_dir prefix
-              resource[:fn].sub!("#{explode_dir}/", '')
+      if path =~ /\.(war|zip)$/
+        #single file that needs unpacking
+        VMC::Cli::ZipUtil.unpack(path, explode_dir)
+      elsif !File.directory? path
+        #single file that doesn't need unpacking
+        FileUtils.mkdir(explode_dir)
+        FileUtils.cp(path,explode_dir)
+      else
+        Dir.chdir(path) do
+          # Stage the app appropriately and do the appropriate fingerprinting, etc.
+          if war_file = Dir.glob('*.war').first
+            VMC::Cli::ZipUtil.unpack(war_file, explode_dir)
+          elsif zip_file = Dir.glob('*.zip').first
+            VMC::Cli::ZipUtil.unpack(zip_file, explode_dir)
+          else
+            check_unreachable_links(path)
+            FileUtils.mkdir(explode_dir)
+
+            files = Dir.glob('{*,.[^\.]*}')
+
+            # Do not process .git files
+            files.delete('.git') if files
+
+            FileUtils.cp_r(files, explode_dir)
+
+            find_sockets(explode_dir).each do |s|
+              File.delete s
             end
-            display 'OK'.green
-          end
-
-        end
-
-        # Perform Packing of the upload bits here.
-        unless VMC::Cli::ZipUtil.get_files_to_pack(explode_dir).empty?
-          display '  Packing application: ', false
-          VMC::Cli::ZipUtil.pack(explode_dir, upload_file)
-          display 'OK'.green
-
-          upload_size = File.size(upload_file);
-          if upload_size > 1024*1024
-            upload_size  = (upload_size/(1024.0*1024.0)).round.to_s + 'M'
-          elsif upload_size > 0
-            upload_size  = (upload_size/1024.0).round.to_s + 'K'
-          end
-        else
-          upload_size = '0K'
-        end
-
-        upload_str = "  Uploading (#{upload_size}): "
-        display upload_str, false
-
-        unless VMC::Cli::ZipUtil.get_files_to_pack(explode_dir).empty?
-          FileWithPercentOutput.display_str = upload_str
-          FileWithPercentOutput.upload_size = File.size(upload_file);
-          file = FileWithPercentOutput.open(upload_file, 'rb')
-        end
-
-        client.upload_app(appname, file, appcloud_resources)
-        display 'OK'.green if VMC::Cli::ZipUtil.get_files_to_pack(explode_dir).empty?
-
-        display 'Push Status: ', false
+          end
+        end
+      end
+
+      # Send the resource list to the cloudcontroller, the response will tell us what it already has..
+      unless @options[:noresources]
+        display '  Checking for available resources: ', false
+        fingerprints = []
+        total_size = 0
+        resource_files = Dir.glob("#{explode_dir}/**/*", File::FNM_DOTMATCH)
+        resource_files.each do |filename|
+          next if (File.directory?(filename) || !File.exists?(filename))
+          fingerprints << {
+            :size => File.size(filename),
+            :sha1 => Digest::SHA1.file(filename).hexdigest,
+            :fn => filename
+          }
+          total_size += File.size(filename)
+        end
+
+        # Check to see if the resource check is worth the round trip
+        if (total_size > (64*1024)) # 64k for now
+          # Send resource fingerprints to the cloud controller
+          appcloud_resources = client.check_resources(fingerprints)
+        end
         display 'OK'.green
-      end
-
-    ensure
-      # Cleanup if we created an exploded directory.
-      FileUtils.rm_f(upload_file) if upload_file
-      FileUtils.rm_rf(explode_dir) if explode_dir
-    end
-
-    def choose_existing_service(appname, user_services)
-      return unless prompt_ok
-      selected = false
-      choose do |menu|
-        menu.header = "The following provisioned services are available:"
-        menu.prompt = 'Please select one you wish to provision: '
-        menu.select_by = :index_or_name
-        user_services.each do |s|
-          menu.choice(s[:name]) do
-            display "Binding Service: ", false
-            client.bind_service(s[:name], appname)
-            display 'OK'.green
-            selected = true
-          end
-        end
-      end
-      selected
-    end
-
-    def choose_new_service(appname, services)
-      return unless prompt_ok
-      choose do |menu|
-        menu.header = "The following system services are available:"
-        menu.prompt = 'Please select one you wish to provision: '
-        menu.select_by = :index_or_name
-        service_choices = []
-        services.each do |service_type, value|
-          value.each do |vendor, version|
-            service_choices << vendor
-          end
-        end
-        service_choices.sort! {|a, b| a.to_s <=> b.to_s }
-        service_choices.each do |vendor|
-          menu.choice(vendor) do
-            default_name = random_service_name(vendor)
-            service_name = ask("Specify the name of the service [#{default_name}]: ")
-            service_name = default_name if service_name.empty?
-            create_service_banner(vendor, service_name)
-            bind_service_banner(service_name, appname)
-          end
-        end
-      end
-    end
-
-    def bind_services(appname, services)
-      user_services = client.services
-      selected_existing = false
-      unless no_prompt || user_services.empty?
-        use_existing = ask "Would you like to use an existing provisioned service [yN]? "
-        if use_existing.upcase == 'Y'
-          selected_existing = choose_existing_service(appname, user_services)
-        end
-      end
-      # Create a new service and bind it here
-      unless selected_existing
-        choose_new_service(appname, services)
-      end
+
+        if appcloud_resources
+          display '  Processing resources: ', false
+          # We can then delete what we do not need to send.
+          appcloud_resources.each do |resource|
+            FileUtils.rm_f resource[:fn]
+            # adjust filenames sans the explode_dir prefix
+            resource[:fn].sub!("#{explode_dir}/", '')
+          end
+          display 'OK'.green
+        end
+
+      end
+
+      # If no resource needs to be sent, add an empty file to ensure we have
+      # a multi-part request that is expected by nginx fronting the CC.
+      if VMC::Cli::ZipUtil.get_files_to_pack(explode_dir).empty?
+        Dir.chdir(explode_dir) do
+          File.new(".__empty__", "w")
+        end
+      end
+      # Perform Packing of the upload bits here.
+      display '  Packing application: ', false
+      VMC::Cli::ZipUtil.pack(explode_dir, upload_file)
+      display 'OK'.green
+
+      upload_size = File.size(upload_file);
+      if upload_size > 1024*1024
+        upload_size  = (upload_size/(1024.0*1024.0)).round.to_s + 'M'
+      elsif upload_size > 0
+        upload_size  = (upload_size/1024.0).round.to_s + 'K'
+      else
+        upload_size = '0K'
+      end
+
+      upload_str = "  Uploading (#{upload_size}): "
+      display upload_str, false
+
+      FileWithPercentOutput.display_str = upload_str
+      FileWithPercentOutput.upload_size = File.size(upload_file);
+      file = FileWithPercentOutput.open(upload_file, 'rb')
+
+      client.upload_app(appname, file, appcloud_resources)
+      display 'OK'.green if VMC::Cli::ZipUtil.get_files_to_pack(explode_dir).empty?
+
+      display 'Push Status: ', false
+      display 'OK'.green
+
+      ensure
+        # Cleanup if we created an exploded directory.
+        FileUtils.rm_f(upload_file) if upload_file
+        FileUtils.rm_rf(explode_dir) if explode_dir
     end
 
     def check_app_limit
@@ -768,9 +591,19 @@
       return display "No running instances for [#{appname}]".yellow if instances_info.empty?
 
       instances_table = table do |t|
-        t.headings = 'Index', 'State', 'Start Time'
+        show_debug = instances_info.any? { |e| e[:debug_port] }
+
+        headings = ['Index', 'State', 'Start Time']
+        headings << 'Debug IP' if show_debug
+        headings << 'Debug Port' if show_debug
+
+        t.headings = headings
+
         instances_info.each do |entry|
-          t << [entry[:index], entry[:state], Time.at(entry[:since]).strftime("%m/%d/%Y %I:%M%p")]
+          row = [entry[:index], entry[:state], Time.at(entry[:since]).strftime("%m/%d/%Y %I:%M%p")]
+          row << entry[:debug_ip] if show_debug
+          row << entry[:debug_port] if show_debug
+          t << row
         end
       end
       display "\n"
@@ -822,18 +655,24 @@
       case health(app)
         when 'N/A'
           # Health manager not running.
-          err "\Application '#{appname}'s state is undetermined, not enough information available." if error_on_health
+          err "\nApplication '#{appname}'s state is undetermined, not enough information available." if error_on_health
           return false
         when 'RUNNING'
           return true
         else
-          return false
+          if app[:meta][:debug] == "suspend"
+            display "\nApplication [#{appname}] has started in a mode that is waiting for you to trigger startup."
+            return true
+          else
+            return false
+          end
       end
     end
 
     def display_logfile(path, content, instance='0', banner=nil)
       banner ||= "====> #{path} <====\n\n"
-      if content && !content.empty?
+
+      unless content.empty?
         display banner
         prefix = "[#{instance}: #{path}] -".bold if @options[:prefixlogs]
         unless prefix
@@ -846,10 +685,6 @@
       end
     end
 
-    def log_file_paths
-      %w[logs/stderr.log logs/stdout.log logs/startup.log]
-    end
-
     def grab_all_logs(appname)
       instances_info_envelope = client.app_instances(appname)
       return if instances_info_envelope.is_a?(Array)
@@ -860,13 +695,21 @@
     end
 
     def grab_logs(appname, instance)
-      log_file_paths.each do |path|
+      files_under(appname, instance, "/logs").each do |path|
         begin
           content = client.app_files(appname, path, instance)
-        rescue
+          display_logfile(path, content, instance)
+        rescue VMC::Client::NotFound, VMC::Client::TargetError
         end
-        display_logfile(path, content, instance)
-      end
+      end
+    end
+
+    def files_under(appname, instance, path)
+      client.app_files(appname, path, instance).split("\n").collect do |l|
+        "#{path}/#{l.split[0]}"
+      end
+    rescue VMC::Client::NotFound, VMC::Client::TargetError
+      []
     end
 
     def grab_crash_logs(appname, instance, was_staged=false)
@@ -877,11 +720,10 @@
       map = VMC::Cli::Config.instances
       instance = map[instance] if map[instance]
 
-      ['/logs/err.log', '/logs/staging.log', 'logs/stderr.log', 'logs/stdout.log', 'logs/startup.log'].each do |path|
-        begin
-          content = client.app_files(appname, path, instance)
-        rescue
-        end
+      (files_under(appname, instance, "/logs") +
+        files_under(appname, instance, "/app/logs") +
+        files_under(appname, instance, "/app/log")).each do |path|
+        content = client.app_files(appname, path, instance)
         display_logfile(path, content, instance)
       end
     end
@@ -899,8 +741,355 @@
         display tail.join("\n") if new_lines > 0
       end
       since + new_lines
-    end
-    rescue
+    rescue VMC::Client::NotFound, VMC::Client::TargetError
+      0
+    end
+
+    def provisioned_services_apps_hash
+      apps = client.apps
+      services_apps_hash = {}
+      apps.each {|app|
+        app[:services].each { |svc|
+          svc_apps = services_apps_hash[svc]
+          unless svc_apps
+            svc_apps = Set.new
+            services_apps_hash[svc] = svc_apps
+          end
+          svc_apps.add(app[:name])
+        } unless app[:services] == nil
+      }
+      services_apps_hash
+    end
+
+    def delete_app(appname, force)
+      app = client.app_info(appname)
+      services_to_delete = []
+      app_services = app[:services]
+      services_apps_hash = provisioned_services_apps_hash
+      app_services.each { |service|
+        del_service = force && no_prompt
+        unless no_prompt || force
+          del_service = ask(
+            "Provisioned service [#{service}] detected, would you like to delete it?",
+            :default => false
+          )
+
+          if del_service
+            apps_using_service = services_apps_hash[service].reject!{ |app| app == appname}
+            if apps_using_service.size > 0
+              del_service = ask(
+                "Provisioned service [#{service}] is also used by #{apps_using_service.size == 1 ? "app" : "apps"} #{apps_using_service.entries}, are you sure you want to delete it?",
+                :default => false
+              )
+            end
+          end
+        end
+        services_to_delete << service if del_service
+      }
+
+      display "Deleting application [#{appname}]: ", false
+      client.delete_app(appname)
+      display 'OK'.green
+
+      services_to_delete.each do |s|
+        delete_service_banner(s)
+      end
+    end
+
+    def do_start(appname, push=false)
+      app = client.app_info(appname)
+      return display "Application '#{appname}' could not be found".red if app.nil?
+      return display "Application '#{appname}' already started".yellow if app[:state] == 'STARTED'
+
+
+
+      if @options[:debug]
+        runtimes = client.runtimes_info
+        return display "Cannot get runtime information." unless runtimes
+
+        runtime = runtimes[app[:staging][:stack].to_sym]
+        return display "Unknown runtime." unless runtime
+
+        unless runtime[:debug_modes] and runtime[:debug_modes].include? @options[:debug]
+          modes = runtime[:debug_modes] || []
+
+          display "\nApplication '#{appname}' cannot start in '#{@options[:debug]}' mode"
+
+          if push
+            display "Try 'vmc start' with one of the following modes: #{modes.inspect}"
+          else
+            display "Available modes: #{modes.inspect}"
+          end
+
+          return
+        end
+      end
+
+      banner = "Staging Application '#{appname}': "
+      display banner, false
+
+      t = Thread.new do
+        count = 0
+        while count < TAIL_TICKS do
+          display '.', false
+          sleep SLEEP_TIME
+          count += 1
+        end
+      end
+
+      app[:state] = 'STARTED'
+      app[:debug] = @options[:debug]
+      app[:console] = VMC::Cli::Framework.lookup_by_framework(app[:staging][:model]).console
+      client.update_app(appname, app)
+
+      Thread.kill(t)
+      clear(LINE_LENGTH)
+      display "#{banner}#{'OK'.green}"
+
+      banner = "Starting Application '#{appname}': "
+      display banner, false
+
+      count = log_lines_displayed = 0
+      failed = false
+      start_time = Time.now.to_i
+
+      loop do
+        display '.', false unless count > TICKER_TICKS
+        sleep SLEEP_TIME
+
+        break if app_started_properly(appname, count > HEALTH_TICKS)
+
+        if !crashes(appname, false, start_time).empty?
+          # Check for the existance of crashes
+          display "\nError: Application [#{appname}] failed to start, logs information below.\n".red
+          grab_crash_logs(appname, '0', true)
+          if push and !no_prompt
+            display "\n"
+            delete_app(appname, false) if ask "Delete the application?", :default => true
+          end
+          failed = true
+          break
+        elsif count > TAIL_TICKS
+          log_lines_displayed = grab_startup_tail(appname, log_lines_displayed)
+        end
+
+        count += 1
+        if count > GIVEUP_TICKS # 2 minutes
+          display "\nApplication is taking too long to start, check your logs".yellow
+          break
+        end
+      end
+      exit(false) if failed
+      clear(LINE_LENGTH)
+      display "#{banner}#{'OK'.green}"
+    end
+
+    def do_stop(appname)
+      app = client.app_info(appname)
+      return display "Application '#{appname}' already stopped".yellow if app[:state] == 'STOPPED'
+      display "Stopping Application '#{appname}': ", false
+      app[:state] = 'STOPPED'
+      client.update_app(appname, app)
+      display 'OK'.green
+    end
+
+    def do_push(appname=nil)
+      unless @app_info || no_prompt
+        @manifest = { "applications" => { @path => { "name" => appname } } }
+
+        interact
+
+        if ask("Would you like to save this configuration?", :default => false)
+          save_manifest
+        end
+
+        resolve_manifest(@manifest)
+
+        @app_info = @manifest["applications"][@path]
+      end
+
+      instances = info(:instances, 1)
+      exec = info(:exec, 'thin start')
+
+      ignore_framework = @options[:noframework]
+      no_start = @options[:nostart]
+
+      appname ||= info(:name)
+      url = info(:url) || info(:urls)
+      mem, memswitch = nil, info(:mem)
+      memswitch = normalize_mem(memswitch) if memswitch
+      command = info(:command)
+      runtime = info(:runtime)
+
+      # Check app existing upfront if we have appname
+      app_checked = false
+      if appname
+        err "Application '#{appname}' already exists, use update" if app_exists?(appname)
+        app_checked = true
+      else
+        raise VMC::Client::AuthError unless client.logged_in?
+      end
+
+      # check if we have hit our app limit
+      check_app_limit
+      # check memsize here for capacity
+      if memswitch && !no_start
+        check_has_capacity_for(mem_choice_to_quota(memswitch) * instances)
+      end
+
+      appname ||= ask("Application Name") unless no_prompt
+      err "Application Name required." if appname.nil? || appname.empty?
+
+      check_deploy_directory(@application)
+
+      if !app_checked and app_exists?(appname)
+        err "Application '#{appname}' already exists, use update or delete."
+      end
+
+      if ignore_framework
+        framework = VMC::Cli::Framework.new
+      elsif f = info(:framework)
+        info = Hash[f["info"].collect { |k, v| [k.to_sym, v] }]
+
+        framework = VMC::Cli::Framework.create(f["name"], info)
+        exec = framework.exec if framework && framework.exec
+      else
+        framework = detect_framework(prompt_ok)
+      end
+
+      err "Application Type undetermined for path '#{@application}'" unless framework
+
+      if not runtime
+        default_runtime = framework.default_runtime @application
+        runtime = detect_runtime(default_runtime, !no_prompt) if framework.prompt_for_runtime?
+      end
+      command = ask("Start Command") if !command && framework.require_start_command?
+
+      default_url = "None"
+      default_url = "#{appname}.#{VMC::Cli::Config.suggest_url}" if framework.require_url?
+
+
+      unless no_prompt || url || !framework.require_url?
+        url = ask(
+          "Application Deployed URL",
+          :default => default_url
+        )
+
+        # common error case is for prompted users to answer y or Y or yes or
+        # YES to this ask() resulting in an unintended URL of y. Special case
+        # this common error
+        url = nil if YES_SET.member? url
+      end
+      url = nil if url == "None"
+      default_url = nil if default_url == "None"
+      url ||= default_url
+
+      if memswitch
+        mem = memswitch
+      elsif prompt_ok
+        mem = ask("Memory Reservation",
+                  :default => framework.memory(runtime),
+                  :choices => mem_choices)
+      else
+        mem = framework.memory runtime
+      end
+
+      # Set to MB number
+      mem_quota = mem_choice_to_quota(mem)
+
+      # check memsize here for capacity
+      check_has_capacity_for(mem_quota * instances) unless no_start
+
+      display 'Creating Application: ', false
+
+      manifest = {
+        :name => "#{appname}",
+        :staging => {
+           :framework => framework.name,
+           :runtime => runtime
+        },
+        :uris => Array(url),
+        :instances => instances,
+        :resources => {
+          :memory => mem_quota
+        }
+      }
+      manifest[:staging][:command] = command if command
+
+      # Send the manifest to the cloud controller
+      client.create_app(appname, manifest)
+      display 'OK'.green
+
+
+      existing = Set.new(client.services.collect { |s| s[:name] })
+
+      if @app_info && services = @app_info["services"]
+        services.each do |name, info|
+          unless existing.include? name
+            create_service_banner(info["type"], name, true)
+          end
+
+          bind_service_banner(name, appname)
+        end
+      end
+
+      # Stage and upload the app bits.
+      upload_app_bits(appname, @application)
+
+      start(appname, true) unless no_start
+    end
+
+    def do_stats(appname)
+      stats = client.app_stats(appname)
+      return display JSON.pretty_generate(stats) if @options[:json]
+
+      stats_table = table do |t|
+        t.headings = 'Instance', 'CPU (Cores)', 'Memory (limit)', 'Disk (limit)', 'Uptime'
+        stats.each do |entry|
+          index = entry[:instance]
+          stat = entry[:stats]
+          hp = "#{stat[:host]}:#{stat[:port]}"
+          uptime = uptime_string(stat[:uptime])
+          usage = stat[:usage]
+          if usage
+            cpu   = usage[:cpu]
+            mem   = (usage[:mem] * 1024) # mem comes in K's
+            disk  = usage[:disk]
+          end
+          mem_quota = stat[:mem_quota]
+          disk_quota = stat[:disk_quota]
+          mem  = "#{pretty_size(mem)} (#{pretty_size(mem_quota, 0)})"
+          disk = "#{pretty_size(disk)} (#{pretty_size(disk_quota, 0)})"
+          cpu = cpu ? cpu.to_s : 'NA'
+          cpu = "#{cpu}% (#{stat[:cores]})"
+          t << [index, cpu, mem, disk, uptime]
+        end
+      end
+
+      if stats.empty?
+        display "No running instances for [#{appname}]".yellow
+      else
+        display stats_table
+      end
+    end
+
+    def all_files(appname, path)
+      instances_info_envelope = client.app_instances(appname)
+      return if instances_info_envelope.is_a?(Array)
+      instances_info = instances_info_envelope[:instances] || []
+      instances_info.each do |entry|
+        begin
+          content = client.app_files(appname, path, entry[:index])
+          display_logfile(
+            path,
+            content,
+            entry[:index],
+            "====> [#{entry[:index]}: #{path}] <====\n".bold
+          )
+        rescue VMC::Client::NotFound, VMC::Client::TargetError
+        end
+      end
+    end
   end
 
   class FileWithPercentOutput < ::File
 
=== modified file 'lib/cli/commands/base.rb'
--- lib/cli/commands/base.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/base.rb	2012-06-13 01:37:18 +0000
@@ -1,33 +1,189 @@
-
 require 'rubygems'
+require 'interact'
 require 'terminal-table/import'
-require 'highline/import'
 
 module VMC::Cli
 
   module Command
 
     class Base
+      include Interactive
+
       attr_reader :no_prompt, :prompt_ok
 
+      MANIFEST = "manifest.yml"
+
       def initialize(options={})
         @options = options.dup
         @no_prompt = @options[:noprompts]
         @prompt_ok = !no_prompt
 
-        # Fix for system ruby and Highline (stdin) on MacOSX
-        if RUBY_PLATFORM =~ /darwin/ && RUBY_VERSION == '1.8.7' && RUBY_PATCHLEVEL <= 174
-          HighLine.track_eof = false
-        end
-
         # Suppress colorize on Windows systems for now.
-        if !!RUBY_PLATFORM['mingw'] || !!RUBY_PLATFORM['mswin32'] || !!RUBY_PLATFORM['cygwin']
+        if WINDOWS
           VMC::Cli::Config.colorize = false
         end
 
-      end
-
-      def client
+        @path = @options[:path] || '.'
+
+        load_manifest manifest_file if manifest_file
+      end
+
+      def manifest_file
+        return @options[:manifest] if @options[:manifest]
+        return @manifest_file if @manifest_file
+
+        where = File.expand_path(@path)
+        while true
+          if File.exists?(File.join(where, MANIFEST))
+            @manifest_file = File.join(where, MANIFEST)
+            break
+          elsif File.basename(where) == "/"
+            @manifest_file = nil
+            break
+          else
+            where = File.expand_path("../", where)
+          end
+        end
+
+        @manifest_file
+      end
+
+      def load_manifest_structure(file)
+        manifest = YAML.load_file file
+
+        Array(manifest["inherit"]).each do |p|
+          manifest = merge_parent(manifest, p)
+        end
+
+        if apps = manifest["applications"]
+          apps.each do |k, v|
+            abs = File.expand_path(k, file)
+            if Dir.pwd.start_with? abs
+              manifest = merge_manifest(manifest, v)
+            end
+          end
+        end
+
+        manifest
+      end
+
+      def resolve_manifest(manifest)
+        if apps = manifest["applications"]
+          apps.each_value do |v|
+            resolve_lexically(v, [manifest])
+          end
+        end
+
+        resolve_lexically(manifest, [manifest])
+      end
+
+      def load_manifest(file)
+        @manifest = load_manifest_structure(file)
+        resolve_manifest(@manifest)
+      end
+
+      def merge_parent(child, path)
+        file = File.expand_path("../" + path, manifest_file)
+        merge_manifest(child, load_manifest_structure(file))
+      end
+
+      def merge_manifest(child, parent)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        parent.merge(child, &merge)
+      end
+
+      def resolve_lexically(val, ctx = [@manifest])
+        case val
+        when Hash
+          val.each_value do |v|
+            resolve_lexically(v, [val] + ctx)
+          end
+        when Array
+          val.each do |v|
+            resolve_lexically(v, ctx)
+          end
+        when String
+          val.gsub!(/\$\{([[:alnum:]\-]+)\}/) do
+            resolve_symbol($1, ctx)
+          end
+        end
+
+        nil
+      end
+
+      def resolve_symbol(sym, ctx)
+        case sym
+        when "target-base"
+          target_base(ctx)
+
+        when "target-url"
+          target_url(ctx)
+
+        when "random-word"
+          "%04x" % [rand(0x0100000)]
+
+        else
+          found = find_symbol(sym, ctx)
+
+          if found
+            resolve_lexically(found, ctx)
+            found
+          else
+            err(sym, "Unknown symbol in manifest: ")
+          end
+        end
+      end
+
+      def find_symbol(sym, ctx)
+        ctx.each do |h|
+          if val = resolve_in(h, sym)
+            return val
+          end
+        end
+
+        nil
+      end
+
+      def resolve_in(hash, *where)
+        find_in_hash(hash, ["properties"] + where) ||
+          find_in_hash(hash, ["applications", @application] + where) ||
+          find_in_hash(hash, where)
+      end
+
+      def manifest(*where)
+        resolve_in(@manifest, *where)
+      end
+
+      def find_in_hash(hash, where)
+        what = hash
+        where.each do |x|
+          return nil unless what.is_a?(Hash)
+          what = what[x]
+        end
+
+        what
+      end
+
+      def target_url(ctx = [])
+        find_symbol("target", ctx) ||
+          (@client && @client.target) ||
+          VMC::Cli::Config.target_url
+      end
+
+      def target_base(ctx = [])
+        VMC::Cli::Config.base_of(find_symbol("target", ctx) || target_url)
+      end
+
+      # Inject a client to help in testing.
+      def client(cli=nil)
+        @client ||= cli
         return @client if @client
         @client = VMC::Client.new(target_url, auth_token)
         @client.trace = VMC::Cli::Config.trace if VMC::Cli::Config.trace
@@ -36,18 +192,11 @@
       end
 
       def client_info
-        return @client_info if @client_info
-        @client_info = client.info
-      end
-
-      def target_url
-        return @target_url if @target_url
-        @target_url = VMC::Cli::Config.target_url
+        @client_info ||= client.info
       end
 
       def auth_token
-        return @auth_token if @auth_token
-        @auth_token = VMC::Cli::Config.auth_token
+        @auth_token = VMC::Cli::Config.auth_token(@options[:token_file])
       end
 
       def runtimes_info
@@ -72,7 +221,6 @@
         end
         @frameworks
       end
-
     end
   end
 end
 
=== added file 'lib/cli/commands/manifest.rb'
--- lib/cli/commands/manifest.rb	1970-01-01 00:00:00 +0000
+++ lib/cli/commands/manifest.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,56 @@
+module VMC::Cli::Command
+  class Manifest < Base
+    include VMC::Cli::ManifestHelper
+
+    def initialize(options)
+      super
+
+      # don't resolve any of the manifest template stuff
+      if manifest_file
+        @manifest = load_manifest_structure manifest_file
+      else
+        @manifest = {}
+      end
+    end
+
+    def edit
+      build_manifest
+      save_manifest
+    end
+
+    def extend(which)
+      parent = load_manifest_structure which
+      @manifest = load_manifest_structure which
+
+      build_manifest
+
+      simplify(@manifest, parent)
+
+      @manifest["inherit"] ||= []
+      @manifest["inherit"] << which
+
+      save_manifest(ask("Save where?"))
+    end
+
+    private
+
+    def simplify(child, parent)
+      return unless child.is_a?(Hash) and parent.is_a?(Hash)
+
+      child.reject! do |k, v|
+        if v == parent[k]
+          puts "rejecting #{k}"
+          true
+        else
+          simplify(v, parent[k])
+          false
+        end
+      end
+    end
+
+    def build_manifest
+      @application = ask("Configure for which application?", :default => ".")
+      interact true
+    end
+  end
+end
 
=== added file 'lib/cli/commands/micro.rb'
--- lib/cli/commands/micro.rb	1970-01-01 00:00:00 +0000
+++ lib/cli/commands/micro.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,115 @@
+module VMC::Cli::Command
+  class Micro < Base
+
+    def initialize(args)
+      super(args)
+    end
+
+    def offline(mode)
+      command('offline')
+    end
+
+    def online(mode)
+      command('online')
+    end
+
+    def status(mode)
+      command('status')
+    end
+
+    def command(cmd)
+      config = build_config
+      switcher(config).send(cmd)
+      store_config(config)
+    end
+
+    def switcher(config)
+      case Micro.platform
+      when :darwin
+        switcher = VMC::Micro::Switcher::Darwin.new(config)
+      when :linux
+        switcher = VMC::Micro::Switcher::Linux.new(config)
+      when :windows
+        switcher = VMC::Micro::Switcher::Windows.new(config)
+      when :dummy # for testing only
+        switcher = VMC::Micro::Switcher::Dummy.new(config)
+      else
+        err "unsupported platform: #{Micro.platform}"
+      end
+    end
+
+    # Returns the configuration needed to run the micro related subcommands.
+    # First loads saved config from file (if there is any), then overrides
+    # loaded values with command line arguments, and finally tries to guess
+    # in case neither was used:
+    #   vmx       location of micro.vmx file
+    #   vmrun     location of vmrun command
+    #   password  password for vcap user (in the guest vm)
+    #   platform  current platform
+    def build_config
+      conf = VMC::Cli::Config.micro # returns {} if there isn't a saved config
+
+      override(conf, 'vmx', true) do
+        locate_vmx(Micro.platform)
+      end
+
+      override(conf, 'vmrun', true) do
+        VMC::Micro::VMrun.locate(Micro.platform)
+      end
+
+      override(conf, 'password') do
+        @password = ask("Please enter your Micro Cloud Foundry VM password (vcap user) password", :echo => "*")
+      end
+
+      conf['platform'] = Micro.platform
+
+      conf
+    end
+
+    # Save the cleartext password if --save is supplied.
+    # Note: it is due to vix we have to use a cleartext password :(
+    # Only if --password is used and not --save is the password deleted from the
+    # config file before it is stored to disk.
+    def store_config(config)
+      if @options[:save]
+        warn("cleartext password saved in: #{VMC::Cli::Config::MICRO_FILE}")
+      elsif @options[:password] || @password
+        config.delete('password')
+      end
+
+      VMC::Cli::Config.store_micro(config)
+    end
+
+    # override with command line arguments and yield the block in case the option isn't set
+    def override(config, option, escape=false, &blk)
+      # override if given on the command line
+      if opt = @options[option.to_sym]
+        opt = VMC::Micro.escape_path(opt) if escape
+        config[option] = opt
+      end
+      config[option] = yield unless config[option]
+    end
+
+    def locate_vmx(platform)
+      paths = YAML.load_file(VMC::Micro.config_file('paths.yml'))
+      vmx_paths = paths[platform.to_s]['vmx']
+      vmx = VMC::Micro.locate_file('micro.vmx', 'micro', vmx_paths)
+      err "Unable to locate micro.vmx, please supply --vmx option" unless vmx
+      vmx
+    end
+
+    def self.platform
+      case RUBY_PLATFORM
+      when /darwin/  # x86_64-darwin11.2.0
+        :darwin
+      when /linux/   # x86_64-linux
+        :linux
+      when /mingw|mswin32|cygwin/ # i386-mingw32
+        :windows
+      else
+        RUBY_PLATFORM
+      end
+    end
+
+  end
+end
 
=== modified file 'lib/cli/commands/misc.rb'
--- lib/cli/commands/misc.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/misc.rb	2012-06-13 01:37:18 +0000
@@ -30,14 +30,15 @@
       client = VMC::Client.new(target_url)
       unless client.target_valid?
         if prompt_ok
-          display "Host is not valid: '#{target_url}'".red
-          show_response = ask "Would you like see the response [yN]? "
-          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response.upcase == 'Y'
+          display "Host is not available or is not valid: '#{target_url}'".red
+          show_response = ask "Would you like see the response?",
+                              :default => false
+          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response
         end
         exit(false)
       else
         VMC::Cli::Config.store_target(target_url)
-        say "Succesfully targeted to [#{target_url}]".green
+        say "Successfully targeted to [#{target_url}]".green
       end
     end
 
 
=== modified file 'lib/cli/commands/services.rb'
--- lib/cli/commands/services.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/services.rb	2012-06-13 01:37:18 +0000
@@ -1,11 +1,16 @@
+require "uuidtools"
+
 module VMC::Cli::Command
 
   class Services < Base
     include VMC::Cli::ServicesHelper
+    include VMC::Cli::TunnelHelper
 
     def services
       ss = client.services_info
       ps = client.services
+      ps.sort! {|a, b| a[:name] <=> b[:name] }
+
       if @options[:json]
         services = { :system => ss, :provisioned => ps }
         return display JSON.pretty_generate(services)
@@ -18,15 +23,15 @@
       unless no_prompt || service
         services = client.services_info
         err 'No services available to provision' if services.empty?
-        choose do |menu|
-          menu.prompt = 'Please select one you wish to provision: '
-          menu.select_by = :index_or_name
-          services.each do |service_type, value|
-            value.each do |vendor, version|
-              menu.choice(vendor.to_s) { service = vendor.to_s }
-            end
-          end
-        end
+        service = ask(
+          "Which service would you like to provision?",
+          { :indexed => true,
+            :choices =>
+              services.values.collect { |type|
+                type.keys.collect(&:to_s)
+              }.flatten
+          }
+        )
       end
       name = @options[:name] unless name
       unless name
@@ -42,13 +47,12 @@
       unless no_prompt || service
         user_services = client.services
         err 'No services available to delete' if user_services.empty?
-        choose do |menu|
-          menu.prompt = 'Please select one you wish to delete: '
-          menu.select_by = :index_or_name
-          user_services.each do |s|
-            menu.choice(s[:name]) { service = s[:name] }
-          end
-        end
+        service = ask(
+          "Which service would you like to delete?",
+          { :indexed => true,
+            :choices => user_services.collect { |s| s[:name] }
+          }
+        )
       end
       err "Service name required." unless service
       display "Deleting service [#{service}]: ", false
@@ -80,5 +84,97 @@
       check_app_for_restart(dest_app)
     end
 
+    def tunnel(service=nil, client_name=nil)
+      unless defined? Caldecott
+        display "To use `vmc tunnel', you must first install Caldecott:"
+        display ""
+        display "\tgem install caldecott"
+        display ""
+        display "Note that you'll need a C compiler. If you're on OS X, Xcode"
+        display "will provide one. If you're on Windows, try DevKit."
+        display ""
+        display "This manual step will be removed in the future."
+        display ""
+        err "Caldecott is not installed."
+      end
+
+      ps = client.services
+      err "No services available to tunnel to" if ps.empty?
+
+      unless service
+        choices = ps.collect { |s| s[:name] }.sort
+        service = ask(
+          "Which service to tunnel to?",
+          :choices => choices,
+          :indexed => true
+        )
+      end
+
+      info = ps.select { |s| s[:name] == service }.first
+
+      err "Unknown service '#{service}'" unless info
+
+      port = pick_tunnel_port(@options[:port] || 10000)
+
+      raise VMC::Client::AuthError unless client.logged_in?
+
+      if not tunnel_pushed?
+        display "Deploying tunnel application '#{tunnel_appname}'."
+        auth = UUIDTools::UUID.random_create.to_s
+        push_caldecott(auth)
+        bind_service_banner(service, tunnel_appname, false)
+        start_caldecott
+      else
+        auth = tunnel_auth
+      end
+
+      if not tunnel_healthy?(auth)
+        display "Redeploying tunnel application '#{tunnel_appname}'."
+
+        # We don't expect caldecott not to be running, so take the
+        # most aggressive restart method.. delete/re-push
+        client.delete_app(tunnel_appname)
+        invalidate_tunnel_app_info
+
+        push_caldecott(auth)
+        bind_service_banner(service, tunnel_appname, false)
+        start_caldecott
+      end
+
+      if not tunnel_bound?(service)
+        bind_service_banner(service, tunnel_appname)
+      end
+
+      conn_info = tunnel_connection_info info[:vendor], service, auth
+      display_tunnel_connection_info(conn_info)
+      display "Starting tunnel to #{service.bold} on port #{port.to_s.bold}."
+      start_tunnel(port, conn_info, auth)
+
+      clients = get_clients_for(info[:vendor])
+
+      if clients.empty?
+        client_name ||= "none"
+      else
+        client_name ||= ask(
+          "Which client would you like to start?",
+          :choices => ["none"] + clients.keys,
+          :indexed => true
+        )
+      end
+
+      if client_name == "none"
+        wait_for_tunnel_end
+      else
+        wait_for_tunnel_start(port)
+        unless start_local_prog(clients, client_name, conn_info, port)
+          err "'#{client_name}' execution failed; is it in your $PATH?"
+        end
+      end
+    end
+
+    def get_clients_for(type)
+      conf = VMC::Cli::Config.clients
+      conf[type] || {}
+    end
   end
 end
 
=== modified file 'lib/cli/commands/user.rb'
--- lib/cli/commands/user.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/commands/user.rb	2012-06-13 01:37:18 +0000
@@ -12,19 +12,24 @@
     def login(email=nil)
       email    = @options[:email] unless email
       password = @options[:password]
-      tries = 0
-      email = ask("Email: ") unless no_prompt || email
-      password = ask("Password: ") {|q| q.echo = '*'} unless no_prompt || password
+      tries ||= 0
+
+      unless no_prompt
+        display "Attempting login to [#{target_url}]" if target_url
+        email ||= ask("Email")
+        password ||= ask("Password", :echo => "*")
+      end
+
       err "Need a valid email" unless email
       err "Need a password" unless password
       login_and_save_token(email, password)
       say "Successfully logged into [#{target_url}]".green
     rescue VMC::Client::TargetError
-      display "Problem with login, invalid account or password.".red
+      display "Problem with login, invalid account or password when attempting to login to '#{target_url}'".red
       retry if (tries += 1) < 3 && prompt_ok && !@options[:password]
       exit 1
     rescue => e
-      display "Problem with login, #{e}, try again or register for an account.".red
+      display "Problem with login to '#{target_url}', #{e}, try again or register for an account.".red
       exit 1
     end
 
@@ -39,8 +44,8 @@
       err "Need to be logged in to change password." unless email
       say "Changing password for '#{email}'\n"
       unless no_prompt
-        password = ask("New Password: ") {|q| q.echo = '*'}
-        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
+        password = ask "New Password", :echo => "*"
+        password2 = ask "Verify Password", :echo => "*"
         err "Passwords did not match, try again" if password != password2
       end
       err "Password required" unless password
@@ -52,7 +57,7 @@
 
     def login_and_save_token(email, password)
       token = client.login(email, password)
-      VMC::Cli::Config.store_token(token)
+      VMC::Cli::Config.store_token(token, @options[:token_file])
     end
 
   end
 
=== modified file 'lib/cli/config.rb'
--- lib/cli/config.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/config.rb	2012-06-13 01:37:18 +0000
@@ -8,56 +8,60 @@
   class Config
 
     DEFAULT_TARGET  = 'api.vcap.me'
-    DEFAULT_SUGGEST = 'vcap.me'
 
     TARGET_FILE    = '~/.vmc_target'
     TOKEN_FILE     = '~/.vmc_token'
     INSTANCES_FILE = '~/.vmc_instances'
     ALIASES_FILE   = '~/.vmc_aliases'
+    CLIENTS_FILE   = '~/.vmc_clients'
+    MICRO_FILE     = '~/.vmc_micro'
+
+    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
 
     class << self
       attr_accessor :colorize
       attr_accessor :output
       attr_accessor :trace
       attr_accessor :nozip
-      attr_reader   :suggest_url
 
       def target_url
         return @target_url if @target_url
         target_file = File.expand_path(TARGET_FILE)
         if File.exists? target_file
-          @target_url = File.read(target_file).strip!
-          ha = @target_url.split('.')
-          ha.shift
-          @suggest_url = ha.join('.')
-          @suggest_url = DEFAULT_SUGGEST if @suggest_url.empty?
+          @target_url = lock_and_read(target_file).strip
         else
           @target_url  = DEFAULT_TARGET
-          @suggest_url = DEFAULT_SUGGEST
         end
         @target_url = "http://#{@target_url}" unless /^https?/ =~ @target_url
         @target_url = @target_url.gsub(/\/+$/, '')
         @target_url
       end
 
+      def base_of(url)
+        url.sub(/^[^\.]+\./, "")
+      end
+
+      def suggest_url
+        @suggest_url ||= base_of(target_url)
+      end
+
       def store_target(target_host)
         target_file = File.expand_path(TARGET_FILE)
-        File.open(target_file, 'w+') { |f| f.puts target_host }
-        FileUtils.chmod 0600, target_file
+        lock_and_write(target_file, target_host)
       end
 
-      def all_tokens
-        token_file = File.expand_path(TOKEN_FILE)
+      def all_tokens(token_file_path=nil)
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
         return nil unless File.exists? token_file
-        contents = File.read(token_file).strip
+        contents = lock_and_read(token_file).strip
         JSON.parse(contents)
       end
 
       alias :targets :all_tokens
 
-      def auth_token
+      def auth_token(token_file_path=nil)
         return @token if @token
-        tokens = all_tokens
+        tokens = all_tokens(token_file_path)
         @token = tokens[target_url] if tokens
       end
 
@@ -65,24 +69,23 @@
         FileUtils.rm_f(File.expand_path(TOKEN_FILE))
       end
 
-      def store_token(token)
-        tokens = all_tokens || {}
+      def store_token(token, token_file_path=nil)
+        tokens = all_tokens(token_file_path) || {}
         tokens[target_url] = token
-        token_file = File.expand_path(TOKEN_FILE)
-        File.open(token_file, 'w+') { |f| f.write(tokens.to_json) }
-        FileUtils.chmod 0600, token_file
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
+        lock_and_write(token_file, tokens.to_json)
       end
 
       def instances
         instances_file = File.expand_path(INSTANCES_FILE)
         return nil unless File.exists? instances_file
-        contents = File.read(instances_file).strip
+        contents = lock_and_read(instances_file).strip
         JSON.parse(contents)
       end
 
       def store_instances(instances)
         instances_file = File.expand_path(INSTANCES_FILE)
-        File.open(instances_file, 'w') { |f| f.write(instances.to_json) }
+        lock_and_write(instances_file, instances.to_json)
       end
 
       def aliases
@@ -100,6 +103,66 @@
         File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
       end
 
+      def micro
+        micro_file = File.expand_path(MICRO_FILE)
+        return {} unless File.exists? micro_file
+        contents = lock_and_read(micro_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_micro(micro)
+        micro_file = File.expand_path(MICRO_FILE)
+        lock_and_write(micro_file, micro.to_json)
+      end
+
+      def deep_merge(a, b)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        a.merge(b, &merge)
+      end
+
+      def clients
+        return @clients if @clients
+
+        stock = YAML.load_file(STOCK_CLIENTS)
+        clients = File.expand_path CLIENTS_FILE
+        if File.exists? clients
+          user = YAML.load_file(clients)
+          @clients = deep_merge(stock, user)
+        else
+          @clients = stock
+        end
+      end
+
+      def lock_and_read(file)
+        File.open(file, File::RDONLY) {|f|
+          if defined? JRUBY_VERSION
+            f.flock(File::LOCK_SH)
+          else
+            f.flock(File::LOCK_EX)
+          end
+          contents = f.read
+          f.flock(File::LOCK_UN)
+          contents
+        }
+      end
+
+      def lock_and_write(file, contents)
+        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.puts contents
+          f.flush
+          f.truncate(f.pos)
+          f.flock(File::LOCK_UN)
+        }
+      end
     end
 
     def initialize(work_dir = Dir.pwd)
 
=== added file 'lib/cli/console_helper.rb'
--- lib/cli/console_helper.rb	1970-01-01 00:00:00 +0000
+++ lib/cli/console_helper.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,160 @@
+require 'net/telnet'
+require 'readline'
+
+module VMC::Cli
+  module ConsoleHelper
+
+    def console_connection_info(appname)
+      app = client.app_info(appname)
+      fw = VMC::Cli::Framework.lookup_by_framework(app[:staging][:model])
+      if !fw.console
+        err "'#{appname}' is a #{fw.name} application.  " +
+          "Console access is not supported for #{fw.name} applications."
+      end
+      instances_info_envelope = client.app_instances(appname)
+      instances_info_envelope = {} if instances_info_envelope.is_a?(Array)
+
+      instances_info = instances_info_envelope[:instances] || []
+      err "No running instances for [#{appname}]" if instances_info.empty?
+
+      entry = instances_info[0]
+      if !entry[:console_port]
+        begin
+          client.app_files(appname, '/app/cf-rails-console')
+          err "Console port not provided for [#{appname}].  Try restarting the app."
+        rescue VMC::Client::TargetError, VMC::Client::NotFound
+          err "Console access not supported for [#{appname}]. " +
+            "Please redeploy your app to enable support."
+        end
+      end
+      conn_info = {'hostname' => entry[:console_ip], 'port' => entry[:console_port]}
+    end
+
+    def start_local_console(port, appname)
+      auth_info = console_credentials(appname)
+      display "Connecting to '#{appname}' console: ", false
+      prompt = console_login(auth_info, port)
+      display "OK".green
+      display "\n"
+      initialize_readline
+      run_console prompt
+    end
+
+    def console_login(auth_info, port)
+      if !auth_info["username"] || !auth_info["password"]
+        err "Unable to verify console credentials."
+      end
+      @telnet_client = telnet_client(port)
+      prompt = nil
+      err_msg = "Login attempt timed out."
+      5.times do
+        begin
+          results = @telnet_client.login("Name"=>auth_info["username"],
+            "Password"=>auth_info["password"])
+          lines = results.sub("Login: Password: ", "").split("\n")
+          last_line = lines.pop
+          if last_line =~ /[$%#>] \z/n
+            prompt = last_line
+          elsif last_line =~ /Login failed/
+            err_msg = last_line
+          end
+          break
+        rescue TimeoutError
+          sleep 1
+        rescue EOFError
+          #This may happen if we login right after app starts
+          close_console
+          sleep 5
+          @telnet_client = telnet_client(port)
+        end
+        display ".", false
+      end
+      unless prompt
+        close_console
+        err err_msg
+      end
+      prompt
+    end
+
+    def send_console_command(cmd)
+      results = @telnet_client.cmd(cmd)
+      results.split("\n")
+    end
+
+    def console_credentials(appname)
+      content = client.app_files(appname, '/app/cf-rails-console/.consoleaccess', '0')
+      YAML.load(content)
+    end
+
+    def close_console
+      @telnet_client.close
+    end
+
+    def console_tab_completion_data(cmd)
+      begin
+        results = @telnet_client.cmd("String"=> cmd + "\t", "Match"=>/\S*\n$/, "Timeout"=>10)
+        results.chomp.split(",")
+      rescue TimeoutError
+        [] #Just return empty results if timeout occurred on tab completion
+      end
+    end
+
+    private
+    def telnet_client(port)
+      Net::Telnet.new({"Port"=>port, "Prompt"=>/[$%#>] \z|Login failed/n, "Timeout"=>30, "FailEOF"=>true})
+    end
+
+    def readline_with_history(prompt)
+      line = Readline::readline(prompt)
+      return nil if line == nil || line == 'quit' || line == 'exit'
+      Readline::HISTORY.push(line) if not line =~ /^\s*$/ and Readline::HISTORY.to_a[-1] != line
+      line
+    end
+
+    def run_console(prompt)
+      prev = trap("INT")  { |x| exit_console; prev.call(x); exit }
+      prev = trap("TERM") { |x| exit_console; prev.call(x); exit }
+      loop do
+        cmd = readline_with_history(prompt)
+        if(cmd == nil)
+          exit_console
+          break
+        end
+        prompt = send_console_command_display_results(cmd, prompt)
+      end
+    end
+
+    def exit_console
+      #TimeoutError expected, as exit doesn't return anything
+      @telnet_client.cmd("String"=>"exit","Timeout"=>1) rescue TimeoutError
+      close_console
+    end
+
+    def send_console_command_display_results(cmd, prompt)
+      begin
+        lines = send_console_command cmd
+        #Assumes the last line is a prompt
+        prompt = lines.pop
+        lines.each {|line| display line if line != cmd}
+      rescue TimeoutError
+        display "Timed out sending command to server.".red
+      rescue EOFError
+        err "The console connection has been terminated.  Perhaps the app was stopped or deleted?"
+      end
+      prompt
+    end
+
+    def initialize_readline
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters= " \t\n`><=;|&{("
+      end
+      Readline.completion_append_character = nil
+      #Assumes that sending a String ending with tab will return a non-empty
+      #String of comma-separated completion options, terminated by a new line
+      #For example, "app.\t" might result in "to_s,nil?,etc\n"
+      Readline.completion_proc = proc {|s|
+        console_tab_completion_data s
+      }
+    end
+  end
+end
 
=== modified file 'lib/cli/core_ext.rb'
--- lib/cli/core_ext.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/core_ext.rb	2012-06-13 01:37:18 +0000
@@ -38,6 +38,10 @@
     raise VMC::Cli::CliExit, "#{prefix}#{message}"
   end
 
+  def warn(msg)
+    say "#{"[WARNING]".yellow} #{msg}"
+  end
+
   def quit(message = nil)
     raise VMC::Cli::GracefulExit, message
   end
@@ -64,7 +68,6 @@
     return sprintf("%.#{prec}fM", size/(1024.0*1024.0)) if size < (1024*1024*1024)
     return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
   end
-
 end
 
 module VMCStringExtensions
 
=== modified file 'lib/cli/frameworks.rb'
--- lib/cli/frameworks.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/frameworks.rb	2012-06-13 01:37:18 +0000
@@ -6,47 +6,78 @@
     DEFAULT_MEM = '256M'
 
     FRAMEWORKS = {
-      'Rails'    => ['rails3',  { :mem => '256M', :description => 'Rails Application'}],
+      'Rails'    => ['rails3',  { :mem => '256M', :description => 'Rails Application', :console=>true}],
       'Spring'   => ['spring',  { :mem => '512M', :description => 'Java SpringSource Spring Application'}],
       'Grails'   => ['grails',  { :mem => '512M', :description => 'Java SpringSource Grails Application'}],
-      'Roo'      => ['spring',  { :mem => '512M', :description => 'Java SpringSource Roo Application'}],
-      'JavaWeb'  => ['spring',  { :mem => '512M', :description => 'Java Web Application'}],
+      'Lift'   =>   ['lift',    { :mem => '512M', :description => 'Scala Lift Application'}],
+      'JavaWeb'  => ['java_web',{ :mem => '512M', :description => 'Java Web Application'}],
+      'Standalone'     => ['standalone',    { :mem => '64M', :description => 'Standalone Application'}],
       'Sinatra'  => ['sinatra', { :mem => '128M', :description => 'Sinatra Application'}],
       'Node'     => ['node',    { :mem => '64M',  :description => 'Node.js Application'}],
+      'PHP'      => ['php',     { :mem => '128M', :description => 'PHP Application'}],
+      'Erlang/OTP Rebar' => ['otp_rebar',  { :mem => '64M',  :description => 'Erlang/OTP Rebar Application'}],
+      'WSGI'     => ['wsgi',    { :mem => '64M',  :description => 'Python WSGI Application'}],
+      'Django'   => ['django',  { :mem => '128M', :description => 'Python Django Application'}],
+      'dotNet'   => ['dotNet',  { :mem => '128M', :description => '.Net Web Application'}],
+      'Rack'     => ['rack', { :mem => '128M', :description => 'Rack Application'}],
+      'Play'     => ['play',  { :mem => '256M', :description => 'Play Framework Application'}]
     }
 
     class << self
 
-      def known_frameworks
-        FRAMEWORKS.keys
+      def known_frameworks(available_frameworks)
+        frameworks = []
+        FRAMEWORKS.each do |key,fw|
+          frameworks << key if available_frameworks.include? [fw[0]]
+        end
+        frameworks
       end
 
       def lookup(name)
-        return Framework.new(*FRAMEWORKS[name])
-      end
-
-      def detect(path)
+        return create(*FRAMEWORKS[name])
+      end
+
+      def lookup_by_framework(name)
+        FRAMEWORKS.each do |key,fw|
+          return create(fw[0],fw[1]) if fw[0] == name
+        end
+      end
+
+      def create(name,opts)
+        if name == "standalone"
+          return StandaloneFramework.new(name, opts)
+        else
+          return Framework.new(name,opts)
+        end
+      end
+
+      def detect(path, available_frameworks)
+        if !File.directory? path
+          if path.end_with?('.war')
+            return detect_framework_from_war path
+          elsif path.end_with?('.zip')
+            return detect_framework_from_zip path, available_frameworks
+          elsif available_frameworks.include?(["standalone"])
+            return Framework.lookup('Standalone')
+          else
+            return nil
+          end
+        end
         Dir.chdir(path) do
-
           # Rails
           if File.exist?('config/environment.rb')
             return Framework.lookup('Rails')
 
-          # Java
+          # Rack
+          elsif File.exist?('config.ru') && available_frameworks.include?(["rack"])
+            return Framework.lookup('Rack')
+
+          # Java Web Apps
           elsif Dir.glob('*.war').first
-            war_file = Dir.glob('*.war').first
-            contents = ZipUtil.entry_lines(war_file)
+            return detect_framework_from_war(Dir.glob('*.war').first)
 
-            # Spring Variations
-            if contents =~ /WEB-INF\/lib\/grails-web.*\.jar/
-              return Framework.lookup('Grails')
-            elsif contents =~ /WEB-INF\/classes\/org\/springframework/
-              return Framework.lookup('Spring')
-            elsif contents =~ /WEB-INF\/lib\/spring-core.*\.jar/
-              return Framework.lookup('Spring')
-            else
-              return Framework.lookup('JavaWeb')
-            end
+          elsif File.exist?('WEB-INF/web.xml')
+            return detect_framework_from_war
 
           # Simple Ruby Apps
           elsif !Dir.glob('*.rb').empty?
@@ -55,43 +86,180 @@
               next if matched_file
               File.open(fname, 'r') do |f|
                 str = f.read # This might want to be limited
-                matched_file = fname if (str && str.match(/^\s*require\s*['"]sinatra['"]/))
+                matched_file = fname if (str && str.match(/^\s*require[\s\(]*['"]sinatra['"]/))
               end
             end
             if matched_file
+              # Sinatra apps
               f = Framework.lookup('Sinatra')
               f.exec = "ruby #{matched_file}"
               return f
             end
 
+          # PHP
+          elsif !Dir.glob('*.php').empty?
+            return Framework.lookup('PHP')
+
+          # Erlang/OTP using Rebar
+          elsif !Dir.glob('releases/*/*.rel').empty? && !Dir.glob('releases/*/*.boot').empty?
+            return Framework.lookup('Erlang/OTP Rebar')
+
+          # Python Django
+          # XXX: not all django projects keep settings.py in top-level directory
+          elsif File.exist?('manage.py') && File.exist?('settings.py')
+            return Framework.lookup('Django')
+
+          # Python
+          elsif !Dir.glob('wsgi.py').empty?
+            return Framework.lookup('WSGI')
+
+          # .Net
+          elsif !Dir.glob('web.config').empty?
+            return Framework.lookup('dotNet')
+
           # Node.js
           elsif !Dir.glob('*.js').empty?
-            # Fixme, make other files work too..
-            if File.exist?('app.js') || File.exist?('index.js') || File.exist?('main.js')
+            if File.exist?('server.js') || File.exist?('app.js') || File.exist?('index.js') || File.exist?('main.js')
               return Framework.lookup('Node')
             end
+
+          # Play or Standalone Apps
+          elsif Dir.glob('*.zip').first
+            zip_file = Dir.glob('*.zip').first
+            return detect_framework_from_zip zip_file, available_frameworks
           end
-        end
-        nil
-      end
-
+
+          # Default to Standalone if no other match was made
+          return Framework.lookup('Standalone') if available_frameworks.include?(["standalone"])
+        end
+      end
+
+      def detect_framework_from_war(war_file=nil)
+        if war_file
+          contents = ZipUtil.entry_lines(war_file)
+        else
+          #assume we are working with current dir
+          contents = Dir['**/*'].join("\n")
+        end
+
+        # Spring/Lift Variations
+        if contents =~ /WEB-INF\/lib\/grails-web.*\.jar/
+          return Framework.lookup('Grails')
+        elsif contents =~ /WEB-INF\/lib\/lift-webkit.*\.jar/
+          return Framework.lookup('Lift')
+        elsif contents =~ /WEB-INF\/classes\/org\/springframework/
+          return Framework.lookup('Spring')
+        elsif contents =~ /WEB-INF\/lib\/spring-core.*\.jar/
+          return Framework.lookup('Spring')
+        elsif contents =~ /WEB-INF\/lib\/org\.springframework\.core.*\.jar/
+          return Framework.lookup('Spring')
+        else
+          return Framework.lookup('JavaWeb')
+        end
+      end
+
+      def detect_framework_from_zip(zip_file, available_frameworks)
+        contents = ZipUtil.entry_lines(zip_file)
+        detect_framework_from_zip_contents(contents, available_frameworks)
+      end
+
+      def detect_framework_from_zip_contents(contents, available_frameworks)
+        if available_frameworks.include?(["play"]) && contents =~ /lib\/play\..*\.jar/
+          return Framework.lookup('Play')
+        elsif available_frameworks.include?(["standalone"])
+          return Framework.lookup('Standalone')
+        end
+      end
     end
 
-    attr_reader   :name, :description, :memory
+    attr_reader   :name, :description, :console
     attr_accessor :exec
 
-    alias :mem :memory
-
     def initialize(framework=nil, opts={})
       @name = framework || DEFAULT_FRAMEWORK
       @memory = opts[:mem] || DEFAULT_MEM
       @description = opts[:description] || 'Unknown Application Type'
       @exec = opts[:exec]
+      @console = opts[:console] || false
     end
 
     def to_s
       description
     end
+
+    def require_url?
+      true
+    end
+
+    def require_start_command?
+      false
+    end
+
+    def prompt_for_runtime?
+      false
+    end
+
+    def default_runtime(path)
+      nil
+    end
+
+    def memory(runtime=nil)
+      @memory
+    end
+
+    alias :mem :memory
+  end
+
+  class StandaloneFramework < Framework
+    def require_url?
+      false
+    end
+
+    def require_start_command?
+      true
+    end
+
+    def prompt_for_runtime?
+      true
+    end
+
+    def default_runtime(path)
+      if !File.directory? path
+        if path =~ /\.(jar|class)$/
+          return "java"
+        elsif path =~ /\.(rb)$/
+          return "ruby18"
+        elsif path =~ /\.(zip)$/
+          return detect_runtime_from_zip path
+        end
+      else
+        Dir.chdir(path) do
+          return "ruby18" if not Dir.glob('**/*.rb').empty?
+          if !Dir.glob('**/*.class').empty? || !Dir.glob('**/*.jar').empty?
+            return "java"
+          elsif Dir.glob('*.zip').first
+            zip_file = Dir.glob('*.zip').first
+            return detect_runtime_from_zip zip_file
+          end
+        end
+      end
+      return nil
+    end
+
+    def memory(runtime=nil)
+      default_mem = @memory
+      default_mem = '128M' if runtime =~ /\Aruby/ || runtime == "php"
+      default_mem = '512M' if runtime == "java" || runtime == "java7"
+      default_mem
+    end
+
+    private
+    def detect_runtime_from_zip(zip_file)
+      contents = ZipUtil.entry_lines(zip_file)
+      if contents =~ /\.(jar)$/
+        return "java"
+      end
+    end
   end
 
 end
 
=== added file 'lib/cli/manifest_helper.rb'
--- lib/cli/manifest_helper.rb	1970-01-01 00:00:00 +0000
+++ lib/cli/manifest_helper.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,302 @@
+require "set"
+
+module VMC::Cli::ManifestHelper
+  include VMC::Cli::ServicesHelper
+
+  DEFAULTS = {
+    "url" => "${name}.${target-base}",
+    "mem" => "128M",
+    "instances" => 1
+  }
+
+  MANIFEST = "manifest.yml"
+
+  YES_SET = Set.new(["y", "Y", "yes", "YES"])
+
+  # take a block and call it once for each app to push/update.
+  # with @application and @app_info set appropriately
+  def each_app(panic=true)
+    if @manifest and all_apps = @manifest["applications"]
+      where = File.expand_path(@path)
+      single = false
+
+      all_apps.each do |path, info|
+        app = File.expand_path("../" + path, manifest_file)
+        if where.start_with?(app)
+          @application = app
+          @app_info = info
+          yield info["name"]
+          single = true
+          break
+        end
+      end
+
+      unless single
+        if where == File.expand_path("../", manifest_file)
+          ordered_by_deps(all_apps).each do |path, info|
+            app = File.expand_path("../" + path, manifest_file)
+            @application = app
+            @app_info = info
+            yield info["name"]
+          end
+        else
+          err "Path '#{@path}' is not known to manifest '#{manifest_file}'."
+        end
+      end
+    else
+      @application = @path
+      @app_info = @manifest
+      if @app_info
+        yield @app_info["name"]
+      elsif panic
+        err "No applications."
+      end
+    end
+
+    nil
+  ensure
+    @application = nil
+    @app_info = nil
+  end
+
+  def interact(many=false)
+    @manifest ||= {}
+    configure_app(many)
+  end
+
+  def target_manifest
+    @options[:manifest] || MANIFEST
+  end
+
+  def save_manifest(save_to = nil)
+    save_to ||= target_manifest
+
+    File.open(save_to, "w") do |f|
+      f.write @manifest.to_yaml
+    end
+
+    say "Manifest written to #{save_to}."
+  end
+
+  def configure_app(many=false)
+    name = manifest("name") ||
+      set(ask("Application Name", :default => manifest("name")), "name")
+
+
+
+    if manifest "framework"
+      framework = VMC::Cli::Framework.lookup_by_framework manifest("framework","name")
+    else
+      framework = detect_framework
+      set framework.name, "framework", "name"
+      set(
+        { "mem" => framework.mem,
+          "description" => framework.description,
+          "exec" => framework.exec
+        },
+        "framework",
+        "info"
+      )
+    end
+
+    default_runtime = manifest "runtime"
+    if not default_runtime
+      default_runtime = framework.default_runtime(@application)
+      set(detect_runtime(default_runtime), "runtime") if framework.prompt_for_runtime?
+    end
+    default_command = manifest "command"
+    set ask("Start Command", :default => default_command), "command" if framework.require_start_command?
+
+    url_template = manifest("url") || DEFAULTS["url"]
+    url_resolved = url_template.dup
+    resolve_lexically(url_resolved)
+
+    if !framework.require_url?
+      url_resolved = "None"
+    end
+    url = ask("Application Deployed URL", :default => url_resolved)
+
+    if url == url_resolved && url != "None"
+      url = url_template
+    end
+
+    # common error case is for prompted users to answer y or Y or yes or
+    # YES to this ask() resulting in an unintended URL of y. Special
+    # case this common error
+    url = url_resolved if YES_SET.member? url
+
+    if(url == "None")
+      url = nil
+    end
+
+    set url, "url"
+
+    default_mem = manifest("mem")
+    default_mem = framework.memory(manifest("runtime")) if not default_mem
+    set ask(
+      "Memory reservation",
+      :default =>
+          default_mem ||
+          DEFAULTS["mem"],
+      :choices => ["128M", "256M", "512M", "1G", "2G"]
+    ), "mem"
+
+    set ask(
+      "How many instances?",
+      :default => manifest("instances") || DEFAULTS["instances"]
+    ), "instances"
+
+    unless manifest "services"
+      user_services = client.services
+      user_services.sort! {|a, b| a[:name] <=> b[:name] }
+
+      unless user_services.empty?
+        if ask "Bind existing services to '#{name}'?", :default => false
+          bind_services(user_services)
+        end
+      end
+
+      services = client.services_info
+      unless services.empty?
+        if ask "Create services to bind to '#{name}'?", :default => false
+          create_services(services.values.collect(&:keys).flatten)
+        end
+      end
+    end
+
+    if many and ask("Configure for another application?", :default => false)
+      @application = ask "Application path?"
+      configure_app
+    end
+  end
+
+  def set(what, *where)
+    where.unshift "applications", @application
+
+    which = @manifest
+    where.each_with_index do |k, i|
+      if i + 1 == where.size
+        which[k] = what
+      else
+        which = (which[k] ||= {})
+      end
+    end
+
+    what
+  end
+
+  # Detect the appropriate framework.
+  def detect_framework(prompt_ok = true)
+    framework = VMC::Cli::Framework.detect(@application, frameworks_info)
+    framework_correct = ask("Detected a #{framework}, is this correct?", :default => true) if prompt_ok && framework
+    if prompt_ok && (framework.nil? || !framework_correct)
+      display "#{"[WARNING]".yellow} Can't determine the Application Type." unless framework
+      framework = nil if !framework_correct
+      framework = VMC::Cli::Framework.lookup(
+        ask(
+          "Select Application Type",
+          :indexed => true,
+          :default => framework,
+          :choices => VMC::Cli::Framework.known_frameworks(frameworks_info)
+        )
+      )
+      display "Selected #{framework}"
+    end
+
+    framework
+  end
+
+  # Detect the appropriate runtime.
+  def detect_runtime(default, prompt_ok=true)
+    runtime = nil
+    runtime_keys=[]
+    runtimes_info.keys.each {|runtime_key| runtime_keys << runtime_key.dup }
+    runtime_keys.sort!
+    if prompt_ok
+      runtime =  ask(
+          "Select Runtime",
+          :indexed => true,
+          :default => default,
+          :choices => runtime_keys
+      )
+      display "Selected #{runtime}"
+    end
+    runtime
+  end
+
+  def bind_services(user_services, chosen = 0)
+    svcname = ask(
+      "Which one?",
+      :indexed => true,
+      :choices => user_services.collect { |p| p[:name] })
+
+    svc = user_services.find { |p| p[:name] == svcname }
+
+    set svc[:vendor], "services", svcname, "type"
+
+    if chosen + 1 < user_services.size && ask("Bind another?", :default => false)
+      bind_services(user_services, chosen + 1)
+    end
+  end
+
+  def create_services(services)
+    svcs = services.collect(&:to_s).sort!
+
+    configure_service(
+      ask(
+        "What kind of service?",
+        :indexed => true,
+        :choices => svcs
+      )
+    )
+
+    if ask "Create another?", :default => false
+      create_services(services)
+    end
+  end
+
+  def configure_service(vendor)
+    default_name = random_service_name(vendor)
+    name = ask "Specify the name of the service", :default => default_name
+
+    set vendor, "services", name, "type"
+  end
+
+  private
+    def ordered_by_deps(apps, abspaths = nil, processed = Set[])
+      unless abspaths
+        abspaths = {}
+        apps.each do |p, i|
+          ep = File.expand_path("../" + p, manifest_file)
+          abspaths[ep] = i
+        end
+      end
+
+      ordered = []
+      apps.each do |path, info|
+        epath = File.expand_path("../" + path, manifest_file)
+
+        if deps = info["depends-on"]
+          dep_apps = {}
+          deps.each do |dep|
+            edep = File.expand_path("../" + dep, manifest_file)
+
+            err "Circular dependency detected." if processed.include? edep
+
+            dep_apps[dep] = abspaths[edep]
+          end
+
+          processed.add(epath)
+
+          ordered += ordered_by_deps(dep_apps, abspaths, processed)
+          ordered << [path, info]
+        elsif not processed.include? epath
+          ordered << [path, info]
+          processed.add(epath)
+        end
+      end
+
+      ordered
+    end
+
+end
 
=== modified file 'lib/cli/runner.rb'
--- lib/cli/runner.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/runner.rb	2012-06-13 01:37:18 +0000
@@ -31,6 +31,7 @@
       opts.on('--passwd PASS')     { |pass|  @options[:password] = pass }
       opts.on('--pass PASS')       { |pass|  @options[:password] = pass }
       opts.on('--password PASS')   { |pass|  @options[:password] = pass }
+      opts.on('--token-file TOKEN_FILE')     { |token_file|  @options[:token_file] = token_file }
       opts.on('--app NAME')        { |name|  @options[:name] = name }
       opts.on('--name NAME')       { |name|  @options[:name] = name }
       opts.on('--bind BIND')       { |bind|  @options[:bind] = bind }
@@ -48,8 +49,21 @@
       opts.on('-t [TKEY]')         { |tkey|  @options[:trace] = tkey || true }
       opts.on('--trace [TKEY]')    { |tkey|  @options[:trace] = tkey || true }
 
+      # start application in debug mode
+      opts.on('-d [MODE]')         { |mode|  @options[:debug] = mode || "run" }
+      opts.on('--debug [MODE]')    { |mode|  @options[:debug] = mode || "run" }
+
+      # override manifest file
+      opts.on('-m FILE')           { |file|  @options[:manifest] = file }
+      opts.on('--manifest FILE')   { |file|  @options[:manifest] = file }
+
       opts.on('-q', '--quiet')     {         @options[:quiet] = true }
 
+      # micro cloud options
+      opts.on('--vmx FILE')        { |file|  @options[:vmx] = file }
+      opts.on('--vmrun FILE')      { |file|  @options[:vmrun] = file }
+      opts.on('--save')            {         @options[:save] = true }
+
       # Don't use builtin zip
       opts.on('--no-zip')          {         @options[:nozip] = true }
       opts.on('--nozip')           {         @options[:nozip] = true }
@@ -73,6 +87,8 @@
       opts.on('-v', '--version')   {         set_cmd(:misc, :version) }
       opts.on('-h', '--help')      {         puts "#{command_usage}\n"; exit }
 
+      opts.on('--port PORT')       { |port|  @options[:port] = port }
+
       opts.on('--runtime RUNTIME') { |rt|    @options[:runtime] = rt }
 
       # deprecated
@@ -107,7 +123,6 @@
   def convert_options!
     # make sure certain options are valid and in correct form.
     @options[:instances] = Integer(@options[:instances]) if @options[:instances]
-    @options[:instance] = Integer(@options[:instance]) if @options[:instance]
   end
 
   def set_cmd(namespace, action, args_range=0)
@@ -204,6 +219,10 @@
       usage('vmc delete-user <user>')
       set_cmd(:admin, :delete_user, 1)
 
+    when 'users'
+      usage('vmc users')
+      set_cmd(:admin, :users)
+
     when 'apps'
       usage('vmc apps')
       set_cmd(:apps, :apps)
@@ -214,19 +233,15 @@
 
     when 'start'
       usage('vmc start <appname>')
-      set_cmd(:apps, :start, 1)
+      set_cmd(:apps, :start, @args.size == 1 ? 1 : 0)
 
     when 'stop'
       usage('vmc stop <appname>')
-      set_cmd(:apps, :stop, 1)
+      set_cmd(:apps, :stop, @args.size == 1 ? 1 : 0)
 
     when 'restart'
       usage('vmc restart <appname>')
-      set_cmd(:apps, :restart, 1)
-
-    when 'rename'
-      usage('vmc rename <appname> <newname>')
-      set_cmd(:apps, :rename, 2)
+      set_cmd(:apps, :restart, @args.size == 1 ? 1 : 0)
 
     when 'mem'
       usage('vmc mem <appname> [memsize]')
@@ -238,7 +253,7 @@
 
     when 'stats'
       usage('vmc stats <appname>')
-      set_cmd(:apps, :stats, 1)
+      set_cmd(:apps, :stats, @args.size == 1 ? 1 : 0)
 
     when 'map'
       usage('vmc map <appname> <url>')
@@ -269,12 +284,12 @@
       set_cmd(:apps, :logs, 1)
 
     when 'instances', 'scale'
-      if @args.size == 1
+      if @args.size > 1
+        usage('vmc instances <appname> <num|delta>')
+        set_cmd(:apps, :instances, 2)
+      else
         usage('vmc instances <appname>')
         set_cmd(:apps, :instances, 1)
-      else
-        usage('vmc instances <appname> <num|delta>')
-        set_cmd(:apps, :instances, 2)
       end
 
     when 'crashes'
@@ -286,7 +301,7 @@
       set_cmd(:apps, :crashlogs, 1)
 
     when 'push'
-      usage('vmc push [appname] [--path PATH] [--url URL] [--instances N] [--mem] [--no-start]')
+      usage('vmc push [appname] [--path PATH] [--url URL] [--instances N] [--mem] [--runtime RUNTIME] [--no-start]')
       if @args.size == 1
         set_cmd(:apps, :push, 1)
       else
@@ -295,7 +310,7 @@
 
     when 'update'
       usage('vmc update <appname> [--path PATH]')
-      set_cmd(:apps, :update, 1)
+      set_cmd(:apps, :update, @args.size == 1 ? 1 : 0)
 
     when 'services'
       usage('vmc services')
@@ -360,6 +375,22 @@
       usage('vmc unalias <alias>')
       set_cmd(:misc, :unalias, 1)
 
+    when 'tunnel'
+      usage('vmc tunnel [servicename] [clientcmd] [--port port]')
+      set_cmd(:services, :tunnel, 0) if @args.size == 0
+      set_cmd(:services, :tunnel, 1) if @args.size == 1
+      set_cmd(:services, :tunnel, 2) if @args.size == 2
+
+    when 'rails-console'
+      usage('vmc rails-console <appname>')
+      set_cmd(:apps, :console, 1)
+
+    when 'micro'
+      usage('vmc micro <online|offline|status> [--password password] [--save] [--vmx file] [--vmrun executable]')
+      if %w[online offline status].include?(@args[0])
+          set_cmd(:micro, @args[0].to_sym, 1)
+      end
+
     when 'help'
       display_help if @args.size == 0
       @help_only = true
@@ -374,6 +405,14 @@
       @args = @args.unshift('--options')
       parse_options!
 
+    when 'manifest'
+      usage('vmc manifest')
+      set_cmd(:manifest, :edit)
+
+    when 'extend-manifest'
+      usage('vmc extend-manifest')
+      set_cmd(:manifest, :extend, 1)
+
     else
       if verb
         display "vmc: Unknown command [#{verb}]"
@@ -407,8 +446,7 @@
 
   def run
 
-    trap('TERM') { print "\nInterrupted\n"; exit(false)}
-    trap('INT')  { print "\nInterrupted\n"; exit(false)}
+    trap('TERM') { print "\nTerminated\n"; exit(false)}
 
     parse_options!
 
@@ -423,7 +461,8 @@
     parse_command!
 
     if @namespace && @action
-      eval("VMC::Cli::Command::#{@namespace.to_s.capitalize}").new(@options).send(@action.to_sym, *@args)
+      cmd = VMC::Cli::Command.const_get(@namespace.to_s.capitalize)
+      cmd.new(@options).send(@action, *@args.collect(&:dup))
     elsif @help_only || @usage
       display_usage
     else
@@ -432,6 +471,10 @@
     end
 
   rescue OptionParser::InvalidOption => e
+    puts(e.message.red)
+    puts("\n")
+    puts(basic_usage)
+    @exit_status = false
   rescue OptionParser::AmbiguousOption => e
     puts(e.message.red)
     puts("\n")
@@ -464,7 +507,10 @@
     puts e.message.red
     puts e.backtrace
     @exit_status = false
-  rescue => e
+  rescue Interrupt => e
+    say("\nInterrupted".red)
+    @exit_status = false
+  rescue Exception => e
     puts e.message.red
     puts e.backtrace
     @exit_status = false
 
=== modified file 'lib/cli/services_helper.rb'
--- lib/cli/services_helper.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/services_helper.rb	2012-06-13 01:37:18 +0000
@@ -8,15 +8,19 @@
 
       return display "No system services available" if services.empty?
 
+      displayed_services = []
+      services.each do |service_type, value|
+        value.each do |vendor, version|
+          version.each do |version_str, service|
+            displayed_services << [ vendor, version_str, service[:description] ]
+          end
+        end
+      end
+      displayed_services.sort! { |a, b| a.first.to_s <=> b.first.to_s}
+
       services_table = table do |t|
         t.headings = 'Service', 'Version', 'Description'
-        services.each do |service_type, value|
-          value.each do |vendor, version|
-            version.each do |version_str, service|
-              t << [ vendor, version_str, service[:description] ]
-            end
-          end
-        end
+        displayed_services.each { |s| t << s }
       end
       display services_table
     end
@@ -46,19 +50,25 @@
     end
 
     def bind_service_banner(service, appname, check_restart=true)
-      display "Binding Service: ", false
+      display "Binding Service [#{service}]: ", false
       client.bind_service(service, appname)
       display 'OK'.green
       check_app_for_restart(appname) if check_restart
     end
 
     def unbind_service_banner(service, appname, check_restart=true)
-      display "Unbinding Service: ", false
+      display "Unbinding Service [#{service}]: ", false
       client.unbind_service(service, appname)
       display 'OK'.green
       check_app_for_restart(appname) if check_restart
     end
 
+    def delete_service_banner(service)
+      display "Deleting service [#{service}]: ", false
+      client.delete_service(service)
+      display 'OK'.green
+    end
+
     def random_service_name(service)
       r = "%04x" % [rand(0x0100000)]
       "#{service.to_s}-#{r}"
 
=== added file 'lib/cli/tunnel_helper.rb'
--- lib/cli/tunnel_helper.rb	1970-01-01 00:00:00 +0000
+++ lib/cli/tunnel_helper.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,332 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'addressable/uri'
+
+begin
+  require 'caldecott'
+rescue LoadError
+end
+
+module VMC::Cli
+  module TunnelHelper
+    PORT_RANGE = 10
+
+    HELPER_APP = File.expand_path("../../../caldecott_helper", __FILE__)
+
+    # bump this AND the version info reported by HELPER_APP/server.rb
+    # this is to keep the helper in sync with any updates here
+    HELPER_VERSION = '0.0.4'
+
+    def tunnel_uniquename
+      random_service_name(tunnel_appname)
+    end
+
+    def tunnel_appname
+      "caldecott"
+    end
+
+    def tunnel_app_info
+      return @tun_app_info if @tunnel_app_info
+      begin
+        @tun_app_info = client.app_info(tunnel_appname)
+      rescue => e
+        @tun_app_info = nil
+      end
+    end
+
+    def tunnel_auth
+      tunnel_app_info[:env].each do |e|
+        name, val = e.split("=", 2)
+        return val if name == "CALDECOTT_AUTH"
+      end
+      nil
+    end
+
+    def tunnel_url
+      return @tunnel_url if @tunnel_url
+
+      tun_url = tunnel_app_info[:uris][0]
+
+      ["https", "http"].each do |scheme|
+        url = "#{scheme}://#{tun_url}"
+        begin
+          RestClient.get(url)
+
+        # https failed
+        rescue Errno::ECONNREFUSED
+
+        # we expect a 404 since this request isn't auth'd
+        rescue RestClient::ResourceNotFound
+          return @tunnel_url = url
+        end
+      end
+
+      err "Cannot determine URL for #{tun_url}"
+    end
+
+    def invalidate_tunnel_app_info
+      @tunnel_url = nil
+      @tunnel_app_info = nil
+    end
+
+    def tunnel_pushed?
+      not tunnel_app_info.nil?
+    end
+
+    def tunnel_healthy?(token)
+      return false unless tunnel_app_info[:state] == 'STARTED'
+
+      begin
+        response = RestClient.get(
+          "#{tunnel_url}/info",
+          "Auth-Token" => token
+        )
+
+        info = JSON.parse(response)
+        if info["version"] == HELPER_VERSION
+          true
+        else
+          stop_caldecott
+          false
+        end
+      rescue RestClient::Exception
+        stop_caldecott
+        false
+      end
+    end
+
+    def tunnel_bound?(service)
+      tunnel_app_info[:services].include?(service)
+    end
+
+    def tunnel_connection_info(type, service, token)
+      display "Getting tunnel connection info: ", false
+      response = nil
+      10.times do
+        begin
+          response = RestClient.get(tunnel_url + "/" + VMC::Client.path("services", service), "Auth-Token" => token)
+          break
+        rescue RestClient::Exception
+          sleep 1
+        end
+
+        display ".", false
+      end
+
+      unless response
+        err "Expected remote tunnel to know about #{service}, but it doesn't"
+      end
+
+      display "OK".green
+
+      info = JSON.parse(response)
+      case type
+      when "rabbitmq"
+        uri = Addressable::URI.parse info["url"]
+        info["hostname"] = uri.host
+        info["port"] = uri.port
+        info["vhost"] = uri.path[1..-1]
+        info["user"] = uri.user
+        info["password"] = uri.password
+        info.delete "url"
+
+      # we use "db" as the "name" for mongo
+      # existing "name" is junk
+      when "mongodb"
+        info["name"] = info["db"]
+        info.delete "db"
+
+      # our "name" is irrelevant for redis
+      when "redis"
+        info.delete "name"
+      end
+
+      ['hostname', 'port', 'password'].each do |k|
+        err "Could not determine #{k} for #{service}" if info[k].nil?
+      end
+
+      info
+    end
+
+    def display_tunnel_connection_info(info)
+      display ''
+      display "Service connection info: "
+
+      to_show = [nil, nil, nil] # reserved for user, pass, db name
+      info.keys.each do |k|
+        case k
+        when "host", "hostname", "port", "node_id"
+          # skip
+        when "user", "username"
+          # prefer "username" over "user"
+          to_show[0] = k unless to_show[0] == "username"
+        when "password"
+          to_show[1] = k
+        when "name"
+          to_show[2] = k
+        else
+          to_show << k
+        end
+      end
+      to_show.compact!
+
+      align_len = to_show.collect(&:size).max + 1
+
+      to_show.each do |k|
+        # TODO: modify the server services rest call to have explicit knowledge
+        # about the items to return.  It should return all of them if
+        # the service is unknown so that we don't have to do this weird
+        # filtering.
+        display "  #{k.ljust align_len}: ", false
+        display "#{info[k]}".yellow
+      end
+      display ''
+    end
+
+    def start_tunnel(local_port, conn_info, auth)
+      @local_tunnel_thread = Thread.new do
+        Caldecott::Client.start({
+          :local_port => local_port,
+          :tun_url => tunnel_url,
+          :dst_host => conn_info['hostname'],
+          :dst_port => conn_info['port'],
+          :log_file => STDOUT,
+          :log_level => ENV["VMC_TUNNEL_DEBUG"] || "ERROR",
+          :auth_token => auth,
+          :quiet => true
+        })
+      end
+
+      at_exit { @local_tunnel_thread.kill }
+    end
+
+
+
+    def pick_tunnel_port(port)
+      original = port
+
+      PORT_RANGE.times do |n|
+        begin
+          TCPSocket.open('localhost', port)
+          port += 1
+        rescue
+          return port
+        end
+      end
+
+      grab_ephemeral_port
+    end
+
+    def grab_ephemeral_port
+      socket = TCPServer.new('0.0.0.0', 0)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      Socket.do_not_reverse_lookup = true
+      port = socket.addr[1]
+      socket.close
+      return port
+    end
+
+    def wait_for_tunnel_start(port)
+      10.times do |n|
+        begin
+          client = TCPSocket.open('localhost', port)
+          display '' if n > 0
+          client.close
+          return true
+        rescue => e
+          display "Waiting for local tunnel to become available", false if n == 0
+          display '.', false
+          sleep 1
+        end
+      end
+      err "Could not connect to local tunnel."
+    end
+
+    def wait_for_tunnel_end
+      display "Open another shell to run command-line clients or"
+      display "use a UI tool to connect using the displayed information."
+      display "Press Ctrl-C to exit..."
+      @local_tunnel_thread.join
+    end
+
+    def resolve_symbols(str, info, local_port)
+      str.gsub(/\$\{\s*([^\}]+)\s*\}/) do
+        case $1
+        when "host"
+          # TODO: determine proper host
+          "localhost"
+        when "port"
+          local_port
+        when "user", "username"
+          info["username"]
+        else
+          info[$1] || ask($1)
+        end
+      end
+    end
+
+    def start_local_prog(clients, command, info, port)
+      client = clients[File.basename(command)]
+
+      cmdline = "#{command} "
+
+      case client
+      when Hash
+        cmdline << resolve_symbols(client["command"], info, port)
+        client["environment"].each do |e|
+          if e =~ /([^=]+)=(["']?)([^"']*)\2/
+            ENV[$1] = resolve_symbols($3, info, port)
+          else
+            err "Invalid environment variable: #{e}"
+          end
+        end
+      when String
+        cmdline << resolve_symbols(client, info, port)
+      else
+        err "Unknown client info: #{client.inspect}."
+      end
+
+      display "Launching '#{cmdline}'"
+      display ''
+
+      system(cmdline)
+    end
+
+    def push_caldecott(token)
+      client.create_app(
+        tunnel_appname,
+        { :name => tunnel_appname,
+          :staging => {:framework => "sinatra"},
+          :uris => ["#{tunnel_uniquename}.#{target_base}"],
+          :instances => 1,
+          :resources => {:memory => 64},
+          :env => ["CALDECOTT_AUTH=#{token}"]
+        }
+      )
+
+      apps_cmd.send(:upload_app_bits, tunnel_appname, HELPER_APP)
+
+      invalidate_tunnel_app_info
+    end
+
+    def stop_caldecott
+      apps_cmd.stop(tunnel_appname)
+
+      invalidate_tunnel_app_info
+    end
+
+    def start_caldecott
+      apps_cmd.start(tunnel_appname)
+
+      invalidate_tunnel_app_info
+    end
+
+    private
+
+    def apps_cmd
+      a = Command::Apps.new(@options)
+      a.client client
+      a
+    end
+  end
+end
 
=== modified file 'lib/cli/usage.rb'
--- lib/cli/usage.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/usage.rb	2012-06-13 01:37:18 +0000
@@ -38,17 +38,18 @@
     push [appname] --url                         Set the url for the application
     push [appname] --instances <N>               Set the expected number <N> of instances
     push [appname] --mem M                       Set the memory reservation for the application
+    push [appname] --runtime RUNTIME             Set the runtime to use for the application
+    push [appname] --debug [MODE]                Push application and start in a debug mode
     push [appname] --no-start                    Do not auto-start the application
 
   Application Operations
-    start <appname>                              Start the application
+    start <appname> [--debug [MODE]]             Start the application
     stop  <appname>                              Stop the application
-    restart <appname>                            Restart the application
+    restart <appname> [--debug [MODE]]           Restart the application
     delete <appname>                             Delete the application
-    rename <appname> <newname>                   Rename the application
 
   Application Updates
-    update <appname> [--path]                    Update the application bits
+    update <appname> [--path,--debug [MODE]]     Update the application bits
     mem <appname> [memsize]                      Update the memory reservation for an application
     map <appname> <url>                          Register the application to the url
     unmap <appname> <url>                        Unregister the application from the url
@@ -76,6 +77,8 @@
     bind-service <servicename> <appname>         Bind a service to an application
     unbind-service <servicename> <appname>       Unbind service from the application
     clone-services <src-app> <dest-app>          Clone service bindings from <src-app> application to <dest-app>
+    tunnel <servicename> [--port]                Create a local tunnel to a service
+    tunnel <servicename> <clientcmd>             Create a local tunnel to a service and start a local client
 
   Administration
     user                                         Display user account information
@@ -88,6 +91,15 @@
     runtimes                                     Display the supported runtimes of the target system
     frameworks                                   Display the recognized frameworks of the target system
 
+  Micro Cloud Foundry
+    micro status                                 Display Micro Cloud Foundry VM status
+    micro offline                                Configure Micro Cloud Foundry VM for offline mode
+    micro online                                 Configure Micro Cloud Foundry VM for online mode
+      [--vmx file]                               Path to micro.vmx
+      [--vmrun executable]                       Path to vmrun executable
+      [--password cleartext]                     Cleartext password for guest VM vcap user
+      [--save]                                   Save cleartext password in ~/.vmc_micro
+
   Misc
     aliases                                      List aliases
     alias <alias[=]command>                      Create an alias for a command
 
=== modified file 'lib/cli/version.rb'
--- lib/cli/version.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/version.rb	2012-06-13 01:37:18 +0000
@@ -2,6 +2,6 @@
   module Cli
     # This version number is used as the RubyGem release version.
     # The internal VMC version number is VMC::VERSION.
-    VERSION = '0.3.10'
+    VERSION = '0.3.18'
   end
 end
 
=== modified file 'lib/cli/zip_util.rb'
--- lib/cli/zip_util.rb	2011-06-17 13:38:56 +0000
+++ lib/cli/zip_util.rb	2012-06-13 01:37:18 +0000
@@ -10,7 +10,7 @@
     class << self
 
       def to_dev_null
-        if !!RUBY_PLATFORM['mingw'] || !!RUBY_PLATFORM['mswin32'] || !!RUBY_PLATFORM['cygwin']
+        if WINDOWS
           'nul'
         else
           '/dev/null'
 
=== modified file 'lib/vmc/client.rb'
--- lib/vmc/client.rb	2011-06-17 13:38:56 +0000
+++ lib/vmc/client.rb	2012-06-13 01:37:18 +0000
@@ -11,6 +11,7 @@
 
 require 'rubygems'
 require 'json/pure'
+require 'open-uri'
 
 require File.expand_path('../const', __FILE__)
 
@@ -24,7 +25,7 @@
   attr_accessor :trace
 
   # Error codes
-  VMC_HTTP_ERROR_CODES = [ 400, 403, 404, 500 ]
+  VMC_HTTP_ERROR_CODES = [ 400, 500 ]
 
   # Errors
   class BadTarget <  RuntimeError; end
@@ -38,7 +39,7 @@
   def initialize(target_url=VMC::DEFAULT_TARGET, auth_token=nil)
     target_url = "http://#{target_url}" unless /^https?/ =~ target_url
     target_url = target_url.gsub(/\/+$/, '')
-    @target =  target_url
+    @target = target_url
     @auth_token = auth_token
   end
 
@@ -59,7 +60,11 @@
   # Global listing of services that are available on the target system
   def services_info
     check_login_status
-    json_get(VMC::GLOBAL_SERVICES_PATH)
+    json_get(path(VMC::GLOBAL_SERVICES_PATH))
+  end
+
+  def runtimes_info
+    json_get(path(VMC::GLOBAL_RUNTIMES_PATH))
   end
 
   ######################################################
@@ -81,7 +86,7 @@
 
   def update_app(name, manifest)
     check_login_status
-    json_put("#{VMC::APPS_PATH}/#{name}", manifest)
+    json_put(path(VMC::APPS_PATH, name), manifest)
   end
 
   def upload_app(name, zipfile, resource_manifest=nil)
@@ -98,27 +103,29 @@
       upload_data[:application] = file
     end
     upload_data[:resources] = resource_manifest.to_json if resource_manifest
-    http_post("#{VMC::APPS_PATH}/#{name}/application", upload_data)
+    http_post(path(VMC::APPS_PATH, name, "application"), upload_data)
+  rescue RestClient::ServerBrokeConnection
+    retry
   end
 
   def delete_app(name)
     check_login_status
-    http_delete("#{VMC::APPS_PATH}/#{name}")
+    http_delete(path(VMC::APPS_PATH, name))
   end
 
   def app_info(name)
     check_login_status
-    json_get("#{VMC::APPS_PATH}/#{name}")
+    json_get(path(VMC::APPS_PATH, name))
   end
 
   def app_update_info(name)
     check_login_status
-    json_get("#{VMC::APPS_PATH}/#{name}/update")
+    json_get(path(VMC::APPS_PATH, name, "update"))
   end
 
   def app_stats(name)
     check_login_status
-    stats_raw = json_get("#{VMC::APPS_PATH}/#{name}/stats")
+    stats_raw = json_get(path(VMC::APPS_PATH, name, "stats"))
     stats = []
     stats_raw.each_pair do |k, entry|
       # Skip entries with no stats
@@ -132,20 +139,20 @@
 
   def app_instances(name)
     check_login_status
-    json_get("#{VMC::APPS_PATH}/#{name}/instances")
+    json_get(path(VMC::APPS_PATH, name, "instances"))
   end
 
   def app_crashes(name)
     check_login_status
-    json_get("#{VMC::APPS_PATH}/#{name}/crashes")
+    json_get(path(VMC::APPS_PATH, name, "crashes"))
   end
 
   # List the directory or download the actual file indicated by
   # the path.
-  def app_files(name, path, instance=0)
+  def app_files(name, path, instance='0')
     check_login_status
-    url = "#{VMC::APPS_PATH}/#{name}/instances/#{instance}/files/#{path}"
-    url.gsub!('//', '/')
+    path = path.gsub('//', '/')
+    url = path(VMC::APPS_PATH, name, "instances", instance, "files", path)
     _, body, headers = http_get(url)
     body
   end
@@ -185,7 +192,7 @@
 
     raise TargetError, "Service [#{service}] is not a valid service choice" unless service_hash
     service_hash[:name] = name
-    json_post(VMC::SERVICES_PATH, service_hash)
+    json_post(path(VMC::SERVICES_PATH), service_hash)
   end
 
   def delete_service(name)
@@ -193,7 +200,7 @@
     svcs = services || []
     names = svcs.collect { |s| s[:name] }
     raise TargetError, "Service [#{name}] not a valid service" unless names.include? name
-    http_delete("#{VMC::SERVICES_PATH}/#{name}")
+    http_delete(path(VMC::SERVICES_PATH, name))
   end
 
   def bind_service(service, appname)
@@ -263,7 +270,7 @@
   # Auth token can be retained and used in creating
   # new clients, avoiding login.
   def login(user, password)
-    status, body, headers = json_post("#{VMC::USERS_PATH}/#{user}/tokens", {:password => password})
+    status, body, headers = json_post(path(VMC::USERS_PATH, user, "tokens"), {:password => password})
     response_info = json_parse(body)
     if response_info
       @user = user
@@ -274,10 +281,10 @@
   # sets the password for the current logged user
   def change_password(new_password)
     check_login_status
-    user_info = json_get("#{VMC::USERS_PATH}/#{@user}")
+    user_info = json_get(path(VMC::USERS_PATH, @user))
     if user_info
       user_info[:password] = new_password
-      json_put("#{VMC::USERS_PATH}/#{@user}", user_info)
+      json_put(path(VMC::USERS_PATH, @user), user_info)
     end
   end
 
@@ -293,18 +300,34 @@
     @proxy = proxy
   end
 
+  def users
+    check_login_status
+    json_get(VMC::USERS_PATH)
+  end
+
   def add_user(user_email, password)
     json_post(VMC::USERS_PATH, { :email => user_email, :password => password })
   end
 
   def delete_user(user_email)
-    http_delete("#{VMC::USERS_PATH}/#{user_email}")
+    check_login_status
+    http_delete(path(VMC::USERS_PATH, user_email))
   end
 
   ######################################################
 
+  def self.path(*path)
+    path.flatten.collect { |x|
+      URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+    }.join("/")
+  end
+
   private
 
+  def path(*args, &blk)
+    self.class.path(*args, &blk)
+  end
+
   def json_get(url)
     status, body, headers = http_get(url, 'application/json')
     json_parse(body)
@@ -357,12 +380,12 @@
     end
 
     req = {
-      :method => method, :url => "#{@target}#{path}",
-      :payload => payload, :headers => headers
+      :method => method, :url => "#{@target}/#{path}",
+      :payload => payload, :headers => headers, :multipart => true
     }
     status, body, response_headers = perform_http_request(req)
 
-    if VMC_HTTP_ERROR_CODES.include?(status)
+    if request_failed?(status)
       # FIXME, old cc returned 400 on not found for file access
       err = (status == 404 || status == 400) ? NotFound : TargetError
       raise err, parse_error_message(status, body)
@@ -373,8 +396,13 @@
     raise BadTarget, "Cannot access target (%s)" % [ e.message ]
   end
 
+  def request_failed?(status)
+    VMC_HTTP_ERROR_CODES.detect{|error_code| status >= error_code}
+  end
+
   def perform_http_request(req)
-    RestClient.proxy = ENV['https_proxy'] || ENV['http_proxy']
+    proxy_uri = URI.parse(req[:url]).find_proxy()
+    RestClient.proxy = proxy_uri.to_s if proxy_uri
 
     # Setup tracing if needed
     unless trace.nil?
@@ -388,9 +416,17 @@
         puts '>>>'
         puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
         puts "REQUEST: #{req[:method]} #{req[:url]}"
-        puts "RESPONSE_HEADERS: #{response.headers}"
+        puts "RESPONSE_HEADERS:"
+        response.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+        end
         puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
-        puts "RESPONSE: [#{response.code}] #{response.body}"
+        puts "RESPONSE: [#{response.code}]"
+        begin
+            puts JSON.pretty_generate(JSON.parse(response.body))
+        rescue
+            puts "#{response.body}"
+        end
         puts '<<<'
       end
     end
 
=== modified file 'lib/vmc/const.rb'
--- lib/vmc/const.rb	2011-06-17 13:38:56 +0000
+++ lib/vmc/const.rb	2012-06-13 01:37:18 +0000
@@ -5,17 +5,18 @@
   VERSION = '0.3.2'
 
   # Targets
-  DEFAULT_TARGET = 'http://api.cloudfoundry.com'
+  DEFAULT_TARGET = 'https://api.cloudfoundry.com'
   DEFAULT_LOCAL_TARGET = 'http://api.vcap.me'
 
   # General Paths
-  INFO_PATH            = '/info'
-  GLOBAL_SERVICES_PATH = '/info/services'
-  RESOURCES_PATH       = '/resources'
+  INFO_PATH            = 'info'
+  GLOBAL_SERVICES_PATH = ['info', 'services']
+  GLOBAL_RUNTIMES_PATH = ['info', 'runtimes']
+  RESOURCES_PATH       = 'resources'
 
   # User specific paths
-  APPS_PATH            = '/apps'
-  SERVICES_PATH        = '/services'
-  USERS_PATH           = '/users'
+  APPS_PATH            = 'apps'
+  SERVICES_PATH        = 'services'
+  USERS_PATH           = 'users'
 
 end
 
=== added directory 'lib/vmc/micro'
=== added file 'lib/vmc/micro.rb'
--- lib/vmc/micro.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,56 @@
+require 'find'
+
+module VMC::Micro
+  def config_file(file)
+    File.join(File.dirname(__FILE__), '..', '..', 'config', 'micro', file)
+  end
+
+  def escape_path(path)
+    path = File.expand_path(path)
+    if RUBY_PLATFORM =~ /mingw|mswin32|cygwin/
+      if path.include?(' ')
+        return '"' + path + '"'
+      else
+        return path
+      end
+    else
+      return path.gsub(' ', '\ ')
+    end
+  end
+
+  def locate_file(file, directory, search_paths)
+    search_paths.each do |path|
+      expanded_path = File.expand_path(path)
+      if File.exists?(expanded_path)
+        Find.find(expanded_path) do |current|
+          if File.directory?(current) && current.include?(directory)
+            full_path = File.join(current, file)
+            return self.escape_path(full_path) if File.exists?(full_path)
+          end
+        end
+      end
+    end
+
+    false
+  end
+
+  def run_command(command, args=nil)
+    # TODO switch to using posix-spawn instead
+    result = %x{#{command} #{args} 2>&1}
+    unless $?.exitstatus == 0
+      if block_given?
+        yield
+      else
+        raise "failed to execute #{command} #{args}:\n#{result}"
+      end
+    else
+      result.split(/\n/)
+    end
+  end
+
+  module_function :config_file
+  module_function :escape_path
+  module_function :locate_file
+  module_function :run_command
+
+end
 
=== added directory 'lib/vmc/micro/switcher'
=== added file 'lib/vmc/micro/switcher/base.rb'
--- lib/vmc/micro/switcher/base.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/switcher/base.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,97 @@
+require 'interact'
+
+module VMC::Micro::Switcher
+  class Base
+    include Interactive
+
+    def initialize(config)
+      @config = config
+
+      @vmrun = VMC::Micro::VMrun.new(config)
+      unless @vmrun.running?
+        if ask("Micro Cloud Foundry VM is not running. Do you want to start it?", :choices => ['y', 'n']) == 'y'
+          display "Starting Micro Cloud Foundry VM: ", false
+          @vmrun.start
+          say "done".green
+        else
+          err "Micro Cloud Foundry VM needs to be running."
+        end
+      end
+
+      err "Micro Cloud Foundry VM initial setup needs to be completed before using 'vmc micro'" unless @vmrun.ready?
+    end
+
+    def offline
+      unless @vmrun.offline?
+        # save online connection type so we can restore it later
+        @config['online_connection_type'] = @vmrun.connection_type
+
+        if (@config['online_connection_type'] != 'nat')
+          if ask("Reconfigure Micro Cloud Foundry VM network to nat mode and reboot?", :choices => ['y', 'n']) == 'y'
+            display "Rebooting Micro Cloud Foundry VM: ", false
+            @vmrun.connection_type = 'nat'
+            @vmrun.reset
+            say "done".green
+          else
+            err "Aborted"
+          end
+        end
+
+        display "Setting Micro Cloud Foundry VM to offline mode: ", false
+        @vmrun.offline!
+        say "done".green
+        display "Setting host DNS server: ", false
+
+        @config['domain'] = @vmrun.domain
+        @config['ip'] = @vmrun.ip
+        set_nameserver(@config['domain'], @config['ip'])
+        say "done".green
+      else
+        say "Micro Cloud Foundry VM already in offline mode".yellow
+      end
+    end
+
+    def online
+      if @vmrun.offline?
+        current_connection_type = @vmrun.connection_type
+        @config['online_connection_type'] ||= current_connection_type
+
+        if (@config['online_connection_type'] != current_connection_type)
+          # TODO handle missing connection type in saved config
+          question = "Reconfigure Micro Cloud Foundry VM network to #{@config['online_connection_type']} mode and reboot?"
+          if ask(question, :choices => ['y', 'n']) == 'y'
+            display "Rebooting Micro Cloud Foundry VM: ", false
+            @vmrun.connection_type = @config['online_connection_type']
+            @vmrun.reset
+            say "done".green
+          else
+            err "Aborted"
+          end
+        end
+
+        display "Unsetting host DNS server: ", false
+        # TODO handle missing domain and ip in saved config (look at the VM)
+        @config['domain'] ||= @vmrun.domain
+        @config['ip'] ||= @vmrun.ip
+        unset_nameserver(@config['domain'], @config['ip'])
+        say "done".green
+
+        display "Setting Micro Cloud Foundry VM to online mode: ", false
+        @vmrun.online!
+        say "done".green
+      else
+        say "Micro Cloud Foundry already in online mode".yellow
+      end
+    end
+
+    def status
+      mode = @vmrun.offline? ? 'offline' : 'online'
+      say "Micro Cloud Foundry VM currently in #{mode.green} mode"
+      # should the VMX path be unescaped?
+      say "VMX Path: #{@vmrun.vmx}"
+      say "Domain: #{@vmrun.domain.green}"
+      say "IP Address: #{@vmrun.ip.green}"
+    end
+  end
+
+end
 
=== added file 'lib/vmc/micro/switcher/darwin.rb'
--- lib/vmc/micro/switcher/darwin.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/switcher/darwin.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,19 @@
+module VMC::Micro::Switcher
+
+  class Darwin < Base
+    def adminrun(command)
+      VMC::Micro.run_command("osascript", "-e 'do shell script \"#{command}\" with administrator privileges'")
+    end
+
+    def set_nameserver(domain, ip)
+      File.open("/tmp/#{domain}", 'w') { |file| file.write("nameserver #{ip}") }
+      adminrun("mkdir -p /etc/resolver;mv /tmp/#{domain} /etc/resolver/")
+    end
+
+    def unset_nameserver(domain, ip)
+      err "domain missing" unless domain
+      adminrun("rm -f /etc/resolver/#{domain}")
+    end
+  end
+
+end
 
=== added file 'lib/vmc/micro/switcher/dummy.rb'
--- lib/vmc/micro/switcher/dummy.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/switcher/dummy.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,15 @@
+# only used for testing
+module VMC::Micro::Switcher
+
+  class Dummy < Base
+    def adminrun(command)
+    end
+
+    def set_nameserver(domain, ip)
+    end
+
+    def unset_nameserver(domain, ip)
+    end
+  end
+
+end
 
=== added file 'lib/vmc/micro/switcher/linux.rb'
--- lib/vmc/micro/switcher/linux.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/switcher/linux.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,16 @@
+module VMC::Micro::Switcher
+
+  class Linux < Base
+    def set_nameserver(domain, ip)
+      VMC::Micro.run_command("sudo", "sed -i'.backup' '1 i nameserver #{ip}' /etc/resolv.conf")
+      # lock resolv.conf so Network Manager doesn't clear out the file when offline
+      VMC::Micro.run_command("sudo", "chattr +i /etc/resolv.conf")
+    end
+
+    def unset_nameserver(domain, ip)
+      VMC::Micro.run_command("sudo", "chattr -i /etc/resolv.conf")
+      VMC::Micro.run_command("sudo", "sed -i'.backup' '/#{ip}/d' /etc/resolv.conf")
+    end
+  end
+
+end
 
=== added file 'lib/vmc/micro/switcher/windows.rb'
--- lib/vmc/micro/switcher/windows.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/switcher/windows.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,31 @@
+module VMC::Micro::Switcher
+
+  class Windows < Base
+    def version?
+      VMC::Micro.run_command("cmd", "/c ver").to_s.scan(/\d+\.\d+/).first.to_f
+    end
+
+    def adminrun(command, args=nil)
+      if version? > 5.2
+        require 'win32ole'
+        shell = WIN32OLE.new("Shell.Application")
+        shell.ShellExecute(command, args, nil, "runas", 0)
+      else
+        # on older version this will try to run the command, and if you don't have
+        # admin privilges it will tell you so and exit
+        VMC::Micro.run_command(command, args)
+      end
+    end
+
+    # TODO better method to figure out the interface name is to get the NAT ip and find the
+    # interface with the correct subnet
+    def set_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static #{ip}")
+    end
+
+    def unset_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static none")
+    end
+  end
+
+end
 
=== added file 'lib/vmc/micro/vmrun.rb'
--- lib/vmc/micro/vmrun.rb	1970-01-01 00:00:00 +0000
+++ lib/vmc/micro/vmrun.rb	2012-06-13 01:37:18 +0000
@@ -0,0 +1,158 @@
+module VMC::Micro
+  class VMrun
+    attr_reader :vmx, :vmrun
+
+    def initialize(config)
+      @platform = config['platform']
+      @user = 'root' # must use root as we muck around with system settings
+      @password = config['password']
+      @vmrun = config['vmrun']
+      @vmx = config['vmx']
+
+      # TODO honor TMPDIR
+      if @platform == :windows
+        @temp_dir = ENV['temp']
+      else
+        @temp_dir = '/tmp'
+      end
+    end
+
+    def connection_type
+      read_variable('ethernet0.connectionType')
+    end
+
+    def connection_type=(type)
+      write_variable("ethernet0.connectionType", type)
+    end
+
+    def nat?
+      connection_type == "nat"
+    end
+
+    def bridged?
+      connection_type == "bridged"
+    end
+
+    def domain
+      # switch to Dir.mktmpdir
+      state_config = VMC::Micro.escape_path(File.join(@temp_dir, 'state.yml'))
+      run('CopyFileFromGuestToHost', "/var/vcap/bosh/state.yml #{state_config}")
+      bosh_config = YAML.load_file(state_config)
+      bosh_config['properties']['domain']
+    end
+
+    def ip
+      # switch to Dir.mktmpdir
+      path = VMC::Micro.escape_path(VMC::Micro.config_file('refresh_ip.rb'))
+      ip_file = VMC::Micro.escape_path(File.join(@temp_dir, 'ip.txt'))
+      run('CopyFileFromHostToGuest', "#{path} /tmp/refresh_ip.rb")
+      run('runProgramInGuest', '/tmp/refresh_ip.rb')
+      run('CopyFileFromGuestToHost', "/tmp/ip.txt #{ip_file}")
+      File.open(ip_file, 'r') { |file| file.read }
+    end
+
+    def list
+      vms = run("list")
+      vms.delete_if { |line| line =~ /^Total/ }
+      vms.map { |line| VMC::Micro.escape_path(File.expand_path(line)) }
+    end
+
+    def offline?
+      command = "-gu #{@user} -gp #{@password} runProgramInGuest"
+      args =  '/usr/bin/test -e /var/vcap/micro/offline'
+      # why not use run_command?
+      result = %x{#{@vmrun} #{command} #{@vmx} #{args}}
+
+      if result.include?('Guest program exited with non-zero exit code: 1')
+        return false
+      elsif $?.exitstatus == 0
+        return true
+      else
+        raise "failed to execute vmrun:\n#{result}"
+      end
+    end
+
+    def offline!
+      path = VMC::Micro.escape_path(VMC::Micro.config_file('offline.conf'))
+      run('CopyFileFromHostToGuest', "#{path} /etc/dnsmasq.d/offline.conf")
+      run('runProgramInGuest', '/usr/bin/touch /var/vcap/micro/offline')
+      restart_dnsmasq
+    end
+
+    def online!
+      run('runProgramInGuest', '/bin/rm -f /etc/dnsmasq.d/offline.conf')
+      run('runProgramInGuest', '/bin/rm -f /var/vcap/micro/offline')
+      restart_dnsmasq
+    end
+
+    # check to see if the micro cloud has been configured
+    # uses default password to check
+    def ready?
+      command = "-gu root -gp 'ca$hc0w' runProgramInGuest"
+      args =  '/usr/bin/test -e /var/vcap/micro/micro.json'
+      result = %x{#{@vmrun} #{command} #{@vmx} #{args}}
+
+      if result.include?('Invalid user name or password for the guest OS') || $?.exitstatus == 0
+        return true
+      elsif $?.exitstatus == 1
+        return false
+      else
+        raise "failed to execute vmrun:\n#{result}"
+      end
+    end
+
+    def read_variable(var)
+      # TODO deal with non-ok return
+      run("readVariable", "runtimeConfig #{var}").first
+    end
+
+    def write_variable(var, value)
+      run('writeVariable', "runtimeConfig #{var} #{value}")
+    end
+
+    def reset
+      run('reset', 'soft')
+    end
+
+    def restart_dnsmasq
+      # restart command doesn't always work, start and stop seems to be more reliable
+      run('runProgramInGuest', '/etc/init.d/dnsmasq stop')
+      run('runProgramInGuest', '/etc/init.d/dnsmasq start')
+    end
+
+    def run(command, args=nil)
+      if command.include?('Guest')
+        command = "-gu #{@user} -gp #{@password} #{command}"
+      end
+      VMC::Micro.run_command(@vmrun, "#{command} #{@vmx} #{args}")
+    end
+
+    def running?
+      vms = list
+      if @platform == :windows
+        vms.map! { |x| x.downcase }
+        vms.include?(@vmx.downcase)
+      else
+        vms.include?(@vmx)
+      end
+    end
+
+    def start
+      run('start') unless running?
+    end
+
+    def stop
+      run('stop') if running?
+    end
+
+    def self.locate(platform)
+      paths = YAML.load_file(VMC::Micro.config_file('paths.yml'))
+      vmrun_paths = paths[platform.to_s]['vmrun']
+      vmrun_exe = @platform == :windows ? 'vmrun.exe' : 'vmrun'
+      vmrun = VMC::Micro.locate_file(vmrun_exe, "VMware", vmrun_paths)
+      err "Unable to locate vmrun, please supply --vmrun option" unless vmrun
+      vmrun
+    end
+  end
+
+end
 
=== modified file 'metadata.yml'
--- metadata.yml	2011-06-17 13:38:56 +0000
+++ metadata.yml	2012-06-13 01:37:18 +0000
@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vmc
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 55
   prerelease: 
   segments: 
   - 0
   - 3
-  - 10
-  version: 0.3.10
+  - 18
+  version: 0.3.18
 platform: ruby
 authors: 
 - VMware
@@ -15,8 +15,7 @@
 bindir: bin
 cert_chain: []
 
-date: 2011-04-11 00:00:00 -07:00
-default_executable: 
+date: 2012-05-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json_pure
@@ -24,7 +23,7 @@
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 1
         segments: 
@@ -32,31 +31,39 @@
         - 5
         - 1
         version: 1.5.1
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 7
+        - 0
+        version: 1.7.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rubyzip2
+  name: rubyzip
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 51
         segments: 
-        - 2
         - 0
-        - 1
-        version: 2.0.1
+        - 9
+        - 4
+        version: 0.9.4
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: highline
+  name: rest-client
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 13
         segments: 
@@ -64,52 +71,100 @@
         - 6
         - 1
         version: 1.6.1
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 7
+        - 0
+        version: 1.7.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rest-client
+  name: terminal-table
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 6
-        - 1
-        version: 1.6.1
-    - - <
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 1
-        - 7
-        - 0
-        version: 1.7.0
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: terminal-table
+  name: interact
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 15
         segments: 
-        - 1
+        - 0
         - 4
-        - 2
-        version: 1.4.2
+        - 0
+        version: 0.4.0
   type: :runtime
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 2
+        - 6
+        version: 2.2.6
+  type: :runtime