wfa 0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gem 'debugger', group:['development', 'test']
+gemspec

data/README.md

@@ -0,0 +1,101 @@
+wfa(1) -- manage workfrom devices
+=================================
+
+## SYNOPSIS
+
+    wfa [-a|--show-all] [list]
+    wfa [-D|--dry-run] [shell] @<device-tag>
+    wfa [-D|--dry-run] [run] @<device-tag> <remote-command ...>
+    wfa identify <device-id> @<device-tag> <name>
+    wfa screen @<device-tag>
+    wfa heartbeats @<device-tag>
+    wfa console
+
+## DESCRIPTION
+
+`wfa` is a tool for listing and connecting to workfrom devices via SSH.
+It is operated using sub-commands, but for simple use cases the sub-command is assumed.
+
+## COMMANDS
+
+### list
+
+Display a list of registered devices.
+Each device has a tag assigned for use in issuing commands.
+This command is assumed if you provide no arguments.
+Use `-a` to list untagged devices.
+
+### shell
+
+Open an interactive shell on the remote device, specified by the device tag.
+This command is assumed if you provide a device tag without additional arguments.
+
+### run
+
+Issue a command on a device and display the output.
+This command is assumed if you provide a device tag with an additional command argument.
+
+### identify
+
+Set a device tag and name, given the device ID.
+Devices must be tagged in order to be maintained with wfa.
+
+### screen
+
+Open a screen window to a shell on the remote device, specified by the device tag.
+Useful if you're running screen and want titled windows for each device.
+
+### heartbeats
+
+List the last 100 or so device heartbeats, specified by the device tag.
+
+### console
+
+Open an interactive Ruby prompt with a ready API handle.
+It's useful for experimentation or exploring the API.
+
+## USAGE
+
+**Note** that you must be logged in to the tunnel server (as yourself) to use the
+SSH tunneling features.
+No authentication is performed, you must have SSH auth already configured to use it.
+
+To see a list of devices:
+
+    wfa
+
+To open a shell on a device:
+
+    wfa @ovation
+
+To run a command on a device:
+
+    wfa @ovation cat /etc/hostname
+
+To run these commands from your own machine, prepend
+`ssh -A <login>@staging.workfrom.co` and they'll work more or less the same way.
+(`-A` enables agent forwarding, which you need to access the devices themselves.)
+
+## ADVANCED
+
+### Installation notes
+
+To install the gem you need to install some library dependencies.
+For example, this works on Debian:
+
+    sudo apt-get install ruby-dev libcurl4-openssl-dev
+
+### Distribution
+
+Currently wfa is distributed via Zack's dropbox. The URL is:
+
+https://dl.dropboxusercontent.com/u/16760254/wfa-latest.gem
+
+To release a new version, Zack just builds the gem and copies to his dropbox public folder.
+
+## FILES
+
+### ~/.wfa.json
+
+Saved settings for `wfa`, including login credentials and backend URL.
+

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems/tasks'
+
+# I am dumb and keep forgetting to update the bundle before releasing
+task :update_bundle do
+  system("bundle")
+  system("git ci -am 'update gemfile.lock'")
+end
+task :release => :update_bundle
+
+require 'fileutils'
+task :clean do
+  FileUtils.rm_rf %w[ pkg man ]
+end
+
+# process the README into a manual page using ronn
+require 'ronn'
+task :man do
+  print "Writing manual page..."
+  FileUtils.mkdir_p 'man'
+  File.open('man/wfa.1','w') do |man|
+    man.write Ronn::Document.new('README.md').to_roff
+  end
+  puts "done."
+end
+task "build:gem:wfa" => :man
+
+Gem::Tasks.new
+task :default => "build:gem:wfa"

data/bin/wfa

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'wfa'
+WFA::Command.new(ARGV).start_wfa_command

data/lib/wfa/command.rb

@@ -0,0 +1,203 @@
+require 'optparse'
+require 'io/console'
+require 'yajl'
+require 'fileutils'
+
+require 'wfa/generic_api'
+
+class WFA::Command
+  def initialize args
+    @device_tag, @before_args, @after_args = extract_device_tag args
+    option_parser.permute!(@before_args)
+
+    @settings = {}
+    load_settings unless no_cache
+
+    @command =
+      if @device_tag.nil?
+        @before_args.shift || 'list'
+      else
+        if @before_args.count > 0
+          @before_args.shift
+        elsif @after_args.count > 0
+          "run"
+        else
+          "shell"
+        end
+      end
+  end
+
+  def start_wfa_command
+    case @command
+    when 'identify'
+        public_send @command, *@before_args, @device_tag, *@after_args
+    else
+        public_send @command, @device_tag, *@after_args
+    end
+    save_settings
+  rescue NoMethodError => e
+    $stderr.puts "no such command: #{@command}"
+  rescue Faraday::ClientError => e
+    $stderr.puts e.message
+  rescue StandardError => e
+    $stderr.puts e.message
+  end
+
+  def console *args
+    puts "Try e.g.: http.get('devices').body"
+    WFA::Console.new self, net
+  end
+
+  # list configured devices
+  def list *args
+    # force a reload of the device list
+    WFA::Device.fetch_and_cache_device_list(net)
+    puts WFA::Device.all(net).select {|device| show_all || device.tag }
+  end
+
+  # open a screen on the specified device
+  def screen device_tag, *args
+    device = WFA::Device.by_tag(net, device_tag) or raise "no such device"
+    shell_command "screen -t #{device.tag} -- ssh -A workfrom@#{device.last_ip_addr}"
+  end
+
+  # open a shell on the specified device
+  def shell device_tag, *args
+    device = WFA::Device.by_tag(net, device_tag) or raise "no such device"
+    shell_command "ssh -A workfrom@#{device.last_ip_addr}"
+  end
+
+  # issue a command on the specified device
+  def run device_tag, *args
+    device = WFA::Device.by_tag(net, device_tag) or raise "no such device"
+    shell_command "ssh -A workfrom@#{device.last_ip_addr} #{args.join(' ')}"
+  end
+
+  def heartbeats device_tag, *args
+    device = WFA::Device.by_tag(net, device_tag) or raise "no such device"
+    puts device.heartbeats(net)
+  end
+
+  def identify port, device_tag, *args
+    device = WFA::Device.find(net, id)
+    if device.update_remote(net, tag:device_tag.sub(/^@/,''), name:args.join(' '))
+      puts 'updated!'
+    else
+      puts 'update failed :('
+    end
+  end
+
+  private
+
+  attr_accessor :dry_run, :base_url_option, :no_cache, :show_all, :login_option, :password_option
+
+  def load_settings
+    @settings = Yajl::Parser.parse(File.read("#{ENV['HOME']}/.wfa.json"), symbolize_keys:true)
+  rescue Errno::ENOENT, Yajl::ParseError
+  end
+
+  def save_settings
+    File.open("#{ENV['HOME']}/.wfa.json", "w").tap do |f|
+      f.write(Yajl::Encoder.encode(@settings))
+      f.close
+      FileUtils.chmod(0600, "#{ENV['HOME']}/.wfa.json")
+    end
+  end
+
+  def login_setting
+    @settings[:login] ||= ask("backend login: ")
+  end
+
+  def password_setting
+    @settings[:password] ||= ask_private("backend password: ")
+  end
+
+  def base_url_setting
+    @settings[:base_url] ||= ask("backend URL: ")
+  end
+
+  def ask prompt
+    print prompt
+    $stdin.readline.chomp
+  end
+
+  def ask_private prompt
+    print prompt
+    $stdin.noecho(&:readline).chomp.tap { puts }
+  end
+
+
+  def net_without_auth
+    GenericApi.connect(base_url_option||base_url_setting)
+  end
+
+  def net
+    @net ||= begin
+      login = login_option||login_setting
+      password = password_option||password_setting
+      url = base_url_option||base_url_setting
+      GenericApi.connect(url, login, password)
+    end
+  end
+
+  # execute a shell command. in dry run mode, just print the command to be executed.
+  def shell_command cmd
+    if dry_run
+      puts cmd
+    else
+      exec cmd
+    end
+  end
+
+  # configure and return the option parser
+  def option_parser
+    self.base_url_option = ENV['WFDEVICE_BACKEND_URL']
+    self.login_option = nil
+    self.password_option = nil
+    self.no_cache = false
+    self.dry_run = false
+    self.show_all = false
+    OptionParser.new("Usage: wfa [-aCD] [<command>] [@<device_tag>] ...") do |opts|
+      opts.on("-u URL", "--base-url URL", "backend base URL") do |url|
+        self.base_url_option = url
+      end
+      opts.on("-l NAME", "--login NAME", "backend login name") do |name|
+        self.login_option = name
+      end
+      opts.on("-p PASS", "--p PASS", "backend password") do |pass|
+        self.password_option = pass
+      end
+      opts.on("-a", "--show-all", "Show untagged devices in listing") do
+        self.show_all = true
+      end
+      opts.on("-C", "--clear-settings", "Clear local settings before the operation") do
+        self.no_cache = true
+      end
+      opts.on("-D", "--dry-run", "Print the command that would be run without running it") do
+        self.dry_run = true
+      end
+    end
+  end
+
+  # given the complete command arguments, find the device tag (if any)
+  # and return arrays of arguments both before and after the tag.
+  # If no tag is present all args are in the returned before args.
+  def extract_device_tag args
+    args = args.dup
+    tag = nil
+    before = []
+    after = []
+    args.each do |a|
+      if tag.nil?
+        if a.match(/^@[\w-]+$/)
+          tag = a
+        else
+          before << a
+        end
+      else
+        after << a
+      end
+    end
+    [tag, before, after]
+  end
+end

data/lib/wfa/console.rb

@@ -0,0 +1,16 @@
+require 'pp'
+require 'pry'
+
+module WFA
+  class Console
+    attr_reader :wfa, :http
+    def initialize app, http
+      @wfa = app
+      @http = http
+      prompt = $PROGRAM_NAME.split('/').last + "> "
+      binding.pry quiet: true,
+        prompt:[->(a,b,c){ prompt }],
+        print:->(io, *ps){ ps.each {|p|PP.pp p, io, 100 } }
+    end
+  end
+end

data/lib/wfa/device.rb

@@ -0,0 +1,98 @@
+require 'csv'
+require 'fileutils'
+require 'time'
+
+class WFA::Device
+  WFDEVICE_PORT_FILE = '/etc/wfdevice_tunnel_port.sh'
+  FING_CSV_FILE = '/var/fing.csv'
+
+  ATTRIBUTES = [
+    :id, :name, :tag, :tunnel_port, :macaddr, :secret_key,
+    :state, :vendor, :hostname, :last_heartbeat, :last_ip_addr
+  ]
+  attr_accessor(*ATTRIBUTES)
+
+  def initialize attrs
+    update attrs
+  end
+
+  def to_s
+    "@%s: %s (%d) [%s] %s" % [
+      tag||"---", name, id, last_ip_addr,
+      last_heartbeat ? time_ago(Time.parse(last_heartbeat)) : ''
+    ]
+  end
+
+  def time_ago timestamp
+    seconds = (Time.now - timestamp).to_i
+    minutes = seconds / 60
+    return "#{seconds}s" unless minutes > 1
+    hours = minutes / 60
+    return "#{minutes}m" unless hours > 1
+    days = hours / 24
+    return "#{hours}h" unless days > 1
+    weeks = days / 7
+    return "#{days}d" unless weeks > 1
+    "#{weeks}w"
+  end
+
+  def heartbeats net
+    net.get(path("heartbeats")).body[:heartbeats].map{|h| WFA::Heartbeat.new(h) }
+  end
+
+  def update_remote net, attrs
+    update attrs
+    net.put(path, name:name, tag:tag).success?
+  end
+
+  def update attrs
+    ATTRIBUTES.each { |attr|
+      if !attrs[attr].nil? && send(attr) != attrs[attr]
+        send("#{attr}=", attrs[attr])
+      end
+    }
+  end
+
+  def path *args
+    (["devices/#{id}"]+args).join("/")
+  end
+
+  class << self
+    def device_list_cache
+      "#{ENV['HOME']}/.wfa_device_list.json"
+    end
+
+    def by_tag net, tag
+      tag = tag.sub(/^@/,'')
+      all(net).detect {|device| device.tag == tag }
+    end
+
+    def find net, id
+      all(net).detect {|device| device.id == id }
+    end
+
+    def all net
+      @all ||= devices_list(net)[:devices].map do |device|
+        new device
+      end
+    end
+
+    def devices_list net
+      get_cached_device_list || fetch_and_cache_device_list(net)
+    end
+
+    def get_cached_device_list
+      File.exists?(device_list_cache) \
+        ? Yajl::Parser.parse(File.read(device_list_cache), symbolize_keys:true) \
+        : raise('no cache!')
+    end
+
+    def fetch_and_cache_device_list net
+      net.get('devices').body.tap do |ds|
+        f = File.open(device_list_cache, "w")
+        f.write(Yajl::Encoder.encode(ds))
+        f.close
+      end
+    end
+  end
+end

data/lib/wfa/generic_api.rb

@@ -0,0 +1,97 @@
+#
+# This module is a starter Ruby client for your REST API, based on Faraday:
+# https://github.com/lostisland/faraday/
+#
+# It supports HTTP basic authentication, sending and recieving JSON, and simple error reporting.
+# I use this as a basis for building API clients in most of my Ruby projects.
+#
+# Use it like this:
+#
+#     http = GenericApi.connect('http://localhost:3000/', 'myname', 'secret')
+#     http.get('boxes.json').body.each do |box|
+#       puts "found a box named #{box[:name]}! Let's put something inside."
+#       http.post('boxes/#{box[:id]}.json', contents: 'something!')
+#     end
+#
+# A few hints for getting started:
+#
+# This uses Patron as the HTTP client but you can change those constants to use
+# another adapter or set to nil to use the built-in default.
+#
+# The response body is a Hash with Symbol keys (not String!).
+# If you're using ActiveSupport, you should use a hash with indifferent access instead.
+#
+# The default MIME type is appropriate for most purposes, but some APIs use it for
+# versioning so bear that in mind and change MIME_TYPE if necessary.
+#
+# Warmest regards,
+#
+# Zack Hobson <zack@zackhobson.com>
+#
+require 'faraday'
+module GenericApi
+  FARADAY_ADAPTER = :patron
+  REQUIRE_DEPENDENCIES = ['patron']
+  MIME_TYPE = 'application/json'
+
+  # Connect and return a `Faraday::Connection` instance:
+  # http://rdoc.info/github/lostisland/faraday/Faraday/Connection
+  #
+  # If login and password are provided, the connection will use basic auth.
+  def self.connect url, login=nil, password=nil
+    Faraday.new(url) do |f|
+      f.use :generic_api, login, password
+      f.adapter(FARADAY_ADAPTER || Faraday.default_adapter)
+    end
+  end
+
+  class Middleware < Faraday::Request::BasicAuthentication
+    Faraday::Middleware.register_middleware generic_api: ->{ self }
+
+    dependency do
+      require 'yajl'
+      (REQUIRE_DEPENDENCIES||[]).each {|dep| require dep }
+    end
+
+    def call(env)
+      # encode with and accept json
+      env[:request_headers]['Accept'] = MIME_TYPE
+      env[:request_headers]['Content-Type'] = MIME_TYPE
+      env[:body] = Yajl::Encoder.encode(env[:body]) if env[:body]
+
+      # response processing
+      super(env).on_complete do |env|
+        begin
+          env[:body] = Yajl::Parser.parse(env[:body], symbolize_keys:true)
+          # XXX or, if you're using ActiveSupport:
+          # env[:body] = Yajl::Parser.parse(env[:body]).with_indifferent_access
+        rescue Yajl::ParseError
+          raise ApiError.new("Unable to parse the response:\n#{env[:body]}", env)
+        end
+        case env[:status]
+        when 300..399
+          raise RedirectError.new(env[:body][:message], env)
+        when 400..499
+          raise AuthError.new(env[:body][:message], env)
+        when 500..599
+          raise ApiError.new(env[:body][:message], env)
+        end
+      end
+    end
+  end
+  class ApiError < Faraday::ClientError
+    def initialize(message, response)
+      super("Upstream API failure: #{message||'Internal error.'}", response)
+    end
+  end
+  class AuthError < Faraday::ClientError
+    def initialize(message, response)
+      super("Authentication failure: #{message||'No reason given.'}", response)
+    end
+  end
+  class RedirectError < Faraday::ClientError
+    def initialize(message, response)
+      super("Redirected: #{message||'No reason given.'}", response)
+    end
+  end
+end

data/lib/wfa/heartbeat.rb

@@ -0,0 +1,14 @@
+require 'time'
+
+class WFA::Heartbeat
+  attr_reader :active_nodes, :created_at, :ip_addr
+  def initialize attrs
+    @ip_addr =  attrs[:ip_addr]
+    @active_nodes =  attrs[:active_nodes]
+    @created_at =  Time.parse(attrs[:created_at])
+  end
+
+  def to_s
+    "%s: %d active nodes [%s]" % [ created_at.strftime("%F %T"), active_nodes, ip_addr ]
+  end
+end

data/lib/wfa/version.rb

@@ -0,0 +1,3 @@
+module WFA
+  VERSION = "0.1"
+end

data/lib/wfa.rb

@@ -0,0 +1,8 @@
+# must be required at start to register itself as a middleware
+module WFA
+  autoload :VERSION, 'wfa/version'
+  autoload :Command, 'wfa/command'
+  autoload :Console, 'wfa/console'
+  autoload :Device, 'wfa/device'
+  autoload :Heartbeat, 'wfa/heartbeat'
+end

data/man/wfa.1

@@ -0,0 +1,121 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "WFA" "1" "June 2014" "" ""
+.
+.SH "NAME"
+\fBwfa\fR \- manage workfrom devices
+.
+.SH "SYNOPSIS"
+.
+.nf
+
+wfa [\-a|\-\-show\-all] [list]
+wfa [\-D|\-\-dry\-run] [shell] @<device\-tag>
+wfa [\-D|\-\-dry\-run] [run] @<device\-tag> <remote\-command \.\.\.>
+wfa identify <device\-id> @<device\-tag> <name>
+wfa screen @<device\-tag>
+wfa heartbeats @<device\-tag>
+wfa console
+.
+.fi
+.
+.SH "DESCRIPTION"
+\fBwfa\fR is a tool for listing and connecting to workfrom devices via SSH\. It is operated using sub\-commands, but for simple use cases the sub\-command is assumed\.
+.
+.SH "COMMANDS"
+.
+.SS "list"
+Display a list of registered devices\. Each device has a tag assigned for use in issuing commands\. This command is assumed if you provide no arguments\. Use \fB\-a\fR to list untagged devices\.
+.
+.SS "shell"
+Open an interactive shell on the remote device, specified by the device tag\. This command is assumed if you provide a device tag without additional arguments\.
+.
+.SS "run"
+Issue a command on a device and display the output\. This command is assumed if you provide a device tag with an additional command argument\.
+.
+.SS "identify"
+Set a device tag and name, given the device ID\. Devices must be tagged in order to be maintained with wfa\.
+.
+.SS "screen"
+Open a screen window to a shell on the remote device, specified by the device tag\. Useful if you\'re running screen and want titled windows for each device\.
+.
+.SS "heartbeats"
+List the last 100 or so device heartbeats, specified by the device tag\.
+.
+.SS "console"
+Open an interactive Ruby prompt with a ready API handle\. It\'s useful for experimentation or exploring the API\.
+.
+.SH "USAGE"
+\fBNote\fR that you must be logged in to the tunnel server (as yourself) to use the SSH tunneling features\. No authentication is performed, you must have SSH auth already configured to use it\.
+.
+.P
+To see a list of devices:
+.
+.IP "" 4
+.
+.nf
+
+wfa
+.
+.fi
+.
+.IP "" 0
+.
+.P
+To open a shell on a device:
+.
+.IP "" 4
+.
+.nf
+
+wfa @ovation
+.
+.fi
+.
+.IP "" 0
+.
+.P
+To run a command on a device:
+.
+.IP "" 4
+.
+.nf
+
+wfa @ovation cat /etc/hostname
+.
+.fi
+.
+.IP "" 0
+.
+.P
+To run these commands from your own machine, prepend \fBssh \-A <login>@staging\.workfrom\.co\fR and they\'ll work more or less the same way\. (\fB\-A\fR enables agent forwarding, which you need to access the devices themselves\.)
+.
+.SH "ADVANCED"
+.
+.SS "Installation notes"
+To install the gem you need to install some library dependencies\. For example, this works on Debian:
+.
+.IP "" 4
+.
+.nf
+
+sudo apt\-get install ruby\-dev libcurl4\-openssl\-dev
+.
+.fi
+.
+.IP "" 0
+.
+.SS "Distribution"
+Currently wfa is distributed via Zack\'s dropbox\. The URL is:
+.
+.P
+https://dl\.dropboxusercontent\.com/u/16760254/wfa\-latest\.gem
+.
+.P
+To release a new version, Zack just builds the gem and copies to his dropbox public folder\.
+.
+.SH "FILES"
+.
+.SS "~/\.wfa\.json"
+Saved settings for \fBwfa\fR, including login credentials and backend URL\.

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: wfa
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Zack Hobson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ronn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Workfrom Admin tools
+email: zack@zackhobson.com
+executables:
+- wfa
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- Gemfile
+- bin/wfa
+- man/wfa.1
+- README.md
+- lib/wfa/command.rb
+- lib/wfa/console.rb
+- lib/wfa/device.rb
+- lib/wfa/generic_api.rb
+- lib/wfa/heartbeat.rb
+- lib/wfa/version.rb
+- lib/wfa.rb
+homepage: http://workfrom.co/
+licenses:
+- private
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: command-line tool for listing and connecting to workfrom devices via SSH
+test_files: []