cypress 5.0.0 → 5.4.0

package/lib/cli.js

@@ -55,6 +55,10 @@ function unknownOption(flag) {
 
 commander.Command.prototype.unknownOption = unknownOption;
 
+var coerceFalseOrString = function coerceFalseOrString(arg) {
+  return arg !== 'false' ? arg : false;
+};
+
 var coerceFalse = function coerceFalse(arg) {
   return arg !== 'false';
 };
@@ -119,8 +123,10 @@ var descriptions = {
   browserOpenMode: 'path to a custom browser to be added to the list of available browsers in Cypress',
   browserRunMode: 'runs Cypress in the browser with the given name. if a filesystem path is supplied, Cypress will attempt to use the browser at that path.',
   cacheClear: 'delete all cached binaries',
+  cachePrune: 'deletes all cached binaries except for the version currently in use',
   cacheList: 'list cached binary versions',
   cachePath: 'print the path to the binary cache',
+  cacheSize: 'Used with the list command to show the sizes of the cached folders',
   ciBuildId: 'the unique identifier for a run on your CI provider. typically a "BUILD_ID" env var. this value is automatically detected for most CI providers',
   config: 'sets configuration values. separate multiple values with a comma. overrides any value in cypress.json.',
   configFile: 'path to JSON file where configuration values are set. defaults to "cypress.json". pass "false" to disable.',
@@ -196,7 +202,7 @@ var castCypressRunOptions = function castCypressRunOptions(opts) {
   // boolean arguments
   var result = R.evolve({
     port: coerceAnyStringToInt,
-    configFile: coerceFalse
+    configFile: coerceFalseOrString
   })(opts);
   return result;
 };
@@ -295,7 +301,7 @@ module.exports = {
 
       require('./tasks/verify').start(options)["catch"](util.logErrorExit1);
     });
-    program.command('cache').usage('[command]').description('Manages the Cypress binary cache').option('list', text('cacheList')).option('path', text('cachePath')).option('clear', text('cacheClear')).action(function (opts, args) {
+    program.command('cache').usage('[command]').description('Manages the Cypress binary cache').option('list', text('cacheList')).option('path', text('cachePath')).option('clear', text('cacheClear')).option('prune', text('cachePrune')).option('--size', text('cacheSize')).action(function (opts, args) {
       if (!args || !args.length) {
         this.outputHelp();
         util.exit(1);
@@ -304,10 +310,15 @@ module.exports = {
       var _args = _slicedToArray(args, 1),
           command = _args[0];
 
-      if (!_.includes(['list', 'path', 'clear'], command)) {
+      if (!_.includes(['list', 'path', 'clear', 'prune'], command)) {
         unknownOption.call(this, "cache ".concat(command), 'command');
       }
 
+      if (command === 'list') {
+        cache.list(opts.size);
+        return;
+      }
+
       cache[command]();
     });
     program.command('info').usage('[command]').description('Prints Cypress and system information').option('--dev', text('dev'), coerceFalse).action(function (opts) {

package/lib/errors.js

@@ -121,7 +121,7 @@ function _templateObject6() {
 }
 
 function _templateObject5() {
-  var data = _taggedTemplateLiteral(["\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n  "], ["\\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n  "]);
+  var data = _taggedTemplateLiteral(["\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n\n    You can also try clearing the cache with 'cypress cache clear' and reinstalling. \n  "], ["\\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n\n    You can also try clearing the cache with 'cypress cache clear' and reinstalling. \n  "]);
 
   _templateObject5 = function _templateObject5() {
     return data;

package/lib/tasks/cache.js

@@ -1,5 +1,11 @@
 "use strict";
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 var state = require('./state');
 
 var logger = require('../logger');
@@ -17,13 +23,18 @@ var moment = require('moment');
 
 var chalk = require('chalk');
 
-var _ = require('lodash'); // output colors for the table
+var _ = require('lodash');
+
+var getFolderSize = require('./get-folder-size');
+
+var Bluebird = require('bluebird'); // output colors for the table
 
 
 var colors = {
   titles: chalk.white,
   dates: chalk.cyan,
-  values: chalk.green
+  values: chalk.green,
+  size: chalk.gray
 };
 
 var logCachePath = function logCachePath() {
@@ -34,27 +45,69 @@ var logCachePath = function logCachePath() {
 var clear = function clear() {
   return fs.removeAsync(state.getCacheDir());
 };
+
+var prune = function prune() {
+  var cacheDir = state.getCacheDir();
+  var currentVersion = util.pkgVersion();
+  var deletedBinary = false;
+  return fs.readdirAsync(cacheDir).then(function (versions) {
+    return Bluebird.all(versions.map(function (version) {
+      if (version !== currentVersion) {
+        deletedBinary = true;
+        var versionDir = join(cacheDir, version);
+        return fs.removeAsync(versionDir);
+      }
+    }));
+  }).then(function () {
+    if (deletedBinary) {
+      logger.always("Deleted all binary caches except for the ".concat(currentVersion, " binary cache."));
+    } else {
+      logger.always("No binary caches found to prune.");
+    }
+  })["catch"]({
+    code: 'ENOENT'
+  }, function () {
+    logger.always("No Cypress cache was found at ".concat(cacheDir, ". Nothing to prune."));
+  });
+};
+
+var fileSizeInMB = function fileSizeInMB(size) {
+  return "".concat((size / 1024 / 1024).toFixed(1), "MB");
+};
 /**
  * Collects all cached versions, finds when each was used
  * and prints a table with results to the terminal
  */
 
 
-var list = function list() {
-  return getCachedVersions().then(function (binaries) {
+var list = function list(showSize) {
+  return getCachedVersions(showSize).then(function (binaries) {
+    var head = [colors.titles('version'), colors.titles('last used')];
+
+    if (showSize) {
+      head.push(colors.titles('size'));
+    }
+
     var table = new Table({
-      head: [colors.titles('version'), colors.titles('last used')]
+      head: head
     });
     binaries.forEach(function (binary) {
       var versionString = colors.values(binary.version);
       var lastUsed = binary.accessed ? colors.dates(binary.accessed) : 'unknown';
-      return table.push([versionString, lastUsed]);
+      var row = [versionString, lastUsed];
+
+      if (showSize) {
+        var size = colors.size(fileSizeInMB(binary.size));
+        row.push(size);
+      }
+
+      return table.push(row);
     });
     logger.always(table.toString());
   });
 };
 
-var getCachedVersions = function getCachedVersions() {
+var getCachedVersions = function getCachedVersions(showSize) {
   var cacheDir = state.getCacheDir();
   return fs.readdirAsync(cacheDir).filter(util.isSemver).map(function (version) {
     return {
@@ -82,12 +135,24 @@ var getCachedVersions = function getCachedVersions() {
       // could not find the binary or gets its stats
       return binary;
     });
+  }).mapSeries(function (binary) {
+    if (showSize) {
+      var binaryDir = state.getBinaryDir(binary.version);
+      return getFolderSize(binaryDir).then(function (size) {
+        return _objectSpread(_objectSpread({}, binary), {}, {
+          size: size
+        });
+      });
+    }
+
+    return binary;
   });
 };
 
 module.exports = {
   path: logCachePath,
   clear: clear,
+  prune: prune,
   list: list,
   getCachedVersions: getCachedVersions
 };

package/lib/tasks/get-folder-size.js

@@ -0,0 +1,107 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var fs = require('../fs');
+
+var _require = require('path'),
+    join = _require.join;
+
+var Bluebird = require('bluebird');
+/**
+ * Get the size of a folder or a file.
+ *
+ * This function returns the actual file size of the folder (size), not the allocated space on disk (size on disk).
+ * For more details between the difference, check this link:
+ * https://www.howtogeek.com/180369/why-is-there-a-big-difference-between-size-and-size-on-disk/
+ *
+ * @param {string} path path to the file or the folder.
+ */
+
+
+function getSize(_x) {
+  return _getSize.apply(this, arguments);
+}
+
+function _getSize() {
+  _getSize = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(path) {
+    var stat, list;
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return fs.lstat(path);
+
+          case 2:
+            stat = _context2.sent;
+
+            if (!stat.isDirectory()) {
+              _context2.next = 8;
+              break;
+            }
+
+            _context2.next = 6;
+            return fs.readdir(path);
+
+          case 6:
+            list = _context2.sent;
+            return _context2.abrupt("return", Bluebird.resolve(list).reduce( /*#__PURE__*/function () {
+              var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(prev, curr) {
+                var currPath, s;
+                return regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        currPath = join(path, curr);
+                        _context.next = 3;
+                        return fs.lstat(currPath);
+
+                      case 3:
+                        s = _context.sent;
+
+                        if (!s.isDirectory()) {
+                          _context.next = 10;
+                          break;
+                        }
+
+                        _context.t0 = prev;
+                        _context.next = 8;
+                        return getSize(currPath);
+
+                      case 8:
+                        _context.t1 = _context.sent;
+                        return _context.abrupt("return", _context.t0 + _context.t1);
+
+                      case 10:
+                        return _context.abrupt("return", prev + s.size);
+
+                      case 11:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x2, _x3) {
+                return _ref.apply(this, arguments);
+              };
+            }(), 0));
+
+          case 8:
+            return _context2.abrupt("return", stat.size);
+
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getSize.apply(this, arguments);
+}
+
+module.exports = getSize;

package/lib/tasks/install.js

@@ -1,5 +1,7 @@
 "use strict";
 
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
 function _templateObject7() {
   var data = _taggedTemplateLiteral(["\n          ", " Warning: Forcing a binary version different than the default.\n\n            The CLI expected to install version: ", "\n\n            Instead we will install version: ", "\n\n            These versions may not work properly together.\n        "]);
 
@@ -20,6 +22,18 @@ function _templateObject6() {
   return data;
 }
 
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function _templateObject5() {
   var data = _taggedTemplateLiteral(["\n    Failed to access ", ":\n\n    ", "\n    "]);
 
@@ -72,10 +86,32 @@ function _templateObject() {
 
 function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
 
+function _wrapRegExp(re, groups) { _wrapRegExp = function _wrapRegExp(re, groups) { return new BabelRegExp(re, undefined, groups); }; var _RegExp = _wrapNativeSuper(RegExp); var _super = RegExp.prototype; var _groups = new WeakMap(); function BabelRegExp(re, flags, groups) { var _this = _RegExp.call(this, re, flags); _groups.set(_this, groups || _groups.get(re)); return _this; } _inherits(BabelRegExp, _RegExp); BabelRegExp.prototype.exec = function (str) { var result = _super.exec.call(this, str); if (result) result.groups = buildGroups(result, this); return result; }; BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { if (typeof substitution === "string") { var groups = _groups.get(this); return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { return "$" + groups[name]; })); } else if (typeof substitution === "function") { var _this = this; return _super[Symbol.replace].call(this, str, function () { var args = []; args.push.apply(args, arguments); if (_typeof(args[args.length - 1]) !== "object") { args.push(buildGroups(args, _this)); } return substitution.apply(this, args); }); } else { return _super[Symbol.replace].call(this, str, substitution); } }; function buildGroups(result, re) { var g = _groups.get(re); return Object.keys(g).reduce(function (groups, name) { groups[name] = result[g[name]]; return groups; }, Object.create(null)); } return _wrapRegExp.apply(this, arguments); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
 var _ = require('lodash');
 
 var os = require('os');
 
+var url = require('url');
+
 var path = require('path');
 
 var chalk = require('chalk');
@@ -109,6 +145,102 @@ var _require2 = require('../errors'),
     throwFormErrorText = _require2.throwFormErrorText,
     errors = _require2.errors;
 
+var getNpmArgv = function getNpmArgv() {
+  var json = process.env.npm_config_argv;
+
+  if (!json) {
+    return;
+  }
+
+  debug('found npm argv json %o', json);
+
+  try {
+    return JSON.parse(json).original || [];
+  } catch (e) {
+    return [];
+  }
+}; // attempt to discover the version specifier used to install Cypress
+// for example: "^5.0.0", "https://cdn.cypress.io/...", ...
+
+
+var getVersionSpecifier = function getVersionSpecifier() {
+  var startDir = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : path.resolve(__dirname, '../..');
+  var argv = getNpmArgv();
+
+  if (argv) {
+    var tgz = _.find(argv, function (t) {
+      return t.endsWith('cypress.tgz');
+    });
+
+    if (tgz) {
+      return tgz;
+    }
+  }
+
+  var getVersionSpecifierFromPkg = function getVersionSpecifierFromPkg(dir) {
+    debug('looking for versionSpecifier %o', {
+      dir: dir
+    });
+
+    var tryParent = function tryParent() {
+      var parentPath = path.resolve(dir, '..');
+
+      if (parentPath === dir) {
+        debug('reached FS root with no versionSpecifier found');
+        return;
+      }
+
+      return getVersionSpecifierFromPkg(parentPath);
+    };
+
+    return fs.readJSON(path.join(dir, 'package.json'))["catch"](function () {
+      return {};
+    }).then(function (pkg) {
+      var specifier = _.chain(['dependencies', 'devDependencies', 'optionalDependencies']).map(function (prop) {
+        return _.get(pkg, "".concat(prop, ".cypress"));
+      }).compact().first().value();
+
+      return specifier || tryParent();
+    });
+  }; // recurse through parent directories until package.json with `cypress` is found
+
+
+  return getVersionSpecifierFromPkg(startDir).then(function (versionSpecifier) {
+    debug('finished looking for versionSpecifier', {
+      versionSpecifier: versionSpecifier
+    });
+    return versionSpecifier;
+  });
+};
+
+var betaNpmUrlRe = /*#__PURE__*/_wrapRegExp(/^\/beta\/npm\/([\.0-9]+)\/([\0-\.0-\uFFFF]+)\/cypress\.tgz$/, {
+  version: 1,
+  artifactSlug: 2
+}); // convert a prerelease NPM package .tgz URL to the corresponding binary .zip URL
+
+
+var getBinaryUrlFromPrereleaseNpmUrl = function getBinaryUrlFromPrereleaseNpmUrl(npmUrl) {
+  var parsed;
+
+  try {
+    parsed = url.parse(npmUrl);
+  } catch (e) {
+    return;
+  }
+
+  var matches = betaNpmUrlRe.exec(parsed.pathname);
+
+  if (parsed.hostname !== 'cdn.cypress.io' || !matches) {
+    return;
+  }
+
+  var _matches$groups = matches.groups,
+      version = _matches$groups.version,
+      artifactSlug = _matches$groups.artifactSlug;
+  parsed.pathname = "/beta/binary/".concat(version, "/").concat(os.platform(), "-").concat(os.arch(), "/").concat(artifactSlug, "/cypress.zip");
+  return parsed.format();
+};
+
 var alreadyInstalledMsg = function alreadyInstalledMsg() {
   if (!util.isPostInstall()) {
     logger.log(stripIndent(_templateObject(), chalk.yellow('--force')));
@@ -204,6 +336,7 @@ var start = function start() {
 
   var pkgVersion = util.pkgVersion();
   var needVersion = pkgVersion;
+  var binaryUrlOverride;
   debug('version in package.json is', needVersion); // let this environment variable reset the binary version we need
 
   if (util.getEnv('CYPRESS_INSTALL_BINARY')) {
@@ -218,14 +351,9 @@ var start = function start() {
       logger.log(stripIndent(_templateObject3(), chalk.yellow('Note:')));
       logger.log();
       return Promise.resolve();
-    } // if this doesn't match the expected version
-    // then print warning to the user
-
-
-    if (envVarVersion !== needVersion) {
-      // reset the version to the env var version
-      needVersion = envVarVersion;
     }
+
+    binaryUrlOverride = envVarVersion;
   }
 
   if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
@@ -242,14 +370,32 @@ var start = function start() {
   }, function (err) {
     return throwFormErrorText(errors.invalidCacheDirectory)(stripIndent(_templateObject5(), chalk.cyan(cacheDir), err.message));
   }).then(function () {
-    return state.getBinaryPkgVersionAsync(binaryDir);
-  }).then(function (binaryVersion) {
+    return Promise.all([state.getBinaryPkgVersionAsync(binaryDir), getVersionSpecifier()]);
+  }).then(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+        binaryVersion = _ref3[0],
+        versionSpecifier = _ref3[1];
+
+    if (!binaryUrlOverride && versionSpecifier) {
+      var computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);
+
+      if (computedBinaryUrl) {
+        debug('computed binary url from version specifier %o', {
+          computedBinaryUrl: computedBinaryUrl,
+          needVersion: needVersion
+        });
+        binaryUrlOverride = computedBinaryUrl;
+      }
+    }
+
+    needVersion = binaryUrlOverride || needVersion;
+    debug('installed version is', binaryVersion, 'version needed is', needVersion);
+
     if (!binaryVersion) {
       debug('no binary installed under cli version');
       return true;
     }
 
-    debug('installed version is', binaryVersion, 'version needed is', needVersion);
     logger.log();
     logger.log(stripIndent(_templateObject6(), chalk.green(binaryVersion), chalk.cyan(installDir)));
     logger.log();
@@ -332,14 +478,16 @@ var start = function start() {
 };
 
 module.exports = {
-  start: start
+  start: start,
+  _getVersionSpecifier: getVersionSpecifier,
+  _getBinaryUrlFromPrereleaseNpmUrl: getBinaryUrlFromPrereleaseNpmUrl
 };
 
-var unzipTask = function unzipTask(_ref2) {
-  var zipFilePath = _ref2.zipFilePath,
-      installDir = _ref2.installDir,
-      progress = _ref2.progress,
-      rendererOptions = _ref2.rendererOptions;
+var unzipTask = function unzipTask(_ref4) {
+  var zipFilePath = _ref4.zipFilePath,
+      installDir = _ref4.installDir,
+      progress = _ref4.progress,
+      rendererOptions = _ref4.rendererOptions;
   return {
     title: util.titleize('Unzipping Cypress'),
     task: function task(ctx, _task3) {

package/lib/util.js

@@ -239,7 +239,7 @@ var dequote = function dequote(str) {
 };
 
 var parseOpts = function parseOpts(opts) {
-  opts = _.pick(opts, 'browser', 'cachePath', 'cacheList', 'cacheClear', 'ciBuildId', 'config', 'configFile', 'cypressVersion', 'destination', 'detached', 'dev', 'exit', 'env', 'force', 'global', 'group', 'headed', 'headless', 'key', 'path', 'parallel', 'port', 'project', 'quiet', 'reporter', 'reporterOptions', 'record', 'spec', 'tag');
+  opts = _.pick(opts, 'browser', 'cachePath', 'cacheList', 'cacheClear', 'cachePrune', 'ciBuildId', 'config', 'configFile', 'cypressVersion', 'destination', 'detached', 'dev', 'exit', 'env', 'force', 'global', 'group', 'headed', 'headless', 'key', 'path', 'parallel', 'port', 'project', 'quiet', 'reporter', 'reporterOptions', 'record', 'spec', 'tag');
 
   if (opts.exit) {
     opts = _.omit(opts, 'exit');
@@ -307,7 +307,7 @@ var util = {
     } // https://github.com/cypress-io/cypress/issues/5431
 
 
-    var NODE_OPTIONS = "--max-http-header-size=".concat(Math.pow(1024, 2), " --http-parser=legacy");
+    var NODE_OPTIONS = "--max-http-header-size=".concat(Math.pow(1024, 2));
 
     if (_.isString(process.env.NODE_OPTIONS)) {
       return {
@@ -449,20 +449,19 @@ var util = {
   },
   getEnv: function getEnv(varName, trim) {
     la(is.unemptyString(varName), 'expected environment variable name, not', varName);
-    var envVar = process.env[varName];
-    var configVar = process.env["npm_config_".concat(varName)];
-    var packageConfigVar = process.env["npm_package_config_".concat(varName)];
+    var configVarName = "npm_config_".concat(varName);
+    var packageConfigVarName = "npm_package_config_".concat(varName);
     var result;
 
-    if (envVar) {
+    if (process.env.hasOwnProperty(varName)) {
       debug("Using ".concat(varName, " from environment variable"));
-      result = envVar;
-    } else if (configVar) {
+      result = process.env[varName];
+    } else if (process.env.hasOwnProperty(configVarName)) {
       debug("Using ".concat(varName, " from npm config"));
-      result = configVar;
-    } else if (packageConfigVar) {
+      result = process.env[configVarName];
+    } else if (process.env.hasOwnProperty(packageConfigVarName)) {
       debug("Using ".concat(varName, " from package.json config"));
-      result = packageConfigVar;
+      result = process.env[packageConfigVarName];
     } // environment variables are often set double quotes to escape characters
     // and on Windows it can lead to weird things: for example
     //  set FOO="C:\foo.txt" && node -e "console.log('>>>%s<<<', process.env.FOO)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cypress",
-  "version": "5.0.0",
+  "version": "5.4.0",
   "main": "index.js",
   "scripts": {
     "postinstall": "node index.js --exec install",
@@ -50,7 +50,8 @@
     "bin",
     "lib",
     "index.js",
-    "types/**/*.d.ts"
+    "types/**/*.d.ts",
+    "types/net-stubbing.ts"
   ],
   "bin": {
     "cypress": "bin/cypress"