@applitools/core-universal 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,66 @@
+# Changelog
+
+## [1.0.0](https://github.com/Applitools-Dev/sdk/compare/js/core-universal@0.0.0...js/core-universal@1.0.0) (2026-03-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* extract universal server from @applitools/core into new package
+
+### Features
+
+* extract universal server from @applitools/core into new package ([2a7257e](https://github.com/Applitools-Dev/sdk/commit/2a7257e638647ebcd7d1040d2785bc9cac458295))
+
+
+### Dependencies
+
+* @applitools/dom-snapshot bumped to 4.15.9
+  #### Bug Fixes
+
+  * expand CSS vars in CSSOM-injected style tags | FLD-4106 ([0821f9e](https://github.com/Applitools-Dev/sdk/commit/0821f9e7f6b20ec05387a8523dc0254bac22591b))
+* @applitools/image bumped to 1.2.7
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+* @applitools/screenshoter bumped to 3.12.14
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+
+* @applitools/nml-client bumped to 1.11.17
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+
+* @applitools/ufg-client bumped to 1.19.2
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+
+* @applitools/core-base bumped to 1.31.3
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+
+* @applitools/ec-client bumped to 1.12.19
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+
+* @applitools/core bumped to 4.56.3
+  #### Performance Improvements
+
+  * use sharp to accelerate png performance in all js packages ([#3547](https://github.com/Applitools-Dev/sdk/issues/3547)) ([6e3c7b9](https://github.com/Applitools-Dev/sdk/commit/6e3c7b9e34815f470032ece52a161001592ad1b1))
+
+
+

package/dist/cli/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+"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 });
+/* eslint no-console: off */
+const core_server_1 = require("../universal/core-server");
+const core_server_process_1 = require("../universal/core-server-process");
+const core_1 = require("@applitools/core");
+const { analyzeLogs, parseLogs, structureLogs } = core_1.logs;
+const yargs_1 = __importDefault(require("yargs"));
+const utils = __importStar(require("@applitools/utils"));
+const fs_1 = __importDefault(require("fs"));
+void yargs_1.default
+    .example([
+    ['eyes universal', 'Run Eyes Universal server on default port (21077)'],
+    ['eyes universal --fork', 'Run Eyes Universal server in a forked process'],
+    ['eyes universal --port 8080', 'Run Eyes Universal server on port 8080'],
+    ['eyes universal --no-singleton', 'Run Eyes Universal server on a non-singleton mode'],
+    ['eyes universal --shutdown-mode stdin', 'Run Eyes Universal server which will close once stdin stream will end'],
+    ['eyes check-network', ''],
+])
+    .version(JSON.parse(fs_1.default.readFileSync(require.resolve('../../package.json'), 'utf-8')).version)
+    .command({
+    command: 'universal',
+    builder: yargs => yargs.options({
+        port: {
+            description: 'run server on a specific port.',
+            type: 'number',
+            default: 21077,
+        },
+        singleton: {
+            description: 'runs server on a singleton mode. It will prevent the server to start in case the same server is already started.',
+            type: 'boolean',
+            default: true,
+        },
+        fork: {
+            description: 'runs server in a forked process.',
+            type: 'boolean',
+            default: false,
+        },
+        debug: {
+            description: 'runs server in a debug mode.',
+            type: 'boolean',
+            default: false,
+        },
+        'port-resolution-mode': {
+            describe: 'preferred algorithm to solve port collisions.\n"lazy" mode will not try find free port.\n"random" mode will run on a random port.\n"next" mode will run on next free port after the given one.',
+            alias: 'port-resolution',
+            type: 'string',
+            default: 'next',
+        },
+        'shutdown-mode': {
+            describe: 'preferred algorithm to automatically kill the process.\n"lazy" mode will end the process once the idle timeout ran out after the last client is disconnected from the server.\n"stdin" mode will end the process once its stdin stream got to its end.',
+            alias: 'shutdown',
+            type: 'string',
+            default: 'lazy',
+        },
+        'idle-timeout': {
+            description: 'time in minutes for server to stay responsible in case of idle.',
+            type: 'number',
+            default: 15,
+            coerce: value => value * 60 * 1000,
+        },
+        cert: {
+            description: 'path to the certificate file.',
+            alias: 'cert-path',
+            type: 'string',
+            implies: 'key',
+        },
+        key: {
+            description: 'path to the key file.',
+            alias: 'key-path',
+            type: 'string',
+            implies: 'cert',
+        },
+        config: {
+            description: 'json string to use instead of cli arguments',
+            type: 'string',
+            coerce: JSON.parse,
+        },
+        maskLog: {
+            description: 'mask sensitive information in the log',
+            type: 'boolean',
+            default: false,
+        },
+    }),
+    handler: async (args) => {
+        if (args.fork) {
+            const { port } = await (0, core_server_process_1.makeCoreServerProcess)({ ...args, fork: false, isProcess: true });
+            // eslint-disable-next-line no-console
+            console.log(port); // NOTE: this is a part of the generic protocol
+        }
+        else {
+            void (0, core_server_1.makeCoreServer)({ ...args, ...args.config, isProcess: true });
+        }
+    },
+})
+    .command({
+    command: 'logs [input]',
+    builder: yargs => yargs.options({
+        input: {
+            description: 'log input to process',
+            type: 'string',
+        },
+        structure: {
+            description: 'group logs by tag names',
+            type: 'boolean',
+        },
+        analyze: {
+            description: 'group logs by tag names',
+            type: 'boolean',
+        },
+    }),
+    handler: async (args) => {
+        var _a;
+        const input = (_a = args.input) !== null && _a !== void 0 ? _a : (await utils.streams.toBuffer(process.stdin)).toString('utf8');
+        const logs = parseLogs(input);
+        if (args.analyze) {
+            console.log(JSON.stringify(analyzeLogs(structureLogs(logs)), null, 2));
+        }
+        else if (args.structure) {
+            console.log(JSON.stringify(structureLogs(logs), null, 2));
+        }
+        else {
+            console.log(JSON.stringify(logs, null, 2));
+        }
+    },
+})
+    .command({
+    command: 'check-network',
+    handler: async () => {
+        await (0, core_1.checkNetwork)();
+    },
+})
+    .wrap(yargs_1.default.terminalWidth()).argv;

package/dist/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./universal/core-server"), exports);
+__exportStar(require("./universal/core-server-process"), exports);

package/dist/universal/core-server-process.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCoreServerProcess = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+function makeCoreServerProcess(options) {
+    return new Promise((resolve, reject) => {
+        const server = (0, child_process_1.fork)(path_1.default.resolve(__dirname, '../../dist/cli/cli.js'), ['universal', `--config=${JSON.stringify(options)}`], {
+            stdio: [options.shutdownMode === 'stdin' ? 'inherit' : 'ignore', 'ignore', 'ignore', 'ipc'],
+            ...options.forkOptions,
+        });
+        const timeout = setTimeout(() => {
+            reject(new Error(`Server didn't respond for 10s after being started`));
+            server.kill();
+        }, 60000);
+        server.on('error', reject);
+        server.once('message', ({ name, payload }) => {
+            var _a;
+            if (name === 'port') {
+                resolve({ port: payload.port, close: () => server.kill() });
+                clearTimeout(timeout);
+                (_a = server.channel) === null || _a === void 0 ? void 0 : _a.unref();
+            }
+        });
+        server.unref();
+    });
+}
+exports.makeCoreServerProcess = makeCoreServerProcess;

package/dist/universal/core-server.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCoreServer = void 0;
+const socket_1 = require("@applitools/socket");
+const spec_driver_webdriver_1 = __importDefault(require("@applitools/spec-driver-webdriver"));
+const spec_driver_1 = require("./spec-driver");
+const ws_server_1 = require("./ws-server");
+const logger_1 = require("@applitools/logger");
+const core_1 = require("@applitools/core");
+const refer_1 = require("./refer");
+const history_1 = require("./history");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+async function makeCoreServer({ environment: defaultEnvironment, agentIdPrefix = `eyes-universal/${require('../../package.json').version}`, debug = false, shutdownMode = 'lazy', idleTimeout = 900000, // 15min
+printStdout = false, isProcess = false, maskLog = false, logger = undefined, ...handlerOptions } = {}) {
+    var _a, _b;
+    const logDirname = (_a = process.env.APPLITOOLS_LOG_DIR) !== null && _a !== void 0 ? _a : path_1.default.resolve(os_1.default.tmpdir(), `applitools-logs`);
+    const baseLogger = logger !== null && logger !== void 0 ? logger : (0, logger_1.makeLogger)({
+        handler: { type: 'rolling file', name: 'universal', dirname: logDirname },
+        level: 'info',
+        format: { label: 'core-universal', colors: false },
+        maskLog,
+    });
+    baseLogger.log('Core universal is going to be initialized with options', {
+        debug,
+        shutdownMode,
+        idleTimeout,
+        printStdout,
+        defaultEnvironment,
+        ...handlerOptions,
+    });
+    const { server, port } = await (0, ws_server_1.makeServer)({ ...handlerOptions, debug }, baseLogger);
+    if (isProcess) {
+        // eslint-disable-next-line no-console
+        console.log(port.toString()); // NOTE: this is a part of the generic protocol
+        (_b = process.send) === null || _b === void 0 ? void 0 : _b.call(process, { name: 'port', payload: { port } }); // NOTE: this is a part of the js specific protocol
+    }
+    if (!server) {
+        baseLogger.console.log(`You are trying to spawn a duplicated server, use the server on port ${port} instead`);
+        return { port };
+    }
+    if (!printStdout)
+        process.stdout.write = () => true; // NOTE: prevent any write to stdout
+    baseLogger.log('Core universal is started on port', port);
+    let idle;
+    let serverClosed = false;
+    if (shutdownMode === 'stdin') {
+        process.stdin.resume();
+        process.stdin.on('end', () => {
+            server.close();
+        });
+    }
+    else if (shutdownMode === 'lazy') {
+        if (idleTimeout) {
+            idle = setTimeout(() => server.close(), idleTimeout);
+        }
+    }
+    server.on('close', () => {
+        clearTimeout(idle);
+        serverClosed = true;
+    });
+    server.on('connection', async (client) => {
+        const refer = (0, refer_1.makeRefer)();
+        const socket = (0, socket_1.makeSocket)(client, {
+            transport: 'ws',
+            logger: baseLogger,
+        });
+        const getHistory = debug ? (0, history_1.withHistory)(socket) : () => null;
+        if (shutdownMode === 'lazy' && idleTimeout) {
+            clearTimeout(idle);
+            socket.on('close', () => {
+                if (server.clients.size > 0 || serverClosed)
+                    return;
+                idle = setTimeout(() => server.close(), idleTimeout);
+            });
+        }
+        const logger = baseLogger.extend({
+            console: {
+                log: (message) => socket.emit('Logger.log', { level: 'info', message }),
+                warn: (message) => socket.emit('Logger.log', { level: 'warn', message }),
+                error: (message) => socket.emit('Logger.log', { level: 'error', message }),
+                fatal: (message) => socket.emit('Logger.log', { level: 'fatal', message }),
+            },
+            maskLog,
+        });
+        logger.console.log(`Logs saved in: ${logDirname}`);
+        const corePromise = socket.wait('Core.makeCore', ({ spec, agentId, environment, cwd }) => {
+            return (0, core_1.makeCore)({
+                spec: spec === 'webdriver' ? spec_driver_webdriver_1.default : (0, spec_driver_1.makeSpec)({ socket, spec }),
+                agentId: `${agentIdPrefix}/${agentId}`,
+                cwd,
+                environment: {
+                    ...defaultEnvironment,
+                    ...environment,
+                    versions: { ...defaultEnvironment === null || defaultEnvironment === void 0 ? void 0 : defaultEnvironment.versions, ...environment === null || environment === void 0 ? void 0 : environment.versions },
+                    universal: true,
+                },
+                logger,
+                maskLog,
+            });
+        });
+        socket.command('Core.getAccountInfo', async (options) => {
+            const core = await corePromise;
+            return core.getAccountInfo(options);
+        });
+        socket.command('Core.getViewportSize', async (options) => {
+            var _a;
+            const core = await corePromise;
+            return (_a = core.getViewportSize) === null || _a === void 0 ? void 0 : _a.call(core, options);
+        });
+        socket.command('Core.setViewportSize', async (options) => {
+            var _a;
+            const core = await corePromise;
+            return (_a = core.setViewportSize) === null || _a === void 0 ? void 0 : _a.call(core, options);
+        });
+        socket.command('Core.closeBatch', async (options) => {
+            const core = await corePromise;
+            return core.closeBatch(options);
+        });
+        socket.command('Core.deleteTest', async (options) => {
+            const core = await corePromise;
+            return core.deleteTest(options);
+        });
+        socket.command('Core.logEvent', async ({ settings }) => {
+            const core = await corePromise;
+            return core.logEvent({ settings });
+        });
+        socket.command('Core.locate', async (options) => {
+            const core = await corePromise;
+            return core.locate(options);
+        });
+        socket.command('Core.locateText', async (options) => {
+            const core = await corePromise;
+            return core.locateText(options);
+        });
+        socket.command('Core.extractText', async (options) => {
+            const core = await corePromise;
+            return core.extractText(options);
+        });
+        socket.command('Core.getECClient', async (options) => {
+            const core = await corePromise;
+            const client = await core.getECClient(options);
+            return { url: client.url };
+        });
+        socket.command('Core.makeManager', async (options) => {
+            var _a;
+            const core = await corePromise;
+            if ((_a = options.settings) === null || _a === void 0 ? void 0 : _a.agentId) {
+                options.settings.agentId = `${agentIdPrefix}/${options.settings.agentId}`;
+            }
+            return refer.ref(await core.makeManager(options));
+        });
+        socket.command('EyesManager.openEyes', async ({ manager, ...options }) => {
+            var _a;
+            const eyes = await ((_a = refer.deref(manager)) === null || _a === void 0 ? void 0 : _a.openEyes(options));
+            const eyesRef = refer.ref(eyes, manager);
+            return eyesRef;
+        });
+        socket.command('EyesManager.getResults', async ({ manager, ...options }) => {
+            var _a;
+            return (_a = refer.deref(manager)) === null || _a === void 0 ? void 0 : _a.getResults(options);
+        });
+        socket.command('Eyes.check', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.check(options);
+        });
+        socket.command('Eyes.checkAndClose', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.checkAndClose(options);
+        });
+        socket.command('Eyes.close', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.close(options);
+        });
+        socket.command('Eyes.abort', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.abort(options);
+        });
+        socket.command('Eyes.getResults', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.getResults(options);
+        });
+        socket.command('Debug.getHistory', async () => {
+            return {
+                ...getHistory(),
+                initialArgs: {
+                    environment: defaultEnvironment,
+                    agentIdPrefix,
+                    debug,
+                    shutdownMode,
+                    idleTimeout,
+                    printStdout,
+                    isProcess,
+                    maskLog,
+                    ...handlerOptions,
+                },
+            };
+        });
+    });
+    process.on('unhandledRejection', error => {
+        baseLogger.error('Unhandled promise rejection', error);
+        /* eslint-disable-next-line no-console */
+        console.error('Unhandled promise rejection', error);
+    });
+    process.on('uncaughtException', error => {
+        baseLogger.error('Uncaught error terminating the process', error);
+        /* eslint-disable-next-line no-console */
+        console.error('Uncaught error terminating the process', error);
+        process.exit(1);
+    });
+    return { port, close: () => server.close() };
+}
+exports.makeCoreServer = makeCoreServer;

package/dist/universal/history.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHistory = void 0;
+//TODO Design a better history tracker
+function withHistory(socket) {
+    const history = {
+        managers: new Map(),
+        eyes: new Map(),
+        startedAt: new Date().toISOString(),
+        unknownEvents: [],
+    };
+    const originalCommand = socket.command;
+    socket.command = function command(name, fn) {
+        return originalCommand(name, async (payload) => {
+            let result, error;
+            try {
+                result = await fn(payload);
+                return result;
+            }
+            catch (err) {
+                error = err;
+                throw error;
+            }
+            finally {
+                if (name === 'Core.makeManager') {
+                    const managerRef = result;
+                    history.managers.set(extractRefId(managerRef), { ...payload, manager: result, eyes: [] });
+                }
+                else if (name.startsWith('EyesManager.')) {
+                    const managerRef = payload.manager;
+                    const managerHistory = history.managers.get(extractRefId(managerRef));
+                    if (managerHistory) {
+                        if (name === 'EyesManager.openEyes') {
+                            if (error) {
+                                managerHistory.eyes.push({ ...payload, error });
+                            }
+                            else {
+                                const eyesRef = result;
+                                managerHistory.eyes.push(eyesRef);
+                                history.eyes.set(extractRefId(eyesRef), { ...payload, eyes: eyesRef, commands: [] });
+                            }
+                        }
+                    }
+                }
+                else if (name.startsWith('Eyes.')) {
+                    const eyesRef = payload.eyes;
+                    const eyesHistory = history.eyes.get(extractRefId(eyesRef));
+                    if (eyesHistory) {
+                        if (name === 'Eyes.check') {
+                            const command = { name, ...payload };
+                            if (error)
+                                command.error = error;
+                            else
+                                command.result = result;
+                            eyesHistory.commands.push(command);
+                        }
+                        else if (name === 'Eyes.close') {
+                            eyesHistory.closed = true;
+                        }
+                        else if (name === 'Eyes.abort') {
+                            eyesHistory.aborted = true;
+                        }
+                        else if (name === 'Eyes.getResults') {
+                            eyesHistory.result = error !== null && error !== void 0 ? error : result;
+                        }
+                    }
+                }
+                else {
+                    history.unknownEvents.push({ name, payload });
+                }
+            }
+        });
+    };
+    return function getHistory() {
+        return {
+            managers: Array.from(history.managers.values(), managerMeta => ({
+                ...managerMeta,
+                eyes: managerMeta.eyes.map(eyesRefOrError => {
+                    return eyesRefOrError instanceof Error ? eyesRefOrError : history.eyes.get(extractRefId(eyesRefOrError));
+                }),
+            })),
+            startedAt: history.startedAt,
+            requestedAt: new Date().toISOString(),
+        };
+    };
+    function extractRefId(ref) {
+        return ref['applitools-ref-id'];
+    }
+}
+exports.withHistory = withHistory;

package/dist/universal/refer.js

@@ -0,0 +1,67 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRefer = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const REF_ID = 'applitools-ref-id';
+function makeRefer() {
+    const store = new Map();
+    const relation = new Map();
+    return { isRef, ref, deref, destroy };
+    function isRef(ref) {
+        return Boolean(ref[REF_ID]);
+    }
+    function ref(value, parentRef) {
+        const ref = utils.general.guid();
+        store.set(ref, value);
+        if (parentRef) {
+            let childRefs = relation.get(parentRef[REF_ID]);
+            if (!childRefs) {
+                childRefs = new Set();
+                relation.set(parentRef[REF_ID], childRefs);
+            }
+            childRefs.add({ [REF_ID]: ref });
+        }
+        return { [REF_ID]: ref };
+    }
+    function deref(ref) {
+        if (isRef(ref)) {
+            return store.get(ref[REF_ID]);
+        }
+        else {
+            return ref;
+        }
+    }
+    function destroy(ref) {
+        if (!isRef(ref))
+            return;
+        const childRefs = relation.get(ref[REF_ID]);
+        if (childRefs) {
+            childRefs.forEach(childRef => destroy(childRef));
+        }
+        store.delete(ref[REF_ID]);
+    }
+}
+exports.makeRefer = makeRefer;

package/dist/universal/spec-driver.js

@@ -0,0 +1,189 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpec = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeSpec({ socket, spec, }) {
+    const commands = {
+        isDriver(driver) {
+            return utils.types.has(driver, 'applitools-ref-id');
+        },
+        isContext(context) {
+            return utils.types.has(context, 'applitools-ref-id');
+        },
+        isElement(element) {
+            return utils.types.has(element, ['applitools-ref-id', 'type']) && element.type === 'element';
+        },
+        isSelector(selector) {
+            return ((utils.types.has(selector, ['applitools-ref-id', 'type']) && selector.type === 'selector') ||
+                utils.types.isString(selector) ||
+                (utils.types.isPlainObject(selector) &&
+                    utils.types.has(selector, 'selector') &&
+                    (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
+        },
+        async isEqualElements(context, element1, element2) {
+            return socket.request('Driver.isEqualElements', { context, element1, element2 });
+        },
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
+        },
+        extractContext(driver) {
+            return driver.context;
+        },
+        extractSelector(element) {
+            return element.selector;
+        },
+        async executeScript(context, script, arg) {
+            return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
+        },
+        async findElement(context, selector, parent) {
+            return socket.request('Driver.findElement', { context, selector, parent });
+        },
+        async findElements(context, selector, parent) {
+            return socket.request('Driver.findElements', { context, selector, parent });
+        },
+        async waitForSelector(context, selector, parent, options) {
+            return socket.request('Driver.waitForSelector', { context, selector, parent, options });
+        },
+        async getElementText(context, element) {
+            return socket.request('Driver.getElementText', { context, element });
+        },
+        async setElementText(context, element, text) {
+            return socket.request('Driver.setElementText', { context, element, text });
+        },
+        async getElementRegion(context, element) {
+            return socket.request('Driver.getElementRegion', { context, element });
+        },
+        async getElementAttribute(context, element, attr) {
+            return socket.request('Driver.getElementAttribute', { context, element, attr });
+        },
+        async hover(context, element) {
+            return socket.request('Driver.hover', { context, element });
+        },
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
+        },
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
+        },
+        async getCapabilities(driver) {
+            return socket.request('Driver.getCapabilities', { driver });
+        },
+        async getDriverInfo(driver) {
+            return socket.request('Driver.getDriverInfo', { driver });
+        },
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
+        },
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
+        },
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
+        },
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
+        },
+        async getSystemBars(driver) {
+            return socket.request('Driver.getSystemBars', { driver });
+        },
+        async getOrientation(driver) {
+            return socket.request('Driver.getOrientation', { driver });
+        },
+        async setOrientation(driver, orientation) {
+            return socket.request('Driver.setOrientation', { driver, orientation });
+        },
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
+        },
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
+        },
+        async performAction(driver, steps) {
+            return socket.request('Driver.performAction', { driver, steps });
+        },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
+        async getCurrentWorld(driver) {
+            return socket.request('Driver.getCurrentWorld', { driver });
+        },
+        async getWorlds(driver) {
+            return socket.request('Driver.getWorlds', { driver });
+        },
+        async switchWorld(driver, name) {
+            return socket.request('Driver.switchWorld', { driver, name });
+        },
+        async reload(driver) {
+            return socket.request('Driver.reload', { driver });
+        },
+        async isUserFunction(ref) {
+            return utils.types.has(ref, 'applitools-ref-id');
+        },
+        async executeUserFunction(userFunction) {
+            return socket.request('Driver.executeUserFunction', userFunction);
+        },
+        async executeBrowserCommands(driver, commands) {
+            return socket.request('Driver.executeBrowserCommands', { driver, commands });
+        },
+        async bringToFront(driver) {
+            return socket.request('Driver.bringToFront', { driver });
+        },
+    };
+    // add default commands to spec (if not already there) such as `isUserFunction`
+    spec = addDefaultCommands(spec);
+    return spec.reduce((spec, name) => {
+        return Object.assign(spec, { [name]: commands[name] });
+    }, {});
+}
+exports.makeSpec = makeSpec;
+// returns a new clone of the spec commands array with additional commands universal can support even if the spec doesn't
+function addDefaultCommands(spec) {
+    const defaultCommands = [
+        {
+            command: 'isUserFunction',
+            dependsOn: ['executeUserFunction'],
+        },
+    ];
+    const commands = spec.slice();
+    defaultCommands.forEach(({ command, dependsOn }) => {
+        if (!commands.includes(command) && dependsOn.every(dep => commands.includes(dep))) {
+            commands.push(command);
+        }
+    });
+    return commands;
+}

package/dist/universal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/universal/ws-server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeServer = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const { name, version } = require('../../package.json');
+const TOKEN_HEADER = 'x-eyes-universal-token';
+const TOKEN = `${name}@${version}`;
+async function makeServer(options = {}, logger) {
+    const { port = 21077, singleton = true, debug = false, portResolutionMode = 'next', cert, key } = options;
+    const secure = Boolean(cert && key);
+    const http = secure ? new https_1.Server({ cert, key }) : new http_1.Server();
+    http.on('request', (request, response) => {
+        if (request.url === '/handshake') {
+            const token = debug ? request.headers[TOKEN_HEADER] : TOKEN;
+            if (request.headers[TOKEN_HEADER] === token) {
+                response.writeHead(200, { [TOKEN_HEADER]: token });
+            }
+            else {
+                response.writeHead(400);
+            }
+            response.end();
+        }
+    });
+    const hostName = process.env.APPLITOOLS_UNIVERSAL_HOST_NAME || 'localhost';
+    http.listen(port, hostName);
+    return new Promise((resolve, reject) => {
+        http.on('listening', () => {
+            const ws = new ws_1.Server({ server: http, path: '/eyes', maxPayload: 256 * 1024 * 1024 });
+            ws.on('close', () => {
+                logger.log('Core universal server is closed');
+                http.close();
+            });
+            ws.on('error', err => {
+                logger.log('Core universal server error', err);
+            });
+            resolve({ server: ws, port: http.address().port });
+        });
+        http.on('error', async (err) => {
+            if (portResolutionMode !== 'lazy' && err.code === 'EADDRINUSE') {
+                if (singleton && (await isHandshakable({ port, secure }))) {
+                    return resolve({ port });
+                }
+                else {
+                    return resolve(await makeServer({ ...options, port: portResolutionMode === 'next' ? port + 1 : 0 }, logger));
+                }
+            }
+            reject(err);
+        });
+    });
+}
+exports.makeServer = makeServer;
+async function isHandshakable({ port, secure }) {
+    const request = secure ? https_1.request : http_1.request;
+    return new Promise(resolve => {
+        const handshake = request(`${secure ? 'https' : 'http'}://localhost:${port}/handshake`, {
+            headers: { [TOKEN_HEADER]: TOKEN },
+        });
+        handshake.on('response', ({ statusCode, headers }) => {
+            resolve(statusCode === 200 && headers[TOKEN_HEADER] === TOKEN);
+        });
+        handshake.on('error', () => resolve(false));
+        handshake.end();
+    });
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@applitools/core-universal",
+  "version": "1.0.0",
+  "homepage": "https://applitools.com",
+  "bugs": {
+    "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/applitools/eyes.sdk.javascript1.git",
+    "directory": "js/packages/core-universal"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Applitools Team",
+    "email": "team@applitools.com"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "bin": "./dist/cli/cli.js",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "lint": "run --top-level eslint '**/*.ts'",
+    "build": "yarn build:dist",
+    "build:dist": "run --top-level tsc --project ./tsconfig.build.json",
+    "build:bin": "bash ../../../scripts/build-binary-local.sh core-universal",
+    "setup": "run --top-level browsers:setup && run --top-level xvfb:setup",
+    "test:e2e": "run --top-level mocha './test/e2e/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
+    "test:bin": "MOCHA_GROUP=bin run --top-level mocha './test/bin/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --require ./test/mocha-global-setup.js"
+  },
+  "dependencies": {
+    "@applitools/core": "4.56.3",
+    "@applitools/driver": "1.25.1",
+    "@applitools/logger": "2.2.8",
+    "@applitools/socket": "1.3.9",
+    "@applitools/spec-driver-webdriver": "1.5.6",
+    "@applitools/utils": "1.14.1",
+    "@types/ws": "8.5.5",
+    "chalk": "4.1.2",
+    "webdriver": "7.31.1",
+    "ws": "8.17.1",
+    "yargs": "17.7.2"
+  },
+  "devDependencies": {
+    "@applitools/bongo": "^5.10.0",
+    "@applitools/test-server": "^1.4.0",
+    "@applitools/test-utils": "^1.5.17",
+    "@types/mocha": "^10.0.7",
+    "@types/node": "^12.20.55",
+    "@types/yargs": "^17.0.22"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "lavamoat": {
+    "allowScripts": {
+      "ws>bufferutil": false,
+      "ws>utf-8-validate": false,
+      "@applitools/core>@applitools/core-base>@applitools/image>sharp": false
+    }
+  }
+}

package/types/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './universal/core-server';
+export * from './universal/core-server-process';

package/types/universal/core-server-process.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { type Options } from './core-server';
+import { type ForkOptions } from 'child_process';
+export declare function makeCoreServerProcess(options: Options & {
+    forkOptions?: ForkOptions;
+}): Promise<{
+    port: number;
+    close: () => void;
+}>;

package/types/universal/core-server.d.ts

@@ -0,0 +1,18 @@
+import { type ServerOptions } from './ws-server';
+import { type Logger } from '@applitools/logger';
+export type Options = ServerOptions & {
+    environment?: Record<string, any>;
+    agentIdPrefix?: string;
+    debug?: boolean;
+    shutdownMode?: 'lazy' | 'stdin';
+    idleTimeout?: number;
+    printStdout?: boolean;
+    isProcess?: boolean;
+    maskLog?: boolean;
+    logger?: Logger;
+};
+export declare function makeCoreServer({ environment: defaultEnvironment, agentIdPrefix, debug, shutdownMode, idleTimeout, // 15min
+printStdout, isProcess, maskLog, logger, ...handlerOptions }?: Options): Promise<{
+    port: number;
+    close?: () => void;
+}>;

package/types/universal/history.d.ts

@@ -0,0 +1,2 @@
+import { type Socket } from '@applitools/socket';
+export declare function withHistory<TSocket extends Socket>(socket: TSocket): () => Record<string, any>;

package/types/universal/refer.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from './types';
+export interface Refer {
+    isRef<TValue = any>(ref: any): ref is Ref<TValue>;
+    ref<TValue>(value: TValue, parentRef?: Ref<unknown>): Ref<TValue>;
+    deref<TValue>(ref: Ref<TValue>): TValue;
+    destroy(ref: Ref<any>): void;
+}
+export declare function makeRefer(): Refer;

package/types/universal/spec-driver.d.ts

@@ -0,0 +1,15 @@
+import type { Ref, ServerSocket, UniversalSpecDriver } from './types';
+import type { SpecType, SpecDriver as BaseSpecDriver, CommonSelector } from '@applitools/driver';
+export type Driver = Ref;
+export type Context = Ref;
+export type Element = Ref;
+export type Selector = string | CommonSelector | Ref;
+export type UserFunction = Ref;
+export type PrimarySpecType = SpecType<Driver, Context, Element, Selector, never, UserFunction>;
+export type SpecDriver = BaseSpecDriver<PrimarySpecType>;
+type CommandName = keyof UniversalSpecDriver<PrimarySpecType>;
+export declare function makeSpec({ socket, spec, }: {
+    socket: ServerSocket<PrimarySpecType, any>;
+    spec: CommandName[];
+}): SpecDriver;
+export {};

package/types/universal/types.d.ts

@@ -0,0 +1,205 @@
+import type { Size, Region } from '@applitools/utils';
+import type { Emitter, Listener, Client, Server } from '@applitools/socket';
+import type { SpecType, DriverInfo, Cookie, WaitOptions } from '@applitools/driver';
+import type * as MainCore from '@applitools/core';
+/**
+ * Wraps the type with a ref if it vas to be refed
+ */
+type Refify<TValue> = TValue extends string | number | boolean | null | undefined ? TValue : TValue extends Array<infer TItem> ? Refify<TItem>[] : Extract<TValue[keyof TValue], (...args: any) => any> extends never ? TValue : Ref<TValue>;
+/**
+ * Creates universalized object out of an ordinary interface:
+ * - Filters out properties that are not of async function type
+ * - Adds domain to the method names (`Domain.methodName`)
+ * - Keep only first (`options`) argument of the methods
+ * - Introduces additional option to the methods with a ref of the current instance
+ * - Refifies return values of the methods
+ */
+type Universalize<TTarget extends Record<string, any>, TDomain extends string, TRefKey extends string = never> = {
+    [TKey in keyof TTarget as NonNullable<TTarget[TKey]> extends (...args: any[]) => Promise<any> ? `${TDomain}.${TKey & string}` : never]: NonNullable<TTarget[TKey]> extends (options: infer TOptions) => Promise<infer TResult> ? (options: TOptions & {
+        [TKey in TRefKey]: Ref<TTarget>;
+    }) => Promise<Refify<TResult>> : never;
+};
+export type Ref<TValue = never> = {
+    'applitools-ref-id': string;
+    type?: string;
+};
+export type ClientSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Emitter<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Client<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Client<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Server<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
+export type ServerSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Listener<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Emitter<Universalize<UniversalLogger, 'Logger'>> & Server<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Server<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Server<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Server<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Client<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
+export interface UniversalCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'> {
+    makeCore(options: {
+        spec: 'webdriver' | (keyof UniversalSpecDriver<TSpec>)[];
+        agentId: string;
+        environment?: Record<string, any>;
+        cwd: string;
+    }): Promise<MainCore.Core<TSpec, TType>>;
+}
+export interface UniversalLogger {
+    log(options: {
+        level: string;
+        message: string;
+    }): Promise<void>;
+}
+export interface UniversalDebug<TSpec extends SpecType> {
+    getHistory(): Promise<any>;
+    checkSpecDriver(options: {
+        driver: TSpec['driver'];
+        commands: (keyof UniversalSpecDriver<TSpec>)[];
+    }): Promise<any>;
+}
+/**
+ * Ideally would be transform SpecDriver type to the type with single object argument
+ * but typescript doesn't have a possibility to convert named tuples to object types at the moment
+ */
+export interface UniversalSpecDriver<T extends SpecType> {
+    isEqualElements(options: {
+        context: T['context'];
+        element1: T['element'];
+        element2: T['element'];
+    }): Promise<boolean>;
+    executeScript(options: {
+        context: T['context'];
+        script: string;
+        arg?: any;
+    }): Promise<any>;
+    findElement(options: {
+        context: T['context'];
+        selector: T['selector'];
+        parent?: T['element'];
+    }): Promise<T['element'] | null>;
+    findElements(options: {
+        context: T['context'];
+        selector: T['selector'];
+        parent?: T['element'];
+    }): Promise<T['element'][]>;
+    waitForSelector(options: {
+        context: T['context'];
+        selector: T['selector'];
+        parent?: T['element'];
+        options?: WaitOptions;
+    }): Promise<T['element'] | null>;
+    getElementRegion(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<Region>;
+    getElementAttribute(options: {
+        context: T['context'];
+        element: T['element'];
+        attr: string;
+    }): Promise<string>;
+    setElementText(options: {
+        context: T['context'];
+        element: T['element'];
+        text: string;
+    }): Promise<void>;
+    getElementText(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<string>;
+    hover(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    click(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    mainContext(options: {
+        context: T['context'];
+    }): Promise<T['context']>;
+    parentContext(options: {
+        context: T['context'];
+    }): Promise<T['context']>;
+    childContext(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<T['context']>;
+    getDriverInfo(options: {
+        driver: T['driver'];
+    }): Promise<DriverInfo>;
+    getCapabilities(options: {
+        driver: T['driver'];
+    }): Promise<Record<string, any>>;
+    setWindowSize(options: {
+        driver: T['driver'];
+        size: Size;
+    }): Promise<void>;
+    getWindowSize(options: {
+        driver: T['driver'];
+    }): Promise<Size>;
+    setViewportSize(options: {
+        driver: T['driver'];
+        size: Size;
+    }): Promise<void>;
+    getViewportSize(options: {
+        driver: T['driver'];
+    }): Promise<Size>;
+    getSystemBars(options: {
+        driver: T['driver'];
+    }): Promise<{
+        statusBar: {
+            visible: boolean;
+            x: number;
+            y: number;
+            height: number;
+            width: number;
+        };
+        navigationBar: {
+            visible: boolean;
+            x: number;
+            y: number;
+            height: number;
+            width: number;
+        };
+    }>;
+    getOrientation(options: {
+        driver: T['driver'];
+    }): Promise<'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary'>;
+    setOrientation(options: {
+        driver: T['driver'];
+        orientation: 'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary';
+    }): Promise<void>;
+    getCookies(options: {
+        driver: T['driver'] | T['context'];
+        context?: boolean;
+    }): Promise<Cookie[]>;
+    getTitle(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    getUrl(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    takeScreenshot(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    performAction(options: {
+        driver: T['driver'];
+        steps: any[];
+    }): Promise<void>;
+    visit(options: {
+        driver: T['driver'];
+        url: string;
+    }): Promise<void>;
+    getCurrentWorld(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    getWorlds(options: {
+        driver: T['driver'];
+    }): Promise<string[]>;
+    switchWorld(options: {
+        driver: T['driver'];
+        name: string;
+    }): Promise<void>;
+    reload(options: {
+        driver: T['driver'];
+    }): Promise<void>;
+    isUserFunction(ref: any): Promise<boolean>;
+    executeUserFunction(userFunction: Ref): Promise<any>;
+    executeBrowserCommands(options: {
+        driver?: T['driver'];
+        commands: any[];
+    }): Promise<any>;
+    bringToFront(options: {
+        driver: T['driver'];
+    }): Promise<void>;
+}
+export {};

package/types/universal/ws-server.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Server as WsServer } from 'ws';
+import { Logger } from '@applitools/logger';
+export type ServerOptions = {
+    port?: number;
+    singleton?: boolean;
+    portResolutionMode?: 'next' | 'random' | 'lazy';
+    debug?: boolean;
+    key?: string | Buffer;
+    cert?: string | Buffer;
+};
+export declare function makeServer(options: ServerOptions | undefined, logger: Logger): Promise<{
+    server?: WsServer;
+    port: number;
+}>;