browsed 0.2.5 → 0.2.6

data/lib/browsed/proxies/proxy-chain-server/node_modules/proxy-chain/build/tcp_tunnel.js

@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+exports.createTunnel = createTunnel;
+exports.closeTunnel = closeTunnel;
+
+var _bluebird = require('bluebird');
+
+var _bluebird2 = _interopRequireDefault(_bluebird);
+
+var _net = require('net');
+
+var _net2 = _interopRequireDefault(_net);
+
+var _handler_tunnel_tcp_chain = require('./handler_tunnel_tcp_chain');
+
+var _handler_tunnel_tcp_chain2 = _interopRequireDefault(_handler_tunnel_tcp_chain);
+
+var _tools = require('./tools');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var runningServers = {};
+
+function createTunnel(proxyUrl, targetHost) {
+    var providedOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var callback = arguments[3];
+
+    // TODO: More and better validations - yeah, make sure targetHost is really a hostname
+    var _targetHost$split = targetHost.split(':'),
+        _targetHost$split2 = _slicedToArray(_targetHost$split, 2),
+        trgHostname = _targetHost$split2[0],
+        trgPort = _targetHost$split2[1];
+
+    if (!trgHostname || !trgPort) throw new Error('target needs to include both hostname and port.');
+
+    var parsedProxyUrl = (0, _tools.parseUrl)(proxyUrl);
+    if (!parsedProxyUrl.hostname) throw new Error('proxyUrl needs to include atleast hostname');
+    if (parsedProxyUrl.scheme !== 'http') throw new Error('Currently only "http" scheme is supported');
+
+    var options = _extends({
+        verbose: false,
+        hostname: 'localhost',
+        port: null
+    }, providedOptions);
+
+    return new _bluebird2.default(function (resolve, reject) {
+        if (options.port) return resolve(options.port);
+        (0, _tools.findFreePort)().then(resolve).catch(reject);
+    }).then(function (port) {
+        var server = _net2.default.createServer();
+
+        var log = function log() {
+            var _console;
+
+            if (options.verbose) (_console = console).log.apply(_console, arguments);
+        };
+
+        server.on('connection', function (srcSocket) {
+            runningServers[port].connections = srcSocket;
+            var remoteAddress = srcSocket.remoteAddress + ':' + srcSocket.remotePort;
+            log('new client connection from %s', remoteAddress);
+
+            srcSocket.pause();
+
+            var tunnel = new _handler_tunnel_tcp_chain2.default({
+                srcSocket: srcSocket,
+                upstreamProxyUrlParsed: parsedProxyUrl,
+                trgParsed: {
+                    hostname: trgHostname,
+                    port: trgPort
+                },
+                log: log
+            });
+
+            tunnel.run();
+
+            srcSocket.on('data', onConnData);
+            srcSocket.once('close', onConnClose);
+            srcSocket.on('error', onConnError);
+
+            function onConnData(d) {
+                log('connection data from %s: %j', remoteAddress, d);
+            }
+
+            function onConnClose() {
+                log('connection from %s closed', remoteAddress);
+            }
+
+            function onConnError(err) {
+                log('Connection %s error: %s', remoteAddress, err.message);
+            }
+        });
+
+        return new _bluebird2.default(function (resolve) {
+            server.listen(port, function (err) {
+                if (err) return reject(err);
+                log('server listening to ', server.address());
+                runningServers[port] = { server: server, connections: [] };
+                resolve(options.hostname + ':' + port);
+            });
+        });
+    }).nodeify(callback);
+}
+
+function closeTunnel(serverPath, closeConnections, callback) {
+    var _serverPath$split = serverPath.split(':'),
+        _serverPath$split2 = _slicedToArray(_serverPath$split, 2),
+        hostname = _serverPath$split2[0],
+        port = _serverPath$split2[1];
+
+    if (!hostname) throw new Error('serverPath must contain hostname');
+    if (!port) throw new Error('serverPath must contain port');
+
+    return new _bluebird2.default(function (resolve) {
+        if (!runningServers[port]) return resolve(false);
+        if (!closeConnections) return resolve();
+        runningServers[port].connections.forEach(function (connection) {
+            return connection.destroy();
+        });
+        resolve();
+    }).then(function (serverExists) {
+        return new _bluebird2.default(function (resolve) {
+            if (!serverExists) return resolve(false);
+            runningServers[port].close(function () {
+                delete runningServers[port];
+                resolve(true);
+            });
+        });
+    }).nodeify(callback);
+}

data/lib/browsed/proxies/proxy-chain-server/node_modules/proxy-chain/build/testing_tcp_service.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var net = require('net');
+
+// TODO: please move this into ./test dir
+
+var server = net.createServer();
+
+server.on('connection', handleConnection);
+
+server.listen(9112, function () {
+    console.log('server listening to %j', server.address());
+});
+
+function handleConnection(conn) {
+    var remoteAddress = conn.remoteAddress + ':' + conn.remotePort;
+    console.log('new client connection from %s', remoteAddress);
+
+    conn.setEncoding('utf8');
+
+    conn.on('data', onConnData);
+    conn.once('close', onConnClose);
+    conn.on('error', onConnError);
+
+    function onConnData(d) {
+        console.log('connection data from %s: %j', remoteAddress, d);
+        conn.write(d);
+    }
+
+    function onConnClose() {
+        console.log('connection from %s closed', remoteAddress);
+    }
+
+    function onConnError(err) {
+        console.log('Connection %s error: %s', remoteAddress, err.message);
+    }
+}

data/lib/browsed/proxies/proxy-chain-server/node_modules/proxy-chain/build/tools.js

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.maybeAddProxyAuthorizationHeader = exports.findFreePort = exports.PORT_SELECTION_CONFIG = exports.addHeader = exports.parseProxyAuthorizationHeader = exports.redactParsedUrl = exports.redactUrl = exports.parseUrl = exports.isInvalidHeader = exports.isHopByHopHeader = exports.parseHostHeader = undefined;
+
+var _url = require('url');
+
+var _url2 = _interopRequireDefault(_url);
+
+var _http_common = require('_http_common');
+
+var _portastic = require('portastic');
+
+var _portastic2 = _interopRequireDefault(_portastic);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import through from 'through';
+
+
+var HOST_HEADER_REGEX = /^((([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9]))(:([0-9]+))?$/;
+
+/**
+ * Parsed the 'Host' HTTP header and returns an object with { host: String, port: Number }.
+ * For example, for 'www.example.com:80' it returns { host: 'www.example.com', port: 80 }.
+ * If port is not present, the function
+ * If the header is invalid, returns null.
+ * @param hostHeader
+ * @return {*}
+ */
+// eslint-disable-line
+var parseHostHeader = exports.parseHostHeader = function parseHostHeader(hostHeader) {
+    var matches = HOST_HEADER_REGEX.exec(hostHeader || '');
+    if (!matches) return null;
+
+    var hostname = matches[1];
+    if (hostname.length > 255) return null;
+
+    var port = null;
+    if (matches[5]) {
+        port = parseInt(matches[6], 10);
+        if (!(port > 0 && port <= 65535)) return null;
+    }
+
+    return { hostname: hostname, port: port };
+};
+
+var HOP_BY_HOP_HEADERS = ['Connection', 'Keep-Alive', 'Proxy-Authenticate', 'Proxy-Authorization', 'TE', 'Trailers', 'Transfer-Encoding', 'Upgrade'];
+
+var HOP_BY_HOP_HEADERS_REGEX = new RegExp('^(' + HOP_BY_HOP_HEADERS.join('|') + ')$', 'i');
+
+var isHopByHopHeader = exports.isHopByHopHeader = function isHopByHopHeader(header) {
+    return HOP_BY_HOP_HEADERS_REGEX.test(header);
+};
+
+// This code is based on Node.js' validateHeader() function from _http_outgoing.js module
+// (see https://github.com/nodejs/node/blob/189d29f39e6de9ccf10682bfd1341819b4a2291f/lib/_http_outgoing.js#L485)
+var isInvalidHeader = exports.isInvalidHeader = function isInvalidHeader(name, value) {
+    // NOTE: These are internal Node.js functions, they might stop working in the future!
+    return typeof name !== 'string' || !name || !(0, _http_common._checkIsHttpToken)(name) || value === undefined || (0, _http_common._checkInvalidHeaderChar)(value);
+};
+
+/**
+ * Sames are Node's url.parse() just adds the 'username', 'password' and 'scheme' fields.
+ * Also this method makes sure "port" is a number rather than a string.
+ * Note that `scheme` is always lower-cased (e.g. `ftp`).
+ * @param url
+ * @ignore
+ */
+var parseUrl = exports.parseUrl = function parseUrl(url) {
+    var parsed = _url2.default.parse(url);
+
+    parsed.username = null;
+    parsed.password = null;
+    parsed.scheme = null;
+
+    if (parsed.auth) {
+        var matches = /^([^:]+)(:?)(.*)$/.exec(parsed.auth);
+        if (matches && matches.length === 4) {
+            parsed.username = matches[1];
+            if (matches[2] === ':') parsed.password = matches[3];
+        }
+    }
+
+    if (parsed.protocol) {
+        var _matches = /^([a-z0-9]+):$/i.exec(parsed.protocol);
+        if (_matches && _matches.length === 2) {
+            parsed.scheme = _matches[1];
+        }
+    }
+
+    if (parsed.port) {
+        parsed.port = parseInt(parsed.port, 10);
+    }
+
+    return parsed;
+};
+
+/**
+ * Redacts password from a URL, so that it can be shown in logs, results etc.
+ * For example, converts URL such as
+ * 'https://username:password@www.example.com/path#hash'
+ * to 'https://username:<redacted>@www.example.com/path#hash'
+ * @param url URL, it must contain at least protocol and hostname
+ * @param passwordReplacement The string that replaces password, by default it is '<redacted>'
+ * @returns {string}
+ * @ignore
+ */
+var redactUrl = exports.redactUrl = function redactUrl(url, passwordReplacement) {
+    return redactParsedUrl(parseUrl(url), passwordReplacement);
+};
+
+var redactParsedUrl = exports.redactParsedUrl = function redactParsedUrl(parsedUrl) {
+    var passwordReplacement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '<redacted>';
+
+    var p = parsedUrl;
+    var auth = null;
+    if (p.username) {
+        if (p.password) {
+            auth = p.username + ':' + passwordReplacement;
+        } else {
+            auth = '' + p.username;
+        }
+    }
+    return p.protocol + '//' + (auth || '') + (auth ? '@' : '') + p.host + (p.path || '') + (p.hash || '');
+};
+
+var PROXY_AUTH_HEADER_REGEX = /^([a-z0-9-]+) ([a-z0-9+/=]+)$/i;
+
+/**
+ * Parses the content of the Proxy-Authorization HTTP header.
+ * @param header
+ * @returns {*} Object with fields { type: String, username: String, password: String }
+ * or null if string parsing failed. Note that password and username might be empty strings.
+ */
+var parseProxyAuthorizationHeader = exports.parseProxyAuthorizationHeader = function parseProxyAuthorizationHeader(header) {
+    var matches = PROXY_AUTH_HEADER_REGEX.exec(header);
+    if (!matches) return null;
+
+    var auth = Buffer.from(matches[2], 'base64').toString();
+    if (!auth) return null;
+
+    var index = auth.indexOf(':');
+    return {
+        type: matches[1],
+        username: index >= 0 ? auth.substr(0, index) : auth,
+        password: index >= 0 ? auth.substr(index + 1) : ''
+    };
+};
+
+/**
+ * Works like Bash tee, but instead of passing output to file,
+ * passes output to log
+ *
+ * @param   {String}   name          identifier
+ * @param   {Boolean}  initialOnly   log only initial chunk of data
+ * @return  {through}                duplex stream (pipe)
+
+export const tee = (name, initialOnly = true) => {
+    console.log('tee');
+    let maxChunks = 2;
+    const duplex = through((chunk) => {
+        if (maxChunks || !initialOnly) {
+            // let msg = chunk.toString();
+            // msg += '';
+            maxChunks--;
+            console.log(`pipe: ${JSON.stringify({
+                context: name,
+                chunkHead: chunk.toString().slice(0, 100),
+            })}`);
+        }
+        duplex.queue(chunk);
+    });
+
+    return duplex;
+};
+*/
+
+var addHeader = exports.addHeader = function addHeader(headers, name, value) {
+    if (headers[name] === undefined) {
+        headers[name] = value;
+    } else if (Array.isArray(headers[name])) {
+        headers[name].push(value);
+    } else {
+        headers[name] = [headers[name], value];
+    }
+};
+
+var PORT_SELECTION_CONFIG = exports.PORT_SELECTION_CONFIG = {
+    FROM: 20000,
+    TO: 60000,
+    RETRY_COUNT: 10
+};
+
+var findFreePort = exports.findFreePort = function findFreePort() {
+    // Let 'min' be a random value in the first half of the PORT_FROM-PORT_TO range,
+    // to reduce a chance of collision if other ProxyChain is started at the same time.
+    var half = Math.floor((PORT_SELECTION_CONFIG.TO - PORT_SELECTION_CONFIG.FROM) / 2);
+
+    var opts = {
+        min: PORT_SELECTION_CONFIG.FROM + Math.floor(Math.random() * half),
+        max: PORT_SELECTION_CONFIG.TO,
+        retrieve: 1
+    };
+
+    return _portastic2.default.find(opts).then(function (ports) {
+        if (ports.length < 1) throw new Error('There are no more free ports in range from ' + PORT_SELECTION_CONFIG.FROM + ' to ' + PORT_SELECTION_CONFIG.TO); // eslint-disable-line max-len
+        return ports[0];
+    });
+};
+
+var maybeAddProxyAuthorizationHeader = exports.maybeAddProxyAuthorizationHeader = function maybeAddProxyAuthorizationHeader(parsedUrl, headers) {
+    if (parsedUrl && parsedUrl.username) {
+        var auth = parsedUrl.username;
+        if (parsedUrl.password || parsedUrl.password === '') auth += ':' + parsedUrl.password;
+        headers['Proxy-Authorization'] = 'Basic ' + Buffer.from(auth).toString('base64');
+    }
+};

data/lib/browsed/proxies/proxy-chain-server/node_modules/proxy-chain/package.json

@@ -0,0 +1,104 @@
+{
+  "_from": "proxy-chain",
+  "_id": "proxy-chain@0.2.7",
+  "_inBundle": false,
+  "_integrity": "sha512-e0s94WDfooeC3zQkvIJ/Eudiy/AywTQK4K6PMYbZdBE2m/eug54ThgCPdBE4txHvzi0A0gAVbX04Kt4RygTlRQ==",
+  "_location": "/proxy-chain",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "proxy-chain",
+    "name": "proxy-chain",
+    "escapedName": "proxy-chain",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/proxy-chain/-/proxy-chain-0.2.7.tgz",
+  "_shasum": "3c24d1a487e37838b0c9fe34317c276f3401e0ec",
+  "_spec": "proxy-chain",
+  "_where": "/Users/sebastianjohnsson/Programming/Javascript/proxy-chain-server",
+  "author": {
+    "name": "Apify",
+    "email": "support@apify.com",
+    "url": "https://www.apify.com"
+  },
+  "bugs": {
+    "url": "https://github.com/apifytech/proxy-chain/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Jan Curn",
+      "email": "jan@apify.com"
+    }
+  ],
+  "dependencies": {
+    "bluebird": "^3.5.1",
+    "portastic": "^1.0.1",
+    "underscore": "^1.9.1"
+  },
+  "deprecated": false,
+  "description": "Node.js implementation of a proxy server (think Squid) with support for SSL, authentication, upstream proxy chaining, and protocol tunneling.",
+  "devDependencies": {
+    "babel-cli": "^6.6.5",
+    "babel-core": "^6.1.21",
+    "babel-eslint": "^8.2.6",
+    "babel-preset-es2015": "^6.1.18",
+    "babel-preset-stage-0": "^6.1.18",
+    "basic-auth": "^2.0.0",
+    "body-parser": "^1.18.2",
+    "chai": "^4.0.2",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb": "^15.0.1",
+    "eslint-config-airbnb-base": "^11.1.0",
+    "eslint-plugin-import": "^2.2.0",
+    "eslint-plugin-jsx-a11y": "^5.0.3",
+    "eslint-plugin-promise": "^3.4.2",
+    "eslint-plugin-react": "^7.0.1",
+    "express": "^4.16.2",
+    "https-proxy-agent": "^2.1.0",
+    "isparta": "^4.0.0",
+    "mocha": "^3.2.0",
+    "phantomjs-prebuilt": "^2.1.16",
+    "proxy": "^0.2.4",
+    "request": "^2.83.0",
+    "sinon": "^6.1.4",
+    "sinon-stub-promise": "^4.0.0",
+    "through": "^2.3.8",
+    "ws": "^6.0.0"
+  },
+  "files": [
+    "build"
+  ],
+  "homepage": "https://blog.apify.com/how-to-make-headless-chrome-and-puppeteer-use-a-proxy-server-with-authentication-249a21a79212",
+  "keywords": [
+    "proxy",
+    "squid",
+    "apify",
+    "tunnel"
+  ],
+  "license": "Apache-2.0",
+  "main": "build/index.js",
+  "name": "proxy-chain",
+  "optionalDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apifytech/proxy-chain.git"
+  },
+  "scripts": {
+    "build": "rm -rf ./build && babel src --out-dir build",
+    "clean": "rm -rf build",
+    "lint": "npm run build && eslint src",
+    "local-proxy": "npm run build && node ./build/run_locally.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "(test $RUNNING_FROM_SCRIPT || (echo \"You must use publish.sh instead of 'npm publish' directly!\"; exit 1)) && npm test && npm run lint",
+    "test": "npm run build && mocha --compilers js:babel-core/register --recursive"
+  },
+  "version": "0.2.7"
+}