pry-remote-em 0.7.5 → 1.0.0

data/bin/pry-remote-em

@@ -1,34 +1,38 @@
 #!/usr/bin/env ruby
 
 require 'uri'
+require 'readline'
 require 'highline'
 require 'pry-remote-em/client'
 require 'optparse'
 
 options = {}
 OptionParser.new do |opts|
-  opts.on("-c", "--connect NAME", "connect to the first pry remote em server matching NAME") do |name|
+  opts.on('-c', '--connect NAME', 'connect to the first pry remote em server matching NAME') do |name|
     options[:connect] = name
-  end 
-  opts.on("-p", "--proxy NAME", "proxy through the broker to the first pry remote em server matching NAME") do |name|
+  end
+  opts.on('-p', '--proxy NAME', 'proxy through the broker to the first pry remote em server matching NAME') do |name|
     options[:proxy] = name
-  end 
+  end
+  opts.on('-P', '--proxy-by-default', 'show servers table with proxy mode enabled by default (ignored on -c or -p)') do |name|
+    options[:proxy_by_default] = true
+  end
 
-  opts.on("--fh HOST", "--filter-host HOST", "only show servers listening at the given address (regexp)") do |host|
+  opts.on('--fh HOST', '--filter-host HOST', 'only show servers listening at the given address (regexp)') do |host|
     if host =~ /^pryems?:\/\//
       ARGV.push(host)
-    else  
+    else
       options[:filter_host] = Regexp.new(host)
-    end 
-  end 
-  opts.on("--fn NAME", "--filter-name NAME", "only show servers with a matching name (regexp)") do |name|
+    end
+  end
+  opts.on('--fn NAME', '--filter-name NAME', 'only show servers with a matching name (regexp)') do |name|
     if name =~ /^pryems?:\/\//
       ARGV.push(name)
-    else  
+    else
       options[:filter_name] = Regexp.new(name)
-    end 
+    end
   end
-  opts.on("--[no-]fs", "--[no-]filter-ssl", "show only servers that support ssl") do |ssl|
+  opts.on('--[no-]fs', '--[no-]filter-ssl', 'show only servers that support ssl') do |ssl|
     options[:filter_ssl] = ssl
   end
 
@@ -37,30 +41,45 @@ OptionParser.new do |opts|
   opts.on('--sp', '--sort-port', 'sort by port') { options[:sort] = :port }
   opts.on('--ss', '--sort-ssl', 'sort by ssl support') { options[:sort] = :ssl }
 
+  opts.on('-d', '--details KEY', "show value from server's details option by given key instead of url in table, use @ to show all details") do |key|
+    options[:show_details] = key
+  end
+
+  opts.on('-i', '--ignore-localhost', 'filter out localhost urls from list') do
+    options[:ignore_localhost] = true
+  end
+
   opts.parse!(ARGV)
-end 
+end
 
-uri = ARGV[0] || "pryem://localhost:#{PryRemoteEm::DEF_BROKERPORT}"
+uri = if ARGV[0].nil? || ARGV[0].empty?
+  host = ENV['PRYEMBROKER'].nil? || ENV['PRYEMBROKER'].empty? ? PryRemoteEm::DEFAULT_BROKER_HOST : ENV['PRYEMBROKER']
+  port = ENV['PRYEMBROKERPORT'].nil? || ENV['PRYEMBROKERPORT'].empty? ? PryRemoteEm::DEFAULT_BROKER_PORT : ENV['PRYEMBROKERPORT']
+  "pryem://#{host}:#{port}"
+else
+  ARGV[0]
+end
 uri = URI.parse(uri)
 unless %w(pryem pryems).include?(uri.scheme)
-  abort "only pryem URIs are currently supported\n usage: pryem[s]://127.0.0.1:#{PryRemoteEm::DEF_BROKERPORT}" 
+  abort "only pryem URIs are currently supported\n usage: pryem[s]://#{PryRemoteEm::DEFAULT_BROKER_HOST}:#{PryRemoteEm::DEFAULT_BROKER_PORT}"
 end
-uri.port = PryRemoteEm::DEF_BROKERPORT unless uri.port
+uri.port = PryRemoteEm::DEFAULT_BROKER_PORT unless uri.port
 
 tried = 0
 auth_proc = proc do
   tried += 1
-  user   = uri.user || ($stdin.tty? ? Readline.readline("user: ") : raise("username is require for authentication"))
+  user   = uri.user || ($stdin.tty? ? Readline.readline('user: ') : raise('username is require for authentication'))
   pass   = if !uri.password.nil? && tried <= 1
              uri.password
            elsif $stdin.tty?
-             HighLine.new.ask("#{user}'s password: ") { |q| q.echo = '*'}
+             HighLine.new.ask("#{user}'s password: ") { |q| q.echo = '*' }
            else
-             raise "password is required to authenticate"
-           end 
+             raise 'password is required to authenticate'
+           end
   [user, pass]
 end
 
 EM.run do
-  PryRemoteEm::Client.start(uri.host, uri.port, options.merge(:auth=>auth_proc, :tls=>uri.scheme=='pryems')) { |e| EM.stop }
+  client_options = options.merge(auth: auth_proc, tls: uri.scheme == 'pryems')
+  PryRemoteEm::Client.start(uri.host, uri.port, client_options) { EM.stop }
 end

data/bin/pry-remote-em-broker

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'pry-remote-em/broker'
+require 'optparse'
+
+options = { tls: false }
+OptionParser.new do |opts|
+  opts.on('-h', '--host HOST', 'host to bind broker server (same as PRYEMBROKER variable, default: "127.0.0.1")') do |host|
+    options[:host] = host
+  end
+
+  opts.on('-p', '--port PORT', 'port to bind broker server (same as PRYEMBROKERPORT variable, default: 6462)') do |port|
+    options[:port] = port
+  end
+
+  opts.on('-s', '--tls', 'use TLS for broker (default: false)') do
+    options[:tls] = true
+  end
+
+  opts.parse!(ARGV)
+end
+
+
+EM.run do
+  trap(:INT) { EM.stop }
+
+  PryRemoteEm::Broker.run options[:host], options[:port], tls: options[:tls], raise_if_port_in_use: true
+end

data/lib/pry-remote-em.rb

@@ -1,29 +1,40 @@
 begin
   require 'openssl'
 rescue LoadError
-  warn "OpenSSL support is not available"
+  warn 'OpenSSL support is not available'
 end
-require 'pry-remote-em/version'
-require 'pry-remote-em/proto'
-require 'eventmachine'
 require 'socket'
 require 'fiber'
 require 'uri'
+require 'eventmachine'
+require 'pry-remote-em/version'
+require 'pry-remote-em/proto'
+require 'pry-remote-em/server'
 
 module PryRemoteEm
-  DEFHOST         = 'localhost'
-  DEFPORT         = 6463
-  DEF_BROKERPORT  = DEFPORT - 1
-  DEF_BROKERHOST  = 'localhost'
-  NEGOTIMER       = 15
+  DEFAULT_SERVER_HOST = '127.0.0.1'
+  DEFAULT_SERVER_PORT = 6463
+  DEFAULT_BROKER_HOST = '127.0.0.1'
+  DEFAULT_BROKER_PORT = 6462
+
+  NEGOTIATION_TIMEOUT         = 15
+  HEARTBEAT_SEND_INTERVAL     = 15
+  HEARTBEAT_CHECK_INTERVAL    = 20
+  RECONNECT_TO_BROKER_TIMEOUT = 3
+
+  MAXIMUM_ERRORS_IN_SANDBOX = 100
 end
 
 
 class Object
-  def remote_pry_em(host = PryRemoteEm::DEFHOST, port = PryRemoteEm::DEFPORT, opts = {:tls => false}, &blk)
-    opts = {:target => self}.merge(opts)
-    PryRemoteEm::Server.run(opts[:target], host, port, opts, &blk)
+  def remote_pry_em(host = nil, port = nil, options = {}, &block)
+    host, options = nil, host if host.kind_of?(Hash) # Support for options hash as first argument instead of third
+
+    options = { target: self, host: host, port: port }.merge(options)
+    PryRemoteEm::Server.run(options, &block)
   end
+
+  alias pry_remote_em remote_pry_em # source of common confusing
 end
 
 

data/lib/pry-remote-em/broker.rb

@@ -1,3 +1,4 @@
+require 'logger'
 require 'socket'
 require 'pry-remote-em'
 require 'pry-remote-em/client/broker'
@@ -9,29 +10,20 @@ module PryRemoteEm
       attr_reader :listening, :host, :port
       alias :listening? :listening
 
-      def run(host = ENV['PRYEMBROKER'] || DEF_BROKERHOST, port = ENV['PRYEMBROKERPORT'] || DEF_BROKERPORT, opts = {:tls => false})
+      def run(host = nil, port = nil, opts = {})
+        host ||= ENV['PRYEMBROKER'].nil? || ENV['PRYEMBROKER'].empty? ? DEFAULT_BROKER_HOST : ENV['PRYEMBROKER']
+        port ||= ENV['PRYEMBROKERPORT'].nil? || ENV['PRYEMBROKERPORT'].empty? ? DEFAULT_BROKER_PORT : ENV['PRYEMBROKERPORT']
+        port = port.to_i if port.kind_of?(String)
         raise "root permission required for port below 1024 (#{port})" if port < 1024 && Process.euid != 0
-        @host      = host
-        @port      = port
+        @host = host
+        @port = port
+        opts = opts.dup
         # Brokers cannot use SSL directly. If they do then when a proxy request to an SSL server is received
         # the client and server will not be able to negotiate a SSL session. The proxied traffic can be SSL
         # encrypted, but the SSL session will be between the client and the server.
-        opts       = opts.dup
         opts[:tls] = false
-        @opts      = opts
-        begin
-          EM.start_server(host, port, PryRemoteEm::Broker, opts) do |broker|
-          end
-          log.info("[pry-remote-em broker] listening on #{opts[:tls] ? 'pryems' : 'pryem'}://#{host}:#{port}")
-          @listening = true
-        rescue => e
-          # EM 1.0.0.beta4's message tells us the port is in use; 0.12.10 just says, 'no acceptor'
-          if (e.message.include?('port is in use') || e.message.include?('no acceptor'))
-            # [pry-remote-em broker] a broker is already listening on #{host}:#{port}
-          else
-            raise e
-          end
-        end
+        @opts = opts
+        start_server(host, port, opts) unless @listening || ENV['PRYEMREMOTEBROKER'] || @opts[:remote_broker]
         client { |c| yield self } if block_given?
       end
 
@@ -40,9 +32,9 @@ module PryRemoteEm
         @waiting   = nil
         @client    = nil
         run(@host, @port, @opts) do
-          PryRemoteEm.servers.each do |url, (sig, name)|
-            next unless EM.get_sockname(sig)
-            register(url, name)
+          PryRemoteEm.servers.each do |id, description|
+            next unless EM.get_sockname(description[:server])
+            register(id: description[:id], urls: description[:urls], name: description[:name], details: description[:details])
           end
         end
       end
@@ -60,31 +52,38 @@ module PryRemoteEm
         @servers ||= {}
       end
 
-      def register(url, name = 'unknown')
-        expand_url(url).each do |u|
-          client { |c| c.send_register_server(u, name) }
-        end
+      def register(description)
+        client { |c| c.send_register_server(description[:id], description[:urls], description[:name], description[:details]) }
       end
 
-      def unregister(url)
-        expand_url(url).each do |u|
-          client { |c| c.send_unregister_server(u) }
-        end
+      def unregister(id)
+        client { |c| c.send_unregister_server(id) }
+      end
+
+      def register_server(id, description)
+        servers[id] = description
+        watch_heartbeats(id)
+        log.info("[pry-remote-em broker] registered #{id} #{description.inspect}")
+      end
+
+      def update_server(server, description)
+        server.update(urls: description[:urls], name: description[:name])
+        server[:details].update(description[:details])
       end
 
-      def expand_url(url)
-        return Array(url) if (u = URI.parse(url)).host != '0.0.0.0'
-        Socket.ip_address_list.select { |a| a.ipv4? }
-         .map(&:ip_address).map{|i| u.clone.tap{|mu| mu.host = i } }
+      def unregister_server(id)
+        server = servers.delete(id) or return
+        log.warn("[pry-remote-em broker] unregister #{id} #{server.inspect}")
+        timer = timers.delete(id)
+        timer.cancel if timer
+        hbeats.delete(id)
       end
 
-      def watch_heartbeats(url)
-        return if timers[url]
-        timers[url] = EM::PeriodicTimer.new(20) do
-          if !hbeats[url] || (Time.new - hbeats[url]) > 20
-            servers.delete(url)
-            timers[url].cancel
-            timers.delete(url)
+      def watch_heartbeats(id)
+        interval = ENV['PRYEMHBCHECK'].nil? || ENV['PRYEMHBCHECK'].empty? ? HEARTBEAT_CHECK_INTERVAL : ENV['PRYEMHBCHECK']
+        timers[id] ||= EM::PeriodicTimer.new(interval) do
+          if !hbeats[id] || (Time.new - hbeats[id]) > 20
+            unregister_server(id)
           end
         end
       end
@@ -101,10 +100,26 @@ module PryRemoteEm
         @connected
       end
 
-    private
+      private
+
+      def start_server(host, port, opts)
+        EM.start_server(host, port, PryRemoteEm::Broker, opts)
+        log.info("[pry-remote-em broker] listening on #{opts[:tls] ? 'pryems' : 'pryem'}://#{host}:#{port}")
+        @listening = true
+      rescue => error
+        if error.message.include?('port is in use')
+          if opts[:raise_if_port_in_use]
+            raise
+          else
+            # A broker is already listening on this port, we can do nothing
+          end
+        else
+          raise
+        end
+      end
 
       def client(&blk)
-        raise ArgumentError.new("A block is required") unless block_given?
+        raise ArgumentError.new('A block is required') unless block_given?
         if @client
           yield @client
           return
@@ -115,9 +130,9 @@ module PryRemoteEm
         else
           @waiting = [blk]
           EM.connect(host, port, Client::Broker, @opts) do |client|
-            client.errback { |e| raise(e || "broker client error") }
+            client.errback { |e| raise(e || 'broker client error') }
             client.callback do
-              @client    = client
+              @client = client
               while (w = @waiting.shift)
                 w.call(client)
               end
@@ -129,25 +144,25 @@ module PryRemoteEm
 
     include Proto
 
-    def receive_server_list
+    def receive_server_reload_list
       send_server_list(Broker.servers)
     end
 
-    def receive_register_server(url, name)
-      url      = URI.parse(url)
-      url.host = peer_ip if ['0.0.0.0', 'localhost', '127.0.0.1'].include?(url.host)
-      log.info("[pry-remote-em broker] registered #{url} - #{name.inspect}") unless Broker.servers[url] == name
-      Broker.servers[url] = name
-      Broker.hbeats[url]  = Time.new
-      Broker.watch_heartbeats(url)
-      name
+    def receive_register_server(id, urls, name, details)
+      @ids.push(id)
+      description = { urls: urls, name: name, details: details }
+      Broker.hbeats[id] = Time.new
+      server = Broker.servers[id]
+      if server
+        Broker.update_server(server, description)
+      else
+        Broker.register_server(id, description)
+      end
     end
 
-    def receive_unregister_server(url)
-      url      = URI.parse(url)
-      url.host = peer_ip if ['0.0.0.0', 'localhost', '127.0.0.1'].include?(url.host)
-      log.warn("[pry-remote-em broker] unregister #{url}")
-      Broker.servers.delete(url)
+    def receive_unregister_server(id)
+      server = Broker.servers[id]
+      Broker.unregister_server(id) if server
     end
 
     def receive_proxy_connection(url)
@@ -156,8 +171,9 @@ module PryRemoteEm
       EM.connect(url.host, url.port, Client::Proxy, self)
     end
 
-    def initialize(opts = {:tls => false}, &blk)
-      @opts   = opts
+    def initialize(opts = {}, &blk)
+      @opts = opts
+      @ids = []
     end
 
     def log
@@ -179,15 +195,16 @@ module PryRemoteEm
 
     def peer_ip
       return @peer_ip if @peer_ip
-      return "" if get_peername.nil?
+      return '' if get_peername.nil?
       @peer_port, @peer_ip = Socket.unpack_sockaddr_in(get_peername)
+      @peer_ip = '127.0.0.1' if @peer_ip == '::1' # Little hack to avoid segmentation fault in EventMachine 1.2.0.1 while connecting to PryRemoteEm Server from localhost with IPv6 address
       @peer_ip
     end
 
     def peer_port
       return @peer_port if @peer_port
-      return "" if get_peername.nil?
-      @peer_port, @peer_ip = Socket.unpack_sockaddr_in(get_peername)
+      return '' if get_peername.nil?
+      peer_ip # Fills peer_port too
       @peer_port
     end
 
@@ -196,5 +213,10 @@ module PryRemoteEm
       send_server_list(Broker.servers)
     end
 
+    def unbind
+      @ids.each do |id|
+        Broker.unregister_server(id)
+      end
+    end
   end # module::Broker
 end # module::PryRemoteEm

data/lib/pry-remote-em/client.rb

@@ -1,24 +1,21 @@
 require 'uri'
 require 'pry-remote-em'
-begin
-  require 'pry-remote-em/client/keyboard'
-rescue LoadError => e
-  warn "[pry-remote-em] unable to load keyboard depenencies (termios); interactive shell commands disabled"
-end
-require "pry-remote-em/client/generic"
+require 'pry-remote-em/client/keyboard'
+require 'pry-remote-em/client/generic'
+require 'pry-remote-em/client/interactive_menu'
 require 'pry'
-require "readline"
-require 'highline'
+#require 'pry-coolline' rescue require 'readline'
 
 module PryRemoteEm
   module Client
     include EM::Deferrable
-    include Client::Generic
+    include Generic
+    include InteractiveMenu
     include Pry::Helpers::BaseHelpers
 
     class << self
-      def start(host = PryRemoteEm::DEFHOST, port = PryRemoteEM::DEFPORT, opts = {:tls => false})
-        EM.connect(host || PryRemoteEm::DEFHOST, port || PryRemoteEm::DEFPORT, PryRemoteEm::Client, opts) do |c|
+      def start(host = nil, port = nil, opts = {})
+        EM.connect(host || PryRemoteEm::DEFAULT_SERVER_HOST, port || PryRemoteEm::DEFAULT_SERVER_PORT, PryRemoteEm::Client, opts) do |c|
           c.callback { yield if block_given? }
           c.errback do |e|
             Kernel.puts "[pry-remote-em] connection failed\n#{e}"
@@ -42,11 +39,17 @@ module PryRemoteEm
     end
 
     def post_init
-      Readline.completion_proc = method(:auto_complete)
+      @input = if defined?(PryCoolline)
+        PryCoolline.make_coolline
+      else
+        Pry.history.load if Pry.config.history.should_load
+        Readline
+      end
+      @input.completion_proc = method(:auto_complete)
     end
 
     def ssl_handshake_completed
-      log.info("[pry-remote-em] TLS connection established")
+      log.info('[pry-remote-em] TLS connection established')
       @opts[:tls] = true
     end
 
@@ -60,9 +63,7 @@ module PryRemoteEm
         reconnect(uri.host, uri.port)
       else
         @unbound = true
-        log.info("[pry-remote-em] session terminated")
-        # prior to 1.0.0.b4 error? returns true here even when it's not
-        return succeed if Gem.loaded_specs["eventmachine"].version < Gem::Version.new("1.0.0.beta4")
+        log.info('[pry-remote-em] session terminated')
         error? ? fail : succeed
       end
     end
@@ -79,108 +80,19 @@ module PryRemoteEm
         log.info("\033[33m[pry-remote-em] no servers are registered with the broker\033[0m")
         Process.exit
       end
-      choice, proxy  = choose_server(list)
-      return unless choice
-      uri, name      = choice[0], choice[1]
+      url, proxy = choose_server(list)
+      return unless url
+      uri = URI.parse(url)
       if proxy
         @opts[:tls]  = uri.scheme == 'pryems'
         @negotiated  = false
         @tls_started = false
-        return send_proxy_connection(uri)
+        return send_proxy_connection(url)
       end
       @reconnect_to = uri
       close_connection
     end
 
-    def choose_server(list)
-      highline    = HighLine.new
-      proxy       = false
-      choice      = nil
-      nm_col_len  = list.values.map(&:length).sort[-1] + 5
-      ur_col_len  = list.keys.map(&:length).sort[-1] + 5
-      header      = sprintf("| %-3s |  %-#{nm_col_len}s |  %-#{ur_col_len}s |", "", "name", "url")
-      border      = ("-" * header.length)
-      table       = [border, header, border]
-      list        = list.to_a.map{|url, name| [URI.parse(url), name]}
-      list        = filter_server_list(list)
-      list        = sort_server_list(list)
-      list.each_with_index do |(url, name), idx|
-        table << sprintf("|  %-2d |  %-#{nm_col_len}s |  %-#{ur_col_len}s |", idx + 1, name, url)
-      end
-      table << border
-      table   = table.join("\n")
-      Kernel.puts table
-      while choice.nil?
-        if proxy
-          question = "(q) to quit; (r) to refresh (c) to connect\nproxy to: "
-        else
-          question = "(q) to quit; (r) to refresh (p) to proxy\nconnect to: "
-        end
-        if (choice = opts.delete(:proxy))
-          proxy = true
-        else
-          choice = opts.delete(:connect) || highline.ask(question)
-          proxy = false
-        end
-
-        return close_connection if ['q', 'quit', 'exit'].include?(choice.downcase)
-        if ['r', 'reload', 'refresh'].include?(choice.downcase)
-          send_server_list
-          return nil
-        end
-        if ['c', 'connect'].include?(choice.downcase)
-          proxy = false
-          choice = nil
-          next
-        end
-        if ['p', 'proxy'].include?(choice.downcase)
-          proxy = true
-          choice = nil
-          next
-        end
-        choice = choice.to_i > 0 ?
-          list[choice.to_i - 1] :
-          list.find{|(url, name)| url.to_s == choice || name == choice }
-        log.error("\033[31mserver not found\033[0m") unless choice
-      end
-      [choice, proxy]
-    end
-
-    def sort_server_list(list)
-      type = opts[:sort] || :host
-      case type
-      when :name
-        list.sort { |a,b| a[1] <=> b[1] }
-      when :host
-        list.sort { |a,b| a[0].host <=> b[0].host }
-      when :ssl
-        list.sort { |a,b| b[0].scheme <=> a[0].scheme }
-      when :port
-        list.sort { |a,b| a[0].port <=> b[0].port }
-      else
-        list.sort { |a,b| a[0].host <=> b[0].host }
-      end
-    end
-
-    def filter_server_list(list)
-      if opts[:filter_host]
-        list = list.select { |url, name| url.host =~ opts[:filter_host] }
-      end
-      if opts[:filter_name]
-        list = list.select { |url, name| name =~ opts[:filter_name] }
-      end
-      if opts.include?(:filter_ssl)
-        list = opts[:filter_ssl] ?
-          list.select{|url, name| url.scheme == 'pryems' } :
-          list.select{|url, name| url.scheme == 'pryem' }
-      end
-      if list.empty?
-        log.info("\033[33m[pry-remote-em] no registered servers match the given filter\033[0m")
-        Process.exit
-      end
-      list
-    end
-
     def receive_auth(a)
       return fail a if a.is_a?(String)
       return authenticate if a == false
@@ -204,11 +116,22 @@ module PryRemoteEm
         @keyboard.bufferio(true)
         @keyboard.close_connection
       end
+      if c == 255 || c == 127
+        Kernel.puts 'command not found'
+      end
+    end
+
+    # TODO detect if the old pager behavior of Pry is supported and use it
+    # through Pry.pager. If it's not then use the SimplePager.
+    def pager
+      pager_class = ENV['PRYEMNOPAGER'] ? Pry::Pager::NullPager : @opts[:pager] || Pry::Pager::SimplePager
+      @pager ||= pager_class.new(Pry::Output.new(Pry))
     end
 
     def receive_raw(r)
-      # Pry::Helpers::BaseHelpers
-      stagger_output(r, $stdout)
+      pager.write(r)
+    rescue Pry::Pager::StopPaging
+      warn '[pry-remote-em] stop paging is not implemented, use PRYEMNOPAGER environment variable to avoid paging at all'
     end
 
     def receive_unknown(j)
@@ -216,7 +139,7 @@ module PryRemoteEm
     end
 
     def authenticate
-      return fail("[pry-remote-em] authentication required") unless @auth
+      return fail('[pry-remote-em] authentication required') unless @auth
       return fail("[pry-remote-em] can't authenticate before negotiation complete") unless @negotiated
       user, pass = @auth.call
       return fail("[pry-remote-em] expected #{@auth} to return a user and password") unless user && pass
@@ -224,6 +147,8 @@ module PryRemoteEm
     end # authenticate
 
     def auto_complete(word)
+      word = word.completed_word if defined?(Coolline) && word.kind_of?(Coolline)
+
       @waiting = Thread.current
       EM.next_tick { send_completion(word) }
       sleep
@@ -243,26 +168,37 @@ module PryRemoteEm
       readline(p)
     end
 
-    def readline(prompt)
+    def readline(prompt = @last_prompt)
+      @last_prompt = prompt
       if @negotiated && !@unbound
-        op       = proc { Readline.readline(prompt, !prompt.nil?) }
-        callback = proc do |l|
-          if '!!' == l[0..1]
+        operation = proc do
+          thread = Thread.current
+          old_trap = Signal.trap(:INT) { thread.raise Interrupt }
+          begin
+            @input.readline(prompt)
+          rescue Interrupt
+            send_clear_buffer
+            puts
+            :ignore_me
+          ensure
+            Signal.trap(:INT, old_trap)
+          end
+        end
+
+        callback  = proc do |l|
+          next if l == :ignore_me
+
+          add_to_history(l) unless l.nil? || l.empty?
+
+          if l.nil?
+            readline
+          elsif '^^' == l[0..1]
             send_msg_bcast(l[2..-1])
-          elsif '!' == l[0]
+          elsif '^' == l[0]
             send_msg(l[1..-1])
           elsif '.' == l[0]
-            if !Client.const_defined?(:Keyboard)
-              Kernel.puts "\033[31minteractive shell commands are not supported without termios\033[0m"
-              readline(prompt)
-            else
-              send_shell_cmd(l[1..-1])
-              if Gem.loaded_specs["eventmachine"].version < Gem::Version.new("1.0.0.beta4")
-                Kernel.puts "\033[1minteractive shell commands are not well supported when running on EventMachine prior to 1.0.0.beta4\033[0m"
-              else
-                @keyboard = EM.open_keyboard(Keyboard, self)
-              end
-            end
+            send_shell_cmd(l[1..-1])
+            @keyboard = EM.open_keyboard(Keyboard, self)
           elsif 'reset' == l.strip
             # TODO work with 'bundle exec pry-remote-em ...'
             # TODO work with 'ruby -I lib bin/pry-remote-em ...'
@@ -270,15 +206,24 @@ module PryRemoteEm
             exec("#{$0} #{ARGV.join(' ')}")
           else
             send_raw(l)
-          end # "!!" == l[0..1]
+          end
         end
-        EM.defer(op, callback)
+
+        EM.defer(operation, callback)
       end
     end # readline(prompt = @last_prompt)
 
+    def add_to_history(line)
+      if defined?(Readline) && @input == Readline
+        Readline::HISTORY.push(line)
+      end
+      # Nothing to do with Coolline, it just works
+    end
   end # module::Client
 end # module::PryRemoteEm
 
+# TODO detect if the old pager behavior of Pry is supported and use it. If it's not
+# then don't bother adding a pager accessor
 # Pry::Helpers::BaseHelpers#stagger_output expects Pry.pager to be defined
 class Pry
   class << self