cypress 5.2.0 → 5.6.0

package/lib/tasks/install.js

@@ -1,152 +1,48 @@
 "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); }
+const _ = require('lodash');
 
-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        "]);
+const os = require('os');
 
-  _templateObject7 = function _templateObject7() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject6() {
-  var data = _taggedTemplateLiteral(["\n      Cypress ", " is installed in ", "\n      "]);
-
-  _templateObject6 = function _templateObject6() {
-    return data;
-  };
-
-  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    "]);
-
-  _templateObject5 = function _templateObject5() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject4() {
-  var data = _taggedTemplateLiteral(["\n        ", " Overriding Cypress cache directory to: ", "\n\n              Previous installs of Cypress may not be found.\n      "]);
-
-  _templateObject4 = function _templateObject4() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject3() {
-  var data = _taggedTemplateLiteral(["\n        ", " Skipping binary installation: Environment variable CYPRESS_INSTALL_BINARY = 0."]);
-
-  _templateObject3 = function _templateObject3() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject2() {
-  var data = _taggedTemplateLiteral(["\n      ", " Warning: It looks like you've installed Cypress globally.\n\n        This will work, but it's not recommended.\n\n        The recommended way to install Cypress is as a devDependency per project.\n\n        You should probably run these commands:\n\n        - ", "\n        - ", "\n    "], ["\n      ", " Warning: It looks like you\\'ve installed Cypress globally.\n\n        This will work, but it'\\s not recommended.\n\n        The recommended way to install Cypress is as a devDependency per project.\n\n        You should probably run these commands:\n\n        - ", "\n        - ", "\n    "]);
-
-  _templateObject2 = function _templateObject2() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject() {
-  var data = _taggedTemplateLiteral(["\n      Skipping installation:\n\n        Pass the ", " option if you'd like to reinstall anyway.\n    "]);
-
-  _templateObject = function _templateObject() {
-    return data;
-  };
-
-  return data;
-}
-
-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');
+const url = require('url');
 
-var url = require('url');
+const path = require('path');
 
-var path = require('path');
+const chalk = require('chalk');
 
-var chalk = require('chalk');
+const debug = require('debug')('cypress:cli');
 
-var debug = require('debug')('cypress:cli');
+const Listr = require('listr');
 
-var Listr = require('listr');
+const verbose = require('@cypress/listr-verbose-renderer');
 
-var verbose = require('@cypress/listr-verbose-renderer');
+const Promise = require('bluebird');
 
-var Promise = require('bluebird');
+const logSymbols = require('log-symbols');
 
-var logSymbols = require('log-symbols');
+const {
+  stripIndent
+} = require('common-tags');
 
-var _require = require('common-tags'),
-    stripIndent = _require.stripIndent;
+const fs = require('../fs');
 
-var fs = require('../fs');
+const download = require('./download');
 
-var download = require('./download');
+const util = require('../util');
 
-var util = require('../util');
+const state = require('./state');
 
-var state = require('./state');
+const unzip = require('./unzip');
 
-var unzip = require('./unzip');
+const logger = require('../logger');
 
-var logger = require('../logger');
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
 
-var _require2 = require('../errors'),
-    throwFormErrorText = _require2.throwFormErrorText,
-    errors = _require2.errors;
-
-var getNpmArgv = function getNpmArgv() {
-  var json = process.env.npm_config_argv;
+const getNpmArgv = () => {
+  const json = process.env.npm_config_argv;
 
   if (!json) {
     return;
@@ -163,27 +59,24 @@ var getNpmArgv = function getNpmArgv() {
 // 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();
+const getVersionSpecifier = (startDir = path.resolve(__dirname, '../..')) => {
+  const argv = getNpmArgv();
 
   if (argv) {
-    var tgz = _.find(argv, function (t) {
-      return t.endsWith('cypress.tgz');
-    });
+    const tgz = _.find(argv, t => t.endsWith('cypress.tgz'));
 
     if (tgz) {
       return tgz;
     }
   }
 
-  var getVersionSpecifierFromPkg = function getVersionSpecifierFromPkg(dir) {
+  const getVersionSpecifierFromPkg = dir => {
     debug('looking for versionSpecifier %o', {
-      dir: dir
+      dir
     });
 
-    var tryParent = function tryParent() {
-      var parentPath = path.resolve(dir, '..');
+    const tryParent = () => {
+      const parentPath = path.resolve(dir, '..');
 
       if (parentPath === dir) {
         debug('reached FS root with no versionSpecifier found');
@@ -193,34 +86,26 @@ var getVersionSpecifier = function getVersionSpecifier() {
       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 fs.readJSON(path.join(dir, 'package.json')).catch(() => ({})).then(pkg => {
+      const specifier = _.chain(['dependencies', 'devDependencies', 'optionalDependencies']).map(prop => _.get(pkg, `${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) {
+  return getVersionSpecifierFromPkg(startDir).then(versionSpecifier => {
     debug('finished looking for versionSpecifier', {
-      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
+const betaNpmUrlRe = /^\/beta\/npm\/(?<version>[0-9.]+)\/(?<artifactSlug>[^/]+)\/cypress\.tgz$/; // convert a prerelease NPM package .tgz URL to the corresponding binary .zip URL
 
-
-var getBinaryUrlFromPrereleaseNpmUrl = function getBinaryUrlFromPrereleaseNpmUrl(npmUrl) {
-  var parsed;
+const getBinaryUrlFromPrereleaseNpmUrl = npmUrl => {
+  let parsed;
 
   try {
     parsed = url.parse(npmUrl);
@@ -228,31 +113,47 @@ var getBinaryUrlFromPrereleaseNpmUrl = function getBinaryUrlFromPrereleaseNpmUrl
     return;
   }
 
-  var matches = betaNpmUrlRe.exec(parsed.pathname);
+  const 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");
+  const {
+    version,
+    artifactSlug
+  } = matches.groups;
+  parsed.pathname = `/beta/binary/${version}/${os.platform()}-${os.arch()}/${artifactSlug}/cypress.zip`;
   return parsed.format();
 };
 
-var alreadyInstalledMsg = function alreadyInstalledMsg() {
+const alreadyInstalledMsg = () => {
   if (!util.isPostInstall()) {
-    logger.log(stripIndent(_templateObject(), chalk.yellow('--force')));
+    logger.log(stripIndent`
+      Skipping installation:
+
+        Pass the ${chalk.yellow('--force')} option if you'd like to reinstall anyway.
+    `);
   }
 };
 
-var displayCompletionMsg = function displayCompletionMsg() {
+const displayCompletionMsg = () => {
   // check here to see if we are globally installed
   if (util.isInstalledGlobally()) {
     // if we are display a warning
     logger.log();
-    logger.warn(stripIndent(_templateObject2(), logSymbols.warning, chalk.cyan('npm uninstall -g cypress'), chalk.cyan('npm install --save-dev cypress')));
+    logger.warn(stripIndent`
+      ${logSymbols.warning} Warning: It looks like you\'ve installed Cypress globally.
+
+        This will work, but it'\s not recommended.
+
+        The recommended way to install Cypress is as a devDependency per project.
+
+        You should probably run these commands:
+
+        - ${chalk.cyan('npm uninstall -g cypress')}
+        - ${chalk.cyan('npm install --save-dev cypress')}
+    `);
     return;
   }
 
@@ -263,52 +164,53 @@ var displayCompletionMsg = function displayCompletionMsg() {
   logger.log();
 };
 
-var downloadAndUnzip = function downloadAndUnzip(_ref) {
-  var version = _ref.version,
-      installDir = _ref.installDir,
-      downloadDir = _ref.downloadDir;
-  var progress = {
+const downloadAndUnzip = ({
+  version,
+  installDir,
+  downloadDir
+}) => {
+  const progress = {
     throttle: 100,
     onProgress: null
   };
-  var downloadDestination = path.join(downloadDir, 'cypress.zip');
-  var rendererOptions = getRendererOptions(); // let the user know what version of cypress we're downloading!
+  const downloadDestination = path.join(downloadDir, 'cypress.zip');
+  const rendererOptions = getRendererOptions(); // let the user know what version of cypress we're downloading!
 
-  logger.log("Installing Cypress ".concat(chalk.gray("(version: ".concat(version, ")"))));
+  logger.log(`Installing Cypress ${chalk.gray(`(version: ${version})`)}`);
   logger.log();
-  var tasks = new Listr([{
+  const tasks = new Listr([{
     title: util.titleize('Downloading Cypress'),
-    task: function task(ctx, _task) {
+    task: (ctx, task) => {
       // as our download progresses indicate the status
-      progress.onProgress = progessify(_task, 'Downloading Cypress');
+      progress.onProgress = progessify(task, 'Downloading Cypress');
       return download.start({
-        version: version,
-        downloadDestination: downloadDestination,
-        progress: progress
-      }).then(function (redirectVersion) {
+        version,
+        downloadDestination,
+        progress
+      }).then(redirectVersion => {
         if (redirectVersion) version = redirectVersion;
-        debug("finished downloading file: ".concat(downloadDestination));
-      }).then(function () {
+        debug(`finished downloading file: ${downloadDestination}`);
+      }).then(() => {
         // save the download destination for unzipping
-        util.setTaskTitle(_task, util.titleize(chalk.green('Downloaded Cypress')), rendererOptions.renderer);
+        util.setTaskTitle(task, util.titleize(chalk.green('Downloaded Cypress')), rendererOptions.renderer);
       });
     }
   }, unzipTask({
-    progress: progress,
+    progress,
     zipFilePath: downloadDestination,
-    installDir: installDir,
-    rendererOptions: rendererOptions
+    installDir,
+    rendererOptions
   }), {
     title: util.titleize('Finishing Installation'),
-    task: function task(ctx, _task2) {
-      var cleanup = function cleanup() {
+    task: (ctx, task) => {
+      const cleanup = () => {
         debug('removing zip file %s', downloadDestination);
         return fs.removeAsync(downloadDestination);
       };
 
-      return cleanup().then(function () {
+      return cleanup().then(() => {
         debug('finished installation in', installDir);
-        util.setTaskTitle(_task2, util.titleize(chalk.green('Finished Installation'), chalk.gray(installDir)), rendererOptions.renderer);
+        util.setTaskTitle(task, util.titleize(chalk.green('Finished Installation'), chalk.gray(installDir)), rendererOptions.renderer);
       });
     }
   }], rendererOptions); // start the tasks!
@@ -316,9 +218,7 @@ var downloadAndUnzip = function downloadAndUnzip(_ref) {
   return Promise.resolve(tasks.run());
 };
 
-var start = function start() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
+const start = (options = {}) => {
   // handle deprecated / removed
   if (util.getEnv('CYPRESS_BINARY_VERSION')) {
     return throwFormErrorText(errors.removed.CYPRESS_BINARY_VERSION)();
@@ -334,21 +234,22 @@ var start = function start() {
     force: false
   });
 
-  var pkgVersion = util.pkgVersion();
-  var needVersion = pkgVersion;
-  var binaryUrlOverride;
+  const pkgVersion = util.pkgVersion();
+  let needVersion = pkgVersion;
+  let binaryUrlOverride;
   debug('version in package.json is', needVersion); // let this environment variable reset the binary version we need
 
   if (util.getEnv('CYPRESS_INSTALL_BINARY')) {
     // because passed file paths are often double quoted
     // and might have extra whitespace around, be robust and trim the string
-    var trimAndRemoveDoubleQuotes = true;
-    var envVarVersion = util.getEnv('CYPRESS_INSTALL_BINARY', trimAndRemoveDoubleQuotes);
+    const trimAndRemoveDoubleQuotes = true;
+    const envVarVersion = util.getEnv('CYPRESS_INSTALL_BINARY', trimAndRemoveDoubleQuotes);
     debug('using environment variable CYPRESS_INSTALL_BINARY "%s"', envVarVersion);
 
     if (envVarVersion === '0') {
       debug('environment variable CYPRESS_INSTALL_BINARY = 0, skipping install');
-      logger.log(stripIndent(_templateObject3(), chalk.yellow('Note:')));
+      logger.log(stripIndent`
+        ${chalk.yellow('Note:')} Skipping binary installation: Environment variable CYPRESS_INSTALL_BINARY = 0.`);
       logger.log();
       return Promise.resolve();
     }
@@ -357,32 +258,36 @@ var start = function start() {
   }
 
   if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
-    var envCache = util.getEnv('CYPRESS_CACHE_FOLDER');
-    logger.log(stripIndent(_templateObject4(), chalk.yellow('Note:'), chalk.cyan(envCache)));
+    const envCache = util.getEnv('CYPRESS_CACHE_FOLDER');
+    logger.log(stripIndent`
+        ${chalk.yellow('Note:')} Overriding Cypress cache directory to: ${chalk.cyan(envCache)}
+
+              Previous installs of Cypress may not be found.
+      `);
     logger.log();
   }
 
-  var installDir = state.getVersionDir(pkgVersion);
-  var cacheDir = state.getCacheDir();
-  var binaryDir = state.getBinaryDir(pkgVersion);
-  return fs.ensureDirAsync(cacheDir)["catch"]({
+  const installDir = state.getVersionDir(pkgVersion);
+  const cacheDir = state.getCacheDir();
+  const binaryDir = state.getBinaryDir(pkgVersion);
+  return fs.ensureDirAsync(cacheDir).catch({
     code: 'EACCES'
-  }, function (err) {
-    return throwFormErrorText(errors.invalidCacheDirectory)(stripIndent(_templateObject5(), chalk.cyan(cacheDir), err.message));
-  }).then(function () {
-    return Promise.all([state.getBinaryPkgVersionAsync(binaryDir), getVersionSpecifier()]);
-  }).then(function (_ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-        binaryVersion = _ref3[0],
-        versionSpecifier = _ref3[1];
+  }, err => {
+    return throwFormErrorText(errors.invalidCacheDirectory)(stripIndent`
+    Failed to access ${chalk.cyan(cacheDir)}:
 
+    ${err.message}
+    `);
+  }).then(() => {
+    return Promise.all([state.getBinaryPkgVersionAsync(binaryDir), getVersionSpecifier()]);
+  }).then(([binaryVersion, versionSpecifier]) => {
     if (!binaryUrlOverride && versionSpecifier) {
-      var computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);
+      const computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);
 
       if (computedBinaryUrl) {
         debug('computed binary url from version specifier %o', {
-          computedBinaryUrl: computedBinaryUrl,
-          needVersion: needVersion
+          computedBinaryUrl,
+          needVersion
         });
         binaryUrlOverride = computedBinaryUrl;
       }
@@ -397,7 +302,9 @@ var start = function start() {
     }
 
     logger.log();
-    logger.log(stripIndent(_templateObject6(), chalk.green(binaryVersion), chalk.cyan(installDir)));
+    logger.log(stripIndent`
+      Cypress ${chalk.green(binaryVersion)} is installed in ${chalk.cyan(installDir)}
+      `);
     logger.log();
 
     if (options.force) {
@@ -412,7 +319,7 @@ var start = function start() {
     }
 
     return true;
-  }).then(function (shouldInstall) {
+  }).then(shouldInstall => {
     // noop if we've been told not to download
     if (!shouldInstall) {
       debug('Not downloading or installing binary');
@@ -420,19 +327,27 @@ var start = function start() {
     }
 
     if (needVersion !== pkgVersion) {
-      logger.log(chalk.yellow(stripIndent(_templateObject7(), logSymbols.warning, chalk.green(pkgVersion), chalk.green(needVersion))));
+      logger.log(chalk.yellow(stripIndent`
+          ${logSymbols.warning} Warning: Forcing a binary version different than the default.
+
+            The CLI expected to install version: ${chalk.green(pkgVersion)}
+
+            Instead we will install version: ${chalk.green(needVersion)}
+
+            These versions may not work properly together.
+        `));
       logger.log();
     } // see if version supplied is a path to a binary
 
 
-    return fs.pathExistsAsync(needVersion).then(function (exists) {
+    return fs.pathExistsAsync(needVersion).then(exists => {
       if (exists) {
         return path.extname(needVersion) === '.zip' ? needVersion : false;
       }
 
-      var possibleFile = util.formAbsolutePath(needVersion);
+      const possibleFile = util.formAbsolutePath(needVersion);
       debug('checking local file', possibleFile, 'cwd', process.cwd());
-      return fs.pathExistsAsync(possibleFile).then(function (exists) {
+      return fs.pathExistsAsync(possibleFile).then(exists => {
         // if this exists return the path to it
         // else false
         if (exists && path.extname(possibleFile) === '.zip') {
@@ -441,20 +356,20 @@ var start = function start() {
 
         return false;
       });
-    }).then(function (pathToLocalFile) {
+    }).then(pathToLocalFile => {
       if (pathToLocalFile) {
-        var absolutePath = path.resolve(needVersion);
+        const absolutePath = path.resolve(needVersion);
         debug('found local file at', absolutePath);
         debug('skipping download');
-        var rendererOptions = getRendererOptions();
+        const rendererOptions = getRendererOptions();
         return new Listr([unzipTask({
           progress: {
             throttle: 100,
             onProgress: null
           },
           zipFilePath: absolutePath,
-          installDir: installDir,
-          rendererOptions: rendererOptions
+          installDir,
+          rendererOptions
         })], rendererOptions).run();
       }
 
@@ -464,52 +379,53 @@ var start = function start() {
       }
 
       debug('preparing to download and unzip version ', needVersion, 'to path', installDir);
-      var downloadDir = os.tmpdir();
+      const downloadDir = os.tmpdir();
       return downloadAndUnzip({
         version: needVersion,
-        installDir: installDir,
-        downloadDir: downloadDir
+        installDir,
+        downloadDir
       });
     }) // delay 1 sec for UX, unless we are testing
-    .then(function () {
+    .then(() => {
       return Promise.delay(1000);
     }).then(displayCompletionMsg);
   });
 };
 
 module.exports = {
-  start: start,
+  start,
   _getVersionSpecifier: getVersionSpecifier,
   _getBinaryUrlFromPrereleaseNpmUrl: getBinaryUrlFromPrereleaseNpmUrl
 };
 
-var unzipTask = function unzipTask(_ref4) {
-  var zipFilePath = _ref4.zipFilePath,
-      installDir = _ref4.installDir,
-      progress = _ref4.progress,
-      rendererOptions = _ref4.rendererOptions;
+const unzipTask = ({
+  zipFilePath,
+  installDir,
+  progress,
+  rendererOptions
+}) => {
   return {
     title: util.titleize('Unzipping Cypress'),
-    task: function task(ctx, _task3) {
+    task: (ctx, task) => {
       // as our unzip progresses indicate the status
-      progress.onProgress = progessify(_task3, 'Unzipping Cypress');
+      progress.onProgress = progessify(task, 'Unzipping Cypress');
       return unzip.start({
-        zipFilePath: zipFilePath,
-        installDir: installDir,
-        progress: progress
-      }).then(function () {
-        util.setTaskTitle(_task3, util.titleize(chalk.green('Unzipped Cypress')), rendererOptions.renderer);
+        zipFilePath,
+        installDir,
+        progress
+      }).then(() => {
+        util.setTaskTitle(task, util.titleize(chalk.green('Unzipped Cypress')), rendererOptions.renderer);
       });
     }
   };
 };
 
-var progessify = function progessify(task, title) {
+const progessify = (task, title) => {
   // return higher order function
-  return function (percentComplete, remaining) {
-    percentComplete = chalk.white(" ".concat(percentComplete, "%")); // pluralize seconds remaining
+  return (percentComplete, remaining) => {
+    percentComplete = chalk.white(` ${percentComplete}%`); // pluralize seconds remaining
 
-    remaining = chalk.gray("".concat(remaining, "s"));
+    remaining = chalk.gray(`${remaining}s`);
     util.setTaskTitle(task, util.titleize(title, percentComplete, remaining), getRendererOptions().renderer);
   };
 }; // if we are running in CI then use
@@ -517,14 +433,14 @@ var progessify = function progessify(task, title) {
 // the default
 
 
-var getRendererOptions = function getRendererOptions() {
-  var renderer = util.isCi() ? verbose : 'default';
+const getRendererOptions = () => {
+  let renderer = util.isCi() ? verbose : 'default';
 
   if (logger.logLevel() === 'silent') {
     renderer = 'silent';
   }
 
   return {
-    renderer: renderer
+    renderer
   };
 };