@applitools/eyes-cypress 3.28.2 → 3.29.0

package/src/plugin/{handleTestResults.js → handleTestResults.ts}

@@ -1,13 +1,11 @@
-const errorDigest = require('./errorDigest')
-const {makeLogger} = require('@applitools/logger')
-const getErrorsAndDiffs = require('./getErrorsAndDiffs')
-const {promisify} = require('util')
-const fs = require('fs')
-const writeFile = promisify(fs.writeFile)
-const {formatters} = require('@applitools/core')
-const {resolve} = require('path')
+import errorDigest from './errorDigest'
+import {makeLogger} from '@applitools/logger'
+import getErrorsAndDiffs from './getErrorsAndDiffs'
+import fs from 'fs'
+import {formatters} from '@applitools/core'
+import {resolve} from 'path'
 
-function printTestResults(testResultsArr) {
+function printTestResults(testResultsArr: any) {
   const logger = makeLogger({
     level: testResultsArr.resultConfig.showLogs ? 'info' : 'silent',
     label: 'eyes',
@@ -26,10 +24,17 @@ function printTestResults(testResultsArr) {
     )
   }
 }
-function handleBatchResultsFile(results, tapFileConfig) {
+function handleBatchResultsFile(results: any, tapFileConfig: any) {
   const fileName = tapFileConfig.tapFileName || `${new Date().toISOString()}-eyes.tap`
   const tapFile = resolve(tapFileConfig.tapDirPath, fileName)
-  return writeFile(tapFile, formatters.toHierarchicTAPString(results, {includeSubTests: false, markNewAsPassed: true}))
+  return fs.writeFile(
+    tapFile,
+    formatters.toHierarchicTAPString(results, {includeSubTests: false, markNewAsPassed: true}),
+    {},
+    (err: any) => {
+      if (err) throw err
+    },
+  )
 }
 
-module.exports = {printTestResults, handleBatchResultsFile}
+export default {printTestResults, handleBatchResultsFile}

package/src/plugin/hooks.ts

@@ -0,0 +1,60 @@
+import handleTestResults from './handleTestResults'
+export type EyesCypressAction = 'before:run' | 'after:run'
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Cypress {
+    interface ResolvedConfigOptions {
+      appliConfFile: {
+        dontCloseBatches: boolean
+        batch: any
+        serverUrl: string
+        proxy: string
+        apiKey: string
+        batchId: string
+        tapDirPath: string
+        tapFileName: string
+      }
+    }
+  }
+}
+
+export default function makeGlobalRunHooks({closeManager, closeBatches, closeUniversalServer}: any): {
+  'after:run': (results: CypressCommandLine.CypressRunResult) => void | Promise<void>
+  'before:run': (runDetails: Cypress.BeforeRunDetails) => void | Promise<void>
+} {
+  return {
+    'before:run': ({config}: Cypress.BeforeRunDetails): void => {
+      if (!(config as Cypress.Config).isTextTerminal) return
+    },
+
+    'after:run': async ({config}: CypressCommandLine.CypressRunResult) => {
+      try {
+        if (!(config as Cypress.Config).isTextTerminal) return
+        const summaries = await closeManager()
+
+        let testResults
+        for (const summary of summaries) {
+          testResults = summary.results.map(({testResults}: any) => 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.handleBatchResultsFile(testResults, {
+            tapDirPath: config.appliConfFile.tapDirPath,
+            tapFileName: config.appliConfFile.tapFileName,
+          })
+        }
+      } finally {
+        await closeUniversalServer()
+      }
+    },
+  }
+}

package/src/plugin/index.ts

@@ -0,0 +1,37 @@
+'use strict'
+import makePluginExport from './pluginExport'
+import makeConfig from './config'
+import makeStartServer from './server'
+import {makeLogger} from '@applitools/logger'
+
+// DON'T REMOVE
+//
+// if remove the `ttsc` will compile the absolute path
+//
+// the absolute path is added because api-extractor goes over the `eyesPlugin`
+// declaration before it goes over the `EyesConfig` definition, and this is why
+// it's important to reverse the order
+export type EyesPluginConfig = {
+  tapDirPath: string
+  tapFileName: string
+  eyesIsDisabled: boolean
+  eyesBrowser: any
+  eyesLayoutBreakpoints: any
+  eyesFailCypressOnDiff: boolean
+  eyesDisableBrowserFetching: boolean
+  eyesTestConcurrency: number
+  eyesWaitBeforeCapture: number
+  eyesPort?: number
+}
+
+const {config, eyesConfig} = makeConfig()
+const logger = makeLogger({level: config.showLogs ? 'info' : 'silent', label: 'eyes'})
+
+const startServer = makeStartServer({logger})
+
+const pluginExport = makePluginExport({
+  startServer,
+  eyesConfig: Object.assign({}, eyesConfig, {appliConfFile: config}),
+})
+
+export default pluginExport

package/src/plugin/isGlobalHooksSupported.ts

@@ -0,0 +1,11 @@
+const CYPRESS_SUPPORTED_VERSION = '6.2.0'
+const CYPRESS_NO_FLAG_VERSION = '6.7.0'
+
+export default function isGlobalHooksSupported(config: any) {
+  const {version, experimentalRunEvents} = config
+
+  return (
+    parseFloat(version) >= parseFloat(CYPRESS_NO_FLAG_VERSION) ||
+    (parseFloat(version) >= parseFloat(CYPRESS_SUPPORTED_VERSION) && !!experimentalRunEvents)
+  )
+}

package/src/plugin/pluginExport.ts

@@ -0,0 +1,118 @@
+import isGlobalHooksSupported from './isGlobalHooksSupported'
+// @ts-ignore
+import {presult} from '@applitools/functional-commons'
+import makeGlobalRunHooks from './hooks'
+import {type EyesPluginConfig} from './'
+
+export default function makePluginExport({startServer, eyesConfig}: any) {
+  return function pluginExport(pluginInitArgs: Cypress.ConfigOptions | NodeJS.Module) {
+    let eyesServer: any, pluginModuleExports: any, pluginExportsE2E: any, pluginExportsComponent: any
+    let pluginExports
+    if ((pluginInitArgs as NodeJS.Module).exports) {
+      const pluginAsNodeJSModule = pluginInitArgs as NodeJS.Module
+      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?.component) {
+        pluginExports.component.setupNodeEvents = setupNodeEvents
+      }
+      if (pluginExports?.e2e) {
+        pluginExports.e2e.setupNodeEvents = setupNodeEvents
+      }
+      if (!pluginExports.component && !pluginExports.e2e) {
+        if (pluginAsNodeJSModule.exports.default) {
+          pluginAsNodeJSModule.exports.default = setupNodeEvents
+        } else {
+          pluginAsNodeJSModule.exports = setupNodeEvents
+        }
+      }
+    } else {
+      // this is required because we are currently support cypress < 10
+      // in the version before 10 the `e2e.setupNodeEvents` and `component.setupNodeEvents` were not supported
+      const pluginAsCypress10PluginOptions = pluginInitArgs as {e2e: {setupNodeEvents: any}; component: {setupNodeEvents: any}}
+      if (pluginAsCypress10PluginOptions.component) {
+        pluginExportsComponent = pluginAsCypress10PluginOptions.component.setupNodeEvents
+        pluginAsCypress10PluginOptions.component.setupNodeEvents = setupNodeEvents
+      }
+      if (pluginAsCypress10PluginOptions.e2e) {
+        pluginExportsE2E = pluginAsCypress10PluginOptions.e2e.setupNodeEvents
+        pluginAsCypress10PluginOptions.e2e.setupNodeEvents = setupNodeEvents
+      }
+    }
+
+    if (!(pluginInitArgs as NodeJS.Module).exports) {
+      return pluginInitArgs
+    }
+    return function getCloseServer() {
+      return eyesServer.close()
+    }
+
+    async function setupNodeEvents(
+      origOn: Cypress.PluginEvents,
+      cypressConfig: Cypress.PluginConfigOptions,
+    ): Promise<EyesPluginConfig> {
+      const {server, port, closeManager, closeBatches, closeUniversalServer} = await startServer()
+      eyesServer = server
+
+      const globalHooks: any = makeGlobalRunHooks({
+        closeManager,
+        closeBatches,
+        closeUniversalServer,
+      })
+
+      if (!pluginModuleExports) {
+        pluginModuleExports = cypressConfig.testingType === 'e2e' ? pluginExportsE2E : pluginExportsComponent
+      }
+
+      const isGlobalHookCalledFromUserHandlerMap = new Map()
+      eyesConfig.eyesIsGlobalHooksSupported = isGlobalHooksSupported(cypressConfig)
+      let moduleExportsResult = {}
+      // in case setupNodeEvents is not defined in cypress.config file
+      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)
+
+      // This piece of code exists because at the point of writing, Cypress does not support multiple event handlers:
+      // https://github.com/cypress-io/cypress/issues/5240#issuecomment-948277554
+      // So we wrap Cypress' `on` function in order to wrap the user-defined handler. This way we can call our own handler
+      // in addition to the user's handler
+      function onThatCallsUserDefinedHandler(eventName: string, handler: any) {
+        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: any[]) {
+          const [err] = await presult(Promise.resolve(globalHooks[eventName].apply(this, args)))
+          await handler.apply(this, args)
+          if (err) {
+            throw err
+          }
+        }
+      }
+    }
+  }
+}

package/src/plugin/{server.js → server.ts}

@@ -1,38 +1,37 @@
-'use strict'
-const connectSocket = require('./webSocket')
-const {makeServerProcess} = require('@applitools/eyes-universal')
-const handleTestResults = require('./handleTestResults')
-const path = require('path')
-const fs = require('fs')
-const semverLt = require('semver/functions/lt')
-const {Server: HttpsServer} = require('https')
-const {Server: WSServer} = require('ws')
-const which = require('which')
-
-function makeStartServer({logger}) {
+import connectSocket, {type SocketWithUniversal} from './webSocket'
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import {makeServerProcess} from '@applitools/eyes-universal'
+import handleTestResults from './handleTestResults'
+import path from 'path'
+import fs from 'fs'
+import {lt as semverLt} from 'semver'
+import {Server as HttpsServer} from 'https'
+import {Server as WSServer} from 'ws'
+import which from 'which'
+import {type Logger} from '@applitools/logger'
+import {AddressInfo} from 'net'
+import {promisify} from 'util'
+
+export default function makeStartServer({logger}: {logger: Logger}) {
   return async function startServer() {
-    const key = fs.readFileSync(path.resolve(__dirname, '../pem/server.key'))
-    const cert = fs.readFileSync(path.resolve(__dirname, '../pem/server.cert'))
-    let port
-
+    const key = fs.readFileSync(path.resolve(__dirname, '../../src/pem/server.key'))
+    const cert = fs.readFileSync(path.resolve(__dirname, '../../src/pem/server.cert'))
     const https = new HttpsServer({
       key,
       cert,
     })
-    await https.listen(0, err => {
-      if (err) {
-        logger.log('error starting plugin server', err)
-      } else {
-        logger.log(`plugin server running at port: ${https.address().port}`)
-        port = https.address().port
-      }
-    })
+    await promisify(https.listen.bind(https))()
 
+    const port = (https.address() as AddressInfo).port
     const wss = new WSServer({server: https, path: '/eyes', maxPayload: 254 * 1024 * 1024})
 
     wss.on('close', () => https.close())
 
-    const forkOptions = {
+    const forkOptions: {
+      detached: boolean
+      execPath?: string
+    } = {
       detached: true,
     }
 
@@ -53,13 +52,13 @@ function makeStartServer({logger}) {
       portResolutionMode: 'random',
     })
 
-    const managers = []
-    let socketWithUniversal
+    const managers: {manager: object; socketWithUniversal: SocketWithUniversal}[] = []
+    let socketWithUniversal: SocketWithUniversal
 
     wss.on('connection', socketWithClient => {
       socketWithUniversal = connectSocket(`ws://localhost:${universalPort}/eyes`)
 
-      socketWithUniversal.setPassthroughListener(message => {
+      socketWithUniversal.setPassthroughListener((message: string) => {
         logger.log('<== ', message.toString().slice(0, 1000))
         const {name, payload} = JSON.parse(message)
         if (name === 'Core.makeManager') {
@@ -69,7 +68,7 @@ function makeStartServer({logger}) {
         socketWithClient.send(message.toString())
       })
 
-      socketWithClient.on('message', message => {
+      socketWithClient.on('message', (message: string) => {
         const msg = JSON.parse(message)
         logger.log('==> ', message.toString().slice(0, 1000))
         if (msg.name === 'Core.makeSDK') {
@@ -134,13 +133,11 @@ function makeStartServer({logger}) {
         ),
       )
     }
-    function closeBatches(settings) {
+    function closeBatches(settings: any) {
       if (socketWithUniversal)
-        return socketWithUniversal.request('Core.closeBatches', {settings}).catch(err => {
+        return socketWithUniversal.request('Core.closeBatches', {settings}).catch((err: Error) => {
           logger.log('@@@', err)
         })
     }
   }
 }
-
-module.exports = makeStartServer

package/src/plugin/{webSocket.js → webSocket.ts}

@@ -1,26 +1,39 @@
-const WebSocket = require('ws')
-const {v4: uuid} = require('uuid')
+import WebSocket from 'ws'
+import {v4 as uuid} from 'uuid'
+import {type Socket} from 'net'
+
+export type SocketWithUniversal = {
+  setPassthroughListener: (_listener: (_message: any) => void) => void
+  once(_type: any, _fn: any): any
+  on(_type: any, _fn: any): any
+  off(_type: any, _fn: any): any
+  disconnect(): void
+  ref(): () => boolean
+  unref(): () => boolean
+  send(_message: any): () => boolean
+  request(_name: string, _payload: any): any
+}
 
-function connectSocket(url) {
-  const socket = new WebSocket(url)
-  let passthroughListener
+export default function connectSocket(url: string): SocketWithUniversal {
+  const socket: WebSocket & {_socket?: Socket} = new WebSocket(url)
+  let passthroughListener: any
   const listeners = new Map()
-  const queue = new Set()
+  const queue = new Set<any>()
   let isReady = false
 
   attach()
 
   function attach() {
-    if (socket.readyState === WebSocket.CONNECTING) socket.on('open', () => attach(socket))
+    if (socket.readyState === WebSocket.CONNECTING) socket.on('open', () => attach())
     else if (socket.readyState === WebSocket.OPEN) {
       isReady = true
-      queue.forEach(command => command())
+      queue.forEach((command: any) => command())
       queue.clear()
 
       socket.on('message', message => {
         const {name, key, payload} = deserialize(message)
-        const fns = listeners.get(name)
-        const keyListeners = key && listeners.get(`${name}/${key}`)
+        const fns: any[] = listeners.get(name)
+        const keyListeners: any[] = key && listeners.get(`${name}/${key}`)
         if (fns) fns.forEach(fn => fn(payload, key))
         if (keyListeners) keyListeners.forEach(fn => fn(payload, key))
 
@@ -39,18 +52,18 @@ function connectSocket(url) {
     queue.clear()
   }
 
-  function setPassthroughListener(fn) {
+  function setPassthroughListener(fn: any) {
     passthroughListener = fn
   }
 
-  function send(message) {
+  function send(message: string) {
     const command = () => socket.send(message)
     if (isReady) command()
     else queue.add(command)
     return () => queue.delete(command)
   }
 
-  function on(type, fn) {
+  function on(type: string | {name: string; key: string}, fn: any) {
     const name = typeof type === 'string' ? type : `${type.name}/${type.key}`
     let fns = listeners.get(name)
     if (!fns) {
@@ -61,12 +74,12 @@ function connectSocket(url) {
     return () => off(name, fn)
   }
 
-  function once(type, fn) {
-    const off = on(type, (...args) => (fn(...args), off()))
+  function once(type: any, fn: any) {
+    const off = on(type, (...args: any[]) => (fn(...args), off()))
     return off
   }
 
-  function off(name, fn) {
+  function off(name: string, fn: any) {
     if (!fn) return listeners.delete(name)
     const fns = listeners.get(name)
     if (!fns) return false
@@ -75,15 +88,15 @@ function connectSocket(url) {
     return existed
   }
 
-  function emit(type, payload) {
+  function emit(type: any, payload: any) {
     return send(serialize(type, payload))
   }
 
-  function request(name, payload) {
+  function request(name: string, payload: any) {
     return new Promise((resolve, reject) => {
       const key = uuid()
       emit({name, key}, payload)
-      once({name, key}, response => {
+      once({name, key}, (response: any) => {
         if (response.error) return reject(response.error)
         return resolve(response.result)
       })
@@ -117,13 +130,11 @@ function connectSocket(url) {
   }
 }
 
-function serialize(type, payload) {
+function serialize(type: any, payload: any) {
   const message = typeof type === 'string' ? {name: type, payload} : {name: type.name, key: type.key, payload}
   return JSON.stringify(message)
 }
 
-function deserialize(message) {
+function deserialize(message: any) {
   return JSON.parse(message)
 }
-
-module.exports = connectSocket

package/src/setup/handlePlugin.js

@@ -1,16 +1,35 @@
 'use strict'
 
 const chalk = require('chalk')
+const boxen = require('boxen')
 const {addEyesCypressPlugin} = require('./addEyesCypressPlugin')
 const isPluginDefined = require('./isPluginDefined')
+const isPluginDefinedESM = require('./isPluginDefinedESM')
 const fs = require('fs')
 
 function handlePlugin(pluginsFilePath) {
   const fileContent = fs.readFileSync(pluginsFilePath, 'utf-8')
-
-  if (!isPluginDefined(fileContent)) {
+  const isESMOrTS = fileContent.indexOf('module.export') === -1
+  if (!isESMOrTS && !isPluginDefined(fileContent)) {
     fs.writeFileSync(pluginsFilePath, addEyesCypressPlugin(fileContent))
     console.log(chalk.cyan('Plugins defined.'))
+  } else if (isESMOrTS && !isPluginDefinedESM(fileContent)) {
+    console.log(
+      boxen(
+        `
+We detected that you are using TS or ESM syntax. Please configure the plugin as follows:
+
+${chalk.green.bold('import eyesPlugin from "@applitools/eyes-cypress"')}
+
+export default ${chalk.green.bold('eyesPlugin(')}definedConfig({
+  //...
+})${chalk.green.bold(')')}
+
+For more information, visit Eyes-Cypress documentation https://www.npmjs.com/package/@applitools/eyes-cypress (manual configuration section)
+`,
+        {padding: 1, borderColor: 'cyan'},
+      ),
+    )
   } else {
     console.log(chalk.cyan('Plugins already defined'))
   }

package/src/setup/isPluginDefinedESM.js

@@ -0,0 +1,5 @@
+function isPluginDefinedTypeScript(content) {
+  return !!content.match(/from\s*['"]@applitools\/eyes-cypress['"]\s*/)
+}
+
+module.exports = isPluginDefinedTypeScript

package/index.d.ts

@@ -1,86 +0,0 @@
-/// <reference types="cypress" />
-import type * as api from '@applitools/eyes-api'
-
-type MaybeArray<T> = T | T[]
-
-type LegacyRegion = {left: number; top: number; width: number; height: number}
-type Selector = {selector: string; type?: 'css' | 'xpath', nodeType?: 'element' | 'shadow-root'} | 'string'
-type Element = HTMLElement | JQuery<HTMLElement>
-type ElementWithOptions = {element: Element, regionId?: string, padding?: any}
-
-interface CypressCheckSettings extends api.CheckSettingsAutomationPlain<Element, Selector>{
-  tag?: CypressCheckSettings['name']
-
-  target?: 'window' | 'region'
-  selector?: Selector
-  element?: Element
-
-  ignore?: MaybeArray<NonNullable<CypressCheckSettings['ignoreRegions']>[number] | LegacyRegion | ElementWithOptions>
-  layout?: MaybeArray<NonNullable<CypressCheckSettings['layoutRegions']>[number] | LegacyRegion| ElementWithOptions>
-  content?: MaybeArray<NonNullable<CypressCheckSettings['contentRegions']>[number] | LegacyRegion| ElementWithOptions>
-  strict?: MaybeArray<NonNullable<CypressCheckSettings['strictRegions']>[number] | LegacyRegion | ElementWithOptions>
-  floating?: MaybeArray<NonNullable<CypressCheckSettings['floatingRegions']>[number] | ((ElementWithOptions | Selector | LegacyRegion) & {maxUpOffset?: number; maxDownOffset?: number; maxLeftOffset?: number; maxRightOffset?: number})>
-  accessibility?: MaybeArray<NonNullable<CypressCheckSettings['accessibilityRegions']>[number] | ((ElementWithOptions | Selector | LegacyRegion) & {accessibilityType?: api.AccessibilityRegionTypePlain})>
-  scriptHooks?: CypressCheckSettings['hooks']
-  ignoreCaret?: boolean
-  ignoreDisplacements?: boolean
-}
-
-interface CypressEyesConfig extends api.ConfigurationPlain<Element, Selector> {
-  browser?: MaybeArray<NonNullable<CypressEyesConfig['browsersInfo']>[number] | {deviceName: string; screenOrientation?: api.ScreenOrientationPlain; name?: string}>
-
-  batchId?:  NonNullable<CypressEyesConfig['batch']>['id']
-  batchName?:  NonNullable<CypressEyesConfig['batch']>['name']
-  batchSequence?:  NonNullable<CypressEyesConfig['batch']>['sequenceName']
-  notifyOnCompletion?:  NonNullable<CypressEyesConfig['batch']>['notifyOnCompletion']
-
-  envName?: CypressEyesConfig['environmentName']
-
-  accessibilitySettings?: NonNullable<CypressEyesConfig['defaultMatchSettings']>['accessibilitySettings']
-}
-
-declare global {
-  namespace Cypress {
-    interface Chainable {
-      /**
-       * Create an Applitools test.
-       * This will start a session with the Applitools server.
-       * @example
-       * cy.eyesOpen({ appName: 'My App' })
-      */
-      eyesOpen(config?: CypressEyesConfig): null
-
-      /**
-       * Generate a screenshot of the current page and add it to the Applitools Test.
-       * @example
-       * cy.eyesCheckWindow()
-       *
-       * OR
-       *
-       * cy.eyesCheckWindow({
-       *  target: 'region',
-       *  selector: '.my-element'
-       * });
-      */
-      eyesCheckWindow(tag?: string): null
-      eyesCheckWindow(settings?: CypressCheckSettings): null
-
-      /**
-       * Close the applitools test and check that all screenshots are valid.
-       * @example cy.eyesClose()
-      */
-      eyesClose(): null
-
-      /**
-       * Returns an object with the applitools test results from a given test / test file. This should be called after close.
-       * @example
-       * after(() => {
-       *  cy.eyesGetAllTestResults().then(summary => {
-       *    console.log(summary)
-       *  })
-       * })
-       */
-      eyesGetAllTestResults(): Chainable<api.TestResultsSummary>
-    }
-  }
-}

package/src/plugin/defaultPort.js

@@ -1 +0,0 @@
-module.exports = 7373

package/src/plugin/hooks.js

@@ -1,41 +0,0 @@
-'use strict'
-const handleTestResults = 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.handleBatchResultsFile(testResults, {
-            tapDirPath: config.appliConfFile.tapDirPath,
-            tapFileName: config.appliConfFile.tapFileName,
-          })
-        }
-      } finally {
-        await closeUniversalServer()
-      }
-    },
-  }
-}
-
-module.exports = makeGlobalRunHooks