v1.8.2

[README] update the link to localtunnel server

.npmignore

@@ -0,0 +1 @@
+support

.travis.yml

@@ -1,3 +1,4 @@
 language: node_js
 node_js:
-    - "0.10"
+    - "4"
+    - "6"

History.md

@@ -1,3 +1,25 @@
+# 1.8.2 (2016-11-17)
+
+* fix host header transform
+* update request dependency
+
+# 1.8.1 (2016-01-20)
+
+* fix bug w/ HostHeaderTransformer and binary data
+
+# 1.8.0 (2015-11-04)
+
+* pass socket errors up to top level
+
+# 1.7.0 (2015-07-22)
+
+* add short arg options
+
+# 1.6.0 (2015-05-15)
+
+* keep sockets alive after connecting
+* add --open param to CLI
+
 # 1.5.0 (2014-10-25)
 
 * capture all errors on remote socket and restart the tunnel

README.md

@@ -1,4 +1,6 @@
-# localtunnel [![Build Status](https://travis-ci.org/defunctzombie/localtunnel.png?branch=master)](https://travis-ci.org/defunctzombie/localtunnel) #
+# localtunnel
+
+[![Build Status](https://travis-ci.org/localtunnel/localtunnel.svg?branch=master)](https://travis-ci.org/localtunnel/localtunnel)
 
 localtunnel exposes your localhost to the world for easy testing and sharing! No need to mess with DNS or deploy just to have others test out your changes.
 
@@ -42,13 +44,17 @@ Creates a new localtunnel to the specified local `port`. `fn` will be called onc
 ```javascript
 var localtunnel = require('localtunnel');
 
-localtunnel(port, function(err, tunnel) {
+var tunnel = localtunnel(port, function(err, tunnel) {
     if (err) ...
 
     // the assigned public url for your tunnel
     // i.e. https://abcdefgjhij.localtunnel.me
     tunnel.url;
 });
+
+tunnel.on('close', function() {
+    // tunnels are closed
+});
 ```
 
 ### opts
@@ -65,7 +71,7 @@ The `tunnel` instance returned to your callback emits the following events
 |error|err|fires when an error happens on the tunnel|
 |close||fires when the tunnel has closed|
 
-The `tunnel instance has the following methods
+The `tunnel` instance has the following methods
 
 |method|args|description|
 |----|----|----|
@@ -79,7 +85,7 @@ Clients in other languages
 
 ## server ##
 
-See defunctzombie/localtunnel-server for details on the server that powers localtunnel.
+See [localtunnel/server](//github.com/localtunnel/server) for details on the server that powers localtunnel.
 
 ## License ##
 MIT

bin/client

@@ -1,32 +1,38 @@
 #!/usr/bin/env node
 var lt_client = require('../client');
+var open_url = require('openurl');
 
-var argv = require('optimist')
+var argv = require('yargs')
-    .usage('Usage: $0 --port [num]')
+    .usage('Usage: $0 --port [num] <options>')
-    .options('host', {
+    .option('h', {
-        default: 'http://localtunnel.me',
+        alias: 'host',
-        describe: 'upstream server providing forwarding'
+        describe: 'Upstream server providing forwarding',
+        default: 'http://localtunnel.me'
     })
-    .options('subdomain', {
+    .option('s', {
-        describe: 'request this subdomain'
+        alias: 'subdomain',
+        describe: 'Request this subdomain'
     })
-    .options('local-host', {
+    .option('l', {
-        describe: 'tunnel traffic to this host instead of localhost, override Host header to this host'
+        alias: 'local-host',
+        describe: 'Tunnel traffic to this host instead of localhost, override Host header to this host'
     })
-    .options('version', {
+    .options('o', {
-        describe: 'print version and exit'
+        alias: 'open',
+        describe: 'opens url in your browser'
     })
-    .describe('port', 'internal http server port')
+    .option('p', {
+        alias: 'port',
+        describe: 'Internal http server port',
+    })
+    .require('port')
+    .help('help', 'Show this help and exit')
+    .version(require('../package').version)
     .argv;
 
-if (argv.version) {
+if (typeof argv.port !== 'number') {
-    console.log(require('../package.json').version);
+    require('yargs').showHelp();
-    process.exit(0);
+    console.error('port must be a number');
-}
-
-if (argv.port == null) {
-    require('optimist').showHelp();
-    console.error('Missing required arguments: port');
     process.exit(1);
 }
 
@@ -44,6 +50,10 @@ lt_client(opt.port, opt, function(err, tunnel) {
 
     console.log('your url is: %s', tunnel.url);
 
+    if (argv.open) {
+        open_url.open(tunnel.url);
+    }
+
     tunnel.on('error', function(err) {
         throw err;
     });

client.js

@@ -1,301 +1,7 @@
-var net = require('net');
-var url = require('url');
 var EventEmitter = require('events').EventEmitter;
-
-var request = require('request');
 var debug = require('debug')('localtunnel:client');
 
-var stream = require('stream');
+var Tunnel = require('./lib/Tunnel');
-var util = require('util');
-
-var Transform = stream.Transform;
-
-var HeaderHostTransformer = function(opts) {
-    if (!(this instanceof HeaderHostTransformer)) {
-        return new HeaderHostTransformer(opts);
-    }
-
-    opts = opts || {}
-    Transform.call(this, opts);
-
-    var self = this;
-    self.host = opts.host || 'localhost';
-    self.replaced = false;
-}
-util.inherits(HeaderHostTransformer, Transform);
-
-HeaderHostTransformer.prototype._transform = function (chunk, enc, cb) {
-    var self = this;
-    chunk = chunk.toString();
-
-    // after replacing the first instance of the Host header
-    // we just become a regular passthrough
-    if (!self.replaced) {
-        self.push(chunk.replace(/(\r\nHost: )\S+/, function(match, $1) {
-            self.replaced = true;
-            return $1 + self.host;
-        }));
-    }
-    else {
-        self.push(chunk);
-    }
-
-    cb();
-};
-
-// manages groups of tunnels
-var TunnelCluster = function(opt) {
-    if (!(this instanceof TunnelCluster)) {
-        return new TunnelCluster(opt);
-    }
-
-    var self = this;
-    self._opt = opt;
-
-    EventEmitter.call(self);
-};
-
-TunnelCluster.prototype.__proto__ = EventEmitter.prototype;
-
-// establish a new tunnel
-TunnelCluster.prototype.open = function() {
-    var self = this;
-
-    var opt = self._opt || {};
-
-    var remote_host = opt.remote_host;
-    var remote_port = opt.remote_port;
-
-    var local_host = opt.local_host || 'localhost';
-    var local_port = opt.local_port;
-
-    debug('establishing tunnel %s:%s <> %s:%s', local_host, local_port, remote_host, remote_port);
-
-    // connection to localtunnel server
-    var remote = net.connect({
-        host: remote_host,
-        port: remote_port
-    });
-
-    remote.on('error', function(err) {
-        // emit connection refused errors immediately, because they
-        // indicate that the tunnel can't be established.
-        if (err.code === 'ECONNREFUSED') {
-            self.emit('error', new Error('connection refused: ' + remote_host + ':' + remote_port + ' (check your firewall settings)'));
-        }
-
-        remote.end();
-    });
-
-    function conn_local() {
-        if (remote.destroyed) {
-            debug('remote destroyed');
-            self.emit('dead');
-            return;
-        }
-
-        debug('connecting locally to %s:%d', local_host, local_port);
-        remote.pause();
-
-        // connection to local http server
-        var local = net.connect({
-            host: local_host,
-            port: local_port
-        });
-
-        function remote_close() {
-            debug('remote close');
-            self.emit('dead');
-            local.end();
-        };
-
-        remote.once('close', remote_close);
-
-        // TODO some languages have single threaded servers which makes opening up
-        // multiple local connections impossible. We need a smarter way to scale
-        // and adjust for such instances to avoid beating on the door of the server
-        local.once('error', function(err) {
-            debug('local error %s', err.message);
-            local.end();
-
-            remote.removeListener('close', remote_close);
-
-            if (err.code !== 'ECONNREFUSED') {
-                return remote.end();
-            }
-
-            // retrying connection to local server
-            setTimeout(conn_local, 1000);
-        });
-
-        local.once('connect', function() {
-            debug('connected locally');
-            remote.resume();
-
-            var stream = remote;
-
-            // if user requested specific local host
-            // then we use host header transform to replace the host header
-            if (opt.local_host) {
-                debug('transform Host header to %s', opt.local_host);
-                stream = remote.pipe(HeaderHostTransformer({ host: opt.local_host }));
-            }
-
-            stream.pipe(local).pipe(remote);
-
-            // when local closes, also get a new remote
-            local.once('close', function(had_error) {
-                debug('local connection closed [%s]', had_error);
-            });
-        });
-    }
-
-    // tunnel is considered open when remote connects
-    remote.once('connect', function() {
-        self.emit('open', remote);
-        conn_local();
-    });
-};
-
-var Tunnel = function(opt) {
-    if (!(this instanceof Tunnel)) {
-        return new Tunnel(opt);
-    }
-
-    var self = this;
-    self._closed = false;
-    self._opt = opt || {};
-
-    self._opt.host = self._opt.host || 'https://localtunnel.me';
-};
-
-Tunnel.prototype.__proto__ = EventEmitter.prototype;
-
-// initialize connection
-// callback with connection info
-Tunnel.prototype._init = function(cb) {
-    var self = this;
-    var opt = self._opt;
-
-    var params = {
-        path: '/',
-        json: true
-    };
-
-    var base_uri = opt.host + '/';
-
-    // optionally override the upstream server
-    var upstream = url.parse(opt.host);
-
-    // no subdomain at first, maybe use requested domain
-    var assigned_domain = opt.subdomain;
-
-    // where to quest
-    params.uri = base_uri + ((assigned_domain) ? assigned_domain : '?new');
-
-    (function get_url() {
-        request(params, function(err, res, body) {
-            if (err) {
-                // TODO (shtylman) don't print to stdout?
-                console.log('tunnel server offline: ' + err.message + ', retry 1s');
-                return setTimeout(get_url, 1000);
-            }
-
-            if (res.statusCode !== 200) {
-                var err = new Error((body && body.message) || 'localtunnel server returned an error, please try again');
-                return cb(err);
-            }
-
-            var port = body.port;
-            var host = upstream.hostname;
-
-            var max_conn = body.max_conn_count || 1;
-
-            cb(null, {
-                remote_host: upstream.hostname,
-                remote_port: body.port,
-                name: body.id,
-                url: body.url,
-                max_conn: max_conn
-            });
-        });
-    })();
-};
-
-Tunnel.prototype._establish = function(info) {
-    var self = this;
-    var opt = self._opt;
-
-    info.local_host = opt.local_host;
-    info.local_port = opt.port;
-
-    var tunnels = self.tunnel_cluster = TunnelCluster(info);
-
-    // only emit the url the first time
-    tunnels.once('open', function() {
-        self.emit('url', info.url);
-    });
-
-    var tunnel_count = 0;
-
-    // track open count
-    tunnels.on('open', function(tunnel) {
-        tunnel_count++;
-        debug('tunnel open [total: %d]', tunnel_count);
-
-        var close_handler = function() {
-            tunnel.destroy();
-        };
-
-        if (self._closed) {
-            return close_handler();
-        }
-
-        self.once('close', close_handler);
-        tunnel.once('close', function() {
-            self.removeListener('close', close_handler);
-        });
-    });
-
-    // when a tunnel dies, open a new one
-    tunnels.on('dead', function(tunnel) {
-        tunnel_count--;
-        debug('tunnel dead [total: %d]', tunnel_count);
-
-        if (self._closed) {
-            return;
-        }
-
-        tunnels.open();
-    });
-
-    // establish as many tunnels as allowed
-    for (var count = 0 ; count < info.max_conn ; ++count) {
-        tunnels.open();
-    }
-};
-
-Tunnel.prototype.open = function(cb) {
-    var self = this;
-
-    self._init(function(err, info) {
-        if (err) {
-            return cb(err);
-        }
-
-        self.url = info.url;
-        self._establish(info);
-        cb();
-    });
-};
-
-// shutdown tunnels
-Tunnel.prototype.close = function() {
-    var self = this;
-
-    self._closed = true;
-    self.emit('close');
-};
 
 module.exports = function localtunnel(port, opt, fn) {
     if (typeof opt === 'function') {

lib/HeaderHostTransformer.js

@@ -0,0 +1,39 @@
+var stream = require('stream');
+var util = require('util');
+
+var Transform = stream.Transform;
+
+var HeaderHostTransformer = function(opts) {
+    if (!(this instanceof HeaderHostTransformer)) {
+        return new HeaderHostTransformer(opts);
+    }
+
+    opts = opts || {}
+    Transform.call(this, opts);
+
+    var self = this;
+    self.host = opts.host || 'localhost';
+    self.replaced = false;
+}
+util.inherits(HeaderHostTransformer, Transform);
+
+HeaderHostTransformer.prototype._transform = function (chunk, enc, cb) {
+    var self = this;
+
+    // after replacing the first instance of the Host header
+    // we just become a regular passthrough
+    if (!self.replaced) {
+        chunk = chunk.toString();
+        self.push(chunk.replace(/(\r\n[Hh]ost: )\S+/, function(match, $1) {
+            self.replaced = true;
+            return $1 + self.host;
+        }));
+    }
+    else {
+        self.push(chunk);
+    }
+
+    cb();
+};
+
+module.exports = HeaderHostTransformer;

lib/Tunnel.js

@@ -0,0 +1,157 @@
+var url = require('url');
+var EventEmitter = require('events').EventEmitter;
+var request = require('request');
+var debug = require('debug')('localtunnel:client');
+
+var TunnelCluster = require('./TunnelCluster');
+
+var Tunnel = function(opt) {
+    if (!(this instanceof Tunnel)) {
+        return new Tunnel(opt);
+    }
+
+    var self = this;
+    self._closed = false;
+    self._opt = opt || {};
+
+    self._opt.host = self._opt.host || 'https://localtunnel.me';
+};
+
+Tunnel.prototype.__proto__ = EventEmitter.prototype;
+
+// initialize connection
+// callback with connection info
+Tunnel.prototype._init = function(cb) {
+    var self = this;
+    var opt = self._opt;
+
+    var params = {
+        path: '/',
+        json: true
+    };
+
+    var base_uri = opt.host + '/';
+
+    // optionally override the upstream server
+    var upstream = url.parse(opt.host);
+
+    // no subdomain at first, maybe use requested domain
+    var assigned_domain = opt.subdomain;
+
+    // where to quest
+    params.uri = base_uri + ((assigned_domain) ? assigned_domain : '?new');
+
+    (function get_url() {
+        request(params, function(err, res, body) {
+            if (err) {
+                // TODO (shtylman) don't print to stdout?
+                console.log('tunnel server offline: ' + err.message + ', retry 1s');
+                return setTimeout(get_url, 1000);
+            }
+
+            if (res.statusCode !== 200) {
+                var err = new Error((body && body.message) || 'localtunnel server returned an error, please try again');
+                return cb(err);
+            }
+
+            var port = body.port;
+            var host = upstream.hostname;
+
+            var max_conn = body.max_conn_count || 1;
+
+            cb(null, {
+                remote_host: upstream.hostname,
+                remote_port: body.port,
+                name: body.id,
+                url: body.url,
+                max_conn: max_conn
+            });
+        });
+    })();
+};
+
+Tunnel.prototype._establish = function(info) {
+    var self = this;
+    var opt = self._opt;
+    
+    // increase max event listeners so that localtunnel consumers don't get
+    // warning messages as soon as they setup even one listener. See #71
+    self.setMaxListeners(info.max_conn + (EventEmitter.defaultMaxListeners || 10));
+
+    info.local_host = opt.local_host;
+    info.local_port = opt.port;
+
+    var tunnels = self.tunnel_cluster = TunnelCluster(info);
+
+    // only emit the url the first time
+    tunnels.once('open', function() {
+        self.emit('url', info.url);
+    });
+
+    // re-emit socket error
+    tunnels.on('error', function(err) {
+        self.emit('error', err);
+    });
+
+    var tunnel_count = 0;
+
+    // track open count
+    tunnels.on('open', function(tunnel) {
+        tunnel_count++;
+        debug('tunnel open [total: %d]', tunnel_count);
+
+        var close_handler = function() {
+            tunnel.destroy();
+        };
+
+        if (self._closed) {
+            return close_handler();
+        }
+
+        self.once('close', close_handler);
+        tunnel.once('close', function() {
+            self.removeListener('close', close_handler);
+        });
+    });
+
+    // when a tunnel dies, open a new one
+    tunnels.on('dead', function(tunnel) {
+        tunnel_count--;
+        debug('tunnel dead [total: %d]', tunnel_count);
+
+        if (self._closed) {
+            return;
+        }
+
+        tunnels.open();
+    });
+
+    // establish as many tunnels as allowed
+    for (var count = 0 ; count < info.max_conn ; ++count) {
+        tunnels.open();
+    }
+};
+
+Tunnel.prototype.open = function(cb) {
+    var self = this;
+
+    self._init(function(err, info) {
+        if (err) {
+            return cb(err);
+        }
+
+        self.url = info.url;
+        self._establish(info);
+        cb();
+    });
+};
+
+// shutdown tunnels
+Tunnel.prototype.close = function() {
+    var self = this;
+
+    self._closed = true;
+    self.emit('close');
+};
+
+module.exports = Tunnel;

lib/TunnelCluster.js

@@ -0,0 +1,123 @@
+var EventEmitter = require('events').EventEmitter;
+var debug = require('debug')('localtunnel:client');
+var net = require('net');
+
+var HeaderHostTransformer = require('./HeaderHostTransformer');
+
+// manages groups of tunnels
+var TunnelCluster = function(opt) {
+    if (!(this instanceof TunnelCluster)) {
+        return new TunnelCluster(opt);
+    }
+
+    var self = this;
+    self._opt = opt;
+
+    EventEmitter.call(self);
+};
+
+TunnelCluster.prototype.__proto__ = EventEmitter.prototype;
+
+// establish a new tunnel
+TunnelCluster.prototype.open = function() {
+    var self = this;
+
+    var opt = self._opt || {};
+
+    var remote_host = opt.remote_host;
+    var remote_port = opt.remote_port;
+
+    var local_host = opt.local_host || 'localhost';
+    var local_port = opt.local_port;
+
+    debug('establishing tunnel %s:%s <> %s:%s', local_host, local_port, remote_host, remote_port);
+
+    // connection to localtunnel server
+    var remote = net.connect({
+        host: remote_host,
+        port: remote_port
+    });
+
+    remote.setKeepAlive(true);
+
+    remote.on('error', function(err) {
+        // emit connection refused errors immediately, because they
+        // indicate that the tunnel can't be established.
+        if (err.code === 'ECONNREFUSED') {
+            self.emit('error', new Error('connection refused: ' + remote_host + ':' + remote_port + ' (check your firewall settings)'));
+        }
+
+        remote.end();
+    });
+
+    function conn_local() {
+        if (remote.destroyed) {
+            debug('remote destroyed');
+            self.emit('dead');
+            return;
+        }
+
+        debug('connecting locally to %s:%d', local_host, local_port);
+        remote.pause();
+
+        // connection to local http server
+        var local = net.connect({
+            host: local_host,
+            port: local_port
+        });
+
+        function remote_close() {
+            debug('remote close');
+            self.emit('dead');
+            local.end();
+        };
+
+        remote.once('close', remote_close);
+
+        // TODO some languages have single threaded servers which makes opening up
+        // multiple local connections impossible. We need a smarter way to scale
+        // and adjust for such instances to avoid beating on the door of the server
+        local.once('error', function(err) {
+            debug('local error %s', err.message);
+            local.end();
+
+            remote.removeListener('close', remote_close);
+
+            if (err.code !== 'ECONNREFUSED') {
+                return remote.end();
+            }
+
+            // retrying connection to local server
+            setTimeout(conn_local, 1000);
+        });
+
+        local.once('connect', function() {
+            debug('connected locally');
+            remote.resume();
+
+            var stream = remote;
+
+            // if user requested specific local host
+            // then we use host header transform to replace the host header
+            if (opt.local_host) {
+                debug('transform Host header to %s', opt.local_host);
+                stream = remote.pipe(HeaderHostTransformer({ host: opt.local_host }));
+            }
+
+            stream.pipe(local).pipe(remote);
+
+            // when local closes, also get a new remote
+            local.once('close', function(had_error) {
+                debug('local connection closed [%s]', had_error);
+            });
+        });
+    }
+
+    // tunnel is considered open when remote connects
+    remote.once('connect', function() {
+        self.emit('open', remote);
+        conn_local();
+    });
+};
+
+module.exports = TunnelCluster;

package.json

@@ -2,15 +2,17 @@
   "author": "Roman Shtylman <shtylman@gmail.com>",
   "name": "localtunnel",
   "description": "expose localhost to the world",
-  "version": "1.5.0",
+  "version": "1.8.2",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git://github.com/shtylman/localtunnel.git"
+    "url": "git://github.com/localtunnel/localtunnel.git"
   },
   "dependencies": {
-    "request": "2.11.4",
+    "request": "2.78.0",
-    "optimist": "0.3.4",
+    "yargs": "3.29.0",
-    "debug": "0.7.4"
+    "debug": "2.2.0",
+    "openurl": "1.1.0"
   },
   "devDependencies": {
     "mocha": "~1.17.0"