rye 0.3.2 → 0.4

data/CHANGES.txt

@@ -1,5 +1,25 @@
 RYE, CHANGES
 
+TODO
+
+* Fingerprints: ssh-keygen -l -f id_rsa_repos.pub
+
+
+#### 0.4.0 (2009-04-06) #############################
+
+* ADDED: to_s and inspect methods for cleaner debugging output
+* ADDED: == method for Rye::Box
+* ADDED: exit code and exit signal to Rye::Rap objects
+* ADDED: commands now raise a Rye::CommandError exception 
+when the command returns an exit code greater than 0. 
+* CHANGED: Box.add_command renamed to Box.run_command
+* FIXED: Box.run_command was parsing arguments incorrectly 
+* FIXED: Box.net_ssh_exec was working on nil stderr
+* FIXED: bin/try handles the new command exceptions
+* ADDED: Command switches can now be sent as Symbols (rbox.ls(:h))
+* ADDED: Rye.host_keys
+* ADDED: bin/rye
+
 
 #### 0.3.2 (2009-04-05) #############################
 

data/README.rdoc

@@ -1,10 +1,10 @@
-= Rye - v0.3
+= Rye - v0.4
 
 Safely run remote commands via SSH in Ruby. 
 
 Rye is similar to Rush[http://rush.heroku.com] but everything happens over SSH (no HTTP daemon) and the default settings are less powerful (for safety). For example, file globs are disabled so unless otherwise specified, you can't do this: <tt>rbox.rm('-rf', '/etc/**/*')</tt>.
 
-See bin/try for working examples.
+See the examples below (which are taken from bin/try).
 
 == Installation
 
@@ -20,7 +20,7 @@ One of:
     rbox = Rye::Box.new('localhost')
     
     # Commands are run as methods on the Rye::Box object
-    puts rbox.uptime                # => 11:02  up 16:01, 3 users
+    puts rbox.uptime                   # => 11:02  up 16:01, 3 users
     
     # The response value for all commands is a Rye::Rap object. The rap is a
     # subclass of Array so you can treat it as an Array, but it can also act 
@@ -57,12 +57,9 @@ One of:
     # Safe-mode is enabled by default. In safe-mode, all command 
     # arguments are thoroughly escaped. This prevents access to
     # environment variables and file globs (among other things).
-    p rbox_safe.echo('$HOME')                   # => "$HOME"
-    p rbox_safe['/etc'].ls('host*')             # => 
-    p rbox_safe.ls('-l | wc -l')                # => 
-    p rbox_safe.echo('$HOME > /tmp/rye-home')   # => "$HOME > /tmp/home"
-    p rbox_safe.cat('/tmp/rye-home')            # => 
-    p rbox_safe.cat('/tmp/rye-home').stderr     # => "No such file or directory"
+    p rbox_safe.echo('$HOME')                                    # => "$HOME"
+    p rbox_safe['/etc'].ls('host*')  rescue Rye::CommandError    # Doesn't exist
+    p rbox_safe.ls('-l | wc -l')     rescue Rye::CommandError    # => '|' is not a valid ls arg
 
     # Here's the same commands with safe-mode disabled:
     p rbox_wild.echo('$HOME')                   # => "/home/rye"
@@ -70,8 +67,6 @@ One of:
     p rbox_wild.ls('-l | wc -l')                # => 110
     p rbox_wild.echo('$HOME > /tmp/rye-home')   # => 
     p rbox_wild.cat('/tmp/rye-home')            # => "/home/rye"
-    p rbox_wild.rm('/tmp/rye-home')             # =>
-
 
 
 == EXAMPLE 3 -- Custom Commands
@@ -86,10 +81,10 @@ One of:
     # automatically become available to all Rye::Box objects.
     module Rye::Cmd
       def rye9000(*args)
-        add_command("ls", args)
+        run_command("ls", args)
       end
       def somescript(*args)
-        add_command("/path/to/my/script", args)
+        run_command("/path/to/my/script", args)
       end
     end
     
@@ -132,6 +127,52 @@ One of:
     p rset.env.first.select { |env| env =~ /RYE/ }  # => ["RYE=Forty Creek"]
 
 
+== EXAMPLE 5 -- ERROR HANDLING
+
+    rbox = Rye::Box.new('localhost', :safe => false)
+
+    # Rye follows the standard convention of taking exception to a non-zero 
+    # exit code by raising a Rye::CommandError. In this case, rye9000.test
+    # is not found by the ls command. 
+    begin
+      rbox.ls('rye9000.test')
+    rescue Rye::CommandError => ex
+      puts ex.exit_code                # => 1
+      puts ex.stderr                   # => ls: rye.test: No such file or directory
+    end
+
+    # The Rye:Rap response objects also give you the STDOUT and STDERR
+    # content separately. Here we redirect STDOUT to STDERR, so this
+    # will return nothing:
+    puts rbox.uname('-a 1>&2').stdout    # =>
+
+    # It all went to STDERR:
+    puts rbox.uname('-a 1>&2').stderr    # => Darwin ryehost 9.6.0 ...
+
+    # There were no actual error so the exit code should be 0.
+    puts rbox.uname('-a 1>&2').exit_code # => 0
+
+== EXAMPLE 6 -- rye
+
+Rye comes with a command-line utility called <tt>rye</tt>.
+
+    # Prints the paths to your private keys
+    $ rye keys
+    
+    # Prints the server host keys (suitable for ~/.ssh/known_hosts)
+    $ rye hostkey HOST1 HOST2
+    
+    # Add your public keys to authorized_keys and authorized_keys2 
+    # on a remote machine
+    $ rye authorize HOST1 HOST2
+    
+More info:
+
+    $ rye -h
+    $ rye COMMAND -h
+    $ rye show-commands
+
+
 == About Safe-Mode
 
 In safe-mode:
@@ -148,21 +189,26 @@ Using a Ruby interface to execute shell commands is pretty awesome, particularly
 
 == Command Whitelist
 
-Rye permits only a limited number of system commands to be run. This default whitelist is defined in Rye::Cmd but you can add your own commands as you please (see Example 2).
-
-== Credits
+Rye permits only a limited number of system commands to be run. This default whitelist is defined in Rye::Cmd[http://github.com/delano/rye/blob/master/lib/rye/cmd.rb] but you can add your own commands as you please (see Example 3).
 
-* Delano Mandelbaum (delano@solutious.com)
+== Dependencies
 
+* OpenSSL[http://www.openssl.org] (The C library)
+* Ruby Gems:
+  * net-ssh
+  * net-scp
+  * highline
+  * drydock
 
-== Thanks
+== Known Issues
 
-* Solutious Incorporated (http://solutious.com) for all the orange juice.
-* The country of Canada for making Rye Whisky. 
+This list will grow. If you find one let me know!
 
+* Rye doesn't read the ~/.ssh/config file yet
 
-== Kudos
+== Thanks
 
+* Solutious Incorporated (http://solutious.com) for all the orange juice.
 * http://github.com/adamwiggins/rush
 * http://github.com/jamis/capistrano/blob/master/lib/capistrano/shell.rb
 * http://www.nofluffjuststuff.com/blog/david_bock/2008/10/ruby_s_closure_cleanup_idiom_and_net_ssh.html
@@ -178,7 +224,7 @@ Rye permits only a limited number of system commands to be run. This default whi
 == Credits
 
 * Delano Mandelbaum (delano@solutious.com)
-
+* Escape, Copyright (C) 2006,2007 Tanaka Akira  <akr@fsij.org>
 
 == License
 

data/bin/rye

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby
+
+# Rye -- A CLI for some handy SSH tools
+#
+# If your reading this via the rdocs you won't be able to see the code
+# See: http://github.com/delano/rye/blob/master/bin/rye
+#
+# Usage: rye
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'stringio'
+require 'yaml'
+require 'drydock'
+require 'rye'
+
+include Drydock
+
+global :p, :path, String, "A directory containing SSH private keys or the path to a private key"
+
+before do |obj|
+  STDERR.puts
+  # Load private keys if specified
+  if obj.global.path
+    keys = Rye.find_private_keys(obj.global.path) 
+    Rye.add_keys(keys)
+  end
+end
+
+after do
+  STDERR.puts
+end
+
+desc "Add your public keys to one or more remote machines"
+option :u, :user, String, "Username"
+argv :hostname
+command :authorize do |obj|
+  raise "You must specify a host" unless obj.argv.hostname
+  
+  highline = HighLine.new # Used for password prompt
+  
+  opts = { :debug => nil }
+  opts[:user] = obj.option.user if obj.option.user
+  
+  obj.argv.each do |hostname|
+    puts "Authorizing #{hostname}"
+    
+    retried = 0
+    begin
+      rbox = Rye::Box.new(hostname, opts).connect
+      
+      # We know we're already authorized b/c we didn't have to give a password
+      if retried == 0
+        puts "%s is already authorized" % rbox.opts[:user]
+        puts
+        next
+      end
+      
+    # An authentication failure means either the requested user doesn't
+    # exist on the remote machine or we need to supply a password. 
+    rescue Net::SSH::AuthenticationFailed => ex
+      retried += 1
+      opts[:password] = highline.ask("Password: ") { |q| q.echo = '' }
+      retry unless retried > 3
+    rescue Net::SSH::AuthenticationFailed
+      STDERR.puts "Authentication failed."
+      exit 1
+    end
+    
+    puts "Added public keys for: ", rbox.authorize_keys
+    
+    puts
+  end
+  
+end
+command_alias :authorize, :authorise
+
+
+desc "Generate a public key from a private key"
+
+
+
+desc "Fetch the host keys for remote machines (suitable for your ~/.ssh/known_hosts file)"
+usage "rye hostkey HOSTNAME [HOSTNAME2 HOSTNAME3 ...]"
+argv :hostname
+command :hostkeys do |obj|
+  raise "You must specify a host" unless obj.argv.hostname
+  ret = Rye.remote_host_keys(obj.argv.hostname)
+  STDERR.puts $/, ret.stderr, $/
+  puts ret.stdout
+end
+command_alias :hostkeys, :hostkey
+
+
+desc "Display your private keys"
+command :keys do |obj|
+  Rye.keys.each do |key|
+    puts key.join(' ')
+  end
+end
+
+desc "Display your public SSH keys"
+usage "rye pubkeys [--pem] [KEYPATH]"
+option :p, :pem, "Output in PEM format"
+argv :keypath
+command :pubkeys do |obj|
+  keys = obj.argv.empty? ? Rye.keys.collect { |k| k[2] } : obj.argv
+  keys.each do |path|
+    STDERR.puts "# Public SSH key for #{path}"
+    k = Rye::Key.from_file(path)
+    puts obj.option.pem ? k.public_key.to_pem : k.public_key.to_ssh2
+  end
+end
+command_alias :pubkeys, :pubkey
+
+
+default :keys
+debug :on
+
+# We can Drydock specifically otherwise it will run at_exit. Rye also
+# uses at_exit for shutting down the ssh-agent. Ruby executes at_exit
+# blocks in reverse order so if Drydock is required first, it's block
+# will run after Rye shuts down the ssh-agent. 
+begin
+  Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+rescue => ex
+  STDERR.puts "ERROR (#{ex.class.to_s}): #{ex.message}"
+  STDERR.puts ex.backtrace if Drydock.debug?
+end

data/bin/try

@@ -24,22 +24,18 @@ puts %Q(
 rbox = Rye::Box.new('localhost')
 
 # Commands are run as methods on the Rye::Box object
-puts rbox.uptime                # => 11:02  up 16:01, 3 users
+puts rbox.uptime                   # => 11:02  up 16:01, 3 users
 
 # The response value for all commands is a Rye::Rap object. The rap is a
 # subclass of Array so you can treat it as an Array, but it can also act 
 # like a String if there's only one element. 
-puts rbox.ls('rye.test')           # => ""
-puts rbox.ls('rye.test').stderr    # => ls: rye.test: No such file or directory
+p rbox.ls(:a, '/')                 # => ['.', '..', 'bin', 'etc', ...]
 
-puts rbox.touch('rye.test')        # => ""
-puts rbox.rm('rye.test')           # => ""
-                                 
 # You can change directories
 puts rbox.pwd                      # => /home/rye
 puts rbox['/usr/bin'].pwd          # => /usr/bin
 puts rbox.pwd                      # => /usr/bin
-puts rbox.cd('/home/rye').pwd      # => /home/rye
+puts rbox.cd(Rye.sysinfo.home).pwd # => /home/rye
 
 # You can specify environment variables
 rbox.add_env(:RYE, "Forty Creek")
@@ -64,12 +60,9 @@ rbox_wild = Rye::Box.new('localhost', :safe => false)
 # Safe-mode is enabled by default. In safe-mode, all command 
 # arguments are thoroughly escaped. This prevents access to
 # environment variables and file globs (among other things).
-p rbox_safe.echo('$HOME')                   # => "$HOME"
-p rbox_safe['/etc'].ls('host*')             # => 
-p rbox_safe.ls('-l | wc -l')                # => 
-p rbox_safe.echo('$HOME > /tmp/rye-home')   # => "$HOME > /tmp/home"
-p rbox_safe.cat('/tmp/rye-home')            # => 
-p rbox_safe.cat('/tmp/rye-home').stderr     # => "No such file or directory"
+p rbox_safe.echo('$HOME')                                    # => "$HOME"
+p rbox_safe['/etc'].ls('host*')  rescue Rye::CommandError    # Doesn't exist
+p rbox_safe.ls('-l | wc -l')     rescue Rye::CommandError    # => '|' is not a valid ls arg
 
 # Here's the same commands with safe-mode disabled:
 p rbox_wild.echo('$HOME')                   # => "/home/rye"
@@ -77,7 +70,7 @@ p rbox_wild['/etc'].ls('host*')             # => ["hostconfig", "hosts"]
 p rbox_wild.ls('-l | wc -l')                # => 110
 p rbox_wild.echo('$HOME > /tmp/rye-home')   # => 
 p rbox_wild.cat('/tmp/rye-home')            # => "/home/rye"
-p rbox_wild.rm('/tmp/rye-home')             # =>
+
 
 
 puts %Q(
@@ -95,10 +88,10 @@ p rbox.commands.member?('rye9000')   # => false
 # automatically become available to all Rye::Box objects.
 module Rye::Cmd
   def rye9000(*args)
-    add_command("ls", args)
+    run_command("ls", args)
   end
   def somescript(*args)
-    add_command("/path/to/my/script", args)
+    run_command("/path/to/my/script", args)
   end
 end
 
@@ -121,7 +114,7 @@ rset.add_boxes(rbox, 'localhost')      # Add boxes as hostnames or objects
 # Calling methods on Rye::Set objects is very similar to calling them on
 # Rye::Box objects. In fact, it's identical:
 p rset.uptime        # => [[14:19:02 up 32 days, 19:35 ...], [14:19:02 up 30 days, 01:35]]
-p rset['/etc'].ls    # => [['file1', 'file2', ...], ['life1', 'life2', ...]]
+p rset['/usr'].ls    # => [['bin', 'etc', ...], ['bin', 'etc', ...]]
 
 # Like Rye::Box, the response value is a Rye::Rap object containing the
 # responses from each box. Each response is itself a Rye::Rap object.
@@ -144,5 +137,35 @@ rset.add_env(:RYE, "Forty Creek")
 p rset.env.first.select { |env| env =~ /RYE/ }  # => ["RYE=Forty Creek"]
 
 
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 5 -- ERROR HANDLING
+#)
+
+rbox = Rye::Box.new('localhost', :safe => false)
+
+# Rye follows the standard convention of taking exception to a non-zero 
+# exit code by raising a Rye::CommandError. In this case, rye9000.test
+# is not found by the ls command.
+begin
+  rbox.ls('rye.test')
+rescue Rye::CommandError => ex
+  puts ex.exit_code                # => 1
+  puts ex.stderr                   # => ls: rye.test: No such file or directory
+end
+
+# The Rye:Rap response objects also give you the STDOUT and STDERR
+# content separately. Here we redirect STDOUT to STDERR, so this
+# will return nothing:
+puts rbox.uname('-a 1>&2').stdout    # =>
+
+# It all went to STDERR:
+puts rbox.uname('-a 1>&2').stderr    # => Darwin ryehost 9.6.0 ...
+
+# There were no actual error so the exit code should be 0.
+puts rbox.uname('-a 1>&2').exit_code # => 0
+
+
+
 
 

data/lib/rye.rb

@@ -1,9 +1,14 @@
 
 require 'rubygems' unless defined? Gem
 
+require 'tempfile'
 require 'net/ssh'
+require 'net/scp'
 require 'thread'
 require 'highline'
+require 'openssl'
+require 'base64'
+
 require 'esc'
 require 'sys'
 
@@ -24,7 +29,7 @@ module Rye
   extend self
 
   unless defined?(SYSINFO)
-    VERSION = 0.3.freeze
+    VERSION = 0.4.freeze
     SYSINFO = SystemInfo.new.freeze
   end
   
@@ -37,30 +42,68 @@ module Rye
   # Accessor for an instance of SystemInfo
   def sysinfo; SYSINFO;  end
   
-  class CommandNotFound < RuntimeError; end
   class NoBoxes < RuntimeError; end
   class NoHost < RuntimeError; end
   class NotConnected < RuntimeError; end
+  class CommandNotFound < RuntimeError; end
+  class CommandError < RuntimeError
+    # * +rap+ a Rye::Rap object
+    def initialize(rap)
+      @rap = rap
+    end
+    def message
+      "(code: %s) %s" % [@rap.exit_code, @rap.stderr.join($/)]
+    end
+    def stderr; @rap.stderr if @rap; end
+    def stdout; @rap.stdout if @rap; end
+    def exit_code; @rap.exit_code if @rap; end
+  end
   
   # Reload Rye dynamically. Useful with irb. 
   # NOTE: does not reload rye.rb. 
   def reload
     pat = File.join(File.dirname(__FILE__), 'rye')
-    %w{rap cmd box set}.each {|lib| load File.join(pat, "#{lib}.rb") }
+    %w{key rap cmd box set}.each {|lib| load File.join(pat, "#{lib}.rb") }
   end
   
   def mutex
     @@mutex
   end
   
+  # Looks for private keys in +path+ and returns and Array of paths
+  # to the files it fines. Raises an Exception if path does not exist.
+  # If path is a file rather than a directory, it will check whether
+  # that single file is a private key.
+  def find_private_keys(path)
+    raise "#{path} does not exist" unless File.exists?(path || '')
+    if File.directory?(path)
+      files = Dir.entries(path).collect { |file| File.join(path, file) }
+    else
+      files = [path]
+    end
+    
+    files = files.select do |file|
+      next if File.directory?(file)
+      pk = nil
+      begin
+        tmp = Rye::Key.from_file(file) 
+        pk = tmp if tmp.private?
+      rescue OpenSSL::PKey::PKeyError
+      end
+      !pk.nil?
+    end
+    files || []
+  end
   
+  
+
+
   # Add one or more private keys to the SSH Agent. 
   # * +keys+ one or more file paths to private keys used for passwordless logins. 
   def add_keys(*keys)
-    keys = [keys].flatten.compact || []
+    keys = keys.flatten.compact || []
     return if keys.empty?
-    Rye::Box.shell("ssh-add", keys) if keys
-    Rye::Box.shell("ssh-add") # Add the user's default keys
+    Rye.shell("ssh-add", keys) if keys
     keys
   end
   
@@ -73,13 +116,105 @@ module Rye
   def keys
     # 2048 76:cb:d7:82:90:92:ad:75:3d:68:6c:a9:21:ca:7b:7f /Users/rye/.ssh/id_rsa (RSA)
     # 2048 7b:a6:ba:55:b1:10:1d:91:9f:73:3a:aa:0c:d4:88:0e /Users/rye/.ssh/id_dsa (DSA)
-    keystr = Rye::Box.shell("ssh-add", '-l')
+    keystr = Rye.shell("ssh-add", '-l')
     return nil unless keystr
-    keystr.split($/).collect do |key|
+    keystr.collect do |key|
       key.split(/\s+/)
     end
   end
   
+  def remote_host_keys(*hostnames)
+    hostnames = hostnames.flatten.compact || []
+    return if hostnames.empty?
+    Rye.shell("ssh-keyscan", hostnames)
+  end
+  
+  # Takes a command with arguments and returns it in a 
+  # single String with escaped args and some other stuff. 
+  # 
+  # * +cmd+ The shell command name or absolute path.
+  # * +args+ an Array of command arguments.  
+  #
+  # The command is searched for in the local PATH (where
+  # Rye is running). An exception is raised if it's not
+  # found. NOTE: Because this happens locally, you won't
+  # want to use this method if the environment is quite
+  # different from the remote machine it will be executed
+  # on. 
+  #
+  # The command arguments are passed through Escape.shell_command
+  # (that means you can't use environment variables or asterisks).
+  #
+  def prepare_command(cmd, *args)
+    args &&= [args].flatten.compact
+    cmd = Rye.which(cmd)
+    raise CommandNotFound.new(cmd || 'nil') unless cmd
+    # Symbols to switches. :l -> -l, :help -> --help
+    args.collect! do |a|
+      a = "-#{a}" if a.is_a?(Symbol) && a.to_s.size == 1
+      a = "--#{a}" if a.is_a?(Symbol)
+      a
+    end
+    Rye.escape(@safe, cmd, *args)
+  end
+  
+  # An all ruby implementation of unix "which" command. 
+  #
+  # * +executable+ the name of the executable
+  # 
+  # Returns the absolute path if found in PATH otherwise nil.
+  def which(executable)
+    return unless executable.is_a?(String)
+    #return executable if File.exists?(executable) # SHOULD WORK, MUST TEST
+    shortname = File.basename(executable)
+    dir = Rye.sysinfo.paths.select do |path|    # dir contains all of the 
+      next unless File.exists? path             # occurrences of shortname  
+      Dir.new(path).entries.member?(shortname)  # found in the paths. 
+    end
+    File.join(dir.first, shortname) unless dir.empty? # Return just the first
+  end
+  
+  # Execute a local system command (via the shell, not SSH)
+  #  
+  # * +cmd+ the executable path (relative or absolute)
+  # * +args+ Array of arguments to be sent to the command. Each element
+  # is one argument:. i.e. <tt>['-l', 'some/path']</tt>
+  #
+  # NOTE: shell is a bit paranoid so it escapes every argument. This means
+  # you can only use literal values. That means no asterisks too. 
+  #
+  # Returns a Rye::Rap object containing the 
+  def shell(cmd, *args)
+    args = args.flatten.compact
+    cmd = cmd.to_s if cmd.is_a?(Symbol)
+    # TODO: allow stdin to be sent to the cmd
+    tf = Tempfile.new(cmd)
+    cmd = Rye.prepare_command(cmd, args)
+    cmd << " 2>#{tf.path}" # Redirect STDERR to file. Works in DOS too.
+    # Deal with STDOUT
+    handle = IO.popen(cmd, "r")
+    stdout = handle.read.chomp
+    handle.close
+    # Then STDERR
+    stderr = File.exists?(tf.path) ? File.read(tf.path) : ''
+    tf.delete
+    # Create the response object
+    rap = Rye::Rap.new(self)
+    rap.add_stdout(stdout || '')
+    rap.add_stderr(stderr || '')
+    rap.exit_code = $?
+    rap
+  end
+  
+  # Creates a string from +cmd+ and +args+. If +safe+ is true
+  # it will send them through Escape.shell_command otherwise 
+  # it will return them joined by a space character. 
+  def escape(safe, cmd, *args)
+    args = args.flatten.compact || []
+    safe ? Escape.shell_command(cmd, *args).to_s : [cmd, args].flatten.compact.join(' ')
+  end
+  
+  
   private 
   
   # Start the SSH Agent locally. This is important
@@ -105,9 +240,8 @@ module Rye
   # 
   def start_sshagent_environment
     return if @@agent_env["SSH_AGENT_PID"]
-
-    lines = Rye::Box.shell("ssh-agent", '-s') || ''
-    lines.split($/).each do |line|
+    lines = Rye.shell("ssh-agent", '-s') || []
+    lines.each do |line|
       next unless line.index("echo").nil?
       line = line.slice(0..(line.index(';')-1))
       key, value = line.chomp.split( /=/ )
@@ -115,6 +249,8 @@ module Rye
     end
     ENV["SSH_AUTH_SOCK"] = @@agent_env["SSH_AUTH_SOCK"]
     ENV["SSH_AGENT_PID"] = @@agent_env["SSH_AGENT_PID"]
+    
+    Rye.shell("ssh-add") # Add the user's default keys
     nil
   end
   
@@ -129,8 +265,8 @@ module Rye
   #
   def end_sshagent_environment
     pid = @@agent_env["SSH_AGENT_PID"]
-    Rye::Box.shell("ssh-agent", '-k') || ''
-    #Rye::Box.shell("kill", ['-9', pid]) if pid
+    Rye.shell("ssh-agent", '-k') || []
+    #Rye.shell("kill", ['-9', pid]) if pid
     @@agent_env.clear
     nil
   end
@@ -142,6 +278,7 @@ module Rye
       start_sshagent_environment            # Run this now
       at_exit { end_sshagent_environment }  # Run this before Ruby exits
     }
+    
   rescue => ex
     STDERR.puts "Error initializing the SSH Agent (is OpenSSL installed?):"
     STDERR.puts ex.message