@applitools/eyes-cypress 3.28.3 → 3.29.0

package/CHANGELOG.md

@@ -12,6 +12,12 @@
 
 
 
+## 3.29.0 - 2023/2/1
+
+### Features
+- Support ESM and TypeScript in Applitools' config file
+### Bug fixes
+
 ## 3.28.3 - 2023/1/20
 
 ### Features

package/README.md

@@ -45,12 +45,38 @@ Normally, this is `cypress/plugins/index.js`. You can read more about it in Cypr
 
  #### Cypress version >= 10:
 
- Add the following code to your `cypress.config.js` file after `module.exports`:
+ Add the following code to your:
+
+ ##### `cypress.config.js`
 
 ```js
-require('@applitools/eyes-cypress')(module)
+const { defineConfig } = require('cypress')
+const eyesPlugin = require('@applitools/eyes-cypress')
+module.exports = eyesPlugin(defineConfig({
+  // the e2e or component configuration
+  e2e: {
+    setupNodeEvents(on, config) {
+    }
+  }
+}))
 ```
+
+##### `cypress.config.ts`
+
+```typescript
+import { defineConfig } from 'cypress'
+import eyesPlugin from '@applitools/eyes-cypress'
+export default eyesPlugin(defineConfig({
+  // the e2e or component configuration
+  e2e: {
+    setupNodeEvents(on, config) {
+    }
+  }
+}))
+```
+
 This file is normally at the root of the project
+
 ##### 2. Configure custom commands
 
 Eyes-Cypress exposes new commands to your tests. This means that more methods will be available on the `cy` object. To enable this, it's required to configure these custom commands.

package/dist/browser/spec-driver.js

@@ -15,12 +15,10 @@ function executeScript(context, script, arg) {
 }
 exports.executeScript = executeScript;
 function mainContext() {
-    //@ts-ignore
     return cy.state('window').document;
 }
 exports.mainContext = mainContext;
 function parentContext(context) {
-    // because Cypress doesn't support cross origin iframe, then childContext might return null, and then the input to parentContext might be null
     if (!context) {
         throw new Error('Context is not accessible');
     }
@@ -36,7 +34,6 @@ function childContext(_context, element) {
 }
 exports.childContext = childContext;
 function getViewportSize() {
-    //@ts-ignore
     const currWindow = cy.state('window');
     const viewportSize = {
         width: currWindow.innerWidth || currWindow.document.documentElement.clientWidth || currWindow.document.body.clientWidth,
@@ -46,7 +43,6 @@ function getViewportSize() {
 }
 exports.getViewportSize = getViewportSize;
 function setViewportSize(vs) {
-    //@ts-ignore
     Cypress.action('cy:viewport:changed', { viewportWidth: vs.size.width, viewportHeight: vs.size.height });
 }
 exports.setViewportSize = setViewportSize;
@@ -95,10 +91,6 @@ function getUrl(context) {
 }
 exports.getUrl = getUrl;
 function getCookies() {
-    //@ts-ignore
     return Cypress.automation('get:cookies', {});
 }
 exports.getCookies = getCookies;
-// export function takeScreenshot(page: Driver): Promise<Buffer>;
-// export function visit(page: Driver, url: string): Promise<void>; (??)
-// export function isStaleElementError(err: any): boolean;

package/dist/expose.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = __importDefault(require("./plugin"));
+exports.default = plugin_1.default;

package/dist/plugin/concurrencyMsg.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require('chalk');
+const MSG = `
+Important notice: Your Applitools visual tests are currently running with a testConcurrency value of 5.
+This means that only up to 5 visual tests can run in parallel, and therefore the execution might be slower.
+If your Applitools license supports a higher concurrency level, learn how to configure it here: https://www.npmjs.com/package/@applitools/eyes-cypress#concurrency.
+Need a higher concurrency in your account? Email us @ sdr@applitools.com with your required concurrency level.`;
+exports.default = { concurrencyMsg: chalk.yellow(MSG), msgText: MSG };

package/dist/plugin/config.js

@@ -0,0 +1,66 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = __importStar(require("@applitools/utils"));
+const configParams_1 = __importDefault(require("./configParams"));
+const DEFAULT_TEST_CONCURRENCY = 5;
+const uuid = __importStar(require("uuid"));
+function makeConfig() {
+    const config = utils.config.getConfig({
+        params: [...configParams_1.default, 'failCypressOnDiff', 'tapDirPath', 'tapFileName', 'disableBrowserFetching', 'testConcurrency'],
+    });
+    if ((!config.batch || !config.batch.id) && !config.batchId) {
+        config.batch = { id: uuid.v4(), ...config.batch };
+    }
+    if (config.failCypressOnDiff === '0') {
+        config.failCypressOnDiff = false;
+    }
+    if (utils.types.isString(config.showLogs)) {
+        config.showLogs = config.showLogs === 'true' || config.showLogs === '1';
+    }
+    if (utils.types.isString(config.testConcurrency)) {
+        config.testConcurrency = Number(config.testConcurrency);
+    }
+    if (config.accessibilityValidation) {
+        config.accessibilitySettings = config.accessibilityValidation;
+        delete config.accessiblityValidation;
+    }
+    const eyesConfig = {
+        tapDirPath: config.tapDirPath,
+        tapFileName: config.tapFileName,
+        eyesIsDisabled: !!config.isDisabled,
+        eyesBrowser: JSON.stringify(config.browser),
+        eyesLayoutBreakpoints: JSON.stringify(config.layoutBreakpoints),
+        eyesFailCypressOnDiff: config.failCypressOnDiff === undefined ? true : !!config.failCypressOnDiff,
+        eyesDisableBrowserFetching: !!config.disableBrowserFetching,
+        eyesTestConcurrency: config.testConcurrency || DEFAULT_TEST_CONCURRENCY,
+        eyesWaitBeforeCapture: config.waitBeforeCapture,
+    };
+    return { config, eyesConfig };
+}
+exports.default = makeConfig;

package/dist/plugin/configParams.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configParams = [
+    'appName',
+    'testName',
+    'displayName',
+    'browser',
+    'url',
+    'apiKey',
+    'showLogs',
+    'batch',
+    'batchId',
+    'batchName',
+    'batchSequenceName',
+    'batchSequence',
+    'properties',
+    'baselineBranchName',
+    'baselineBranch',
+    'baselineEnvName',
+    'baselineName',
+    'envName',
+    'ignoreCaret',
+    'isDisabled',
+    'matchLevel',
+    'parentBranchName',
+    'parentBranch',
+    'branchName',
+    'branch',
+    'proxy',
+    'autProxy',
+    'saveDiffs',
+    'saveFailedTests',
+    'saveNewTests',
+    'compareWithParentBranch',
+    'ignoreBaseline',
+    'serverUrl',
+    'concurrency',
+    'testConcurrency',
+    'useDom',
+    'enablePatterns',
+    'ignoreDisplacements',
+    'accessibilitySettings',
+    'notifyOnCompletion',
+    'batchNotify',
+    'dontCloseBatches',
+];
+exports.default = configParams;

package/dist/plugin/errorDigest.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const colors = {
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    teal: '\x1b[38;5;86m',
+    orange: '\x1b[38;5;214m',
+    reset: '\x1b[0m',
+};
+const formatByStatus = {
+    Passed: {
+        color: 'green',
+        symbol: '\u2713',
+        title: (tests) => `Passed - ${tests} tests`,
+    },
+    Failed: {
+        color: 'red',
+        symbol: '\u2716',
+        title: (tests) => `Errors - ${tests} tests`,
+    },
+    Unresolved: {
+        color: 'orange',
+        symbol: '\u26A0',
+        title: (tests) => `Diffs detected - ${tests} tests`,
+    },
+};
+function stringifyTestResults(testResults) {
+    const hostDisplaySize = testResults.hostDisplaySize;
+    const viewport = hostDisplaySize ? `[${hostDisplaySize.width}x${hostDisplaySize.height}]` : '';
+    const testName = `${testResults.name} ${viewport}`;
+    return testName + (testResults.error ? ` : ${testResults.error}` : '');
+}
+function testResultsSection(title, results) {
+    return results.length ? `${indent()}${title}${indent(3)}${results.join(indent(3))}` : '';
+}
+function stringifyError(testResults) {
+    return testResults.error ? stringifyTestResults(testResults) : `[Eyes test not started] : ${testResults}`;
+}
+function indent(spaces = 2) {
+    return `\n   ${'  '.repeat(spaces)}`;
+}
+function hasError(testResult) {
+    return testResult.error || testResult instanceof Error;
+}
+function errorDigest({ passed, failed, diffs, logger, isInteractive }) {
+    logger.log('errorDigest: diff errors', diffs);
+    logger.log('errorDigest: test errors', failed);
+    const testResultsUrl = diffs.length ? colorify(` ${diffs[0].url} `, 'teal') : '';
+    const testResultsPrefix = testResultsUrl ? 'See details at:' : '';
+    const footer = testResultsUrl ? `\n${indent()}${colorify(testResultsPrefix)}${testResultsUrl}` : '';
+    return (colorify('Eyes-Cypress detected diffs or errors during execution of visual tests.') +
+        colorify(` ${testResultsPrefix}${testResultsUrl}`) +
+        testResultsToString(passed, 'Passed') +
+        testResultsToString(diffs, 'Unresolved') +
+        testResultsToString(failed, 'Failed') +
+        footer +
+        '\n\n');
+    function testResultsToString(testResultsArr, category) {
+        const { color, title, symbol } = formatByStatus[category];
+        const results = testResultsArr.reduce((acc, testResults) => {
+            if (!testResults.isEmpty) {
+                const error = hasError(testResults) ? stringifyError(testResults) : undefined;
+                acc.push(`${colorify(symbol, color)} ${colorify(error || stringifyTestResults(testResults))}`);
+            }
+            return acc;
+        }, []);
+        const coloredTitle = results.length ? colorify(title(results.length), color) : '';
+        return testResultsSection(coloredTitle, results);
+    }
+    function colorify(msg, color = 'reset') {
+        return isInteractive ? msg : `${colors[color]}${msg}${colors.reset}`;
+    }
+}
+exports.default = errorDigest;

package/dist/plugin/getErrorsAndDiffs.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getErrorsAndDiffs(testResultsArr) {
+    return testResultsArr.reduce(({ failed, diffs, passed }, testResults) => {
+        if (testResults instanceof Error || testResults.error) {
+            failed.push(testResults);
+        }
+        else {
+            const testStatus = testResults.status;
+            if (testStatus === 'Passed') {
+                passed.push(testResults);
+            }
+            else {
+                if (testStatus === 'Unresolved') {
+                    if (testResults.isNew) {
+                        testResults.error = new Error(`${testResults.name}. Please approve the new baseline at ${testResults.url}`);
+                        failed.push(testResults);
+                    }
+                    else {
+                        diffs.push(testResults);
+                    }
+                }
+                else if (testStatus === 'Failed') {
+                    failed.push(testResults);
+                }
+            }
+        }
+        return { failed, diffs, passed };
+    }, { failed: [], diffs: [], passed: [] });
+}
+exports.default = getErrorsAndDiffs;

package/dist/plugin/handleTestResults.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errorDigest_1 = __importDefault(require("./errorDigest"));
+const logger_1 = require("@applitools/logger");
+const getErrorsAndDiffs_1 = __importDefault(require("./getErrorsAndDiffs"));
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@applitools/core");
+const path_1 = require("path");
+function printTestResults(testResultsArr) {
+    const logger = (0, logger_1.makeLogger)({
+        level: testResultsArr.resultConfig.showLogs ? 'info' : 'silent',
+        label: 'eyes',
+    });
+    if (!testResultsArr.testResults)
+        return;
+    const { passed, failed, diffs } = (0, getErrorsAndDiffs_1.default)(testResultsArr.testResults);
+    if ((failed.length || diffs.length) && !!testResultsArr.resultConfig.eyesFailCypressOnDiff) {
+        throw new Error((0, errorDigest_1.default)({
+            passed,
+            failed,
+            diffs,
+            logger,
+            isInteractive: !testResultsArr.resultConfig.isTextTerminal,
+        }));
+    }
+}
+function handleBatchResultsFile(results, tapFileConfig) {
+    const fileName = tapFileConfig.tapFileName || `${new Date().toISOString()}-eyes.tap`;
+    const tapFile = (0, path_1.resolve)(tapFileConfig.tapDirPath, fileName);
+    return fs_1.default.writeFile(tapFile, core_1.formatters.toHierarchicTAPString(results, { includeSubTests: false, markNewAsPassed: true }), {}, (err) => {
+        if (err)
+            throw err;
+    });
+}
+exports.default = { printTestResults, handleBatchResultsFile };

package/dist/plugin/hooks.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const handleTestResults_1 = __importDefault(require("./handleTestResults"));
+function makeGlobalRunHooks({ closeManager, closeBatches, closeUniversalServer }) {
+    return {
+        'before:run': ({ config }) => {
+            if (!config.isTextTerminal)
+                return;
+        },
+        'after:run': async ({ config }) => {
+            try {
+                if (!config.isTextTerminal)
+                    return;
+                const summaries = await closeManager();
+                let testResults;
+                for (const summary of summaries) {
+                    testResults = summary.results.map(({ testResults }) => testResults);
+                }
+                if (!config.appliConfFile.dontCloseBatches) {
+                    await closeBatches({
+                        batchIds: [config.appliConfFile.batchId || config.appliConfFile.batch.id],
+                        serverUrl: config.appliConfFile.serverUrl,
+                        proxy: config.appliConfFile.proxy,
+                        apiKey: config.appliConfFile.apiKey,
+                    });
+                }
+                if (config.appliConfFile.tapDirPath) {
+                    await handleTestResults_1.default.handleBatchResultsFile(testResults, {
+                        tapDirPath: config.appliConfFile.tapDirPath,
+                        tapFileName: config.appliConfFile.tapFileName,
+                    });
+                }
+            }
+            finally {
+                await closeUniversalServer();
+            }
+        },
+    };
+}
+exports.default = makeGlobalRunHooks;

package/dist/plugin/index.js

@@ -0,0 +1,17 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginExport_1 = __importDefault(require("./pluginExport"));
+const config_1 = __importDefault(require("./config"));
+const server_1 = __importDefault(require("./server"));
+const logger_1 = require("@applitools/logger");
+const { config, eyesConfig } = (0, config_1.default)();
+const logger = (0, logger_1.makeLogger)({ level: config.showLogs ? 'info' : 'silent', label: 'eyes' });
+const startServer = (0, server_1.default)({ logger });
+const pluginExport = (0, pluginExport_1.default)({
+    startServer,
+    eyesConfig: Object.assign({}, eyesConfig, { appliConfFile: config }),
+});
+exports.default = pluginExport;

package/dist/plugin/isGlobalHooksSupported.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CYPRESS_SUPPORTED_VERSION = '6.2.0';
+const CYPRESS_NO_FLAG_VERSION = '6.7.0';
+function isGlobalHooksSupported(config) {
+    const { version, experimentalRunEvents } = config;
+    return (parseFloat(version) >= parseFloat(CYPRESS_NO_FLAG_VERSION) ||
+        (parseFloat(version) >= parseFloat(CYPRESS_SUPPORTED_VERSION) && !!experimentalRunEvents));
+}
+exports.default = isGlobalHooksSupported;

package/dist/plugin/pluginExport.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isGlobalHooksSupported_1 = __importDefault(require("./isGlobalHooksSupported"));
+const functional_commons_1 = require("@applitools/functional-commons");
+const hooks_1 = __importDefault(require("./hooks"));
+function makePluginExport({ startServer, eyesConfig }) {
+    return function pluginExport(pluginInitArgs) {
+        let eyesServer, pluginModuleExports, pluginExportsE2E, pluginExportsComponent;
+        let pluginExports;
+        if (pluginInitArgs.exports) {
+            const pluginAsNodeJSModule = pluginInitArgs;
+            pluginExports =
+                pluginAsNodeJSModule.exports && pluginAsNodeJSModule.exports.default
+                    ? pluginAsNodeJSModule.exports.default
+                    : pluginAsNodeJSModule.exports;
+            if (pluginExports.component) {
+                pluginExportsComponent = pluginExports.component.setupNodeEvents;
+            }
+            if (pluginExports.e2e) {
+                pluginExportsE2E = pluginExports.e2e.setupNodeEvents;
+            }
+            if (!pluginExports.e2e && !pluginExports.component) {
+                pluginModuleExports = pluginExports;
+            }
+            if (pluginExports === null || pluginExports === void 0 ? void 0 : pluginExports.component) {
+                pluginExports.component.setupNodeEvents = setupNodeEvents;
+            }
+            if (pluginExports === null || pluginExports === void 0 ? void 0 : pluginExports.e2e) {
+                pluginExports.e2e.setupNodeEvents = setupNodeEvents;
+            }
+            if (!pluginExports.component && !pluginExports.e2e) {
+                if (pluginAsNodeJSModule.exports.default) {
+                    pluginAsNodeJSModule.exports.default = setupNodeEvents;
+                }
+                else {
+                    pluginAsNodeJSModule.exports = setupNodeEvents;
+                }
+            }
+        }
+        else {
+            const pluginAsCypress10PluginOptions = pluginInitArgs;
+            if (pluginAsCypress10PluginOptions.component) {
+                pluginExportsComponent = pluginAsCypress10PluginOptions.component.setupNodeEvents;
+                pluginAsCypress10PluginOptions.component.setupNodeEvents = setupNodeEvents;
+            }
+            if (pluginAsCypress10PluginOptions.e2e) {
+                pluginExportsE2E = pluginAsCypress10PluginOptions.e2e.setupNodeEvents;
+                pluginAsCypress10PluginOptions.e2e.setupNodeEvents = setupNodeEvents;
+            }
+        }
+        if (!pluginInitArgs.exports) {
+            return pluginInitArgs;
+        }
+        return function getCloseServer() {
+            return eyesServer.close();
+        };
+        async function setupNodeEvents(origOn, cypressConfig) {
+            const { server, port, closeManager, closeBatches, closeUniversalServer } = await startServer();
+            eyesServer = server;
+            const globalHooks = (0, hooks_1.default)({
+                closeManager,
+                closeBatches,
+                closeUniversalServer,
+            });
+            if (!pluginModuleExports) {
+                pluginModuleExports = cypressConfig.testingType === 'e2e' ? pluginExportsE2E : pluginExportsComponent;
+            }
+            const isGlobalHookCalledFromUserHandlerMap = new Map();
+            eyesConfig.eyesIsGlobalHooksSupported = (0, isGlobalHooksSupported_1.default)(cypressConfig);
+            let moduleExportsResult = {};
+            if (typeof pluginModuleExports === 'function') {
+                moduleExportsResult = await pluginModuleExports(onThatCallsUserDefinedHandler, cypressConfig);
+            }
+            if (eyesConfig.eyesIsGlobalHooksSupported) {
+                for (const [eventName, eventHandler] of Object.entries(globalHooks)) {
+                    if (!isGlobalHookCalledFromUserHandlerMap.get(eventName)) {
+                        origOn.call(this, eventName, eventHandler);
+                    }
+                }
+            }
+            return Object.assign({}, eyesConfig, { eyesPort: port }, moduleExportsResult);
+            function onThatCallsUserDefinedHandler(eventName, handler) {
+                const isRunEvent = eventName === 'before:run' || eventName === 'after:run';
+                let handlerToCall = handler;
+                if (eyesConfig.eyesIsGlobalHooksSupported && isRunEvent) {
+                    handlerToCall = handlerThatCallsUserDefinedHandler;
+                    isGlobalHookCalledFromUserHandlerMap.set(eventName, true);
+                }
+                return origOn.call(this, eventName, handlerToCall);
+                async function handlerThatCallsUserDefinedHandler(...args) {
+                    const [err] = await (0, functional_commons_1.presult)(Promise.resolve(globalHooks[eventName].apply(this, args)));
+                    await handler.apply(this, args);
+                    if (err) {
+                        throw err;
+                    }
+                }
+            }
+        }
+    };
+}
+exports.default = makePluginExport;

package/dist/plugin/server.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webSocket_1 = __importDefault(require("./webSocket"));
+const eyes_universal_1 = require("@applitools/eyes-universal");
+const handleTestResults_1 = __importDefault(require("./handleTestResults"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const semver_1 = require("semver");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const which_1 = __importDefault(require("which"));
+const util_1 = require("util");
+function makeStartServer({ logger }) {
+    return async function startServer() {
+        const key = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../src/pem/server.key'));
+        const cert = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../src/pem/server.cert'));
+        const https = new https_1.Server({
+            key,
+            cert,
+        });
+        await (0, util_1.promisify)(https.listen.bind(https))();
+        const port = https.address().port;
+        const wss = new ws_1.Server({ server: https, path: '/eyes', maxPayload: 254 * 1024 * 1024 });
+        wss.on('close', () => https.close());
+        const forkOptions = {
+            detached: true,
+        };
+        const cypressVersion = require('cypress/package.json').version;
+        if ((0, semver_1.lt)(cypressVersion, '7.0.0')) {
+            forkOptions.execPath = await (0, which_1.default)('node');
+        }
+        const { port: universalPort, close: closeUniversalServer } = await (0, eyes_universal_1.makeServerProcess)({
+            idleTimeout: 0,
+            shutdownMode: 'stdin',
+            forkOptions,
+            singleton: false,
+            portResolutionMode: 'random',
+        });
+        const managers = [];
+        let socketWithUniversal;
+        wss.on('connection', socketWithClient => {
+            socketWithUniversal = (0, webSocket_1.default)(`ws://localhost:${universalPort}/eyes`);
+            socketWithUniversal.setPassthroughListener((message) => {
+                logger.log('<== ', message.toString().slice(0, 1000));
+                const { name, payload } = JSON.parse(message);
+                if (name === 'Core.makeManager') {
+                    managers.push({ manager: payload.result, socketWithUniversal });
+                }
+                socketWithClient.send(message.toString());
+            });
+            socketWithClient.on('message', (message) => {
+                const msg = JSON.parse(message);
+                logger.log('==> ', message.toString().slice(0, 1000));
+                if (msg.name === 'Core.makeSDK') {
+                    const newMessage = Buffer.from(JSON.stringify({
+                        name: msg.name,
+                        key: msg.key,
+                        payload: Object.assign(msg.payload, { cwd: process.cwd() }),
+                    }), 'utf-8');
+                    socketWithUniversal.send(newMessage);
+                }
+                else if (msg.name === 'Test.printTestResults') {
+                    try {
+                        if (msg.payload.resultConfig.tapDirPath && msg.payload.resultConfig.shouldCreateTapFile) {
+                            handleTestResults_1.default.handleBatchResultsFile(msg.payload.testResults, {
+                                tapFileName: msg.payload.resultConfig.tapFileName,
+                                tapDirPath: msg.payload.resultConfig.tapDirPath,
+                            });
+                        }
+                        handleTestResults_1.default.printTestResults({
+                            testResults: msg.payload.testResults,
+                            resultConfig: msg.payload.resultConfig,
+                        });
+                        socketWithClient.send(JSON.stringify({
+                            name: 'Test.printTestResults',
+                            key: msg.key,
+                            payload: { result: 'success' },
+                        }));
+                    }
+                    catch (ex) {
+                        socketWithClient.send(JSON.stringify({
+                            name: 'Test.printTestResults',
+                            key: msg.key,
+                            payload: { result: ex.message.toString() },
+                        }));
+                    }
+                }
+                else {
+                    socketWithUniversal.send(message);
+                }
+            });
+        });
+        return {
+            server: wss,
+            port,
+            closeManager,
+            closeBatches,
+            closeUniversalServer,
+        };
+        function closeManager() {
+            return Promise.all(managers.map(({ manager, socketWithUniversal }) => socketWithUniversal.request('EyesManager.closeManager', {
+                manager,
+                throwErr: false,
+            })));
+        }
+        function closeBatches(settings) {
+            if (socketWithUniversal)
+                return socketWithUniversal.request('Core.closeBatches', { settings }).catch((err) => {
+                    logger.log('@@@', err);
+                });
+        }
+    };
+}
+exports.default = makeStartServer;