jscmd 0.0.2

data/bin/jscmd

@@ -0,0 +1,44 @@
+#! /opt/local/bin/ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # no rubygems to load, so we fail silently
+end
+
+if File.exist?(File.dirname(__FILE__) + "/../lib/jscmd.rb")
+  $LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+end
+
+require 'jscmd'
+require 'optparse'
+
+OPTIONS = {
+  :port     => 9000
+}
+MANDATORY_OPTIONS = %w()
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+JS Commander: Remote JavaScript Console
+
+Usage: #{File.basename($0)} [options]
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-p", "--port=PORT", Integer,
+          "Start proxy server on the specified port.",
+          "Default: 9000") { |OPTIONS[:port]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+
+  if MANDATORY_OPTIONS && MANDATORY_OPTIONS.find { |option| OPTIONS[option.to_sym].nil? }
+    puts opts; exit
+  end
+end
+
+# do stuff
+server = JSCommander::Broker.new(:Port => OPTIONS[:port], :AccessLog => [], :ProxyVia => nil)
+server.start

data/lib/jscmd.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), 'jscmd/**/*.rb')].sort.each { |lib| require lib }

data/lib/jscmd/agent.js

@@ -0,0 +1,253 @@
+({
+    createXHR: function() {
+        if (window.ActiveXObject) {
+            try {
+                return new ActiveXObject("Msxml2.XMLHTTP");
+            } catch (e) {
+                try {
+                    return new ActiveXObject("Microsoft.XMLHTTP");
+                } catch (e2) {
+                    return null;
+                }
+            }
+        } else if (window.XMLHttpRequest) {
+            return new XMLHttpRequest();
+        } else {
+            return null;
+        }
+    },
+        
+    queue: [],
+
+    evaluate: function(script, recordValue) {
+        function dir(o) {
+            var list = [];
+            var maxNameLen = 0;
+            var valueLenLimit = 200;
+            for (name in o) {
+                var value = null;
+                try {
+                    value = "" + (o[name] != null ? o[name] : null);
+                } catch (e) {
+                    value = "[Error: " + e + "]";
+                    // value = "[Error]";
+                }
+                value = value.replace(/\\/g, "\\\\");
+                value = value.replace(/\r/g, "");
+                value = value.replace(/\n/g, "\\n");
+                if (value.length > valueLenLimit) value = value.substring(0, valueLenLimit) + "...";
+                list.push([name, value]);
+                if (name.length > maxNameLen) maxNameLen = name.length;
+            }
+            for (var i = 0; i < list.length; i++) {
+                var name = list[i][0], value = list[i][1];
+                list[i] = name + (new Array(maxNameLen + 3 - name.length).join(" ")) + value;
+            }
+            return list.sort().join("\n");
+        }
+        var $_ = this.lastValue;
+        var value = eval(script);
+        if (recordValue) {
+            this.lastValue = value;
+        }
+        return value;
+    },
+
+    poll: function() {
+        var content = this.queue.length > 0 ? this.queue.shift() : "";
+        var xhr = this.createXHR();
+        xhr.open("POST", "/_remote_js_proxy/poll", true);
+        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+        var self = this;
+        xhr.onreadystatechange = function() {
+            if (xhr.readyState == 4) {
+                delete self.currentXHR;
+                try {
+                    if (xhr.status == 200) {
+                        var text = xhr.responseText;
+                        if (text) {
+                            var value = null;
+                            try {
+                                var option = text.substring(0, 1);
+                                var script = text.substring(1, text.length);
+                                if (option == 'P') {
+                                    // get properties for code completion
+                                    var obj = self.evaluate.apply(window, [script, false]);
+                                    value = "V" + self.getAllProperties(obj).join(",");
+                                } else if (option == 'E') {
+                                    // just evaluate
+                                    value = "V" + self.evaluate.apply(window, [script, true]);
+                                } else {
+                                    value = "Ebad request: " + text;
+                                }
+                            } catch (e) {
+                                value = "E" + e.toString();
+                            }
+                            self.queue.push(value);
+                        }
+                    }
+                } catch (e) {
+                    // failed to poll; ignore
+                }
+                if (!self.aborted) {
+                    if (self.queue.length > 0) {
+                        self.poll();
+                    } else {
+                        // if polling failed, try again later
+                        setTimeout(function() { self.poll() }, 5000);
+                    }
+                }
+            }
+        }
+        this.currentXHR = xhr;
+        if (this.queue.length > 0) {
+            // mark that there are more messages pending
+            content = "+" + content;
+        }
+        xhr.send(encodeURI(content));
+    },
+
+    startPoll: function() {
+        this.startPoll = function() {}
+        if (window.top.parent != window) return;
+        this.poll();
+    },
+
+    abortPoll: function(retry) {
+        if (!retry) {
+            // don't retry any more
+            this.aborted = true;
+        }
+        if (this.currentXHR) {
+            this.currentXHR.abort();
+        }
+    },
+
+    pushValue: function(value) {
+        this.queue.push(value);
+        this.abortPoll(true);
+        this.startPoll(); // in case startPoll has not been called yet
+    },
+
+    attachEvent: function(event, handler) {
+        if (window.addEventListener) {
+            window.addEventListener(event, handler, false);
+        } else {
+            window.attachEvent("on" + event, handler);
+        }
+    },
+
+    getAllProperties: function(obj) {
+        var result = [];
+        for (var i in obj) {
+            result.push(i);
+        }
+        for (var i = 0; i < this.dontEnums.length; i++) {
+            var e = this.dontEnums[i];
+            if (Object.prototype.toString.apply(obj).match(/object (\w+)/)) {
+                if (e.check(obj, RegExp.$1)) {
+                    for (var k in e.properties) {
+                        var names = e.properties[k].split(/\s+/);
+                        for (var j = 0; j < names.length; j++) {
+                            if (obj[names[j]]) {
+                                result.push(names[j]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    },
+
+    // dontEnums is copied from jsh. thanks!
+    // http://d.hatena.ne.jp/brazil/20061022
+    dontEnums: [
+		{check: function(obj, objType){return objType=='String'}, properties: {
+			F:'charAt charCodeAt concat indexOf lastIndexOf match replace search slice split substr substring toLowerCase toUpperCase valueOf '+ 
+			  'anchor big blink bold fixed fontcolor fontsize italics link small strike sub sup',
+			N:'length'
+		}},
+		{check: function(obj, objType){return objType=='Array'}, properties: {
+			F:'concat join pop push unshift shift sort reverse slice splice toString valueOf '+
+				'every filter forEach map some',
+			N:'length'
+		}},
+		{check: function(obj, objType){return objType=='Boolean'}, properties: {
+			F:'toString valueOf'
+		}},
+		{check: function(obj, objType){return objType=='Date'}, properties: {
+			F:'getDate getYear getFullYear getHours getMilliseconds getMinutes getMonth getSeconds getTime getDay '+
+				'setDate setYear setFullYear setHours setMilliseconds setMinutes setMonth setSeconds setTime '+
+				'getUTCDate getUTCFullYear getUTCHours getUTCMilliseconds getUTCMinutes getUTCMonth getUTCSeconds getUTCDay '+
+				'setUTCDate setUTCFullYear setUTCHours setUTCMilliseconds setUTCMinutes setUTCMonth setUTCSeconds '+
+				'toGMTString toLocaleString toUTCString UTC getTimezoneOffset parse toString valueOf toSource'
+		}},
+		{check: function(obj, objType){return objType=='Number'}, properties: {
+			F:'toExponential toFixed toPrecision toSource toString valueOf'
+		}},
+		{check: function(obj, objType){return objType=='RegExp'}, properties: {
+			F:'exec test toSource toString',
+			B:'global ignoreCase multiline',
+			N:'lastIndex',
+			S:'source'
+		}},
+		{check: function(obj, objType){return obj.navigator}, properties: {
+			F:'Array String Number Date RegExp Boolean '+ 
+				'escape unescape decodeURI decodeURIComponent encodeURI encodeURIComponent '+
+				'eval isFinite isNaN parseFloat parseInt',
+			O:'Math undefined',
+			N:'Infinity NaN'
+		}},
+		{check: function(obj, objType){return objType=='Math'}, properties: {
+			F:'abs acos asin atan atan2 ceil cos exp floor log max min pow random round sin sqrt tan',
+			N:'E LN2 LN10 LOG2E LOG10E PI SQRT1_2 SQRT2'
+		}},
+		{check: function(obj, objType){return obj.MAX_VALUE}, properties: {
+			N:'MAX_VALUE MIN_VALUE NaN NEGATIVE_INFINITY POSITIVE_INFINITY'
+		}},
+		{check: function(obj, objType){return obj.fromCharCode}, properties: {
+			F:'fromCharCode'
+		}},
+		{check: function(obj, objType){return objType=='Function'}, properties: {
+			F:'apply call toSource toString'
+            }}
+    ],
+
+    init: function() {
+        var self = this;
+        
+        this.attachEvent("abort", function() { self.abortPoll() });
+        this.attachEvent("unload", function() { self.abortPoll() });
+        this.attachEvent("pagehide", function() { self.abortPoll() });
+        
+        this.attachEvent("load", function() { self.startPoll() });
+        this.attachEvent("pageshow", function() { self.startPoll() });
+
+        window.onerror = function(message, file, line) {
+            self.pushValue("E" + 
+                           "Message: " + message + "\n" +
+                           "File: " + file + "\n" +
+                           "Line: " + line + "\n");
+        }
+        setTimeout(function() { self.startPoll() }, 3000);
+        
+        if (!window.console) {
+            window.console = {};
+            var levels = ["debug", "info", "warn", "error"];
+            for (var i = 0; i < levels.length; i++) {
+                (function() {
+                    var level = levels[i];
+                    window.console[level] = function() {
+                        var message = [];
+                        for (var i = 0; i < arguments.length; i++) {
+                            message.push(arguments[i]);
+                        }
+                        self.pushValue("V[" + level + "] " + message.join(", "));
+                    }
+                })();
+            }
+            window.console.log = window.console.info;
+        }
+    }
+}).init();

data/lib/jscmd/asynchttpproxy.rb

@@ -0,0 +1,140 @@
+#
+# asynchttpproxy.rb: Asynchronous HTTP Proxy Server
+#
+# Copyright 2007 Shinya Kasatani
+#
+# The original WEBrick::HTTPProxyServer sends response to the client
+# after the whole content has been downloaded to the proxy, 
+# while this AsyncHTTPProxyServer sends the response concurrently while
+# downloading the content.
+# 
+# Based on webrick/httpproxy.rb. The original copyright notice follows:
+#
+# httpproxy.rb -- HTTPProxy Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2002 GOTO Kentaro
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+
+require 'stringio'
+require 'webrick/httpproxy'
+
+module WEBrick
+  class AsyncHTTPProxyServer < HTTPProxyServer
+    def proxy_service(req, res)
+      # Proxy Authentication
+      proxy_auth(req, res)      
+      
+      # Create Request-URI to send to the origin server
+      uri  = req.request_uri
+      path = uri.path.dup
+      path << "?" << uri.query if uri.query
+      
+      # Choose header fields to transfer
+      header = Hash.new
+      choose_header(req, header)
+      set_via(header)
+      
+      # select upstream proxy server
+      if proxy = proxy_uri(req, res)
+        proxy_host = proxy.host
+        proxy_port = proxy.port
+        if proxy.userinfo
+          credentials = "Basic " + [proxy.userinfo].pack("m*")
+          credentials.chomp!
+          header['proxy-authorization'] = credentials
+        end
+      end
+      
+
+      response = nil
+      q = Queue.new
+      p_reader, p_writer = IO.pipe
+      thread = Thread.start do
+        begin
+          @logger.debug "downloading #{uri}"
+          http = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port)
+          http.start{
+            if @config[:ProxyTimeout]
+              ##################################   these issues are 
+              http.open_timeout = 30   # secs  #   necessary (maybe bacause
+              http.read_timeout = 60   # secs  #   Ruby's bug, but why?)
+              ##################################
+            end
+            http_req = nil
+            http_req_body = nil
+            case req.request_method
+            when "GET"
+              http_req = Net::HTTP::Get.new(path, header)
+            when "POST"
+              http_req = Net::HTTP::Post.new(path, header)
+              http_req_body = req.body || ""
+            when "HEAD"
+              http_req = Net::HTTP::Head.new(path, header)
+            else
+              raise HTTPStatus::MethodNotAllowed,
+              "unsupported method `#{req.request_method}'."
+            end
+            http.request(http_req, http_req_body) do |response|
+              q.push response
+              size = 0
+              last_size = 0
+              response.read_body do |str|
+                last_size = size
+                size += str.size
+                if last_size / 500000 != size / 500000
+                  @logger.debug "downloading #{uri}: size=#{size}"
+                end
+                p_writer.write str
+              end
+              @logger.debug "finished downloading #{uri}: size=#{size}"
+              p_writer.close
+            end
+          }
+        rescue Exception => err
+          logger.debug("#{err.class}: #{err.message}")
+          q.push err
+          # raise HTTPStatus::ServiceUnavailable, err.message
+        end
+      end
+      response = q.pop
+      if response.is_a?(Exception)
+        @logger.debug "failed to download #{uri}"
+        raise HTTPStatus::ServiceUnavailable, response.message
+      end
+      
+      # Persistent connction requirements are mysterious for me.
+      # So I will close the connection in every response.
+      res['proxy-connection'] = "close"
+      res['connection'] = "close"
+      
+      # Convert Net::HTTP::HTTPResponse to WEBrick::HTTPProxy
+      res.status = response.code.to_i
+      choose_header(response, res)
+      set_cookie(response, res)
+      set_via(res)
+      res.body = p_reader
+      def res.flush_body
+        if @body.is_a?(IO)
+          begin
+            str_body = @body.read
+          ensure
+            @body.close
+          end
+          @body = str_body
+        end
+        @body
+      end
+      
+      @logger.debug "downloading #{uri}: content-length=#{res.header['content-length']}"
+      
+      # Process contents
+      if handler = @config[:ProxyContentHandler]
+        handler.call(req, res)
+      end
+    end
+  end
+end
+

data/lib/jscmd/jscommander.rb

@@ -0,0 +1,339 @@
+#
+# jscommander.rb: Remote JavaScript Console
+#
+# Copyright 2007 Shinya Kasatani
+#
+
+require 'uri'
+require 'thread'
+require 'webrick'
+require 'zlib'
+
+module JSCommander
+  SCRIPT_DIR = "/_remote_js_proxy/"
+  
+  class PipeQueue
+    attr_reader :reader, :writer
+    
+    def initialize
+      @reader, @writer = IO.pipe
+    end
+    
+    def push(obj)
+      data = Marshal.dump(obj)
+      @writer.write([data.size].pack("N") + data)
+    end
+
+    def pop
+      size = @reader.read(4).unpack("N")[0]
+      Marshal.load(@reader.read(size))
+    end
+  end
+
+  # types are: V: value, E: error, A: active message from proxy
+  Message = Struct.new(:value, :type, :clients)
+  
+  class Broker
+    attr_reader :cmd_queue, :msg_queue
+
+    def initialize(opts = {})
+      @cmd_queue = PipeQueue.new
+      @msg_queue = PipeQueue.new
+      @proxy = ProxyServer.new(self, opts)
+      @shell = Shell.new(self)
+    end
+    
+    def start
+      @proxy_pid = fork do
+        begin
+          Signal.trap('INT') {}
+          Signal.trap('TERM') { @proxy.shutdown }
+          IO.for_fd(0).close
+          @proxy.start
+        rescue Exception => e
+          p e
+        end
+      end
+      Signal.trap("TERM") { shutdown }
+      @shell.run # @shell.run should block
+    end
+
+    def shutdown
+      $stderr.puts "shutdown"
+      Process.kill "TERM", @proxy_pid
+      Process.waitall
+      exit(0)
+    end
+  end
+
+  class Shell
+    class SimpleConsole
+      def show_banner
+      end
+
+      def readline
+        line = $stdin.readline
+        line.chomp! if line
+        line
+      end
+      
+      def close
+      end
+    end
+    
+    class ReadlineConsole
+      HISTORY_PATH = "~/.jscmd_history"
+      
+      def history_path
+        File.expand_path(HISTORY_PATH)
+      end
+
+      def initialize(shell)
+        @shell = shell
+        require 'readline'
+        if File.exist?(history_path)
+          hist = File.readlines(history_path).map{|line| line.chomp}
+          Readline::HISTORY.push(*hist)
+        end
+        Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+-*/%"
+        Readline.completion_append_character = nil
+        Readline.completion_proc = proc do |word|
+          if word =~ /\.$/
+            @shell.object_props($`).map{|name| word + name}
+          elsif word =~ /\.([^.]+)$/
+            prefix = $1
+            parent = $`
+            props = @shell.object_props(parent)
+            props.select{|name|name[0...(prefix.size)] == prefix}.map{|name| "#{parent}.#{name}"}
+          else
+            props = @shell.object_props("this")
+            prefix = word
+            props.select{|name|name[0...(prefix.size)] == prefix}
+          end
+        end
+      end
+      
+      def show_banner
+        puts "Press Ctrl+D to exit."
+      end
+      
+      def close
+        open(history_path, "ab") do |f|
+          Readline::HISTORY.each{|line| f.puts(line)}
+        end
+      end
+
+      def readline
+        line = Readline.readline("#{@shell.clients}> ", true)
+        Readline::HISTORY.pop if /^\s*$/ =~ line
+        line
+      end
+    end
+
+    def console
+      @console ||= $stdin.tty? ? ReadlineConsole.new(self) : SimpleConsole.new
+    end
+
+    attr_reader :clients
+    
+    def initialize(broker)
+      @broker = broker
+      @clients = nil
+      @msg_lock = Mutex.new
+    end
+
+    def send_script(line, &handler)
+      @msg_lock.synchronize do
+        @broker.cmd_queue.push(line)
+        yield read_msg
+      end
+    end
+
+    def read_msg
+      msg = @broker.msg_queue.pop
+      # p msg
+      @clients = msg.clients
+      msg
+    end
+
+    def object_props(object)
+      send_script("P" + object) do |r|
+        if r.type == "V" && r.value
+          r.value.split(/,/)
+        else
+          []
+        end
+      end
+    end
+
+    def run
+      # read and print messages in background
+      Thread.start do
+        while IO.select([@broker.msg_queue.reader], nil, nil, nil)
+          @msg_lock.synchronize do
+            if IO.select([@broker.msg_queue.reader], nil, nil, 0)
+              msg = read_msg
+              puts msg.value || ""
+              Process.kill "INT", $$  # interrupt readline
+            end
+          end
+        end
+      end
+
+      console.show_banner
+      
+      begin
+        loop do
+          break unless line = console.readline
+          send_script("E" + line) do |msg|
+            puts msg.value if msg.value
+          end
+        end
+      rescue Interrupt
+        retry
+      rescue SystemExit
+        return
+      rescue Exception => e
+        $stderr.puts "#{e.inspect} at:\n#{e.backtrace.join("\n")}"
+      ensure
+        begin
+          console.close
+        rescue Exception => e
+          $stderr.puts "failed to close console: #{e.inspect}"
+        end
+      end
+      @broker.shutdown
+    end
+  end
+
+  class ProxyServer < WEBrick::AsyncHTTPProxyServer
+    def initialize(broker, args = {})
+      @broker = broker
+      @cmd_queue = PipeQueue.new
+      @clients = []
+      super({:ProxyContentHandler => method(:handle_content).to_proc}.merge(args))
+    end
+
+    def start
+      Thread.start do
+        sleep 1
+        begin
+          poll_cmd_queue
+        rescue Exception => e
+          p e
+        end
+      end
+      super
+    end
+
+    def service(req, res)
+      if req.path == "#{SCRIPT_DIR}agent.js"
+        res.content_type = "application/x-javascript"
+        res.body = File.read(File.join(File.dirname(__FILE__), "agent.js"))
+      elsif req.path == "#{SCRIPT_DIR}poll"
+        serve_script(req, res)
+      else
+        if req.header["accept-encoding"] && !req.header["accept-encoding"].empty?
+          if req.header["accept-encoding"].first.split(/,/).include?("gzip")
+            req.header["accept-encoding"] = ["gzip"]
+          else
+            req.header.delete "accept-encoding"
+          end
+        end
+        super
+      end
+    end
+    
+    def format_clients
+      @clients.map{|c|"[#{URI.parse(c.header["referer"].to_s).host}]"}.join(",")
+    end
+
+    def poll_cmd_queue
+      while @status == :Running
+        cmd = @broker.cmd_queue.pop
+        cmd_line = cmd[1...(cmd.size)]
+        if cmd_line.strip.empty?
+          @broker.msg_queue.push(Message.new(nil, "V", format_clients))
+        else
+          @cmd_queue.push(cmd)
+        end
+      end
+    end
+
+    def serve_script(req, res)
+      # puts "serve:#{req.body}"
+      @clients << req
+      if req.body && req.body =~ /^(\+?)([VE])/
+        more = $1 == '+'
+        type = $2
+        # V: value
+        # E: error
+        @broker.msg_queue.push Message.new(URI.decode($'), type, format_clients)
+        if more
+          res.content_type = "text/plain"
+          res.body = ''
+          return
+        end
+      else
+        # empty message - maybe a new client connected?
+        @broker.msg_queue.push Message.new(nil, "A", format_clients)
+      end
+      while @status == :Running
+        req_socket = req.instance_eval{@socket}
+        sockets = [req_socket, @cmd_queue.reader]
+        if @clients.first != req
+          # don't poll cmd_queue if this is request is not the first one
+          sockets.pop
+        end
+        r = IO.select(sockets, nil, nil, 1)
+        if r
+          if r[0].include?(@cmd_queue.reader)
+            line = @cmd_queue.pop
+            res.content_type = "text/plain"
+            res.body = line
+            return
+          elsif r[0].include?(req_socket)
+            @clients.delete(req); req = nil
+            @broker.msg_queue.push(Message.new("aborted", "A", format_clients))
+            raise WEBrick::HTTPStatus::EOFError
+          end
+        end
+      end
+      # server is shutting down
+      raise WEBrick::HTTPStatus::EOFError
+    ensure
+      @clients.delete(req) if req
+    end
+
+    def handle_content(req, res)
+      # $stderr.puts "handle_content:type=#{res.content_type}, status=#{res.status}, encoding=#{res.header["content-encoding"]}"
+      if res.content_type =~ %r{^text/html} && res.status == 200
+        res.flush_body
+        # we cannot always trust content_type, so check if the content looks like html
+        body = res.body
+        if res.header["content-encoding"] == "gzip"
+          body = Zlib::GzipReader.new(StringIO.new(body)).read
+        end
+        if body =~ /^\s*</
+          body = body.dup
+          # puts "injecting javascript"
+          script_tag = '<script type="text/javascript" src="/_remote_js_proxy/agent.js"></script>'
+          unless body.sub!(%r{<head( .*?)?>}i){|s|s+script_tag}
+            body = script_tag + body
+          end
+          if res.header["content-encoding"] == "gzip"
+            io = StringIO.new
+            writer = Zlib::GzipWriter.new(io)
+            writer.write(body)
+            writer.close
+            res.body = io.string
+          else
+            res.body = body
+          end
+          res.content_length = res.body.size if res.content_length
+        end
+      end
+    end
+  end
+end
+