diff --git a/appshell/node-core/Server.js b/appshell/node-core/Server.js
index 74624985d..bd274b98d 100644
--- a/appshell/node-core/Server.js
+++ b/appshell/node-core/Server.js
@@ -36,7 +36,7 @@ maxerr: 50, node: true */
     
     var fs                = require("fs"),
         http              = require("http"),
-        WebSocket         = require("ws-deploy"),
+        WebSocket         = require("./thirdparty/ws"),
         EventEmitter      = require("events").EventEmitter,
         Logger            = require("./Logger"),
         ConnectionManager = require("./ConnectionManager"),
diff --git a/appshell/node-core/package.json b/appshell/node-core/package.json
index 5d5dfa1ad..fc533bd79 100644
--- a/appshell/node-core/package.json
+++ b/appshell/node-core/package.json
@@ -4,8 +4,5 @@
   "description": "Node core for appshell",
   "main": "Launcher.js",
   "author": "Joel Brandt <joelrbrandt@gmail.com>",
-  "license": "MIT",
-  "dependencies": {
-    "ws-deploy": "git+https://github.com/joelrbrandt/ws-deploy.git#7a3bdc6b21ebd66d4b360003391257945ab0585f"
-  }
+  "license": "MIT"
 }
diff --git a/appshell/node-core/thirdparty/ws/README.md b/appshell/node-core/thirdparty/ws/README.md
new file mode 100644
index 000000000..55a916884
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/README.md
@@ -0,0 +1,73 @@
+# Overview
+
+This module contains a minimal repackaging of ws for deployment.
+It is currently at version 0.4.25. The main repository for ws can be
+found at https://github.com/einaros/ws
+
+This repository also incorporates options.js instead of relying on it
+as an external dependency. The main repository for options.js can be
+found at https://github.com/einaros/options.js
+
+No modifications are made to either library except for a.) removing
+files that are not necessary for deployment and b.) fixing up paths.
+Specifically, this module was made by following these steps:
+
+1. Start with version 0.4.25 of ws
+2. Incorporate options.js directly into ws and fix up paths
+3. Remove files not needed for deployment (tests, etc.)
+4. Remove "compiled" code, and fix up paths to use "fallback"
+JS code by default. (Removing "compiled" code makes it easier
+to have this work in a cross-platform way.)
+
+Both ws and options.js are written by Einar Otto Stangvik and licensed
+under the MIT license (see below).
+
+## License for ws##
+
+(The MIT License)
+
+Copyright (c) 2011 Einar Otto Stangvik &lt;einaros@gmail.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## License for options.js##
+
+(The MIT License)
+
+Copyright (c) 2012 Einar Otto Stangvik &lt;einaros@gmail.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/ws/index.js b/appshell/node-core/thirdparty/ws/index.js
new file mode 100644
index 000000000..3423ff232
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/index.js
@@ -0,0 +1,26 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+module.exports = require('./lib/WebSocket');
+module.exports.Server = require('./lib/WebSocketServer');
+module.exports.Sender = require('./lib/Sender');
+module.exports.Receiver = require('./lib/Receiver');
+
+module.exports.createServer = function (options, connectionListener) {
+  var server = new module.exports.Server(options);
+  if (typeof connectionListener === 'function') {
+    server.on('connection', connectionListener);
+  }
+  return server;
+};
+
+module.exports.connect = module.exports.createConnection = function (address, openListener) {
+  var client = new module.exports(address);
+  if (typeof openListener === 'function') {
+    client.on('open', openListener);
+  }
+  return client;
+};
diff --git a/appshell/node-core/thirdparty/ws/lib/BufferPool.js b/appshell/node-core/thirdparty/ws/lib/BufferPool.js
new file mode 100644
index 000000000..faf8637c0
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/BufferPool.js
@@ -0,0 +1,59 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var util = require('util');
+
+function BufferPool(initialSize, growStrategy, shrinkStrategy) {
+  if (typeof initialSize === 'function') {
+    shrinkStrategy = growStrategy;
+    growStrategy = initialSize;
+    initialSize = 0;
+  }
+  else if (typeof initialSize === 'undefined') {
+    initialSize = 0;
+  }
+  this._growStrategy = (growStrategy || function(db, size) {
+    return db.used + size;
+  }).bind(null, this);
+  this._shrinkStrategy = (shrinkStrategy || function(db) {
+    return initialSize;
+  }).bind(null, this);
+  this._buffer = initialSize ? new Buffer(initialSize) : null;
+  this._offset = 0;
+  this._used = 0;
+  this._changeFactor = 0;
+  this.__defineGetter__('size', function(){
+    return this._buffer == null ? 0 : this._buffer.length;
+  });
+  this.__defineGetter__('used', function(){
+    return this._used;
+  });
+}
+
+BufferPool.prototype.get = function(length) {
+  if (this._buffer == null || this._offset + length > this._buffer.length) {
+    var newBuf = new Buffer(this._growStrategy(length));
+    this._buffer = newBuf;
+    this._offset = 0;
+  }
+  this._used += length;
+  var buf = this._buffer.slice(this._offset, this._offset + length);
+  this._offset += length;
+  return buf;
+}
+
+BufferPool.prototype.reset = function(forceNewBuffer) {
+  var len = this._shrinkStrategy();
+  if (len < this.size) this._changeFactor -= 1;
+  if (forceNewBuffer || this._changeFactor < -2) {
+    this._changeFactor = 0;
+    this._buffer = len ? new Buffer(len) : null;
+  }
+  this._offset = 0;
+  this._used = 0;
+}
+
+module.exports = BufferPool;
diff --git a/appshell/node-core/thirdparty/ws/lib/BufferUtil.js b/appshell/node-core/thirdparty/ws/lib/BufferUtil.js
new file mode 100644
index 000000000..508542c9e
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/BufferUtil.js
@@ -0,0 +1,47 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+module.exports.BufferUtil = {
+  merge: function(mergedBuffer, buffers) {
+    var offset = 0;
+    for (var i = 0, l = buffers.length; i < l; ++i) {
+      var buf = buffers[i];
+      buf.copy(mergedBuffer, offset);
+      offset += buf.length;
+    }
+  },
+  mask: function(source, mask, output, offset, length) {
+    var maskNum = mask.readUInt32LE(0, true);
+    var i = 0;
+    for (; i < length - 3; i += 4) {
+      var num = maskNum ^ source.readUInt32LE(i, true);
+      if (num < 0) num = 4294967296 + num;
+      output.writeUInt32LE(num, offset + i, true);
+    }
+    switch (length % 4) {
+      case 3: output[offset + i + 2] = source[i + 2] ^ mask[2];
+      case 2: output[offset + i + 1] = source[i + 1] ^ mask[1];
+      case 1: output[offset + i] = source[i] ^ mask[0];
+      case 0:;
+    }
+  },
+  unmask: function(data, mask) {
+    var maskNum = mask.readUInt32LE(0, true);
+    var length = data.length;
+    var i = 0;
+    for (; i < length - 3; i += 4) {
+      var num = maskNum ^ data.readUInt32LE(i, true);
+      if (num < 0) num = 4294967296 + num;
+      data.writeUInt32LE(num, i, true);
+    }
+    switch (length % 4) {
+      case 3: data[i + 2] = data[i + 2] ^ mask[2];
+      case 2: data[i + 1] = data[i + 1] ^ mask[1];
+      case 1: data[i] = data[i] ^ mask[0];
+      case 0:;
+    }
+  }
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/ErrorCodes.js b/appshell/node-core/thirdparty/ws/lib/ErrorCodes.js
new file mode 100644
index 000000000..55ebd529b
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/ErrorCodes.js
@@ -0,0 +1,24 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+module.exports = {
+  isValidErrorCode: function(code) {
+    return (code >= 1000 && code <= 1011 && code != 1004 && code != 1005 && code != 1006) ||
+         (code >= 3000 && code <= 4999);
+  },
+  1000: 'normal',
+  1001: 'going away',
+  1002: 'protocol error',
+  1003: 'unsupported data',
+  1004: 'reserved',
+  1005: 'reserved for extensions',
+  1006: 'reserved for extensions',
+  1007: 'inconsistent or invalid data',
+  1008: 'policy violation',
+  1009: 'message too big',
+  1010: 'extension handshake missing',
+  1011: 'an unexpected condition prevented the request from being fulfilled',
+};
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/ws/lib/Receiver.hixie.js b/appshell/node-core/thirdparty/ws/lib/Receiver.hixie.js
new file mode 100644
index 000000000..f54ad966b
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/Receiver.hixie.js
@@ -0,0 +1,180 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var util = require('util');
+
+/**
+ * State constants
+ */
+
+var EMPTY = 0
+  , BODY = 1;
+var BINARYLENGTH = 2
+  , BINARYBODY = 3;
+
+/**
+ * Hixie Receiver implementation
+ */
+
+function Receiver () {
+  this.state = EMPTY;
+  this.buffers = [];
+  this.messageEnd = -1;
+  this.spanLength = 0;
+  this.dead = false;
+
+  this.onerror = function() {};
+  this.ontext = function() {};
+  this.onbinary = function() {};
+  this.onclose = function() {};
+  this.onping = function() {};
+  this.onpong = function() {};
+}
+
+module.exports = Receiver;
+
+/**
+ * Add new data to the parser.
+ *
+ * @api public
+ */
+
+Receiver.prototype.add = function(data) {
+  var self = this;
+  function doAdd() {
+    if (self.state === EMPTY) {
+      if (data.length == 2 && data[0] == 0xFF && data[1] == 0x00) {
+        self.reset();
+        self.onclose();
+        return;
+      }
+      if (data[0] === 0x80) {
+        self.messageEnd = 0;
+	self.state = BINARYLENGTH;
+        data = data.slice(1);
+      } else {
+
+      if (data[0] !== 0x00) {
+        self.error('payload must start with 0x00 byte', true);
+        return;
+      }
+      data = data.slice(1);
+      self.state = BODY;
+
+      }
+    }
+    if (self.state === BINARYLENGTH) {
+      var i = 0;
+      while ((i < data.length) && (data[i] & 0x80)) {
+        self.messageEnd = 128 * self.messageEnd + (data[i] & 0x7f);
+        ++i;
+      }
+      if (i < data.length) {
+        self.messageEnd = 128 * self.messageEnd + (data[i] & 0x7f);
+        self.state = BINARYBODY;
+        ++i;
+      }
+      if (i > 0)
+        data = data.slice(i);
+    }
+    if (self.state === BINARYBODY) {
+      var dataleft = self.messageEnd - self.spanLength;
+      if (data.length >= dataleft) {
+	// consume the whole buffer to finish the frame
+        self.buffers.push(data);
+        self.spanLength += dataleft;
+        self.messageEnd = dataleft;
+        return self.parse();
+      }
+      // frame's not done even if we consume it all
+      self.buffers.push(data);
+      self.spanLength += data.length;
+      return;
+    }
+    self.buffers.push(data);
+    if ((self.messageEnd = bufferIndex(data, 0xFF)) != -1) {
+      self.spanLength += self.messageEnd;
+      return self.parse();
+    }
+    else self.spanLength += data.length;
+  }
+  while(data) data = doAdd();
+}
+
+/**
+ * Releases all resources used by the receiver.
+ *
+ * @api public
+ */
+
+Receiver.prototype.cleanup = function() {
+  this.dead = true;
+  this.state = EMPTY;
+  this.buffers = [];
+}
+
+/**
+ * Process buffered data.
+ *
+ * @api public
+ */
+
+Receiver.prototype.parse = function() {
+  var output = new Buffer(this.spanLength);
+  var outputIndex = 0;
+  for (var bi = 0, bl = this.buffers.length; bi < bl - 1; ++bi) {
+    var buffer = this.buffers[bi];
+    buffer.copy(output, outputIndex);
+    outputIndex += buffer.length;
+  }
+  var lastBuffer = this.buffers[this.buffers.length - 1];
+  if (this.messageEnd > 0) lastBuffer.copy(output, outputIndex, 0, this.messageEnd);
+  if (this.state !== BODY) --this.messageEnd;
+  var tail = null;
+  if (this.messageEnd < lastBuffer.length - 1) {
+    tail = lastBuffer.slice(this.messageEnd + 1);
+  }
+  this.reset();
+  this.ontext(output.toString('utf8'));
+  return tail;
+}
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Receiver.prototype.error = function (reason, terminate) {
+  this.reset();
+  this.onerror(reason, terminate);
+  return this;
+}
+
+/**
+ * Reset parser state
+ *
+ * @api private
+ */
+
+Receiver.prototype.reset = function (reason) {
+  if (this.dead) return;
+  this.state = EMPTY;
+  this.buffers = [];
+  this.messageEnd = -1;
+  this.spanLength = 0;
+}
+
+/**
+ * Internal api
+ */
+
+function bufferIndex(buffer, byte) {
+  for (var i = 0, l = buffer.length; i < l; ++i) {
+    if (buffer[i] === byte) return i;
+  }
+  return -1;
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/Receiver.js b/appshell/node-core/thirdparty/ws/lib/Receiver.js
new file mode 100644
index 000000000..2752726fd
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/Receiver.js
@@ -0,0 +1,591 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var util = require('util')
+  , Validation = require('./Validation').Validation
+  , ErrorCodes = require('./ErrorCodes')
+  , BufferPool = require('./BufferPool')
+  , bufferUtil = require('./BufferUtil').BufferUtil;
+
+/**
+ * Node version 0.4 and 0.6 compatibility
+ */
+
+var isNodeV4 = /^v0\.4/.test(process.version);
+
+/**
+ * HyBi Receiver implementation
+ */
+
+function Receiver () {
+  // memory pool for fragmented messages
+  var fragmentedPoolPrevUsed = -1;
+  this.fragmentedBufferPool = new BufferPool(1024, function(db, length) {
+    return db.used + length;
+  }, function(db) {
+    return fragmentedPoolPrevUsed = fragmentedPoolPrevUsed >= 0 ?
+      (fragmentedPoolPrevUsed + db.used) / 2 :
+      db.used;
+  });
+
+  // memory pool for unfragmented messages
+  var unfragmentedPoolPrevUsed = -1;
+  this.unfragmentedBufferPool = new BufferPool(1024, function(db, length) {
+    return db.used + length;
+  }, function(db) {
+    return unfragmentedPoolPrevUsed = unfragmentedPoolPrevUsed >= 0 ?
+      (unfragmentedPoolPrevUsed + db.used) / 2 :
+      db.used;
+  });
+
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0,
+    fragmentedOperation: false
+  };
+  this.overflow = [];
+  this.headerBuffer = new Buffer(10);
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.currentMessage = [];
+  this.expectHeader(2, this.processPacket);
+  this.dead = false;
+
+  this.onerror = function() {};
+  this.ontext = function() {};
+  this.onbinary = function() {};
+  this.onclose = function() {};
+  this.onping = function() {};
+  this.onpong = function() {};
+};
+
+module.exports = Receiver;
+
+/**
+ * Add new data to the parser.
+ *
+ * @api public
+ */
+
+Receiver.prototype.add = function(data) {
+  var dataLength = data.length;
+  if (dataLength == 0) return;
+  if (this.expectBuffer == null) {
+    this.overflow.push(data);
+    return;
+  }
+  var toRead = Math.min(dataLength, this.expectBuffer.length - this.expectOffset);
+  fastCopy(toRead, data, this.expectBuffer, this.expectOffset);
+  this.expectOffset += toRead;
+  if (toRead < dataLength) {
+    this.overflow.push(data.slice(toRead));
+  }
+  while (this.expectBuffer && this.expectOffset == this.expectBuffer.length) {
+    var bufferForHandler = this.expectBuffer;
+    this.expectBuffer = null;
+    this.expectOffset = 0;
+    this.expectHandler.call(this, bufferForHandler);
+  }
+}
+
+/**
+ * Releases all resources used by the receiver.
+ *
+ * @api public
+ */
+
+Receiver.prototype.cleanup = function() {
+  this.dead = true;
+  this.overflow = null;
+  this.headerBuffer = null;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.unfragmentedBufferPool = null;
+  this.fragmentedBufferPool = null;
+  this.state = null;
+  this.currentMessage = null;
+  this.onerror = null;
+  this.ontext = null;
+  this.onbinary = null;
+  this.onclose = null;
+  this.onping = null;
+  this.onpong = null;
+}
+
+/**
+ * Waits for a certain amount of header bytes to be available, then fires a callback.
+ *
+ * @api private
+ */
+
+Receiver.prototype.expectHeader = function(length, handler) {
+  if (length == 0) {
+    handler(null);
+    return;
+  }
+  this.expectBuffer = this.headerBuffer.slice(this.expectOffset, this.expectOffset + length);
+  this.expectHandler = handler;
+  var toRead = length;
+  while (toRead > 0 && this.overflow.length > 0) {
+    var fromOverflow = this.overflow.pop();
+    if (toRead < fromOverflow.length) this.overflow.push(fromOverflow.slice(toRead));
+    var read = Math.min(fromOverflow.length, toRead);
+    fastCopy(read, fromOverflow, this.expectBuffer, this.expectOffset);
+    this.expectOffset += read;
+    toRead -= read;
+  }
+}
+
+/**
+ * Waits for a certain amount of data bytes to be available, then fires a callback.
+ *
+ * @api private
+ */
+
+Receiver.prototype.expectData = function(length, handler) {
+  if (length == 0) {
+    handler(null);
+    return;
+  }
+  this.expectBuffer = this.allocateFromPool(length, this.state.fragmentedOperation);
+  this.expectHandler = handler;
+  var toRead = length;
+  while (toRead > 0 && this.overflow.length > 0) {
+    var fromOverflow = this.overflow.pop();
+    if (toRead < fromOverflow.length) this.overflow.push(fromOverflow.slice(toRead));
+    var read = Math.min(fromOverflow.length, toRead);
+    fastCopy(read, fromOverflow, this.expectBuffer, this.expectOffset);
+    this.expectOffset += read;
+    toRead -= read;
+  }
+}
+
+/**
+ * Allocates memory from the buffer pool.
+ *
+ * @api private
+ */
+
+Receiver.prototype.allocateFromPool = !isNodeV4
+  ? function(length, isFragmented) { return (isFragmented ? this.fragmentedBufferPool : this.unfragmentedBufferPool).get(length); }
+  : function(length) { return new Buffer(length); };
+
+/**
+ * Start processing a new packet.
+ *
+ * @api private
+ */
+
+Receiver.prototype.processPacket = function (data) {
+  if ((data[0] & 0x70) != 0) {
+    this.error('reserved fields must be empty', 1002);
+    return;
+  }
+  this.state.lastFragment = (data[0] & 0x80) == 0x80;
+  this.state.masked = (data[1] & 0x80) == 0x80;
+  var opcode = data[0] & 0xf;
+  if (opcode === 0) {
+    // continuation frame
+    this.state.fragmentedOperation = true;
+    this.state.opcode = this.state.activeFragmentedOperation;
+    if (!(this.state.opcode == 1 || this.state.opcode == 2)) {
+      this.error('continuation frame cannot follow current opcode', 1002);
+      return;
+    }
+  }
+  else {
+    if (opcode < 3 && this.state.activeFragmentedOperation != null) {
+      this.error('data frames after the initial data frame must have opcode 0', 1002);
+      return;
+    }
+    this.state.opcode = opcode;
+    if (this.state.lastFragment === false) {
+      this.state.fragmentedOperation = true;
+      this.state.activeFragmentedOperation = opcode;
+    }
+    else this.state.fragmentedOperation = false;
+  }
+  var handler = opcodes[this.state.opcode];
+  if (typeof handler == 'undefined') this.error('no handler for opcode ' + this.state.opcode, 1002);
+  else {
+    handler.start.call(this, data);
+  }
+}
+
+/**
+ * Endprocessing a packet.
+ *
+ * @api private
+ */
+
+Receiver.prototype.endPacket = function() {
+  if (!this.state.fragmentedOperation) this.unfragmentedBufferPool.reset(true);
+  else if (this.state.lastFragment) this.fragmentedBufferPool.reset(false);
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  if (this.state.lastFragment && this.state.opcode === this.state.activeFragmentedOperation) {
+    // end current fragmented operation
+    this.state.activeFragmentedOperation = null;
+  }
+  this.state.lastFragment = false;
+  this.state.opcode = this.state.activeFragmentedOperation != null ? this.state.activeFragmentedOperation : 0;
+  this.state.masked = false;
+  this.expectHeader(2, this.processPacket);
+}
+
+/**
+ * Reset the parser state.
+ *
+ * @api private
+ */
+
+Receiver.prototype.reset = function() {
+  if (this.dead) return;
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0,
+    fragmentedOperation: false
+  };
+  this.fragmentedBufferPool.reset(true);
+  this.unfragmentedBufferPool.reset(true);
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.overflow = [];
+  this.currentMessage = [];
+}
+
+/**
+ * Unmask received data.
+ *
+ * @api private
+ */
+
+Receiver.prototype.unmask = function (mask, buf, binary) {
+  if (mask != null && buf != null) bufferUtil.unmask(buf, mask);
+  if (binary) return buf;
+  return buf != null ? buf.toString('utf8') : '';
+}
+
+/**
+ * Concatenates a list of buffers.
+ *
+ * @api private
+ */
+
+Receiver.prototype.concatBuffers = function(buffers) {
+  var length = 0;
+  for (var i = 0, l = buffers.length; i < l; ++i) length += buffers[i].length;
+  var mergedBuffer = new Buffer(length);
+  bufferUtil.merge(mergedBuffer, buffers);
+  return mergedBuffer;
+}
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Receiver.prototype.error = function (reason, protocolErrorCode) {
+  this.reset();
+  this.onerror(reason, protocolErrorCode);
+  return this;
+}
+
+/**
+ * Buffer utilities
+ */
+
+function readUInt16BE(start) {
+  return (this[start]<<8) +
+         this[start+1];
+}
+
+function readUInt32BE(start) {
+  return (this[start]<<24) +
+         (this[start+1]<<16) +
+         (this[start+2]<<8) +
+         this[start+3];
+}
+
+function fastCopy(length, srcBuffer, dstBuffer, dstOffset) {
+  switch (length) {
+    default: srcBuffer.copy(dstBuffer, dstOffset, 0, length); break;
+    case 16: dstBuffer[dstOffset+15] = srcBuffer[15];
+    case 15: dstBuffer[dstOffset+14] = srcBuffer[14];
+    case 14: dstBuffer[dstOffset+13] = srcBuffer[13];
+    case 13: dstBuffer[dstOffset+12] = srcBuffer[12];
+    case 12: dstBuffer[dstOffset+11] = srcBuffer[11];
+    case 11: dstBuffer[dstOffset+10] = srcBuffer[10];
+    case 10: dstBuffer[dstOffset+9] = srcBuffer[9];
+    case 9: dstBuffer[dstOffset+8] = srcBuffer[8];
+    case 8: dstBuffer[dstOffset+7] = srcBuffer[7];
+    case 7: dstBuffer[dstOffset+6] = srcBuffer[6];
+    case 6: dstBuffer[dstOffset+5] = srcBuffer[5];
+    case 5: dstBuffer[dstOffset+4] = srcBuffer[4];
+    case 4: dstBuffer[dstOffset+3] = srcBuffer[3];
+    case 3: dstBuffer[dstOffset+2] = srcBuffer[2];
+    case 2: dstBuffer[dstOffset+1] = srcBuffer[1];
+    case 1: dstBuffer[dstOffset] = srcBuffer[0];
+  }
+}
+
+/**
+ * Opcode handlers
+ */
+
+var opcodes = {
+  // text
+  '1': {
+    start: function(data) {
+      var self = this;
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        opcodes['1'].getData.call(self, firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expectHeader(2, function(data) {
+          opcodes['1'].getData.call(self, readUInt16BE.call(data, 0));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expectHeader(8, function(data) {
+          if (readUInt32BE.call(data, 0) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported', 1008);
+            return;
+          }
+          opcodes['1'].getData.call(self, readUInt32BE.call(data, 4));
+        });
+      }
+    },
+    getData: function(length) {
+      var self = this;
+      if (self.state.masked) {
+        self.expectHeader(4, function(data) {
+          var mask = data;
+          self.expectData(length, function(data) {
+            opcodes['1'].finish.call(self, mask, data);
+          });
+        });
+      }
+      else {
+        self.expectData(length, function(data) {
+          opcodes['1'].finish.call(self, null, data);
+        });
+      }
+    },
+    finish: function(mask, data) {
+      var packet = this.unmask(mask, data, true);
+      if (packet != null) this.currentMessage.push(packet);
+      if (this.state.lastFragment) {
+        var messageBuffer = this.concatBuffers(this.currentMessage);
+        if (!Validation.isValidUTF8(messageBuffer)) {
+          this.error('invalid utf8 sequence', 1007);
+          return;
+        }
+        this.ontext(messageBuffer.toString('utf8'), {masked: this.state.masked, buffer: messageBuffer});
+        this.currentMessage = [];
+      }
+      this.endPacket();
+    }
+  },
+  // binary
+  '2': {
+    start: function(data) {
+      var self = this;
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        opcodes['2'].getData.call(self, firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expectHeader(2, function(data) {
+          opcodes['2'].getData.call(self, readUInt16BE.call(data, 0));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expectHeader(8, function(data) {
+          if (readUInt32BE.call(data, 0) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported', 1008);
+            return;
+          }
+          opcodes['2'].getData.call(self, readUInt32BE.call(data, 4, true));
+        });
+      }
+    },
+    getData: function(length) {
+      var self = this;
+      if (self.state.masked) {
+        self.expectHeader(4, function(data) {
+          var mask = data;
+          self.expectData(length, function(data) {
+            opcodes['2'].finish.call(self, mask, data);
+          });
+        });
+      }
+      else {
+        self.expectData(length, function(data) {
+          opcodes['2'].finish.call(self, null, data);
+        });
+      }
+    },
+    finish: function(mask, data) {
+      var packet = this.unmask(mask, data, true);
+      if (packet != null) this.currentMessage.push(packet);
+      if (this.state.lastFragment) {
+        var messageBuffer = this.concatBuffers(this.currentMessage);
+        this.onbinary(messageBuffer, {masked: this.state.masked, buffer: messageBuffer});
+        this.currentMessage = [];
+      }
+      this.endPacket();
+    }
+  },
+  // close
+  '8': {
+    start: function(data) {
+      var self = this;
+      if (self.state.lastFragment == false) {
+        self.error('fragmented close is not supported', 1002);
+        return;
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        opcodes['8'].getData.call(self, firstLength);
+      }
+      else {
+        self.error('control frames cannot have more than 125 bytes of data', 1002);
+      }
+    },
+    getData: function(length) {
+      var self = this;
+      if (self.state.masked) {
+        self.expectHeader(4, function(data) {
+          var mask = data;
+          self.expectData(length, function(data) {
+            opcodes['8'].finish.call(self, mask, data);
+          });
+        });
+      }
+      else {
+        self.expectData(length, function(data) {
+          opcodes['8'].finish.call(self, null, data);
+        });
+      }
+    },
+    finish: function(mask, data) {
+      var self = this;
+      data = self.unmask(mask, data, true);
+      if (data && data.length == 1) {
+        self.error('close packets with data must be at least two bytes long', 1002);
+        return;
+      }
+      var code = data && data.length > 1 ? readUInt16BE.call(data, 0) : 1000;
+      if (!ErrorCodes.isValidErrorCode(code)) {
+        self.error('invalid error code', 1002);
+        return;
+      }
+      var message = '';
+      if (data && data.length > 2) {
+        var messageBuffer = data.slice(2);
+        if (!Validation.isValidUTF8(messageBuffer)) {
+          self.error('invalid utf8 sequence', 1007);
+          return;
+        }
+        message = messageBuffer.toString('utf8');
+      }
+      this.onclose(code, message, {masked: self.state.masked});
+      this.reset();
+    },
+  },
+  // ping
+  '9': {
+    start: function(data) {
+      var self = this;
+      if (self.state.lastFragment == false) {
+        self.error('fragmented ping is not supported', 1002);
+        return;
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        opcodes['9'].getData.call(self, firstLength);
+      }
+      else {
+        self.error('control frames cannot have more than 125 bytes of data', 1002);
+      }
+    },
+    getData: function(length) {
+      var self = this;
+      if (self.state.masked) {
+        self.expectHeader(4, function(data) {
+          var mask = data;
+          self.expectData(length, function(data) {
+            opcodes['9'].finish.call(self, mask, data);
+          });
+        });
+      }
+      else {
+        self.expectData(length, function(data) {
+          opcodes['9'].finish.call(self, null, data);
+        });
+      }
+    },
+    finish: function(mask, data) {
+      this.onping(this.unmask(mask, data, true), {masked: this.state.masked, binary: true});
+      this.endPacket();
+    }
+  },
+  // pong
+  '10': {
+    start: function(data) {
+      var self = this;
+      if (self.state.lastFragment == false) {
+        self.error('fragmented pong is not supported', 1002);
+        return;
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        opcodes['10'].getData.call(self, firstLength);
+      }
+      else {
+        self.error('control frames cannot have more than 125 bytes of data', 1002);
+      }
+    },
+    getData: function(length) {
+      var self = this;
+      if (this.state.masked) {
+        this.expectHeader(4, function(data) {
+          var mask = data;
+          self.expectData(length, function(data) {
+            opcodes['10'].finish.call(self, mask, data);
+          });
+        });
+      }
+      else {
+        this.expectData(length, function(data) {
+          opcodes['10'].finish.call(self, null, data);
+        });
+      }
+    },
+    finish: function(mask, data) {
+      this.onpong(this.unmask(mask, data, true), {masked: this.state.masked, binary: true});
+      this.endPacket();
+    }
+  }
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/Sender.hixie.js b/appshell/node-core/thirdparty/ws/lib/Sender.hixie.js
new file mode 100644
index 000000000..1754afb65
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/Sender.hixie.js
@@ -0,0 +1,123 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var events = require('events')
+  , util = require('util')
+  , EventEmitter = events.EventEmitter;
+
+/**
+ * Hixie Sender implementation
+ */
+
+function Sender(socket) {
+  this.socket = socket;
+  this.continuationFrame = false;
+  this.isClosed = false;
+}
+
+module.exports = Sender;
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+util.inherits(Sender, events.EventEmitter);
+
+/**
+ * Frames and writes data.
+ *
+ * @api public
+ */
+
+Sender.prototype.send = function(data, options, cb) {
+  if (this.isClosed) return;
+/*
+  if (options && options.binary) {
+    this.error('hixie websockets do not support binary');
+    return;
+  }
+*/
+  var isString = typeof data == 'string'
+    , length = isString ? Buffer.byteLength(data) : data.length
+    , lengthbytes = (length > 127) ? 2 : 1 // assume less than 2**14 bytes
+    , writeStartMarker = this.continuationFrame == false
+    , writeEndMarker = !options || !(typeof options.fin != 'undefined' && !options.fin)
+    , buffer = new Buffer((writeStartMarker ? ((options && options.binary) ? (1 + lengthbytes) : 1) : 0) + length + ((writeEndMarker && !(options && options.binary)) ? 1 : 0))
+    , offset = writeStartMarker ? 1 : 0;
+
+  if (writeStartMarker) {
+    if (options && options.binary) {
+      buffer.write('\x80', 'binary');
+      // assume length less than 2**14 bytes
+      if (lengthbytes > 1) 
+        buffer.write(String.fromCharCode(128+length/128), offset++, 'binary');
+      buffer.write(String.fromCharCode(length&0x7f), offset++, 'binary');
+    } else
+      buffer.write('\x00', 'binary');
+  }
+
+  if (isString) buffer.write(data, offset, 'utf8');
+  else data.copy(buffer, offset, 0);
+
+  if (writeEndMarker) {
+    if (options && options.binary) {
+      // sending binary, not writing end marker
+    } else 
+      buffer.write('\xff', offset + length, 'binary');
+    this.continuationFrame = false;
+  }
+  else this.continuationFrame = true;
+
+  try {
+    this.socket.write(buffer, 'binary', cb);
+  } catch (e) {
+    this.error(e.toString());
+  }
+}
+
+/**
+ * Sends a close instruction to the remote party.
+ *
+ * @api public
+ */
+
+Sender.prototype.close = function(code, data, mask, cb) {
+  if (this.isClosed) return;
+  this.isClosed = true;
+  try {
+    if (this.continuationFrame) this.socket.write(new Buffer([0xff], 'binary'));
+    this.socket.write(new Buffer([0xff, 0x00]), 'binary', cb);
+  } catch (e) {
+    this.error(e.toString());
+  }
+}
+
+/**
+ * Sends a ping message to the remote party. Not available for hixie.
+ *
+ * @api public
+ */
+
+Sender.prototype.ping = function(data, options) {}
+
+/**
+ * Sends a pong message to the remote party. Not available for hixie.
+ *
+ * @api public
+ */
+
+Sender.prototype.pong = function(data, options) {}
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Sender.prototype.error = function (reason) {
+  this.emit('error', reason);
+  return this;
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/Sender.js b/appshell/node-core/thirdparty/ws/lib/Sender.js
new file mode 100644
index 000000000..6e82bc693
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/Sender.js
@@ -0,0 +1,220 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var events = require('events')
+  , util = require('util')
+  , EventEmitter = events.EventEmitter
+  , ErrorCodes = require('./ErrorCodes')
+  , bufferUtil = require('./BufferUtil').BufferUtil;
+
+/**
+ * HyBi Sender implementation
+ */
+
+function Sender(socket) {
+  this._socket = socket;
+  this.firstFragment = true;
+}
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+util.inherits(Sender, events.EventEmitter);
+
+/**
+ * Sends a close instruction to the remote party.
+ *
+ * @api public
+ */
+
+Sender.prototype.close = function(code, data, mask) {
+  if (typeof code !== 'undefined') {
+    if (typeof code !== 'number' ||
+      !ErrorCodes.isValidErrorCode(code)) throw new Error('first argument must be a valid error code number');
+  }
+  code = code || 1000;
+  var dataBuffer = new Buffer(2 + (data ? Buffer.byteLength(data) : 0));
+  writeUInt16BE.call(dataBuffer, code, 0);
+  if (dataBuffer.length > 2) dataBuffer.write(data, 2);
+  this.frameAndSend(0x8, dataBuffer, true, mask);
+}
+
+/**
+ * Sends a ping message to the remote party.
+ *
+ * @api public
+ */
+
+Sender.prototype.ping = function(data, options) {
+  var mask = options && options.mask;
+  this.frameAndSend(0x9, data || '', true, mask);
+}
+
+/**
+ * Sends a pong message to the remote party.
+ *
+ * @api public
+ */
+
+Sender.prototype.pong = function(data, options) {
+  var mask = options && options.mask;
+  this.frameAndSend(0xa, data || '', true, mask);
+}
+
+/**
+ * Sends text or binary data to the remote party.
+ *
+ * @api public
+ */
+
+Sender.prototype.send = function(data, options, cb) {
+  var finalFragment = options && options.fin === false ? false : true;
+  var mask = options && options.mask;
+  var opcode = options && options.binary ? 2 : 1;
+  if (this.firstFragment === false) opcode = 0;
+  else this.firstFragment = false;
+  if (finalFragment) this.firstFragment = true
+  this.frameAndSend(opcode, data, finalFragment, mask, cb);
+}
+
+/**
+ * Frames and sends a piece of data according to the HyBi WebSocket protocol.
+ *
+ * @api private
+ */
+
+Sender.prototype.frameAndSend = function(opcode, data, finalFragment, maskData, cb) {
+  var canModifyData = false;
+
+  if (!data) {
+    try {
+      this._socket.write(new Buffer([opcode | (finalFragment ? 0x80 : 0), 0 | (maskData ? 0x80 : 0)].concat(maskData ? [0, 0, 0, 0] : [])), 'binary', cb);
+    }
+    catch (e) {
+      if (typeof cb == 'function') cb(e);
+      else this.emit('error', e);
+    }
+    return;
+  }
+
+  if (!Buffer.isBuffer(data)) {
+    canModifyData = true;
+    data = (data && typeof data.buffer !== 'undefined') ? getArrayBuffer(data.buffer) : new Buffer(data);
+  }
+
+  var dataLength = data.length
+    , dataOffset = maskData ? 6 : 2
+    , secondByte = dataLength;
+
+  if (dataLength >= 65536) {
+    dataOffset += 8;
+    secondByte = 127;
+  }
+  else if (dataLength > 125) {
+    dataOffset += 2;
+    secondByte = 126;
+  }
+
+  var mergeBuffers = dataLength < 32768 || (maskData && !canModifyData);
+  var totalLength = mergeBuffers ? dataLength + dataOffset : dataOffset;
+  var outputBuffer = new Buffer(totalLength);
+  outputBuffer[0] = finalFragment ? opcode | 0x80 : opcode;
+
+  switch (secondByte) {
+    case 126:
+      writeUInt16BE.call(outputBuffer, dataLength, 2);
+      break;
+    case 127:
+      writeUInt32BE.call(outputBuffer, 0, 2);
+      writeUInt32BE.call(outputBuffer, dataLength, 6);
+  }
+
+  if (maskData) {
+    outputBuffer[1] = secondByte | 0x80;
+    var mask = this._randomMask || (this._randomMask = getRandomMask());
+    outputBuffer[dataOffset - 4] = mask[0];
+    outputBuffer[dataOffset - 3] = mask[1];
+    outputBuffer[dataOffset - 2] = mask[2];
+    outputBuffer[dataOffset - 1] = mask[3];
+    if (mergeBuffers) {
+      bufferUtil.mask(data, mask, outputBuffer, dataOffset, dataLength);
+      try {
+        this._socket.write(outputBuffer, 'binary', cb);
+      }
+      catch (e) {
+        if (typeof cb == 'function') cb(e);
+        else this.emit('error', e);
+      }
+    }
+    else {
+      bufferUtil.mask(data, mask, data, 0, dataLength);
+      try {
+        this._socket.write(outputBuffer, 'binary');
+        this._socket.write(data, 'binary', cb);
+      }
+      catch (e) {
+        if (typeof cb == 'function') cb(e);
+        else this.emit('error', e);
+      }
+    }
+  }
+  else {
+    outputBuffer[1] = secondByte;
+    if (mergeBuffers) {
+      data.copy(outputBuffer, dataOffset);
+      try {
+        this._socket.write(outputBuffer, 'binary', cb);
+      }
+      catch (e) {
+        if (typeof cb == 'function') cb(e);
+        else this.emit('error', e);
+      }
+    }
+    else {
+      try {
+        this._socket.write(outputBuffer, 'binary');
+        this._socket.write(data, 'binary', cb);
+      }
+      catch (e) {
+        if (typeof cb == 'function') cb(e);
+        else this.emit('error', e);
+      }
+    }
+  }
+}
+
+module.exports = Sender;
+
+function writeUInt16BE(value, offset) {
+  this[offset] = (value & 0xff00)>>8;
+  this[offset+1] = value & 0xff;
+}
+
+function writeUInt32BE(value, offset) {
+  this[offset] = (value & 0xff000000)>>24;
+  this[offset+1] = (value & 0xff0000)>>16;
+  this[offset+2] = (value & 0xff00)>>8;
+  this[offset+3] = value & 0xff;
+}
+
+function getArrayBuffer(array) {
+  var l = array.byteLength
+    , buffer = new Buffer(l);
+  for (var i = 0; i < l; ++i) {
+    buffer[i] = array[i];
+  }
+  return buffer;
+}
+
+function getRandomMask() {
+  return new Buffer([
+    ~~(Math.random() * 255),
+    ~~(Math.random() * 255),
+    ~~(Math.random() * 255),
+    ~~(Math.random() * 255)
+  ]);
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/Validation.js b/appshell/node-core/thirdparty/ws/lib/Validation.js
new file mode 100644
index 000000000..2c7c4fd48
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/Validation.js
@@ -0,0 +1,12 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+ 
+module.exports.Validation = {
+  isValidUTF8: function(buffer) {
+    return true;
+  }
+};
+
diff --git a/appshell/node-core/thirdparty/ws/lib/WebSocket.js b/appshell/node-core/thirdparty/ws/lib/WebSocket.js
new file mode 100644
index 000000000..ea6a209c7
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/WebSocket.js
@@ -0,0 +1,662 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var util = require('util')
+  , events = require('events')
+  , http = require('http')
+  , https = require('https')
+  , crypto = require('crypto')
+  , url = require('url')
+  , fs = require('fs')
+  , Options = require('./options')
+  , Sender = require('./Sender')
+  , Receiver = require('./Receiver')
+  , SenderHixie = require('./Sender.hixie')
+  , ReceiverHixie = require('./Receiver.hixie');
+
+/**
+ * Constants
+ */
+
+// Default protocol version
+
+var protocolVersion = 13;
+
+// Close timeout
+
+var closeTimeout = 30000; // Allow 5 seconds to terminate the connection cleanly
+
+/**
+ * Node version 0.4 and 0.6 compatibility
+ */
+
+var isNodeV4 = /^v0\.4/.test(process.version);
+
+/**
+ * WebSocket implementation
+ */
+
+function WebSocket(address, options) {
+  var self = this;
+
+  this._socket = null;
+  this.bytesReceived = 0;
+  this.readyState = null;
+  this.supports = {};
+
+  if (Object.prototype.toString.call(address) == '[object Array]') {
+    initAsServerClient.apply(this, address.concat(options));
+  }
+  else initAsClient.apply(this, arguments);
+}
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+util.inherits(WebSocket, events.EventEmitter);
+
+/**
+ * Ready States
+ */
+
+WebSocket.CONNECTING = 0;
+WebSocket.OPEN = 1;
+WebSocket.CLOSING = 2;
+WebSocket.CLOSED = 3;
+
+/**
+ * Gracefully closes the connection, after sending a description message to the server
+ *
+ * @param {Object} data to be sent to the server
+ * @api public
+ */
+
+WebSocket.prototype.close = function(code, data) {
+  if (this.readyState == WebSocket.CLOSING || this.readyState == WebSocket.CLOSED) return;
+  if (this.readyState == WebSocket.CONNECTING) {
+    this.readyState = WebSocket.CLOSED;
+    return;
+  }
+  try {
+    this.readyState = WebSocket.CLOSING;
+    this._closeCode = code;
+    this._closeMessage = data;
+    var mask = !this._isServer;
+    this._sender.close(code, data, mask);
+  }
+  catch (e) {
+    this.emit('error', e);
+  }
+  finally {
+    this.terminate();
+  }
+}
+
+/**
+ * Pause the client stream
+ *
+ * @api public
+ */
+
+WebSocket.prototype.pause = function() {
+  if (this.readyState != WebSocket.OPEN) throw new Error('not opened');
+  return this._socket.pause();
+}
+
+/**
+ * Sends a ping
+ *
+ * @param {Object} data to be sent to the server
+ * @param {Object} Members - mask: boolean, binary: boolean
+ * @param {boolean} dontFailWhenClosed indicates whether or not to throw if the connection isnt open
+ * @api public
+ */
+
+WebSocket.prototype.ping = function(data, options, dontFailWhenClosed) {
+  if (this.readyState != WebSocket.OPEN) {
+    if (dontFailWhenClosed === true) return;
+    throw new Error('not opened');
+  }
+  options = options || {};
+  if (typeof options.mask == 'undefined') options.mask = !this._isServer;
+  this._sender.ping(data, options);
+}
+
+/**
+ * Sends a pong
+ *
+ * @param {Object} data to be sent to the server
+ * @param {Object} Members - mask: boolean, binary: boolean
+ * @param {boolean} dontFailWhenClosed indicates whether or not to throw if the connection isnt open
+ * @api public
+ */
+
+WebSocket.prototype.pong = function(data, options, dontFailWhenClosed) {
+  if (this.readyState != WebSocket.OPEN) {
+    if (dontFailWhenClosed === true) return;
+    throw new Error('not opened');
+  }
+  options = options || {};
+  if (typeof options.mask == 'undefined') options.mask = !this._isServer;
+  this._sender.pong(data, options);
+}
+
+/**
+ * Resume the client stream
+ *
+ * @api public
+ */
+
+WebSocket.prototype.resume = function() {
+  if (this.readyState != WebSocket.OPEN) throw new Error('not opened');
+  return this._socket.resume();
+}
+
+/**
+ * Sends a piece of data
+ *
+ * @param {Object} data to be sent to the server
+ * @param {Object} Members - mask: boolean, binary: boolean
+ * @param {function} Optional callback which is executed after the send completes
+ * @api public
+ */
+
+WebSocket.prototype.send = function(data, options, cb) {
+  if (typeof options == 'function') {
+    cb = options;
+    options = {};
+  }
+  if (this.readyState != WebSocket.OPEN) {
+    if (typeof cb == 'function') cb(new Error('not opened'));
+    else throw new Error('not opened');
+    return;
+  }
+  if (!data) data = '';
+  if (this._queue) {
+    var self = this;
+    this._queue.push(function() { self.send(data, options, cb); });
+    return;
+  }
+  options = options || {};
+  options.fin = true;
+  if (typeof options.mask == 'undefined') options.mask = !this._isServer;
+  if (data instanceof fs.ReadStream) {
+    startQueue(this);
+    var self = this;
+    sendStream(this, data, options, function(error) {
+      process.nextTick(function() { executeQueueSends(self); });
+      if (typeof cb == 'function') cb(error);
+    });
+  }
+  else this._sender.send(data, options, cb);
+}
+
+/**
+ * Streams data through calls to a user supplied function
+ *
+ * @param {Object} Members - mask: boolean, binary: boolean
+ * @param {function} 'function (error, send)' which is executed on successive ticks of which send is 'function (data, final)'.
+ * @api public
+ */
+
+WebSocket.prototype.stream = function(options, cb) {
+  if (typeof options == 'function') {
+    cb = options;
+    options = {};
+  }
+  if (typeof cb != 'function') throw new Error('callback must be provided');
+  if (this.readyState != WebSocket.OPEN) {
+    if (typeof cb == 'function') cb(new Error('not opened'));
+    else throw new Error('not opened');
+    return;
+  }
+  if (this._queue) {
+    var self = this;
+    this._queue.push(function() { self.stream(options, cb); });
+    return;
+  }
+  options = options || {};
+  if (typeof options.mask == 'undefined') options.mask = !this._isServer;
+  startQueue(this);
+  var self = this;
+  var send = function(data, final) {
+    try {
+      if (self.readyState != WebSocket.OPEN) throw new Error('not opened');
+      options.fin = final === true;
+      self._sender.send(data, options);
+      if (!final) process.nextTick(cb.bind(null, null, send));
+      else executeQueueSends(self);
+    }
+    catch (e) {
+      if (typeof cb == 'function') cb(e);
+      else {
+        delete self._queue;
+        self.emit('error', e);
+      }
+    }
+  }
+  process.nextTick(cb.bind(null, null, send));
+}
+
+/**
+ * Immediately shuts down the connection
+ *
+ * @api public
+ */
+
+WebSocket.prototype.terminate = function() {
+  if (this.readyState == WebSocket.CLOSED) return;
+  if (this._socket) {
+    try {
+      // End the connection
+      this._socket.end();
+    }
+    catch (e) {
+      // Socket error during end() call, so just destroy it right now
+      cleanupWebsocketResources.call(this, true);
+      return;
+    }
+
+    // Add a timeout to ensure that the connection is completely
+    // cleaned up within 30 seconds, even if the clean close procedure
+    // fails for whatever reason
+    this._closeTimer = setTimeout(cleanupWebsocketResources.bind(this, true), closeTimeout);
+  }
+  else if (this.readyState == WebSocket.CONNECTING) {
+    cleanupWebsocketResources.call(this, true);
+  }
+};
+
+/**
+ * Emulates the W3C Browser based WebSocket interface using function members.
+ *
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+
+['open', 'error', 'close', 'message'].forEach(function(method) {
+  Object.defineProperty(WebSocket.prototype, 'on' + method, {
+    /**
+     * Returns the current listener
+     *
+     * @returns {Mixed} the set function or undefined
+     * @api public
+     */
+
+    get: function get() {
+      var listener = this.listeners(method)[0];
+      return listener ? (listener._listener ? listener._listener : listener) : undefined;
+    },
+
+    /**
+     * Start listening for events
+     *
+     * @param {Function} listener the listener
+     * @returns {Mixed} the set function or undefined
+     * @api public
+     */
+
+    set: function set(listener) {
+      this.removeAllListeners(method);
+      this.addEventListener(method, listener);
+    }
+  });
+});
+
+/**
+ * Emulates the W3C Browser based WebSocket interface using addEventListener.
+ *
+ * @see https://developer.mozilla.org/en/DOM/element.addEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+WebSocket.prototype.addEventListener = function(method, listener) {
+  if (typeof listener === 'function') {
+    if (method === 'message') {
+      function onMessage (data) {
+        listener.call(this, new MessageEvent(data));
+      }
+      // store a reference so we can return the original function from the addEventListener hook
+      onMessage._listener = listener;
+      this.on(method, onMessage);
+    }
+    else if (method === 'close') {
+      function onClose (code, message) {
+        listener.call(this, new CloseEvent(code, message));
+      }
+      // store a reference so we can return the original function from the addEventListener hook
+      onClose._listener = listener;
+      this.on(method, onClose);
+    } else {
+      this.on(method, listener);
+    }
+  }
+}
+
+module.exports = WebSocket;
+
+/**
+ * W3C MessageEvent
+ *
+ * @see http://www.w3.org/TR/html5/comms.html
+ * @api private
+ */
+
+function MessageEvent(dataArg) {
+  // Currently only the data attribute is implemented. More can be added later if needed.
+  this.data = dataArg;
+}
+
+/**
+ * W3C CloseEvent
+ *
+ * @see http://www.w3.org/TR/html5/comms.html
+ * @api private
+ */
+
+function CloseEvent(code, reason) {
+  this.wasClean = (typeof code == 'undefined' || code == 1000);
+  this.code = code;
+  this.reason = reason;
+}
+
+/**
+ * Entirely private apis,
+ * which may or may not be bound to a sepcific WebSocket instance.
+ */
+
+ function initAsServerClient(req, socket, upgradeHead, options) {
+  options = new Options({
+    protocolVersion: protocolVersion,
+    protocol: null
+  }).merge(options);
+
+  // expose state properties
+  this.protocol = options.value.protocol;
+  this.protocolVersion = options.value.protocolVersion;
+  this.supports.binary = (this.protocolVersion != 'hixie-76');
+  this.upgradeReq = req;
+  this.readyState = WebSocket.CONNECTING;
+  this._isServer = true;
+
+  // establish connection
+  if (options.value.protocolVersion == 'hixie-76') establishConnection.call(this, ReceiverHixie, SenderHixie, socket, upgradeHead);
+  else establishConnection.call(this, Receiver, Sender, socket, upgradeHead);
+}
+
+function initAsClient(address, options) {
+  options = new Options({
+    origin: null,
+    protocolVersion: protocolVersion,
+    host: null,
+    protocol: null
+  }).merge(options);
+  if (options.value.protocolVersion != 8 && options.value.protocolVersion != 13) {
+    throw new Error('unsupported protocol version');
+  }
+
+  // verify url and establish http class
+  var serverUrl = url.parse(address);
+  var isUnixSocket = serverUrl.protocol === 'ws+unix:';
+  if (!serverUrl.host && !isUnixSocket) throw new Error('invalid url');
+  var isSecure = serverUrl.protocol === 'wss:' || serverUrl.protocol === 'https:';
+  var httpObj = isSecure ? https : http;
+
+  // expose state properties
+  this._isServer = false;
+  this.url = address;
+  this.protocolVersion = options.value.protocolVersion;
+  this.supports.binary = (this.protocolVersion != 'hixie-76');
+
+  // begin handshake
+  var key = new Buffer(options.value.protocolVersion + '-' + Date.now()).toString('base64');
+  var shasum = crypto.createHash('sha1');
+  shasum.update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11');
+  var expectedServerKey = shasum.digest('base64');
+
+  // node<=v0.4.x compatibility
+  var agent;
+  if (isNodeV4) {
+    isNodeV4 = true;
+    agent = new httpObj.Agent({
+      host: serverUrl.hostname,
+      port: serverUrl.port || (isSecure ? 443 : 80)
+    });
+  }
+
+  var requestOptions = {
+    port: serverUrl.port || (isSecure ? 443 : 80),
+    host: serverUrl.hostname,
+    headers: {
+      'Connection': 'Upgrade',
+      'Upgrade': 'websocket',
+      'Sec-WebSocket-Version': options.value.protocolVersion,
+      'Sec-WebSocket-Key': key
+    }
+  };
+  if (options.value.protocol) {
+    requestOptions.headers['Sec-WebSocket-Protocol'] = options.value.protocol;
+  }
+  if (options.value.host) {
+    requestOptions.headers['Host'] = options.value.host;
+  }
+
+  if (isNodeV4) {
+    requestOptions.path = (serverUrl.pathname || '/') + (serverUrl.search || '');
+    requestOptions.agent = agent;
+  }
+  else requestOptions.path = serverUrl.path || '/';
+  if (isUnixSocket) {
+    requestOptions.socketPath = serverUrl.pathname;
+  }
+  if (options.value.origin) {
+    if (options.value.protocolVersion < 13) requestOptions.headers['Sec-WebSocket-Origin'] = options.value.origin;
+    else requestOptions.headers['Origin'] = options.value.origin;
+  }
+
+  var self = this;
+  var req = httpObj.request(requestOptions);
+  (isNodeV4 ? agent : req).on('error', function(error) {
+    self.emit('error', error);
+    cleanupWebsocketResources.call(this, error);
+  });
+  (isNodeV4 ? agent : req).once('response', function(res) {
+    var error = new Error('unexpected server response (' + res.statusCode + ')');
+    self.emit('error', error);
+    cleanupWebsocketResources.call(this, error);
+  });
+  (isNodeV4 ? agent : req).once('upgrade', function(res, socket, upgradeHead) {
+    if (self.readyState == WebSocket.CLOSED) {
+      // client closed before server accepted connection
+      self.emit('close');
+      removeAllListeners(self);
+      socket.end();
+      return;
+    }
+    var serverKey = res.headers['sec-websocket-accept'];
+    if (typeof serverKey == 'undefined' || serverKey !== expectedServerKey) {
+      self.emit('error', 'invalid server key');
+      removeAllListeners(self);
+      socket.end();
+      return;
+    }
+
+    establishConnection.call(self, Receiver, Sender, socket, upgradeHead);
+
+    // perform cleanup on http resources
+    removeAllListeners(isNodeV4 ? agent : req);
+    req = null;
+    agent = null;
+  });
+
+  req.end();
+  this.readyState = WebSocket.CONNECTING;
+}
+
+function establishConnection(ReceiverClass, SenderClass, socket, upgradeHead) {
+  this._socket = socket;
+  socket.setTimeout(0);
+  socket.setNoDelay(true);
+  var self = this;
+  this._receiver = new ReceiverClass();
+
+  // socket cleanup handlers
+  socket.on('end', cleanupWebsocketResources.bind(this));
+  socket.on('close', cleanupWebsocketResources.bind(this));
+  socket.on('error', cleanupWebsocketResources.bind(this));
+
+  // ensure that the upgradeHead is added to the receiver
+  function firstHandler(data) {
+    if (self.readyState != WebSocket.OPEN) return;
+    if (upgradeHead && upgradeHead.length > 0) {
+      self.bytesReceived += upgradeHead.length;
+      var head = upgradeHead;
+      upgradeHead = null;
+      self._receiver.add(head);
+    }
+    dataHandler = realHandler;
+    if (data) {
+      self.bytesReceived += data.length;
+      self._receiver.add(data);
+    }
+  }
+  // subsequent packets are pushed straight to the receiver
+  function realHandler(data) {
+    if (data) self.bytesReceived += data.length;
+    self._receiver.add(data);
+  }
+  var dataHandler = firstHandler;
+  socket.on('data', dataHandler);
+  // if data was passed along with the http upgrade,
+  // this will schedule a push of that on to the receiver.
+  // this has to be done on next tick, since the caller
+  // hasn't had a chance to set event handlers on this client
+  // object yet.
+  process.nextTick(firstHandler);
+
+  // receiver event handlers
+  self._receiver.ontext = function (data, flags) {
+    flags = flags || {};
+    self.emit('message', data, flags);
+  };
+  self._receiver.onbinary = function (data, flags) {
+    flags = flags || {};
+    flags.binary = true;
+    self.emit('message', data, flags);
+  };
+  self._receiver.onping = function(data, flags) {
+    flags = flags || {};
+    self.pong(data, {mask: !self._isServer, binary: flags.binary === true}, true);
+    self.emit('ping', data, flags);
+  };
+  self._receiver.onpong = function(data, flags) {
+    self.emit('pong', data, flags);
+  };
+  self._receiver.onclose = function(code, data, flags) {
+    flags = flags || {};
+    self.close(code, data);
+  };
+  self._receiver.onerror = function(reason, errorCode) {
+    // close the connection when the receiver reports a HyBi error code
+    self.close(typeof errorCode != 'undefined' ? errorCode : 1002, '');
+    self.emit('error', reason, errorCode);
+  };
+
+  // finalize the client
+  this._sender = new SenderClass(socket);
+  this._sender.on('error', function(error) {
+    self.close(1002, '');
+    self.emit('error', error);
+  });
+  this.readyState = WebSocket.OPEN;
+  this.emit('open');
+}
+
+function startQueue(instance) {
+  instance._queue = instance._queue || [];
+}
+
+function executeQueueSends(instance) {
+  var queue = instance._queue;
+  if (typeof queue == 'undefined') return;
+  delete instance._queue;
+  for (var i = 0, l = queue.length; i < l; ++i) {
+    queue[i]();
+  }
+}
+
+function sendStream(instance, stream, options, cb) {
+  stream.on('data', function(data) {
+    if (instance.readyState != WebSocket.OPEN) {
+      if (typeof cb == 'function') cb(new Error('not opened'));
+      else {
+        delete instance._queue;
+        instance.emit('error', new Error('not opened'));
+      }
+      return;
+    }
+    options.fin = false;
+    instance._sender.send(data, options);
+  });
+  stream.on('end', function() {
+    if (instance.readyState != WebSocket.OPEN) {
+      if (typeof cb == 'function') cb(new Error('not opened'));
+      else {
+        delete instance._queue;
+        instance.emit('error', new Error('not opened'));
+      }
+      return;
+    }
+    options.fin = true;
+    instance._sender.send(null, options);
+    if (typeof cb == 'function') cb(null);
+  });
+}
+
+function cleanupWebsocketResources(error) {
+  if (this.readyState == WebSocket.CLOSED) return;
+  var emitClose = this.readyState != WebSocket.CONNECTING;
+  this.readyState = WebSocket.CLOSED;
+
+  clearTimeout(this._closeTimer);
+
+  if (this._socket) {
+    removeAllListeners(this._socket);
+    // catch all socket error after removing all standard handlers
+    var socket = this._socket;
+    this._socket.on('error', function() {
+      try { socket.destroy(); } catch (e) {}
+    });
+    try {
+      if (!error) this._socket.end();
+      else this._socket.terminate();
+    }
+    catch (e) { /* Ignore termination errors */ }
+    this._socket = null;
+  }
+  if (this._sender) {
+    removeAllListeners(this._sender);
+    this._sender = null;
+  }
+  if (this._receiver) {
+    this._receiver.cleanup();
+    this._receiver = null;
+  }
+  if (emitClose) this.emit('close', this._closeCode || 1000, this._closeMessage || '');
+  removeAllListeners(this);
+  this.on('error', function() {}); // catch all errors after this
+  delete this._queue;
+}
+
+function removeAllListeners(instance) {
+  if (isNodeV4) {
+    // node v4 doesn't *actually* remove all listeners globally,
+    // so we do that instead
+    instance._events = {};
+  }
+  else instance.removeAllListeners();
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/WebSocketServer.js b/appshell/node-core/thirdparty/ws/lib/WebSocketServer.js
new file mode 100644
index 000000000..fa406c718
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/WebSocketServer.js
@@ -0,0 +1,425 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var util = require('util')
+  , events = require('events')
+  , http = require('http')
+  , crypto = require('crypto')
+  , url = require('url')
+  , Options = require('./options')
+  , WebSocket = require('./WebSocket')
+  , tls = require('tls')
+  , url = require('url');
+
+/**
+ * WebSocket Server implementation
+ */
+
+function WebSocketServer(options, callback) {
+  options = new Options({
+    host: '0.0.0.0',
+    port: null,
+    server: null,
+    verifyClient: null,
+    path: null,
+    noServer: false,
+    disableHixie: false,
+    clientTracking: true
+  }).merge(options);
+  if (!options.value.port && !options.value.server && !options.value.noServer) {
+    throw new TypeError('`port` or a `server` must be provided');
+  }
+
+  var self = this;
+
+  if (options.value.port) {
+    this._server = http.createServer(function (req, res) {
+      res.writeHead(200, {'Content-Type': 'text/plain'});
+      res.end('Not implemented');
+    });
+    this._server.listen(options.value.port, options.value.host, callback);
+    this._closeServer = function() { self._server.close(); };
+  }
+  else if (options.value.server) {
+    this._server = options.value.server;
+    if (options.value.path) {
+      // take note of the path, to avoid collisions when multiple websocket servers are
+      // listening on the same http server
+      if (this._server._webSocketPaths && options.value.server._webSocketPaths[options.value.path]) {
+        throw new Error('two instances of WebSocketServer cannot listen on the same http server path');
+      }
+      if (typeof this._server._webSocketPaths !== 'object') {
+        this._server._webSocketPaths = {};
+      }
+      this._server._webSocketPaths[options.value.path] = 1;
+    }
+  }
+  if (this._server) this._server.once('listening', function() { self.emit('listening'); });
+
+  if (typeof this._server != 'undefined') {
+    this._server.on('error', function(error) {
+      self.emit('error', error)
+    });
+    this._server.on('upgrade', function(req, socket, upgradeHead) {
+      self.handleUpgrade(req, socket, upgradeHead, function(client) {
+        self.emit('connection'+req.url, client);
+        self.emit('connection', client);
+      });
+    });
+  }
+
+  this.options = options.value;
+  this.path = options.value.path;
+  this.clients = [];
+}
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+util.inherits(WebSocketServer, events.EventEmitter);
+
+/**
+ * Immediately shuts down the connection.
+ *
+ * @api public
+ */
+
+WebSocketServer.prototype.close = function() {
+  // terminate all associated clients
+  var error = null;
+  try {
+    for (var i = 0, l = this.clients.length; i < l; ++i) {
+      this.clients[i].terminate();
+    }
+  }
+  catch (e) {
+    error = e;
+  }
+
+  // remove path descriptor, if any
+  if (this.path && this._server._webSocketPaths) {
+    delete this._server._webSocketPaths[this.path];
+    if (Object.keys(this._server._webSocketPaths).length == 0) {
+      delete this._server._webSocketPaths;
+    }
+  }
+
+  // close the http server if it was internally created
+  try {
+    if (typeof this._closeServer !== 'undefined') {
+      this._closeServer();
+    }
+  }
+  finally {
+    delete this._server;
+  }
+  if (error) throw error;
+}
+
+/**
+ * Handle a HTTP Upgrade request.
+ *
+ * @api public
+ */
+
+WebSocketServer.prototype.handleUpgrade = function(req, socket, upgradeHead, cb) {
+  // check for wrong path
+  if (this.options.path) {
+    var u = url.parse(req.url);
+    if (u && u.pathname !== this.options.path) return;
+  }
+
+  if (typeof req.headers.upgrade === 'undefined' || req.headers.upgrade.toLowerCase() !== 'websocket') {
+    abortConnection(socket, 400, 'Bad Request');
+    return;
+  }
+
+  if (req.headers['sec-websocket-key1']) handleHixieUpgrade.apply(this, arguments);
+  else handleHybiUpgrade.apply(this, arguments);
+}
+
+module.exports = WebSocketServer;
+
+/**
+ * Entirely private apis,
+ * which may or may not be bound to a sepcific WebSocket instance.
+ */
+
+function handleHybiUpgrade(req, socket, upgradeHead, cb) {
+  // handle premature socket errors
+  var errorHandler = function() {
+    try { socket.destroy(); } catch (e) {}
+  }
+  socket.on('error', errorHandler);
+
+  // verify key presence
+  if (!req.headers['sec-websocket-key']) {
+    abortConnection(socket, 400, 'Bad Request');
+    return;
+  }
+
+  // verify version
+  var version = parseInt(req.headers['sec-websocket-version']);
+  if ([8, 13].indexOf(version) === -1) {
+    abortConnection(socket, 400, 'Bad Request');
+    return;
+  }
+
+  // verify client
+  var origin = version < 13 ?
+    req.headers['sec-websocket-origin'] :
+    req.headers['origin'];
+
+  // handler to call when the connection sequence completes
+  var self = this;
+  var completeHybiUpgrade = function() {
+     var protocol = req.headers['sec-websocket-protocol'];
+
+    // calc key
+    var key = req.headers['sec-websocket-key'];
+    var shasum = crypto.createHash('sha1');
+    shasum.update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
+    key = shasum.digest('base64');
+
+    var headers = [
+        'HTTP/1.1 101 Switching Protocols'
+      , 'Upgrade: websocket'
+      , 'Connection: Upgrade'
+      , 'Sec-WebSocket-Accept: ' + key
+    ];
+
+    if (typeof protocol != 'undefined') {
+      headers.push('Sec-WebSocket-Protocol: ' + protocol);
+    }
+
+    // allows external modification/inspection of handshake headers
+    self.emit('headers', headers);
+
+    socket.setTimeout(0);
+    socket.setNoDelay(true);
+    try {
+      socket.write(headers.concat('', '').join('\r\n'));
+    }
+    catch (e) {
+      // if the upgrade write fails, shut the connection down hard
+      try { socket.destroy(); } catch (e) {}
+      return;
+    }
+
+    var client = new WebSocket([req, socket, upgradeHead], {
+      protocolVersion: version,
+      protocol: protocol
+    });
+
+    if (self.options.clientTracking) {
+      self.clients.push(client);
+      client.on('close', function() {
+        var index = self.clients.indexOf(client);
+        if (index != -1) {
+          self.clients.splice(index, 1);
+        }
+      });
+    }
+
+    // signal upgrade complete
+    socket.removeListener('error', errorHandler);
+    cb(client);
+  }
+
+  // optionally call external client verification handler
+  if (typeof this.options.verifyClient == 'function') {
+    var info = {
+      origin: origin,
+      secure: typeof req.connection.encrypted !== 'undefined',
+      req: req
+    };
+    if (this.options.verifyClient.length == 2) {
+      this.options.verifyClient(info, function(result) {
+        if (!result) abortConnection(socket, 401, 'Unauthorized')
+        else completeHybiUpgrade();
+      });
+      return;
+    }
+    else if (!this.options.verifyClient(info)) {
+      abortConnection(socket, 401, 'Unauthorized');
+      return;
+    }
+  }
+
+  completeHybiUpgrade();
+}
+
+function handleHixieUpgrade(req, socket, upgradeHead, cb) {
+  // handle premature socket errors
+  var errorHandler = function() {
+    try { socket.destroy(); } catch (e) {}
+  }
+  socket.on('error', errorHandler);
+
+  // bail if options prevent hixie
+  if (this.options.disableHixie) {
+    abortConnection(socket, 401, 'Hixie support disabled');
+    return;
+  }
+
+  // verify key presence
+  if (!req.headers['sec-websocket-key2']) {
+    abortConnection(socket, 400, 'Bad Request');
+    return;
+  }
+
+  var origin = req.headers['origin']
+    , self = this;
+
+  // setup handshake completion to run after client has been verified
+  var onClientVerified = function() {
+    var wshost;
+    if (!req.headers['x-forwarded-host'])
+        wshost = req.headers.host;
+    else
+        wshost = req.headers['x-forwarded-host'];
+    var location = ((req.headers['x-forwarded-proto'] === 'https' || socket.encrypted) ? 'wss' : 'ws') + '://' + wshost + req.url
+      , protocol = req.headers['sec-websocket-protocol'];
+
+    // handshake completion code to run once nonce has been successfully retrieved
+    var completeHandshake = function(nonce, rest) {
+      // calculate key
+      var k1 = req.headers['sec-websocket-key1']
+        , k2 = req.headers['sec-websocket-key2']
+        , md5 = crypto.createHash('md5');
+
+      [k1, k2].forEach(function (k) {
+        var n = parseInt(k.replace(/[^\d]/g, ''))
+          , spaces = k.replace(/[^ ]/g, '').length;
+        if (spaces === 0 || n % spaces !== 0){
+          abortConnection(socket, 400, 'Bad Request');
+          return;
+        }
+        n /= spaces;
+        md5.update(String.fromCharCode(
+          n >> 24 & 0xFF,
+          n >> 16 & 0xFF,
+          n >> 8  & 0xFF,
+          n       & 0xFF));
+      });
+      md5.update(nonce.toString('binary'));
+
+      var headers = [
+          'HTTP/1.1 101 Switching Protocols'
+        , 'Upgrade: WebSocket'
+        , 'Connection: Upgrade'
+        , 'Sec-WebSocket-Location: ' + location
+      ];
+      if (typeof protocol != 'undefined') headers.push('Sec-WebSocket-Protocol: ' + protocol);
+      if (typeof origin != 'undefined') headers.push('Sec-WebSocket-Origin: ' + origin);
+
+      socket.setTimeout(0);
+      socket.setNoDelay(true);
+      try {
+        // merge header and hash buffer
+        var headerBuffer = new Buffer(headers.concat('', '').join('\r\n'));
+        var hashBuffer = new Buffer(md5.digest('binary'), 'binary');
+        var handshakeBuffer = new Buffer(headerBuffer.length + hashBuffer.length);
+        headerBuffer.copy(handshakeBuffer, 0);
+        hashBuffer.copy(handshakeBuffer, headerBuffer.length);
+
+        // do a single write, which - upon success - causes a new client websocket to be setup
+        socket.write(handshakeBuffer, 'binary', function(err) {
+          if (err) return; // do not create client if an error happens
+          var client = new WebSocket([req, socket, rest], {
+            protocolVersion: 'hixie-76',
+            protocol: protocol
+          });
+          if (self.options.clientTracking) {
+            self.clients.push(client);
+            client.on('close', function() {
+              var index = self.clients.indexOf(client);
+              if (index != -1) {
+                self.clients.splice(index, 1);
+              }
+            });
+          }
+
+          // signal upgrade complete
+          socket.removeListener('error', errorHandler);
+          cb(client);
+        });
+      }
+      catch (e) {
+        try { socket.destroy(); } catch (e) {}
+        return;
+      }
+    }
+
+    // retrieve nonce
+    var nonceLength = 8;
+    if (upgradeHead && upgradeHead.length >= nonceLength) {
+      var nonce = upgradeHead.slice(0, nonceLength);
+      var rest = upgradeHead.length > nonceLength ? upgradeHead.slice(nonceLength) : null;
+      completeHandshake.call(self, nonce, rest);
+    }
+    else {
+      // nonce not present in upgradeHead, so we must wait for enough data
+      // data to arrive before continuing
+      var nonce = new Buffer(nonceLength);
+      upgradeHead.copy(nonce, 0);
+      var received = upgradeHead.length;
+      var rest = null;
+      var handler = function (data) {
+        var toRead = Math.min(data.length, nonceLength - received);
+        if (toRead === 0) return;
+        data.copy(nonce, received, 0, toRead);
+        received += toRead;
+        if (received == nonceLength) {
+          socket.removeListener('data', handler);
+          if (toRead < data.length) rest = data.slice(toRead);
+          completeHandshake.call(self, nonce, rest);
+        }
+      }
+      socket.on('data', handler);
+    }
+  }
+
+  // verify client
+  if (typeof this.options.verifyClient == 'function') {
+    var info = {
+      origin: origin,
+      secure: typeof req.connection.encrypted !== 'undefined',
+      req: req
+    };
+    if (this.options.verifyClient.length == 2) {
+      var self = this;
+      this.options.verifyClient(info, function(result) {
+        if (!result) abortConnection(socket, 401, 'Unauthorized')
+        else onClientVerified.apply(self);
+      });
+      return;
+    }
+    else if (!this.options.verifyClient(info)) {
+      abortConnection(socket, 401, 'Unauthorized');
+      return;
+    }
+  }
+
+  // no client verification required
+  onClientVerified();
+}
+
+function abortConnection(socket, code, name) {
+  try {
+    var response = [
+      'HTTP/1.1 ' + code + ' ' + name,
+      'Content-type: text/html'
+    ];
+    socket.write(response.concat('', '').join('\r\n'));
+  }
+  catch (e) { /* ignore errors - we've aborted this connection */ }
+  finally {
+    // ensure that an early aborted connection is shut down completely
+    try { socket.destroy(); } catch (e) {}
+  }
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/browser.js b/appshell/node-core/thirdparty/ws/lib/browser.js
new file mode 100644
index 000000000..37cafe11d
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/browser.js
@@ -0,0 +1,5 @@
+/// shim for browser packaging
+
+module.exports = function() {
+  return global.WebSocket || global.MozWebSocket;
+}
diff --git a/appshell/node-core/thirdparty/ws/lib/options.js b/appshell/node-core/thirdparty/ws/lib/options.js
new file mode 100644
index 000000000..a10cd72dc
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/lib/options.js
@@ -0,0 +1,80 @@
+/*!
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+var fs = require('fs');
+
+function Options(defaults) {
+  var internalValues = {};
+  var values = this.value = {};
+  Object.keys(defaults).forEach(function(key) {
+    internalValues[key] = defaults[key];
+    Object.defineProperty(values, key, {
+      get: function() { return internalValues[key]; },
+      configurable: false,
+      enumerable: true
+    });
+  });
+  this.reset = function() {
+    Object.keys(defaults).forEach(function(key) {
+      internalValues[key] = defaults[key];
+    });
+    return this;
+  }
+  this.merge = function(options, required) {
+    options = options || {};
+    if (Object.prototype.toString.call(required) === '[object Array]') {
+      var missing = [];
+      for (var i = 0, l = required.length; i < l; ++i) {
+        var key = required[i];
+        if (typeof options[key] === 'undefined') {
+          missing.push(key);
+        }
+      }
+      if (missing.length > 0) {
+        if (missing.length > 1) {
+          throw new Error('options ' +
+            missing.slice(0, missing.length - 1).join(', ') + ' and ' +
+            missing[missing.length - 1] + ' must be defined');
+        }
+        else throw new Error('option ' + missing[0] + ' must be defined');
+      }
+    }
+    Object.keys(options).forEach(function(key) {
+      if (typeof internalValues[key] !== 'undefined') {
+        internalValues[key] = options[key];
+      }
+    });
+    return this;
+  }
+  this.copy = function(keys) {
+    var obj = {};
+    Object.keys(defaults).forEach(function(key) {
+      if (keys.indexOf(key) !== -1) {
+        obj[key] = values[key];
+      }
+    });
+    return obj;
+  }
+  this.read = function(filename, cb) {
+    if (typeof cb == 'function') {
+      var self = this;
+      fs.readFile(filename, function(error, data) {
+        if (error) return cb(error);
+        var conf = JSON.parse(data);
+        self.merge(conf);
+        cb();
+      });
+    }
+    else {
+      var conf = JSON.parse(fs.readFileSync(filename));
+      this.merge(conf);
+    }
+    return this;
+  }
+  Object.freeze(values);
+  Object.freeze(this);
+}
+
+module.exports = Options;
diff --git a/appshell/node-core/thirdparty/ws/package.json b/appshell/node-core/thirdparty/ws/package.json
new file mode 100644
index 000000000..408d273c2
--- /dev/null
+++ b/appshell/node-core/thirdparty/ws/package.json
@@ -0,0 +1,13 @@
+{
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "name": "ws-deploy",
+  "description": "Minimal deployment version of a simple to use, blazing fast and thoroughly tested websocket client, server and console for node.js, up-to-date against RFC-6455",
+  "version": "0.4.25",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/joelrbrandt/ws-deploy.git"
+  },
+  "engines": {
+    "node": ">=0.4.0"
+  }
+}
diff --git a/scripts/download_deps.sh b/scripts/download_deps.sh
index ab31d52fa..c8695ba4e 100755
--- a/scripts/download_deps.sh
+++ b/scripts/download_deps.sh
@@ -113,18 +113,4 @@ else
 
 fi
 
-if [ "$os" = "darwin" ]; then # Building on mac
-    echo "Bootstrapping Node core"
-    pushd "$root_dir/appshell/node-core"
-    OLDPATH=PATH
-    PATH="$root_dir/deps/node/bin:$PATH"
-    npm install
-    PATH=OLDPATH
-    popd
-elif [ "$os" = "msys" ]; then # Building on win
-    echo "Bootstrapping Node core"
-    # npm.cmd must be run from cmd.exe
-    cmd.exe /c "scripts\win_bootstrap_node.bat"
-fi
-
 echo "Node setup complete!"
diff --git a/scripts/win_bootstrap_node.bat b/scripts/win_bootstrap_node.bat
deleted file mode 100644
index 18965bb2f..000000000
--- a/scripts/win_bootstrap_node.bat
+++ /dev/null
@@ -1,5 +0,0 @@
-set PATH=%CD%\deps\node;%PATH%
-cd appshell\node-core
-cmd.exe /C npm.cmd install
-cd ..\..
-exit /b