cypress 15.2.0 → 15.3.0

package/{lib → dist}/errors.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -8,8 +17,8 @@ exports.getError = getError;
 exports.formErrorText = formErrorText;
 const chalk_1 = __importDefault(require("chalk"));
 const common_tags_1 = require("common-tags");
-const lazy_ass_1 = __importDefault(require("lazy-ass"));
-const check_more_types_1 = __importDefault(require("check-more-types"));
+const lodash_1 = __importDefault(require("lodash"));
+const assert_1 = __importDefault(require("assert"));
 const util_1 = __importDefault(require("./util"));
 const state_1 = __importDefault(require("./tasks/state"));
 const docsUrl = 'https://on.cypress.io';
@@ -238,7 +247,8 @@ const CYPRESS_RUN_BINARY = {
     },
 };
 function addPlatformInformation(info) {
-    return util_1.default.getPlatformInfo().then((platform) => {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = yield util_1.default.getPlatformInfo();
         return Object.assign(Object.assign({}, info), { platform });
     });
 }
@@ -255,7 +265,8 @@ function addPlatformInformation(info) {
   ```
  */
 function getError(errorObject) {
-    return formErrorText(errorObject).then((errorMessage) => {
+    return __awaiter(this, void 0, void 0, function* () {
+        const errorMessage = yield formErrorText(errorObject);
         const err = new Error(errorMessage);
         err.known = true;
         return err;
@@ -266,30 +277,31 @@ function getError(errorObject) {
  * and if possible a way to solve it. Resolves with a string.
  */
 function formErrorText(info, msg, prevMessage) {
-    return addPlatformInformation(info).then((obj) => {
+    return __awaiter(this, void 0, void 0, function* () {
+        const infoWithPlatform = yield addPlatformInformation(info);
         const formatted = [];
         function add(msg) {
             formatted.push((0, common_tags_1.stripIndents)(msg));
         }
-        (0, lazy_ass_1.default)(check_more_types_1.default.unemptyString(obj.description), 'expected error description to be text', obj.description);
+        assert_1.default.ok(lodash_1.default.isString(infoWithPlatform.description) && !lodash_1.default.isEmpty(infoWithPlatform.description), 'expected error description to be text.');
         // assuming that if there the solution is a function it will handle
         // error message and (optional previous error message)
-        if (check_more_types_1.default.fn(obj.solution)) {
-            const text = obj.solution(msg, prevMessage);
-            (0, lazy_ass_1.default)(check_more_types_1.default.unemptyString(text), 'expected solution to be text', text);
+        if (lodash_1.default.isFunction(infoWithPlatform.solution)) {
+            const text = infoWithPlatform.solution(msg, prevMessage);
+            assert_1.default.ok(lodash_1.default.isString(text) && !lodash_1.default.isEmpty(text), 'expected solution to be text.');
             add(`
-        ${obj.description}
+        ${infoWithPlatform.description}
 
         ${text}
 
       `);
         }
         else {
-            (0, lazy_ass_1.default)(check_more_types_1.default.unemptyString(obj.solution), 'expected error solution to be text', obj.solution);
+            assert_1.default.ok(lodash_1.default.isString(infoWithPlatform.solution) && !lodash_1.default.isEmpty(infoWithPlatform.solution), 'expected error solution to be text.');
             add(`
-        ${obj.description}
+        ${infoWithPlatform.description}
 
-        ${obj.solution}
+        ${infoWithPlatform.solution}
 
       `);
             if (msg) {
@@ -304,14 +316,14 @@ function formErrorText(info, msg, prevMessage) {
         add(`
       ${exports.hr}
 
-      ${obj.platform}
+      ${infoWithPlatform.platform}
     `);
-        if (obj.footer) {
+        if (infoWithPlatform.footer) {
             add(`
 
         ${exports.hr}
 
-        ${obj.footer}
+        ${infoWithPlatform.footer}
       `);
         }
         return formatted.join('\n\n');
@@ -329,9 +341,10 @@ const raise = (info) => {
 };
 exports.raise = raise;
 const throwFormErrorText = (info) => {
-    return (msg, prevMessage) => {
-        return formErrorText(info, msg, prevMessage).then((0, exports.raise)(info));
-    };
+    return (msg, prevMessage) => __awaiter(void 0, void 0, void 0, function* () {
+        const errorText = yield formErrorText(info, msg, prevMessage);
+        (0, exports.raise)(info)(errorText);
+    });
 };
 exports.throwFormErrorText = throwFormErrorText;
 /**
@@ -341,13 +354,12 @@ exports.throwFormErrorText = throwFormErrorText;
  * @example return exitWithError(errors.invalidCypressEnv)('foo')
  */
 const exitWithError = (info) => {
-    return (msg) => {
-        return formErrorText(info, msg).then((text) => {
-            // eslint-disable-next-line no-console
-            console.error(text);
-            process.exit(info.exitCode || 1);
-        });
-    };
+    return (msg) => __awaiter(void 0, void 0, void 0, function* () {
+        const text = yield formErrorText(info, msg);
+        // eslint-disable-next-line no-console
+        console.error(text);
+        process.exit(info.exitCode || 1);
+    });
 };
 exports.exitWithError = exitWithError;
 exports.errors = {

package/{lib → dist}/exec/open.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -7,7 +16,7 @@ exports.start = exports.processOpenOptions = void 0;
 const debug_1 = __importDefault(require("debug"));
 const util_1 = __importDefault(require("../util"));
 const spawn_1 = __importDefault(require("./spawn"));
-const verify_1 = __importDefault(require("../tasks/verify"));
+const verify_1 = require("../tasks/verify");
 const shared_1 = require("./shared");
 const errors_1 = require("../errors");
 const debug = (0, debug_1.default)('cypress:cli');
@@ -65,7 +74,7 @@ const processOpenOptions = (options = {}) => {
     return args;
 };
 exports.processOpenOptions = processOpenOptions;
-const start = (options = {}) => {
+const start = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
     function open() {
         try {
             const args = (0, exports.processOpenOptions)(options);
@@ -84,9 +93,9 @@ const start = (options = {}) => {
     if (options.dev) {
         return open();
     }
-    return verify_1.default.start()
-        .then(open);
-};
+    yield (0, verify_1.start)();
+    return open();
+});
 exports.start = start;
 exports.default = {
     start: exports.start,

package/{lib → dist}/exec/run.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -7,7 +16,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const debug_1 = __importDefault(require("debug"));
 const util_1 = __importDefault(require("../util"));
 const spawn_1 = __importDefault(require("./spawn"));
-const verify_1 = __importDefault(require("../tasks/verify"));
+const verify_1 = require("../tasks/verify");
 const errors_1 = require("../errors");
 const shared_1 = require("./shared");
 const debug = (0, debug_1.default)('cypress:cli:run');
@@ -133,34 +142,36 @@ const runModule = {
     processRunOptions,
     isValidProject,
     // resolves with the number of failed tests
-    start(options = {}) {
-        lodash_1.default.defaults(options, {
-            key: null,
-            spec: null,
-            reporter: null,
-            reporterOptions: null,
-            project: process.cwd(),
-        });
-        function run() {
-            try {
-                const args = processRunOptions(options);
-                debug('run to spawn.start args %j', args);
-                return spawn_1.default.start(args, {
-                    dev: options.dev,
-                });
-            }
-            catch (err) {
-                if (err.details) {
-                    return (0, errors_1.exitWithError)(err.details)();
+    start() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            lodash_1.default.defaults(options, {
+                key: null,
+                spec: null,
+                reporter: null,
+                reporterOptions: null,
+                project: process.cwd(),
+            });
+            function run() {
+                try {
+                    const args = processRunOptions(options);
+                    debug('run to spawn.start args %j', args);
+                    return spawn_1.default.start(args, {
+                        dev: options.dev,
+                    });
+                }
+                catch (err) {
+                    if (err.details) {
+                        return (0, errors_1.exitWithError)(err.details)();
+                    }
+                    throw err;
                 }
-                throw err;
             }
-        }
-        if (options.dev) {
+            if (options.dev) {
+                return run();
+            }
+            yield (0, verify_1.start)();
             return run();
-        }
-        return verify_1.default.start()
-            .then(run);
+        });
     },
 };
 exports.default = runModule;

package/dist/exec/spawn.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 child_process_1 = __importDefault(require("child_process"));
+const path_1 = __importDefault(require("path"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const debug_1 = __importDefault(require("debug"));
+const util_1 = __importDefault(require("../util"));
+const state_1 = __importDefault(require("../tasks/state"));
+const xvfb_1 = __importDefault(require("./xvfb"));
+const verify_1 = require("../tasks/verify");
+const errors_1 = require("../errors");
+const readline_1 = __importDefault(require("readline"));
+const process_1 = require("process");
+const debug = (0, debug_1.default)('cypress:cli');
+function isPlatform(platform) {
+    return os_1.default.platform() === platform;
+}
+function needsStderrPiped(needsXvfb) {
+    return lodash_1.default.some([
+        isPlatform('darwin'),
+        (needsXvfb && isPlatform('linux')),
+        util_1.default.isPossibleLinuxWithIncorrectDisplay(),
+    ]);
+}
+function needsEverythingPipedDirectly() {
+    return isPlatform('win32');
+}
+function getStdio(needsXvfb) {
+    if (needsEverythingPipedDirectly()) {
+        return 'pipe';
+    }
+    // https://github.com/cypress-io/cypress/issues/921
+    // https://github.com/cypress-io/cypress/issues/1143
+    // https://github.com/cypress-io/cypress/issues/1745
+    if (needsStderrPiped(needsXvfb)) {
+        // returning pipe here so we can massage stderr
+        // and remove garbage from Xlib and libuv
+        // due to starting the Xvfb process on linux
+        return ['inherit', 'inherit', 'pipe'];
+    }
+    return 'inherit';
+}
+const spawnModule = {
+    start(args_1) {
+        return __awaiter(this, arguments, void 0, function* (args, options = {}) {
+            const needsXvfb = xvfb_1.default.isNeeded();
+            let executable = state_1.default.getPathToExecutable(state_1.default.getBinaryDir());
+            if (util_1.default.getEnv('CYPRESS_RUN_BINARY')) {
+                executable = path_1.default.resolve(util_1.default.getEnv('CYPRESS_RUN_BINARY'));
+            }
+            debug('needs to start own Xvfb?', needsXvfb);
+            // Always push cwd into the args
+            // which additionally acts as a signal to the
+            // binary that it was invoked through the NPM module
+            args = args || [];
+            if (typeof args === 'string') {
+                args = [args];
+            }
+            args = [...args, '--cwd', process.cwd(), '--userNodePath', process.execPath, '--userNodeVersion', process.versions.node];
+            lodash_1.default.defaults(options, {
+                dev: false,
+                env: process.env,
+                detached: false,
+                stdio: getStdio(needsXvfb),
+            });
+            const spawn = (overrides = {}) => {
+                return new bluebird_1.default((resolve, reject) => {
+                    lodash_1.default.defaults(overrides, {
+                        onStderrData: false,
+                    });
+                    const { onStderrData } = overrides;
+                    const envOverrides = util_1.default.getEnvOverrides(options);
+                    const electronArgs = [];
+                    const node11WindowsFix = isPlatform('win32');
+                    let startScriptPath;
+                    if (options.dev) {
+                        executable = 'node';
+                        // if we're in dev then reset
+                        // the launch cmd to be 'npm run dev'
+                        startScriptPath = path_1.default.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js');
+                        debug('in dev mode the args became %o', args);
+                    }
+                    if (!options.dev && (0, verify_1.needsSandbox)()) {
+                        electronArgs.push('--no-sandbox');
+                    }
+                    // strip dev out of child process options
+                    /**
+                     * @type {import('child_process').ForkOptions}
+                     */
+                    let stdioOptions = lodash_1.default.pick(options, 'env', 'detached', 'stdio');
+                    // figure out if we're going to be force enabling or disabling colors.
+                    // also figure out whether we should force stdout and stderr into thinking
+                    // it is a tty as opposed to a pipe.
+                    stdioOptions.env = lodash_1.default.extend({}, stdioOptions.env, envOverrides);
+                    if (node11WindowsFix) {
+                        stdioOptions = lodash_1.default.extend({}, stdioOptions, { windowsHide: false });
+                    }
+                    if (util_1.default.isPossibleLinuxWithIncorrectDisplay()) {
+                        // make sure we use the latest DISPLAY variable if any
+                        debug('passing DISPLAY', process.env.DISPLAY);
+                        stdioOptions.env.DISPLAY = process.env.DISPLAY;
+                    }
+                    if (stdioOptions.env.ELECTRON_RUN_AS_NODE) {
+                        // Since we are running electron as node, we need to add an entry point file.
+                        startScriptPath = path_1.default.join(state_1.default.getBinaryPkgPath(path_1.default.dirname(executable)), '..', 'index.js');
+                    }
+                    else {
+                        // Start arguments with "--" so Electron knows these are OUR
+                        // arguments and does not try to sanitize them. Otherwise on Windows
+                        // an url in one of the arguments crashes it :(
+                        // https://github.com/cypress-io/cypress/issues/5466
+                        args = [...electronArgs, '--', ...args];
+                    }
+                    if (startScriptPath) {
+                        args.unshift(startScriptPath);
+                    }
+                    if (process.env.CYPRESS_INTERNAL_DEV_DEBUG) {
+                        args.unshift(process.env.CYPRESS_INTERNAL_DEV_DEBUG);
+                    }
+                    debug('spawn args %o %o', args, lodash_1.default.omit(stdioOptions, 'env'));
+                    debug('spawning Cypress with executable: %s', executable);
+                    const child = child_process_1.default.spawn(executable, args, stdioOptions);
+                    function resolveOn(event) {
+                        return function (code, signal) {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                debug('child event fired %o', { event, code, signal });
+                                if (code === null) {
+                                    const errorObject = errors_1.errors.childProcessKilled(event, signal);
+                                    const err = yield (0, errors_1.getError)(errorObject);
+                                    return reject(err);
+                                }
+                                resolve(code);
+                            });
+                        };
+                    }
+                    child.on('close', resolveOn('close'));
+                    child.on('exit', resolveOn('exit'));
+                    child.on('error', reject);
+                    if (isPlatform('win32')) {
+                        const rl = readline_1.default.createInterface({
+                            input: process_1.stdin,
+                            output: process_1.stdout,
+                        });
+                        // on windows, SIGINT does not propagate to the child process when ctrl+c is pressed
+                        // this makes sure all nested processes are closed(ex: firefox inside the server)
+                        rl.on('SIGINT', function () {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                const kill = (yield Promise.resolve().then(() => __importStar(require('tree-kill')))).default;
+                                kill(child.pid, 'SIGINT');
+                            });
+                        });
+                    }
+                    // if stdio options is set to 'pipe', then
+                    //   we should set up pipes:
+                    //  process STDIN (read stream) => child STDIN (writeable)
+                    //  child STDOUT => process STDOUT
+                    //  child STDERR => process STDERR with additional filtering
+                    if (child.stdin) {
+                        debug('piping process STDIN into child STDIN');
+                        process_1.stdin.pipe(child.stdin);
+                    }
+                    if (child.stdout) {
+                        debug('piping child STDOUT to process STDOUT');
+                        child.stdout.pipe(process_1.stdout);
+                    }
+                    // if this is defined then we are manually piping for linux
+                    // to filter out the garbage
+                    if (child.stderr) {
+                        debug('piping child STDERR to process STDERR');
+                        child.stderr.on('data', (data) => {
+                            const str = data.toString();
+                            // if we have a callback and this explicitly returns
+                            // false then bail
+                            if (onStderrData && onStderrData(str)) {
+                                return;
+                            }
+                            // else pass it along!
+                            process_1.stderr.write(data);
+                        });
+                    }
+                    // https://github.com/cypress-io/cypress/issues/1841
+                    // https://github.com/cypress-io/cypress/issues/5241
+                    // In some versions of node, it will throw on windows
+                    // when you close the parent process after piping
+                    // into the child process. unpiping does not seem
+                    // to have any effect. so we're just catching the
+                    // error here and not doing anything.
+                    process_1.stdin.on('error', (err) => {
+                        if (['EPIPE', 'ENOTCONN'].includes(err.code)) {
+                            return;
+                        }
+                        throw err;
+                    });
+                    if (stdioOptions.detached) {
+                        child.unref();
+                    }
+                });
+            };
+            const spawnInXvfb = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield xvfb_1.default.start();
+                    const code = yield userFriendlySpawn();
+                    return code;
+                }
+                finally {
+                    yield xvfb_1.default.stop();
+                }
+            });
+            const userFriendlySpawn = (linuxWithDisplayEnv) => __awaiter(this, void 0, void 0, function* () {
+                debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
+                let brokenGtkDisplay = false;
+                const overrides = {};
+                if (linuxWithDisplayEnv) {
+                    lodash_1.default.extend(overrides, {
+                        electronLogging: true,
+                        onStderrData(str) {
+                            // if we receive a broken pipe anywhere
+                            // then we know that's why cypress exited early
+                            if (util_1.default.isBrokenGtkDisplay(str)) {
+                                brokenGtkDisplay = true;
+                            }
+                        },
+                    });
+                }
+                try {
+                    const code = yield spawn(overrides);
+                    if (code !== 0 && brokenGtkDisplay) {
+                        util_1.default.logBrokenGtkDisplayWarning();
+                        return spawnInXvfb();
+                    }
+                    return code;
+                }
+                catch (error) {
+                    // we can format and handle an error message from the code above
+                    // prevent wrapping error again by using "known: undefined" filter
+                    if (error.known === undefined) {
+                        const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.unexpected);
+                        yield raiseErrorFn(error.message);
+                    }
+                    throw error;
+                }
+            });
+            if (needsXvfb) {
+                return spawnInXvfb();
+            }
+            // if we are on linux and there's already a DISPLAY
+            // set, then we may need to rerun cypress after
+            // spawning our own Xvfb server
+            const linuxWithDisplayEnv = util_1.default.isPossibleLinuxWithIncorrectDisplay();
+            return userFriendlySpawn(linuxWithDisplayEnv);
+        });
+    },
+};
+exports.default = spawnModule;

package/dist/exec/versions.js

@@ -0,0 +1,67 @@
+"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 debug_1 = __importDefault(require("debug"));
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("../util"));
+const state_1 = __importDefault(require("../tasks/state"));
+const errors_1 = require("../errors");
+const debug = (0, debug_1.default)('cypress:cli');
+const getBinaryDirectory = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (util_1.default.getEnv('CYPRESS_RUN_BINARY')) {
+        let envBinaryPath = path_1.default.resolve(util_1.default.getEnv('CYPRESS_RUN_BINARY'));
+        try {
+            const envBinaryDir = yield state_1.default.parseRealPlatformBinaryFolderAsync(envBinaryPath);
+            if (!envBinaryDir) {
+                const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath));
+                yield raiseErrorFn();
+            }
+            debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
+            return envBinaryDir;
+        }
+        catch (err) {
+            const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath));
+            yield raiseErrorFn(err.message);
+        }
+    }
+    return state_1.default.getBinaryDir();
+});
+const getVersions = () => __awaiter(void 0, void 0, void 0, function* () {
+    const binDir = yield getBinaryDirectory();
+    const pkg = yield state_1.default.getBinaryPkgAsync(binDir);
+    const versions = {
+        binary: state_1.default.getBinaryPkgVersion(pkg),
+        electronVersion: state_1.default.getBinaryElectronVersion(pkg),
+        electronNodeVersion: state_1.default.getBinaryElectronNodeVersion(pkg),
+    };
+    debug('binary versions %o', versions);
+    const buildInfo = util_1.default.pkgBuildInfo();
+    let packageVersion = util_1.default.pkgVersion();
+    if (!buildInfo)
+        packageVersion += ' (development)';
+    else if (!buildInfo.stable)
+        packageVersion += ' (pre-release)';
+    const versionsFinal = {
+        package: packageVersion,
+        binary: versions.binary || 'not installed',
+        electronVersion: versions.electronVersion || 'not found',
+        electronNodeVersion: versions.electronNodeVersion || 'not found',
+    };
+    debug('combined versions %o', versions);
+    return versionsFinal;
+});
+const versionsModule = {
+    getVersions,
+};
+exports.default = versionsModule;