cypress 15.1.0 → 15.3.0

package/dist/tasks/download.js

@@ -0,0 +1,304 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const assert_1 = __importDefault(require("assert"));
+const lodash_1 = __importDefault(require("lodash"));
+const url_1 = __importDefault(require("url"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const request_1 = __importDefault(require("@cypress/request"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const request_progress_1 = __importDefault(require("request-progress"));
+const common_tags_1 = require("common-tags");
+const proxy_from_env_1 = require("proxy-from-env");
+const errors_1 = require("../errors");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const util_1 = __importDefault(require("../util"));
+const debug = (0, debug_1.default)('cypress:cli');
+const defaultBaseUrl = 'https://download.cypress.io/';
+const defaultMaxRedirects = 10;
+const getProxyForUrlWithNpmConfig = (url) => {
+    return (0, proxy_from_env_1.getProxyForUrl)(url) ||
+        process.env.npm_config_https_proxy ||
+        process.env.npm_config_proxy ||
+        null;
+};
+const getBaseUrl = () => {
+    if (util_1.default.getEnv('CYPRESS_DOWNLOAD_MIRROR')) {
+        let baseUrl = util_1.default.getEnv('CYPRESS_DOWNLOAD_MIRROR');
+        if (!(baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.endsWith('/'))) {
+            baseUrl += '/';
+        }
+        return baseUrl || defaultBaseUrl;
+    }
+    return defaultBaseUrl;
+};
+const getCA = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (process.env.npm_config_cafile) {
+        try {
+            const caFileContent = yield fs_extra_1.default.readFile(process.env.npm_config_cafile, 'utf8');
+            return caFileContent;
+        }
+        catch (error) {
+            debug('error reading ca file', error);
+            return;
+        }
+    }
+    if (process.env.npm_config_ca) {
+        return process.env.npm_config_ca;
+    }
+    return;
+});
+const prepend = (arch, urlPath, version) => {
+    const endpoint = url_1.default.resolve(getBaseUrl(), urlPath);
+    const platform = os_1.default.platform();
+    const pathTemplate = util_1.default.getEnv('CYPRESS_DOWNLOAD_PATH_TEMPLATE', true);
+    if ((platform === 'win32') && (arch === 'arm64')) {
+        debug(`detected platform ${platform} architecture ${arch} combination`);
+        arch = 'x64';
+        debug(`overriding to download ${platform}-${arch} instead`);
+    }
+    return pathTemplate
+        ? (pathTemplate
+            .replace(/\\?\$\{endpoint\}/g, endpoint)
+            .replace(/\\?\$\{platform\}/g, platform)
+            .replace(/\\?\$\{arch\}/g, arch)
+            .replace(/\\?\$\{version\}/g, version))
+        : `${endpoint}?platform=${platform}&arch=${arch}`;
+};
+const getUrl = (arch, version) => {
+    if (lodash_1.default.isString(version) && version.match(/^https?:\/\/.*$/)) {
+        debug('version is already an url', version);
+        return version;
+    }
+    const urlPath = version ? `desktop/${version}` : 'desktop';
+    return prepend(arch, urlPath, version || '');
+};
+const statusMessage = (err) => {
+    return (err.statusCode
+        ? [err.statusCode, err.statusMessage].join(' - ')
+        : err.toString());
+};
+const prettyDownloadErr = (err, url) => {
+    const msg = (0, common_tags_1.stripIndent) `
+    URL: ${url}
+    ${statusMessage(err)}
+  `;
+    debug(msg);
+    return (0, errors_1.throwFormErrorText)(errors_1.errors.failedDownload)(msg);
+};
+/**
+ * Checks checksum and file size for the given file. Allows both
+ * values or just one of them to be checked.
+ */
+const verifyDownloadedFile = (filename, expectedSize, expectedChecksum) => __awaiter(void 0, void 0, void 0, function* () {
+    if (expectedSize && expectedChecksum) {
+        debug('verifying checksum and file size');
+        return bluebird_1.default.join(util_1.default.getFileChecksum(filename), util_1.default.getFileSize(filename), (checksum, filesize) => {
+            if (checksum === expectedChecksum && filesize === expectedSize) {
+                debug('downloaded file has the expected checksum and size ✅');
+                return;
+            }
+            debug('raising error: checksum or file size mismatch');
+            const text = (0, common_tags_1.stripIndent) `
+          Corrupted download
+
+          Expected downloaded file to have checksum: ${expectedChecksum}
+          Computed checksum: ${checksum}
+
+          Expected downloaded file to have size: ${expectedSize}
+          Computed size: ${filesize}
+        `;
+            debug(text);
+            throw new Error(text);
+        });
+    }
+    if (expectedChecksum) {
+        debug('only checking expected file checksum %d', expectedChecksum);
+        const checksum = yield util_1.default.getFileChecksum(filename);
+        if (checksum === expectedChecksum) {
+            debug('downloaded file has the expected checksum ✅');
+            return;
+        }
+        debug('raising error: file checksum mismatch');
+        const text = (0, common_tags_1.stripIndent) `
+      Corrupted download
+
+      Expected downloaded file to have checksum: ${expectedChecksum}
+      Computed checksum: ${checksum}
+    `;
+        throw new Error(text);
+    }
+    if (expectedSize) {
+        // maybe we don't have a checksum, but at least CDN returns content length
+        // which we can check against the file size
+        debug('only checking expected file size %d', expectedSize);
+        const filesize = yield util_1.default.getFileSize(filename);
+        if (filesize === expectedSize) {
+            debug('downloaded file has the expected size ✅');
+            return;
+        }
+        debug('raising error: file size mismatch');
+        const text = (0, common_tags_1.stripIndent) `
+        Corrupted download
+
+        Expected downloaded file to have size: ${expectedSize}
+        Computed size: ${filesize}
+      `;
+        throw new Error(text);
+    }
+    debug('downloaded file lacks checksum or size to verify');
+    return;
+});
+// downloads from given url
+// return an object with
+// {filename: ..., downloaded: true}
+const downloadFromUrl = ({ url, downloadDestination, progress, ca, version, redirectTTL = defaultMaxRedirects }) => {
+    if (redirectTTL <= 0) {
+        return bluebird_1.default.reject(new Error((0, common_tags_1.stripIndent) `
+          Failed downloading the Cypress binary.
+          There were too many redirects. The default allowance is ${defaultMaxRedirects}.
+          Maybe you got stuck in a redirect loop?
+        `));
+    }
+    return new bluebird_1.default((resolve, reject) => {
+        const proxy = getProxyForUrlWithNpmConfig(url);
+        debug('Downloading package', {
+            url,
+            proxy,
+            downloadDestination,
+        });
+        if (ca) {
+            debug('using custom CA details from npm config');
+        }
+        const reqOptions = Object.assign(Object.assign(Object.assign({ uri: url }, (proxy ? { proxy } : {})), (ca ? { agentOptions: { ca } } : {})), { method: 'GET', followRedirect: false });
+        const req = (0, request_1.default)(reqOptions);
+        // closure
+        let started = null;
+        let expectedSize;
+        let expectedChecksum;
+        (0, request_progress_1.default)(req, {
+            throttle: progress.throttle,
+        })
+            .on('response', (response) => {
+            // we have computed checksum and filesize during test runner binary build
+            // and have set it on the S3 object as user meta data, available via
+            // these custom headers "x-amz-meta-..."
+            // see https://github.com/cypress-io/cypress/pull/4092
+            expectedSize = response.headers['x-amz-meta-size'] ||
+                response.headers['content-length'];
+            expectedChecksum = response.headers['x-amz-meta-checksum'];
+            if (expectedChecksum) {
+                debug('expected checksum %s', expectedChecksum);
+            }
+            if (expectedSize) {
+                // convert from string (all Amazon custom headers are strings)
+                expectedSize = Number(expectedSize);
+                debug('expected file size %d', expectedSize);
+            }
+            // start counting now once we've gotten
+            // response headers
+            started = new Date();
+            if (/^3/.test(response.statusCode)) {
+                const redirectVersion = response.headers['x-version'];
+                const redirectUrl = response.headers.location;
+                debug('redirect version:', redirectVersion);
+                debug('redirect url:', redirectUrl);
+                downloadFromUrl({ url: redirectUrl, progress, ca, downloadDestination, version: redirectVersion, redirectTTL: redirectTTL - 1 })
+                    .then(resolve).catch(reject);
+                // if our status code does not start with 200
+            }
+            else if (!/^2/.test(response.statusCode)) {
+                debug('response code %d', response.statusCode);
+                const err = new Error((0, common_tags_1.stripIndent) `
+          Failed downloading the Cypress binary.
+          Response code: ${response.statusCode}
+          Response message: ${response.statusMessage}
+        `);
+                reject(err);
+                // status codes here are all 2xx
+            }
+            else {
+                // We only enable this pipe connection when we know we've got a successful return
+                // and handle the completion with verify and resolve
+                // there was a possible race condition between end of request and close of writeStream
+                // that is made ordered with this Promise.all
+                bluebird_1.default.all([new bluebird_1.default((r) => {
+                        return response.pipe(fs_extra_1.default.createWriteStream(downloadDestination).on('close', r));
+                    }), new bluebird_1.default((r) => response.on('end', r))])
+                    .then(() => {
+                    debug('downloading finished');
+                    verifyDownloadedFile(downloadDestination, expectedSize, expectedChecksum)
+                        .then(() => debug('verified'))
+                        .then(() => resolve(version))
+                        .catch(reject);
+                });
+            }
+        })
+            .on('error', (e) => {
+            if (e.code === 'ECONNRESET')
+                return; // sometimes proxies give ECONNRESET but we don't care
+            reject(e);
+        })
+            .on('progress', (state) => {
+            // total time we've elapsed
+            // starting on our first progress notification
+            const elapsed = +new Date() - +started;
+            // request-progress sends a value between 0 and 1
+            const percentage = util_1.default.convertPercentToPercentage(state.percent);
+            const eta = util_1.default.calculateEta(percentage, elapsed);
+            // send up our percent and seconds remaining
+            progress.onProgress(percentage, util_1.default.secsRemaining(eta));
+        });
+    });
+};
+/**
+ * Download Cypress.zip from external versionUrl to local file.
+ * @param [string] version Could be "3.3.0" or full URL
+ * @param [string] downloadDestination Local filename to save as
+ */
+const start = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+    let { version, downloadDestination, progress, redirectTTL } = opts;
+    if (!downloadDestination) {
+        assert_1.default.ok(lodash_1.default.isString(downloadDestination) && !lodash_1.default.isEmpty(downloadDestination), 'missing download dir');
+    }
+    if (!progress) {
+        progress = { onProgress: () => {
+                return {};
+            } };
+    }
+    const arch = yield util_1.default.getRealArch();
+    const versionUrl = getUrl(arch, version);
+    progress.throttle = 100;
+    debug('needed Cypress version: %s', version);
+    debug('source url %s', versionUrl);
+    debug(`downloading cypress.zip to "${downloadDestination}"`);
+    try {
+        // ensure download dir exists
+        yield fs_extra_1.default.ensureDir(path_1.default.dirname(downloadDestination));
+        const ca = yield getCA();
+        return downloadFromUrl(Object.assign({ url: versionUrl, downloadDestination, progress, ca, version }, (redirectTTL ? { redirectTTL } : {})));
+    }
+    catch (err) {
+        return prettyDownloadErr(err, versionUrl);
+    }
+});
+const downloadModule = {
+    start,
+    getUrl,
+    getProxyForUrlWithNpmConfig,
+    getCA,
+};
+exports.default = downloadModule;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const bluebird_1 = __importDefault(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(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stat = yield fs_extra_1.default.lstat(path);
+        if (stat.isDirectory()) {
+            const list = yield fs_extra_1.default.readdir(path);
+            return bluebird_1.default.resolve(list).reduce((prev, curr) => __awaiter(this, void 0, void 0, function* () {
+                const currPath = (0, path_1.join)(path, curr);
+                const s = yield fs_extra_1.default.lstat(currPath);
+                if (s.isDirectory()) {
+                    return prev + (yield getSize(currPath));
+                }
+                return prev + s.size;
+            }), 0);
+        }
+        return stat.size;
+    });
+}
+exports.default = getSize;

package/dist/tasks/install.js

@@ -0,0 +1,326 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const debug_1 = __importDefault(require("debug"));
+const listr2_1 = require("listr2");
+const log_symbols_1 = __importDefault(require("log-symbols"));
+const common_tags_1 = require("common-tags");
+const promises_1 = __importDefault(require("timers/promises"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const download_1 = __importDefault(require("./download"));
+const util_1 = __importDefault(require("../util"));
+const state_1 = __importDefault(require("./state"));
+const unzip_1 = __importDefault(require("./unzip"));
+const logger_1 = __importDefault(require("../logger"));
+const errors_1 = require("../errors");
+const VerboseRenderer_1 = __importDefault(require("../VerboseRenderer"));
+const debug = (0, debug_1.default)('cypress:cli');
+// Import package.json dynamically to avoid TypeScript JSON import issues
+const { buildInfo, version } = require('../../package.json');
+function _getBinaryUrlFromBuildInfo(arch, { commitSha, commitBranch }) {
+    const platform = os_1.default.platform();
+    if ((platform === 'win32') && (arch === 'arm64')) {
+        debug(`detected platform ${platform} architecture ${arch} combination`);
+        arch = 'x64';
+        debug(`overriding to download ${platform}-${arch} pre-release binary instead`);
+    }
+    return `https://cdn.cypress.io/beta/binary/${version}/${platform}-${arch}/${commitBranch}-${commitSha}/cypress.zip`;
+}
+const alreadyInstalledMsg = () => {
+    if (!util_1.default.isPostInstall()) {
+        logger_1.default.log((0, common_tags_1.stripIndent) `
+      Skipping installation:
+
+        Pass the ${chalk_1.default.yellow('--force')} option if you'd like to reinstall anyway.
+    `);
+    }
+};
+const displayCompletionMsg = () => {
+    // check here to see if we are globally installed
+    if (util_1.default.isInstalledGlobally()) {
+        // if we are display a warning
+        logger_1.default.log();
+        logger_1.default.warn((0, common_tags_1.stripIndent) `
+      ${log_symbols_1.default.warning} Warning: It looks like you\'ve installed Cypress globally.
+
+        The recommended way to install Cypress is as a devDependency per project.
+
+        You should probably run these commands:
+
+        - ${chalk_1.default.cyan('npm uninstall -g cypress')}
+        - ${chalk_1.default.cyan('npm install --save-dev cypress')}
+    `);
+        return;
+    }
+    logger_1.default.log();
+    logger_1.default.log('You can now open Cypress by running one of the following, depending on your package manager:');
+    logger_1.default.log();
+    logger_1.default.log(chalk_1.default.cyan('- npx cypress open'));
+    logger_1.default.log(chalk_1.default.cyan('- yarn cypress open'));
+    logger_1.default.log(chalk_1.default.cyan('- pnpm cypress open'));
+    logger_1.default.log();
+    logger_1.default.log(chalk_1.default.grey('https://on.cypress.io/opening-the-app'));
+    logger_1.default.log();
+};
+const downloadAndUnzip = ({ version, installDir, downloadDir }) => {
+    const progress = {
+        throttle: 100,
+        onProgress: null,
+    };
+    const downloadDestination = path_1.default.join(downloadDir, `cypress-${process.pid}.zip`);
+    const rendererOptions = getRendererOptions();
+    // let the user know what version of cypress we're downloading!
+    logger_1.default.log(`Installing Cypress ${chalk_1.default.gray(`(version: ${version})`)}`);
+    logger_1.default.log();
+    const tasks = new listr2_1.Listr([
+        {
+            options: { title: util_1.default.titleize('Downloading Cypress') },
+            task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+                // as our download progresses indicate the status
+                progress.onProgress = progessify(task, 'Downloading Cypress');
+                const redirectVersion = yield download_1.default.start({ version, downloadDestination, progress });
+                if (redirectVersion)
+                    version = redirectVersion;
+                debug(`finished downloading file: ${downloadDestination}`);
+                // save the download destination for unzipping
+                util_1.default.setTaskTitle(task, util_1.default.titleize(chalk_1.default.green('Downloaded Cypress')), rendererOptions.renderer);
+            }),
+        },
+        unzipTask({
+            progress,
+            zipFilePath: downloadDestination,
+            installDir,
+            rendererOptions,
+        }),
+        {
+            options: { title: util_1.default.titleize('Finishing Installation') },
+            task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+                const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+                    debug('removing zip file %s', downloadDestination);
+                    yield fs_extra_1.default.remove(downloadDestination);
+                });
+                yield cleanup();
+                debug('finished installation in', installDir);
+                util_1.default.setTaskTitle(task, util_1.default.titleize(chalk_1.default.green('Finished Installation'), chalk_1.default.gray(installDir)), rendererOptions.renderer);
+            }),
+        },
+    ], { rendererOptions });
+    // start the tasks!
+    return tasks.run();
+};
+const validateOS = () => __awaiter(void 0, void 0, void 0, function* () {
+    const platformInfo = yield util_1.default.getPlatformInfo();
+    return platformInfo.match(/(win32-x64|win32-arm64|linux-x64|linux-arm64|darwin-x64|darwin-arm64)/);
+});
+/**
+ * Returns the version to install - either a string like `1.2.3` to be fetched
+ * from the download server or a file path or HTTP URL.
+ */
+function getVersionOverride({ arch, envVarVersion, buildInfo }) {
+    // let this environment variable reset the binary version we need
+    if (envVarVersion) {
+        return envVarVersion;
+    }
+    if (buildInfo && !buildInfo.stable) {
+        logger_1.default.log(chalk_1.default.yellow((0, common_tags_1.stripIndent) `
+        ${log_symbols_1.default.warning} Warning: You are installing a pre-release build of Cypress.
+
+        Bugs may be present which do not exist in production builds.
+
+        This build was created from:
+          * Commit SHA: ${buildInfo.commitSha}
+          * Commit Branch: ${buildInfo.commitBranch}
+          * Commit Timestamp: ${buildInfo.commitDate}
+      `));
+        logger_1.default.log();
+        return _getBinaryUrlFromBuildInfo(arch, buildInfo);
+    }
+}
+function getEnvVarVersion() {
+    if (!util_1.default.getEnv('CYPRESS_INSTALL_BINARY'))
+        return;
+    // because passed file paths are often double quoted
+    // and might have extra whitespace around, be robust and trim the string
+    const trimAndRemoveDoubleQuotes = true;
+    const envVarVersion = util_1.default.getEnv('CYPRESS_INSTALL_BINARY', trimAndRemoveDoubleQuotes);
+    debug('using environment variable CYPRESS_INSTALL_BINARY "%s"', envVarVersion);
+    return envVarVersion;
+}
+const start = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
+    debug('installing with options %j', options);
+    const envVarVersion = getEnvVarVersion();
+    if (envVarVersion === '0') {
+        debug('environment variable CYPRESS_INSTALL_BINARY = 0, skipping install');
+        logger_1.default.log((0, common_tags_1.stripIndent) `
+        ${chalk_1.default.yellow('Note:')} Skipping binary installation: Environment variable CYPRESS_INSTALL_BINARY = 0.`);
+        logger_1.default.log();
+        return;
+    }
+    lodash_1.default.defaults(options, {
+        force: false,
+        buildInfo,
+    });
+    if (util_1.default.getEnv('CYPRESS_CACHE_FOLDER')) {
+        const envCache = util_1.default.getEnv('CYPRESS_CACHE_FOLDER');
+        logger_1.default.log((0, common_tags_1.stripIndent) `
+        ${chalk_1.default.yellow('Note:')} Overriding Cypress cache directory to: ${chalk_1.default.cyan(envCache)}
+
+              Previous installs of Cypress may not be found.
+      `);
+        logger_1.default.log();
+    }
+    const pkgVersion = util_1.default.pkgVersion();
+    const arch = yield util_1.default.getRealArch();
+    const versionOverride = getVersionOverride({ arch, envVarVersion, buildInfo: options.buildInfo });
+    const versionToInstall = versionOverride || pkgVersion;
+    debug('version in package.json is %s, version to install is %s', pkgVersion, versionToInstall);
+    const installDir = state_1.default.getVersionDir(pkgVersion, options.buildInfo);
+    const cacheDir = state_1.default.getCacheDir();
+    const binaryDir = state_1.default.getBinaryDir(pkgVersion);
+    if (!(yield validateOS())) {
+        return (0, errors_1.throwFormErrorText)(errors_1.errors.invalidOS)();
+    }
+    try {
+        yield fs_extra_1.default.ensureDir(cacheDir);
+    }
+    catch (err) {
+        if (err.code === 'EACCES') {
+            return (0, errors_1.throwFormErrorText)(errors_1.errors.invalidCacheDirectory)((0, common_tags_1.stripIndent) `
+        Failed to access ${chalk_1.default.cyan(cacheDir)}:
+
+        ${err.message}
+      `);
+        }
+        throw err;
+    }
+    const binaryPkg = yield state_1.default.getBinaryPkgAsync(binaryDir);
+    const binaryVersion = yield state_1.default.getBinaryPkgVersion(binaryPkg);
+    const shouldInstall = () => {
+        if (!binaryVersion) {
+            debug('no binary installed under cli version');
+            return true;
+        }
+        logger_1.default.log();
+        logger_1.default.log((0, common_tags_1.stripIndent) `
+      Cypress ${chalk_1.default.green(binaryVersion)} is installed in ${chalk_1.default.cyan(installDir)}
+      `);
+        logger_1.default.log();
+        if (options.force) {
+            debug('performing force install over existing binary');
+            return true;
+        }
+        if ((binaryVersion === versionToInstall) || !util_1.default.isSemver(versionToInstall)) {
+            // our version matches, tell the user this is a noop
+            alreadyInstalledMsg();
+            return false;
+        }
+        return true;
+    };
+    // noop if we've been told not to download
+    if (!shouldInstall()) {
+        return debug('Not downloading or installing binary');
+    }
+    if (envVarVersion) {
+        logger_1.default.log(chalk_1.default.yellow((0, common_tags_1.stripIndent) `
+        ${log_symbols_1.default.warning} Warning: Forcing a binary version different than the default.
+
+          The CLI expected to install version: ${chalk_1.default.green(pkgVersion)}
+
+          Instead we will install version: ${chalk_1.default.green(versionToInstall)}
+
+          These versions may not work properly together.
+      `));
+        logger_1.default.log();
+    }
+    const getLocalFilePath = () => __awaiter(void 0, void 0, void 0, function* () {
+        // see if version supplied is a path to a binary
+        if (yield fs_extra_1.default.pathExists(versionToInstall)) {
+            return path_1.default.extname(versionToInstall) === '.zip' ? versionToInstall : false;
+        }
+        const possibleFile = util_1.default.formAbsolutePath(versionToInstall);
+        debug('checking local file', possibleFile, 'cwd', process.cwd());
+        // if this exists return the path to it
+        // else false
+        if ((yield fs_extra_1.default.pathExists(possibleFile)) && path_1.default.extname(possibleFile) === '.zip') {
+            return possibleFile;
+        }
+        return false;
+    });
+    const pathToLocalFile = yield getLocalFilePath();
+    if (pathToLocalFile) {
+        const absolutePath = path_1.default.resolve(versionToInstall);
+        debug('found local file at', absolutePath);
+        debug('skipping download');
+        const rendererOptions = getRendererOptions();
+        return new listr2_1.Listr([unzipTask({
+                progress: {
+                    throttle: 100,
+                    onProgress: null,
+                },
+                zipFilePath: absolutePath,
+                installDir,
+                rendererOptions,
+            })], { rendererOptions }).run();
+    }
+    if (options.force) {
+        debug('Cypress already installed at', installDir);
+        debug('but the installation was forced');
+    }
+    debug('preparing to download and unzip version ', versionToInstall, 'to path', installDir);
+    const downloadDir = os_1.default.tmpdir();
+    yield downloadAndUnzip({ version: versionToInstall, installDir, downloadDir });
+    // delay 1 sec for UX, unless we are testing
+    yield promises_1.default.setTimeout(1000);
+    displayCompletionMsg();
+});
+const unzipTask = ({ zipFilePath, installDir, progress, rendererOptions }) => {
+    return {
+        options: { title: util_1.default.titleize('Unzipping Cypress') },
+        task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+            // as our unzip progresses indicate the status
+            progress.onProgress = progessify(task, 'Unzipping Cypress');
+            yield unzip_1.default.start({ zipFilePath, installDir, progress });
+            util_1.default.setTaskTitle(task, util_1.default.titleize(chalk_1.default.green('Unzipped Cypress')), rendererOptions.renderer);
+        }),
+    };
+};
+const progessify = (task, title) => {
+    // return higher order function
+    return (percentComplete, remaining) => {
+        const percentCompleteStr = chalk_1.default.white(` ${percentComplete}%`);
+        // pluralize seconds remaining
+        const remainingStr = chalk_1.default.gray(`${remaining}s`);
+        util_1.default.setTaskTitle(task, util_1.default.titleize(title, percentCompleteStr, remainingStr), getRendererOptions().renderer);
+    };
+};
+// if we are running in CI then use
+// the verbose renderer else use
+// the default
+const getRendererOptions = () => {
+    let renderer = util_1.default.isCi() ? VerboseRenderer_1.default : 'default';
+    if (logger_1.default.logLevel() === 'silent') {
+        renderer = 'silent';
+    }
+    return {
+        renderer,
+    };
+};
+exports.default = {
+    start,
+    _getBinaryUrlFromBuildInfo,
+};