fanforce-cli 1.1.0

data/lib/fanforce/cli/commands_support.rb

@@ -0,0 +1,210 @@
+class Fanforce::CLI
+  require 'fileutils'
+
+  def get_heroku_app_name(app, environment)
+    heroku_app_name = "#{environment==:production ? 'prd' : 'stg'}-#{app.dir_name}"
+    heroku_app_name.length > 30 ? heroku_app_name.gsub!(/(a|e|i|o|u)/, '') : heroku_app_name
+  end
+
+  def setup_files(app)
+    if File.directory?("#{app.dir}/tmp")
+      puts "#{'Found  '.format(:green,:bold)} #{app.dir_name}/tmp/"
+    else
+      Dir.mkdir("#{app.dir}/tmp")
+      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/tmp/"
+    end
+
+    if File.exists?("#{app.dir}/config.ru")
+      app.update_file(:config_ru)
+      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/config.ru"
+    else
+      app.create_file(:config_ru)
+      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/config.ru"
+    end
+
+    if File.exists?("#{app.dir}/.gitignore")
+      app.update_file(:gitignore)
+      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/.gitignore"
+    else
+      app.create_file(:gitignore)
+      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/.gitignore"
+    end
+
+    if File.exists?("#{app.dir}/Gemfile")
+      app.update_file(:gemfile)
+      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/Gemfile"
+    else
+      app.create_file(:gemfile)
+      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/Gemfile"
+    end
+
+    if File.exists?("#{app.dir}/Rakefile")
+      app.update_file(:rakefile)
+      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/Rakefile"
+    else
+      app.create_file(:rakefile)
+      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/Rakefile"
+    end
+
+    restart(app, :development)
+  end
+
+  def setup_envs(app, environment)
+    environments = environment == :all ? [:development, :staging, :production] : [environment]
+
+    if !File.exists?("#{$HomeDir}/.env/_bind.yml")
+      return puts "#{'Oops'.format(:bold)}... you must setup .env/_bind.yml before trying to update env variables."
+    end
+
+    environments.each do |environment|
+      vars = Env.vars_by_app(environment)[app.dir_name]
+      has_workers = File.directory?("#{app.dir}/workers") ? true : false
+
+      next puts "#{'Skipped'.format(:bold)} #{environment.to_s.titleize} has 0 env variables" if vars.blank? or vars.size == 0
+      puts "#{'Updated'.format(:green,:bold)} #{environment.to_s.titleize}#{has_workers ? '... and workers have' : ' has'} #{vars.size} env variables"
+
+      push_env_to(environment, app, vars)
+    end
+  end
+
+  def setup_pow(app)
+    Run.pow_create(app, app.root_domain)
+    Run.pow_create(app, Fanforce.default_short_domain)
+  end
+
+  def setup_local_git(app)
+    if Run.git_init.include?('Reinitialized')
+      puts "#{'Found '.format(:green,:bold)}" + 'local repository'
+    else
+      puts "#{'Initialized '.format(:green,:bold)}" + 'local repository'
+      Run.git_add
+      Run.git_first_commit
+      puts "#{'Created     '.format(:green,:bold)}" + 'initial fanforce commit'
+    end
+  end
+
+  def setup_bitbucket(app)
+    bitbucket = BitBucket.new(login: $Config[:bitbucket][:user], password: $Config[:bitbucket][:password])
+    begin
+      find_bitbucket_repo(bitbucket, app.dir_name)
+      "#{'Found   '.format(:green,:bold)}" + "#{app.dir_name} repository already exists on bitbucket"
+    rescue
+      create_bitbucket_repo(bitbucket, app.dir_name)
+      puts "#{'Created '.format(:green,:bold)}" + "#{app.dir_name} repository on bitbucket"
+    end
+
+    if (`git remote`).split(/\r?\n/).include?($Config[:bitbucket][:user])
+      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{$Config[:bitbucket][:user]}"
+      `git remote rm #{$Config[:bitbucket][:user]}`
+    elsif (`git remote`).split(/\r?\n/).include?('bitbucket')
+      `git remote rm bitbucket`
+      puts "#{'Removed '.format(:red,:bold)}" + "git remote for #{$Config[:bitbucket][:user]}"
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for bitbucket"
+    else
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for bitbucket"
+    end
+    `git remote add bitbucket git@bitbucket.org:#{$Config[:bitbucket][:user]}/#{app.dir_name}.git`
+
+    puts "#{'Pushing '.format(:green,:bold)}" + "latest commit to #{$Config[:bitbucket][:user]}..."
+    Run.command("git push bitbucket --all")
+  end
+
+  def find_bitbucket_repo(bitbucket, repo)
+    bitbucket.repos.find($Config[:bitbucket][:user], repo)
+  end
+
+  def create_bitbucket_repo(bitbucket, repo)
+    bitbucket.repos.create(name: repo, is_private: true)
+  rescue BitBucket::Error::Unauthorized => e
+    raise "Bitbucket user #{$Config[:bitbucket][:user]} does not seem to exist: #{e.message}"
+    raise
+  end
+
+  def auth_heroku(environment)
+    @heroku ||= {}
+    @heroku[environment] ||= Heroku::API.new(:username => $Config[:heroku][environment][:user], :password => $Config[:heroku][environment][:password])
+  rescue Exception => e
+    raise "Heroku user #{$Config[:heroku][environment][:user]} does not seem to exist: #{e.message}" if e.response.status == 404
+    raise
+  end
+
+  def setup_heroku(app, environment)
+    return puts "OOPS...  #{environment.to_s.upcase}".format(:red,:bold) + ' has not been setup for Heroku' if $Config[:heroku].blank? or $Config[:heroku][environment].blank?
+
+    heroku = auth_heroku(environment)
+    heroku_app_name = get_heroku_app_name(app, environment)
+    begin
+      heroku.get_app(heroku_app_name)
+      puts "#{'Found   '.format(:green,:bold)}" + "#{environment} app on heroku (#{heroku_app_name})"
+    rescue
+      heroku.post_app(name: heroku_app_name)
+      puts "#{'Created '.format(:green,:bold)}" + "#{environment} on heroku (#{heroku_app_name})"
+    end
+
+    vars = Env.vars_by_app(environment)[app.dir_name]
+    heroku.put_config_vars(heroku_app_name, vars) if vars
+
+    # Setup standard app domain
+    domain = "#{app._id}.#{Fanforce.apps_base_domain}"
+    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+    else
+      heroku.post_domain(heroku_app_name, domain)
+      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    end
+
+    # Setup default short domain
+    domain = "#{app._id}.#{Fanforce.default_short_domain}"
+    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+    else
+      heroku.post_domain(heroku_app_name, domain)
+      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    end
+
+    remote_name = "#{environment==:staging ? 'stg' : 'prd'}-heroku"
+    if (`git remote`).split(/\r?\n/).include?(remote_name)
+      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{remote_name}"
+      `git remote rm #{remote_name}`
+    else
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for #{remote_name}"
+    end
+    `git remote add #{remote_name} git@#{$Config[:heroku][environment][:git_ssh_domain] || 'heroku.com'}:#{heroku_app_name}.git`
+
+    puts "#{'Pushing '.format(:green,:bold)}" + "latest commit to #{remote_name}..."
+    Run.command("git push #{remote_name} master")
+  end
+
+  ######################################################################################################################
+
+  def push_env_to(environment, app, vars, create_worker_env=true)
+    vars.each {|k,v| puts "  - #{k}" }
+    workers_dir = "#{app.dir}/workers"
+    workers_env_dir = "#{workers_dir}/.env"
+    if create_worker_env and File.directory?(workers_dir) and vars['IRON_PROJECT_ID']
+      FileUtils.mkdir_p(workers_env_dir) unless File.directory?(workers_env_dir)
+      File.open("#{workers_env_dir}/#{environment}.rb", 'w') {|f| f.write convert_hash_to_ruby_env(vars) }
+    end
+    if environment == :development
+      app.update_file(:powenv)
+      File.open("#{app.dir}/.appenv", 'w') {|f| f.write convert_hash_to_shell_env(vars) }
+    else
+      return if $Config[:heroku][environment].blank?
+      heroku = auth_heroku(environment)
+      heroku_app_name = get_heroku_app_name(app, environment)
+      heroku.put_config_vars(heroku_app_name, vars)
+    end
+    restart(app, environment)
+  end
+
+  def convert_hash_to_shell_env(hash)
+    hash.inject('') {|script, (k,v)| script += "export #{k}=#{v.to_s.to_json}\n" }
+  end
+
+  def convert_hash_to_ruby_env(hash)
+    hash.inject('') {|script, (k,v)| script += "ENV['#{k}']=#{v.to_s.to_json}\n" }
+  end
+
+end

data/lib/fanforce/cli/env.rb

@@ -0,0 +1,41 @@
+class Fanforce::CLI::Env
+  require 'singleton'
+  require 'forwardable'
+  include Singleton
+
+  def load_vars_by_app(environment)
+    vars = {}
+    Fanforce::CLI::Apps.dir_names.each do |dir_name|
+      vars[dir_name] ||= {}
+      vars[dir_name]['FANFORCE_APP_ID'] = Fanforce::CLI::App.parse_dir_name(dir_name)[:_id]
+    end
+
+    raw_yaml = File.read("#{$HomeDir}/.env/_bind.yml")
+    bindings = (raw_yaml.present?) ? YAML.load(raw_yaml) : {}
+    bindings.each do |filename, dir_names|
+      file = YAML.load_file("#{$HomeDir}/.env/#{filename}.yml").symbolize_keys
+      next if file[environment].blank?
+
+      dir_names = Fanforce::CLI::Apps.dir_names if dir_names.is_a?(String) and dir_names.upcase == 'ALL'
+      file[environment].each do |k,v|
+        dir_names.each do |dir_name|
+          vars[dir_name] ||= {}
+          vars[dir_name]["#{filename}_#{k}".upcase] = v
+        end
+      end
+    end
+
+    return vars
+  end
+
+  def vars_by_app(environment)
+    @vars ||= {}
+    @vars[environment] ||= load_vars_by_app(environment)
+  end
+
+  class << self
+    extend Forwardable
+    def_delegators :instance, *Fanforce::CLI::Env.instance_methods(false)
+  end
+
+end

data/lib/fanforce/cli/files.rb

@@ -0,0 +1,266 @@
+class Fanforce::CLI::Files
+
+# CONFIG.RU #######################################################################
+
+  def self.create_config_ru(app)
+    file = config_ru_required_lines.join("\n") + "\n\n"
+    if (fanforce_config_lines = fanforce_config_lines(app._id)).size > 0
+      file += "FanforceApp.config do |config|\n"
+      file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      file += "end\n"
+    end
+    file += "run FanforceApp\n"
+    File.open("#{app.dir}/config.ru", 'w') {|f| f.write file }
+  end
+
+  def self.update_config_ru(app)
+    return create_config_ru(app) if !File.exists?("#{app.dir}/config.ru")
+
+    lines = File.open("#{app.dir}/config.ru", 'r') {|f| f.readlines}
+
+    lines.clone.each {|l| lines.delete(l) if config_ru_required_lines.include?(l.strip) }
+    config_ru_required_lines.reverse.each {|l| lines.unshift(l+"\n") }
+
+    config_options = extract_fanforce_config_options(lines, 'config.ru')
+
+    fanforce_config_keys_to_require.each do |k|
+      config_options[k] = fanforce_config_lines(app._id)[k] if config_options[k].blank?
+    end
+
+    fanforce_config_keys_to_overwrite.each do |k|
+      config_options[k] = fanforce_config_lines(app._id)[k]
+    end
+
+    lines = replace_fanforce_config_options_in_config_ru(lines, config_options)
+
+    File.open("#{app.dir}/config.ru", 'w') {|f| f.write(lines.join('')) }
+  end
+
+  def self.replace_fanforce_config_options_in_config_ru(lines, config_options)
+    if (block = extract_fanforce_config_block(lines, 'config.ru'))
+      new_block  = "FanforceApp.config do |config|\n"
+      new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      new_block += "end\n"
+      new_block += "run FanforceApp"
+    else
+      block = extract_run_fanforce_line(lines)
+      new_block = "run FanforceApp"
+    end
+    lines.join('').gsub(block[:code], new_block).lines.to_a
+  end
+
+  def self.config_ru_required_lines
+    [
+        "require 'bundler'; Bundler.setup",
+        "require 'fanforce/app_factory'"
+    ]
+  end
+
+  # RAKEFILE #######################################################################
+
+  def self.create_rakefile(app)
+    file = rakefile_required_lines.join("\n") + "\n\n"
+    if (fanforce_config_lines = fanforce_config_lines(app._id)).size > 0
+      file += "FanforceApp.config do |config|\n"
+      file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      file += "end\n"
+    end
+    file += "load 'fanforce/app_factory.rake'\n"
+    File.open("#{app.dir}/Rakefile", 'w') {|f| f.write file }
+  end
+
+  def self.update_rakefile(app)
+    return create_rakefile(app) if !File.exists?("#{app.dir}/Rakefile")
+
+    lines = File.open("#{app.dir}/Rakefile", 'r') {|f| f.readlines}
+
+    lines.clone.each {|l| lines.delete(l) if rakefile_required_lines.include?(l.strip) }
+    rakefile_required_lines.reverse.each {|l| lines.unshift(l+"\n") }
+
+    config_options = extract_fanforce_config_options(lines, 'Rakefile')
+
+    fanforce_config_keys_to_require.each do |k|
+      config_options[k] = fanforce_config_lines(app._id)[k] if config_options[k].blank?
+    end
+
+    fanforce_config_keys_to_overwrite.each do |k|
+      config_options[k] = fanforce_config_lines(app._id)[k]
+    end
+
+    lines = replace_fanforce_config_options_in_rakefile(lines, config_options)
+
+    File.open("#{app.dir}/Rakefile", 'w') {|f| f.write(lines.join('')) }
+  end
+
+  def self.replace_fanforce_config_options_in_rakefile(lines, config_options)
+    if (block = extract_fanforce_config_block(lines, 'Rakefile'))
+      new_block  = "FanforceApp.config do |config|\n"
+      new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      new_block += "end\n"
+      new_block += "load 'fanforce/app_factory.rake'"
+    else
+      block = extract_load_fanforce_line(lines)
+      new_block = "load 'fanforce/app_factory.rake'"
+    end
+    lines.join('').gsub(block[:code], new_block).lines.to_a
+  end
+
+  def self.rakefile_required_lines
+    [
+        "require 'bundler'; Bundler.setup",
+        "require 'fanforce/app_factory'"
+    ]
+  end
+
+  ########################################################################
+
+  def self.extract_load_fanforce_line(lines)
+    code = lines.join('')
+    regex = Regexp.compile('( *load\s+(\'|")fanforce/app_factory.rake(\'|"))', Regexp::MULTILINE)
+    if code !~ regex
+      raise "No valid \"load 'fanforce/app_factory.rake'\" line was found in your Rakefile."
+    end
+    {:code => $1}
+  end
+
+  def self.extract_run_fanforce_line(lines)
+    code = lines.join('')
+    regex = Regexp.compile('( *run\s+FanforceApp)', Regexp::MULTILINE)
+    if code !~ regex
+      raise "No valid \"run FanforceApp\" line was found in your config.ru."
+    end
+    {:code => $1}
+  end
+
+  def self.extract_fanforce_config_block(lines, filename)
+    code = lines.join('')
+    regex = Regexp.compile('( *FanforceApp\.config\s*(do|{)\s*\|\s*([A-Za-z]+)\s*\|(.*)(end|})\s*(run\s+FanforceApp|load\s+(\'|")fanforce/app_factory.rake(\'|")))', Regexp::MULTILINE)
+    if code !~ regex || ($2 == '{' and $5 != '}') || ($2 == 'do' and $5 != 'end')
+      return nil
+    end
+    {
+        :code          => $1,
+        :start_keyword => $2,
+        :config_var    => $3,
+        :config_code   => $4,
+        :end_keyword   => $5
+    }
+  end
+
+  def self.extract_fanforce_config_options(lines, filename)
+    block = extract_fanforce_config_block(lines, filename)
+    return [] if !block
+    regex = Regexp.compile(block[:config_var]+'\.([\w]+)\s*=\s*(((?!'+block[:config_var]+'\.).)+)', Regexp::MULTILINE)
+    block[:config_code].scan(regex).inject({}) {|result, match| result.update "config.#{match[0]}" => match[1].strip }
+  end
+
+  def self.fanforce_config_lines(app_id)
+    lines = {}
+    return lines
+  end
+
+  def self.fanforce_config_keys_to_require
+    []
+  end
+
+  def self.fanforce_config_keys_to_overwrite
+    keys = []
+    return keys
+  end
+
+  # GEMFILE #######################################################################
+
+  def self.create_gemfile(app)
+    file  = gemfile_source_lines.join("\n") + "\n"
+    file += gemfile_ruby_version + "\n\n"
+    file += gemfile_factory_line + "\n\n"
+    File.open("#{app.dir}/Gemfile", 'w') {|f| f.write file }
+  end
+
+  def self.update_gemfile(app)
+    return create_gemfile(app) if !File.exists?("#{app.dir}/Gemfile")
+
+    lines = File.open("#{app.dir}/Gemfile", 'r') {|f| f.readlines}.map {|l| l.strip }
+    gemfile_source_lines.reverse.each {|l| lines.delete(l); lines.unshift(l) }
+
+    lines.clone.each {|l| lines.delete(l) if l =~ /^ruby .+/ }
+    lines.each_with_index do |l,i|
+      next if l =~ /^source .+/
+      lines.insert(i, gemfile_ruby_version) and break
+    end
+
+    lines = lines.map do |l|
+      l.include?("gem 'fanforce-app-factory'") ? gemfile_factory_line : l
+    end
+    lines << gemfile_factory_line if !lines.include?(gemfile_factory_line)
+
+    File.open("#{app.dir}/Gemfile", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.gemfile_source_lines
+    [
+      "source 'https://rubygems.org'",
+    ]
+  end
+
+  def self.gemfile_ruby_version
+    "ruby '1.9.3'"
+  end
+
+  def self.gemfile_factory_line
+    line = "gem 'fanforce-app-factory'"
+    return line if !$Config[:app_factory_gem].is_a?(Hash)
+
+    line += ", '#{$Config[:app_factory_gem][:version]}'" if $Config[:app_factory_gem][:version].present?
+    line += ", :path => '#{$Config[:app_factory_gem][:path]}'" if $Config[:app_factory_gem][:path].present?
+    line += ", :git => '#{$Config[:app_factory_gem][:git]}'" if $Config[:app_factory_gem][:git].present?
+    line
+  end
+
+  # .GITIGNORE #######################################################################
+
+  def self.create_gitignore(app)
+    file = gitignore_lines.join("\n") + "\n"
+    File.open("#{app.dir}/.gitignore", 'w') {|f| f.write file }
+  end
+
+  def self.update_gitignore(app)
+    return create_gitignore(app) if !File.exists?("#{app.dir}/.gitignore")
+
+    lines = File.open("#{app.dir}/.gitignore", 'r') {|f| f.readlines}.map {|l| l.strip }
+
+    gitignore_lines.each do |line|
+      lines << line if !lines.include?(line)
+    end
+
+    File.open("#{app.dir}/.gitignore", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.gitignore_lines
+    %w(*.gem *.rbc .bundle .config coverage InstalledFiles lib/bundler/man pkg rdoc spec/reports test/tmp test/version_tmp tmp .idea/ .sass-cache/ .DS_STORE .powenv .pluginenv .appenv .widgetenv .*env.rb .yardoc _yardoc doc/)
+  end
+
+  # .POWENV #######################################################################
+
+  def self.create_powenv(app)
+    file = powenv_lines.join("\n") + "\n"
+    File.open("#{app.dir}/.powenv", 'w') {|f| f.write file }
+  end
+
+  def self.update_powenv(app)
+    return create_powenv(app) if !File.exists?("#{app.dir}/.powenv")
+
+    lines = File.open("#{app.dir}/.powenv", 'r') {|f| f.readlines}.map {|l| l.strip }
+
+    powenv_lines.each do |line|
+      lines << line if !lines.include?(line)
+    end
+
+    File.open("#{app.dir}/.powenv", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.powenv_lines
+    ['source .appenv']
+  end
+
+end

data/lib/fanforce/cli/help.rb

@@ -0,0 +1,93 @@
+module Fanforce::CLI::Help
+  extend Fanforce::CLI::Help
+
+  def intro(executable, runtype)
+    response  = "-----------------------------------------------------------------------------------------------------------------------\n"
+    response += "USAGE: #{executable} <command>\n"
+  end
+
+  def commands(allowed_commands)
+    response  = "\n\nAVAILABLE COMMANDS...\n-----------------------------------------------------------------------------------------------------------------------\n"
+    commands  = allowed_commands.inject([]) do |results, c|
+      results << self.send(:"#{c}_command") rescue next results
+    end
+    response += commands.join("-----------------------------------------------------------------------------------------------------------------------\n")
+    response += "-----------------------------------------------------------------------------------------------------------------------\n\n"
+  end
+
+  def for(command, allowed_commands)
+    response  = "\n#{command.to_s.upcase} COMMAND...\n-----------------------------------------------------------------------------------------------------------------------\n"
+    response += "-----------------------------------------------------------------------------------------------------------------------\n\n"
+  end
+
+  def list_command; <<-eos
+list                                                Show a list of all apps in the current directory
+  eos
+  end
+
+  def create_command; <<-eos
+create     app-ID                                   Creates a new app folder and sets up the file structure
+  eos
+  end
+
+  def update_command; <<-eos
+update     *all|app-ID                              Similar to the create command, except it updates existing files
+  eos
+  end
+
+  def delete_command; <<-eos
+delete     app-ID                                   Delete the app folder and all related services
+  eos
+  end
+
+  def push_command; <<-eos
+push       development|RACK_ENV  [*all|OR...]       Push all changes to the environment specified
+                                      |env          Update environment vars in remote environments
+                                      |bitbucket    Push the latest commit to bitbucket
+                                      |heroku       Push the latest commit to heroku and restart
+                                      |iron         Push changes to workers
+  eos
+  end
+
+  def restart_command; <<-eos
+restart    [*development|RACK_ENV|all]              Runs `touch tmp/restart` if development or else `heroku restart`
+  eos
+  end
+
+  def count_command; <<-eos
+count                                               Display the number of fanforce apps in the current directory
+  eos
+  end
+
+  def bundle_command; <<-eos
+bundle     (install|update)                         Run bundle on all apps in current fanforce
+  eos
+  end
+
+  def git_command; <<-eos
+git        [ANY GIT COMMAND]                        Run the same git command across all apps in current fanforce
+git        status:overview                          A custom git command that displays a simple status for each app
+  eos
+  end
+
+  def iron_command; <<-eos
+iron       (upload|reset|delete) [*all|RACK_ENV]    Updates env variables and upload one or more workers to iron.io
+  eos
+  end
+
+  def version_command; <<-eos
+version                                             Display your current Fanforce CLI version number
+  eos
+  end
+
+  def config_command; <<-eos
+config                                              Display your Fanforce CLI config in the current directory
+  eos
+  end
+
+  def cleanorgs_command; <<-eos
+cleanorgs  environment supercore_api_key            Remove installs that are no longer valid in the db
+  eos
+  end
+
+end

data/lib/fanforce/cli/run.rb

@@ -0,0 +1,51 @@
+module Fanforce::CLI::Run
+  require 'pty'
+
+  def self.bundle_install(dir)
+    Dir.chdir(dir) do
+      command('gem install bundler') if Gem::Specification::find_all_by_name('bundler').empty?
+      command('bundle install')
+    end
+  end
+
+  def self.pow_create(app, root_domain)
+    domain = "#{app._id}.#{root_domain}"
+
+    symbolic_link = "#{ENV['HOME']}/.pow/#{domain.gsub('.gg','')}"
+    File.delete(symbolic_link) if File.exists?(symbolic_link)
+    `ln -s #{app.dir} #{symbolic_link}`
+    puts "#{'Connected'.format(:bold,:green)} #{domain} to #{app.dir}/"
+  end
+
+  def self.pow_destroy(app, root_domain)
+    domain = "#{app._id}.#{root_domain}"
+    symbolic_link = "#{ENV['HOME']}/.pow/#{domain.gsub('.gg','')}"
+    if File.exists?(symbolic_link)
+      File.delete(symbolic_link)
+      puts "#{'Removed'.format(:bold,:green)} #{domain}"
+    else
+      puts "#{'Already Removed'.format(:bold,:green)} #{domain} to #{app.dir}/"
+    end
+  end
+
+  def self.git_init
+    `git init`
+  end
+
+  def self.git_add
+    `git add .`
+  end
+
+  def self.git_first_commit
+    `git commit -m "initial fanforce commit"`
+  end
+
+  def self.command(command, print_now=true)
+    output = []
+    PTY.spawn(command) do |stdin, stdout, pid|
+      stdin.each { |line| output << line; print line if print_now }
+    end
+    output.join("\n")
+  end
+
+end