selenium-webdriver 4.7.1 → 4.8.1

package/CHANGES.md

@@ -1,3 +1,34 @@
+## v4.8.1
+
+#### :rocket: New Feature
+
+* Add script pinning (#11584)
+
+#### :nail_care: Polish
+
+* Add CDP support for v110 and remove v107
+* Updating Selenium Manager binaries for 4.8.1 release
+
+#### :bug: Bug Fix
+
+fix: iedriver download with selenium-manager #11579
+
+## v4.8.0
+
+#### :rocket: New Feature
+
+* Add initial BiDi Support (#11395)
+* Add window wrappers getSize and setSize
+* Add BiDi browser context commands (#11473)
+* Add BiDi methods to listen to js logs and any type of logs
+* Add BiDi filtering capability to LogInspector (#11495)
+* Add comment with name of large JS executions (#11038)
+
+#### :nail_care: Polish
+
+* Add CDP support for v109 and remove v106
+* Deprecate setHeadless() in Chrome and Firefox (#11467)
+
 ## v4.7.1
 
 #### :nail_care: Polish

package/LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2022 Software Freedom Conservancy (SFC)
+   Copyright 2023 Software Freedom Conservancy (SFC)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/NOTICE

@@ -1,2 +1,2 @@
-Copyright 2011-2022 Software Freedom Conservancy
+Copyright 2011-2023 Software Freedom Conservancy
 Copyright 2004-2011 Selenium committers

package/bidi/browsingContext.js

@@ -0,0 +1,194 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+class BrowsingContext {
+  constructor(driver) {
+    this._driver = driver
+  }
+
+  async init({ browsingContextId, type, referenceContext }) {
+    if (!(await this._driver.getCapabilities()).get('webSocketUrl')) {
+      throw Error('WebDriver instance must support BiDi protocol')
+    }
+
+    if (type != undefined && !['window', 'tab'].includes(type)) {
+      throw Error(`Valid types are 'window' & 'tab'. Received: ${type}`)
+    }
+
+    this.bidi = await this._driver.getBidi()
+    this._id =
+      browsingContextId == undefined
+        ? (await this.create(type, referenceContext))['result']['context']
+        : browsingContextId
+  }
+
+  /**
+   * Creates a browsing context for the given type and referenceContext
+   */
+  async create(type, referenceContext) {
+    const params = {
+      method: 'browsingContext.create',
+      params: {
+        type: type,
+        referenceContext: referenceContext,
+      },
+    }
+    return await this.bidi.send(params)
+  }
+
+  /**
+   * @returns id
+   */
+  get id() {
+    return this._id
+  }
+
+  /**
+   * @param url the url to navigate to
+   * @param readinessState type of readiness state: "none" / "interactive" / "complete"
+   * @returns NavigateResult object
+   */
+  async navigate(url, readinessState = undefined) {
+    if (
+      readinessState != undefined &&
+      !['none', 'interactive', 'complete'].includes(readinessState)
+    ) {
+      throw Error(
+        `Valid readiness states are 'none', 'interactive' & 'complete'. Received: ${readinessState}`
+      )
+    }
+
+    const params = {
+      method: 'browsingContext.navigate',
+      params: {
+        context: this._id,
+        url: url,
+        wait: readinessState,
+      },
+    }
+    const navigateResult = (await this.bidi.send(params))['result']
+
+    return new NavigateResult(
+      navigateResult['url'],
+      navigateResult['navigation']
+    )
+  }
+
+  /**
+   * @param maxDepth the max depth of the descendents of browsing context tree
+   * @returns BrowsingContextInfo object
+   */
+  async getTree(maxDepth = undefined) {
+    const params = {
+      method: 'browsingContext.getTree',
+      params: {
+        root: this._id,
+        maxDepth: maxDepth,
+      },
+    }
+
+    let result = await this.bidi.send(params)
+    if ('error' in result) {
+      throw Error(result['error'])
+    }
+
+    result = result['result']['contexts'][0]
+    return new BrowsingContextInfo(
+      result['context'],
+      result['url'],
+      result['children'],
+      result['parent']
+    )
+  }
+
+  /**
+   * Closes the browing context
+   * @returns {Promise<void>}
+   */
+  async close() {
+    const params = {
+      method: 'browsingContext.close',
+      params: {
+        context: this._id,
+      },
+    }
+    await this.bidi.send(params)
+  }
+}
+
+class NavigateResult {
+  constructor(url, navigationId) {
+    this._url = url
+    this._navigationId = navigationId
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get navigationId() {
+    return this._navigationId
+  }
+}
+
+class BrowsingContextInfo {
+  constructor(id, url, children, parentBrowsingContext) {
+    this._id = id
+    this._url = url
+    this._children = children
+    this._parentBrowsingContext = parentBrowsingContext
+  }
+
+  get id() {
+    return this._id
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get children() {
+    return this._children
+  }
+
+  get parentBrowsingContext() {
+    return this._parentBrowsingContext
+  }
+}
+
+/**
+ * initiate browsing context instance and return
+ * @param driver
+ * @param browsingContextId The browsing context of current window/tab
+ * @param type "window" or "tab"
+ * @param referenceContext To get a browsing context for this reference if passed
+ * @returns {Promise<BrowsingContext>}
+ */
+async function getBrowsingContextInstance(
+  driver,
+  { browsingContextId, type, referenceContext }
+) {
+  let instance = new BrowsingContext(driver)
+  await instance.init({ browsingContextId, type, referenceContext })
+  return instance
+}
+
+/**
+ * API
+ * @type {function(*, {*,*,*}): Promise<BrowsingContext>}
+ */
+module.exports = getBrowsingContextInstance

package/bidi/filterBy.js

@@ -0,0 +1,46 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+class FilterBy {
+  constructor(level) {
+    this.level_ = level
+  }
+
+  static logLevel(level) {
+    if (
+      level === undefined ||
+      (level != undefined &&
+        !['debug', 'error', 'info', 'warning'].includes(level))
+    ) {
+      throw Error(
+        `Please pass valid log level. Valid log levels are 'debug', 'error', 'info' and 'warning'. Received: ${level}`
+      )
+    }
+
+    return new FilterBy(level)
+  }
+
+  getLevel() {
+    return this.level_
+  }
+}
+
+// PUBLIC API
+
+module.exports = {
+  FilterBy,
+}

package/bidi/index.js

@@ -0,0 +1,224 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+const { EventEmitter } = require('node:events')
+const WebSocket = require('ws')
+
+const RESPONSE_TIMEOUT = 1000 * 30
+
+class Index extends EventEmitter {
+  id = 0
+  isConnected = false
+  events = []
+  browsingContexts = []
+
+  /**
+   * Create a new websocket connection
+   * @param _webSocketUrl
+   */
+  constructor (_webSocketUrl) {
+    super()
+    this.isConnected = false
+    this._ws = new WebSocket(_webSocketUrl)
+    this._ws.on('open', () => {
+      this.isConnected = true
+    })
+  }
+
+  /**
+   * Resolve connection
+   * @returns {Promise<unknown>}
+   */
+  async waitForConnection () {
+    return new Promise((resolve) => {
+      if (this.isConnected) {
+        resolve()
+      } else {
+        this._ws.once('open', () => {
+          resolve()
+        })
+      }
+    })
+  }
+
+  /**
+   * @returns {WebSocket}
+   */
+  get socket () {
+    return this._ws
+  }
+
+  /**
+   * @returns {boolean|*}
+   */
+  get isConnected () {
+    return this.isConnected
+  }
+
+  /**
+   * Sends a bidi request
+   * @param params
+   * @returns {Promise<unknown>}
+   */
+  async send (params) {
+    if (!this.isConnected) {
+      await this.waitForConnection()
+    }
+
+    const id = ++this.id
+
+    this._ws.send(JSON.stringify({ id, ...params }))
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Request with id ${id} timed out`))
+        handler.off('message', listener)
+      }, RESPONSE_TIMEOUT)
+
+      const listener = (data) => {
+        try {
+          const payload = JSON.parse(data.toString())
+          if (payload.id === id) {
+            clearTimeout(timeoutId)
+            handler.off('message', listener)
+            resolve(payload)
+          }
+        } catch (err) {
+          log.error(`Failed parse message: ${err.message}`)
+        }
+      }
+
+      const handler = this._ws.on('message', listener)
+    })
+  }
+
+  /**
+   * Subscribe to events
+   * @param events
+   * @param browsingContexts
+   * @returns {Promise<void>}
+   */
+  async subscribe (events, browsingContexts) {
+    function toArray (arg) {
+      if (arg === undefined) {
+        return []
+      }
+
+      return Array.isArray(arg) ? [...arg] : [arg]
+    }
+
+    const eventsArray = toArray(events)
+    const contextsArray = toArray(browsingContexts)
+
+    const params = {
+      method: 'session.subscribe', params: {},
+    }
+
+    if (eventsArray.length && eventsArray.some(
+      event => typeof event !== 'string')) {
+      throw new TypeError('events should be string or string array')
+    }
+
+    if (contextsArray.length && contextsArray.some(
+      context => typeof context !== 'string')) {
+      throw new TypeError('browsingContexts should be string or string array')
+    }
+
+    if (eventsArray.length) {
+      params.params.events = eventsArray
+    }
+
+    if (contextsArray.length) {
+      params.params.contexts = contextsArray
+    }
+
+    await this.send(params)
+  }
+
+  /**
+   * Unsubscribe to events
+   * @param events
+   * @param browsingContexts
+   * @returns {Promise<void>}
+   */
+  async unsubscribe (events, browsingContexts) {
+    if (typeof events === 'string') {
+      this.events = this.events.filter(event => event !== events)
+    } else if (Array.isArray(events)) {
+      this.events = this.events.filter(event => !events.includes(event))
+    }
+
+    if (typeof browsingContexts === 'string') {
+      this.browsingContexts.pop()
+    } else if (Array.isArray(browsingContexts)) {
+      this.browsingContexts =
+        this.browsingContexts.filter(id => !browsingContexts.includes(id))
+    }
+
+    const params = {
+      method: 'session.unsubscribe', params: {
+        events: this.events,
+      }
+    }
+
+    if (this.browsingContexts.length > 0) {
+      params.params.contexts = this.browsingContexts
+    }
+
+    await this.send(params)
+  }
+
+  /**
+   * Get Bidi Status
+   * @returns {Promise<*>}
+   */
+  get status () {
+    return this.send({
+      method: 'session.status', params: {}
+    })
+  }
+
+  /**
+   * Close ws connection.
+   * @returns {Promise<unknown>}
+   */
+  close () {
+    const closeWebSocket = (callback) => {
+      // don't close if it's already closed
+      if (this._ws.readyState === 3) {
+        callback()
+      } else {
+        // don't notify on user-initiated shutdown ('disconnect' event)
+        this._ws.removeAllListeners('close')
+        this._ws.once('close', () => {
+          this._ws.removeAllListeners()
+          callback()
+        })
+        this._ws.close()
+      }
+    }
+    return new Promise((fulfill, reject) => {
+      closeWebSocket(fulfill)
+    })
+  }
+}
+
+/**
+ * API
+ * @type {function(*): Promise<Index>}
+ */
+module.exports = Index

package/bidi/logEntries.js

@@ -0,0 +1,87 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+'use strict'
+
+class BaseLogEntry {
+  constructor (level, text, timeStamp, stackTrace) {
+    this._level = level
+    this._text = text
+    this._timeStamp = timeStamp
+    this._stackTrace = stackTrace
+  }
+
+  get level () {
+    return this._level
+  }
+
+  get text () {
+    return this._text
+  }
+
+  get timeStamp () {
+    return this._timeStamp
+  }
+
+  get stackTrace () {
+    return this._stackTrace
+  }
+}
+
+class GenericLogEntry extends BaseLogEntry {
+  constructor (level, text, timeStamp, type, stackTrace) {
+    super(level, text, timeStamp, stackTrace)
+    this._type = type
+  }
+
+  get type () {
+    return this._type
+  }
+}
+
+class ConsoleLogEntry extends GenericLogEntry {
+  constructor (level, text, timeStamp, type, method, realm, args, stackTrace) {
+    super(level, text, timeStamp, type, stackTrace)
+    this._method = method
+    this._realm = realm
+    this._args = args
+  }
+
+  get method () {
+    return this._method
+  }
+
+  get realm () {
+    return this._realm
+  }
+
+  get args () {
+    return this._args
+  }
+}
+
+class JavascriptLogEntry extends GenericLogEntry {
+  constructor (level, text, timeStamp, type, stackTrace) {
+    super(level, text, timeStamp, type, stackTrace)
+  }
+}
+
+// PUBLIC API
+
+module.exports = {
+  BaseLogEntry, GenericLogEntry, ConsoleLogEntry, JavascriptLogEntry,
+}

package/bidi/logInspector.js

@@ -0,0 +1,269 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+const { FilterBy } = require('./filterBy')
+const { ConsoleLogEntry, JavascriptLogEntry, GenericLogEntry } = require('./logEntries')
+
+const LOG = {
+  TYPE_CONSOLE : 'console',
+  TYPE_JS_LOGS : 'javascript',
+}
+
+class LogInspector {
+  bidi
+  ws
+
+  constructor (driver, browsingContextIds) {
+    this._driver = driver
+    this._browsingContextIds = browsingContextIds
+    this.listener = {}
+  }
+
+  /**
+   * Subscribe to log event
+   * @returns {Promise<void>}
+   */
+  async init () {
+    this.bidi = await this._driver.getBidi()
+    await this.bidi.subscribe('log.entryAdded', this._browsingContextIds)
+  }
+
+  /**
+   * @param kind
+   */
+  logListener (kind) {
+    if (!(kind in this.listener)) {
+      this.listener[kind] = []
+    }
+  }
+
+  /**
+   * Listen to Console logs
+   * @param callback
+   * @returns {Promise<void>}
+   */
+  async onConsoleEntry(callback, filterBy = undefined) {
+    if (filterBy != undefined && !(filterBy instanceof FilterBy)) {
+      throw Error(`Pass valid FilterBy object. Received: ${filterBy}`)
+    }
+
+    this.ws = await this.bidi.socket
+
+    this.ws.on('message', (event) => {
+      const { params } = JSON.parse(Buffer.from(event.toString()))
+
+      if (params?.type === LOG.TYPE_CONSOLE) {
+        let consoleEntry = new ConsoleLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.method,
+          params.realm,
+          params.args,
+          params.stackTrace
+        )
+
+        if (filterBy != undefined) {
+          if (params?.level === filterBy.getLevel()) {
+            callback(consoleEntry)
+          }
+          return
+        }
+
+        callback(consoleEntry)
+      }
+    })
+  }
+
+  /**
+   * Listen to JS logs
+   * @param callback
+   * @returns {Promise<void>}
+   */
+  async onJavascriptLog(callback, filterBy = undefined) {
+    if (filterBy != undefined && !(filterBy instanceof FilterBy)) {
+      throw Error(`Pass valid FilterBy object. Received: ${filterBy}`)
+    }
+
+    this.ws = await this.bidi.socket
+
+    this.ws.on('message', (event) => {
+      const { params } = JSON.parse(Buffer.from(event.toString()))
+
+      if (params?.type === LOG.TYPE_JS_LOGS) {
+        let jsEntry = new JavascriptLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.stackTrace
+        )
+
+        if (filterBy != undefined) {
+          if (params?.level === filterBy.getLevel()) {
+            callback(jsEntry)
+          }
+          return
+        }
+
+        callback(jsEntry)
+      }
+    })
+  }
+
+  /**
+   * Listen to JS Exceptions
+   * @param callback
+   * @returns {Promise<void>}
+   */
+  async onJavascriptException(callback) {
+    this.ws = await this.bidi.socket
+    let enabled =
+      LOG.TYPE_JS_EXCEPTION in this.listener ||
+      this.logListener(LOG.TYPE_JS_EXCEPTION)
+    this.listener[LOG.TYPE_JS_EXCEPTION].push(callback)
+
+    if (enabled) {
+      return
+    }
+
+    this.ws.on('message', (event) => {
+      const { params } = JSON.parse(Buffer.from(event.toString()))
+      if (params?.type === 'javascript' && params?.level === 'error') {
+        let jsErrorEntry = new JavascriptLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.stackTrace
+        )
+
+        this.listener[LOG.TYPE_JS_EXCEPTION].forEach((listener) => {
+          listener(jsErrorEntry)
+        })
+      }
+    })
+  }
+
+  /**
+   * Listen to any logs
+   * @param callback
+   * @returns {Promise<void>}
+   */
+  async onLog(callback, filterBy = undefined) {
+    if (filterBy != undefined && !(filterBy instanceof FilterBy)) {
+      throw Error(`Pass valid FilterBy object. Received: ${filterBy}`)
+    }
+
+    this.ws = await this.bidi.socket
+
+    this.ws.on('message', (event) => {
+      const { params } = JSON.parse(Buffer.from(event.toString()))
+      if (params?.type === 'javascript') {
+        let jsEntry = new JavascriptLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.stackTrace
+        )
+
+        if (filterBy != undefined) {
+          if (params?.level === filterBy.getLevel()) {
+            callback(jsEntry)
+          }
+          return
+        }
+
+        callback(jsEntry)
+        return
+      }
+  
+      if (params?.type === 'console') {
+        let consoleEntry = new ConsoleLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.method,
+          params.realm,
+          params.args,
+          params.stackTrace
+        )
+        
+        if (filterBy != undefined) {
+          if (params?.level === filterBy.getLevel()) {
+            callback(consoleEntry)
+          }
+          return
+        }
+
+        callback(consoleEntry)
+        return
+      }
+
+      if (
+        params != undefined &&
+        !['console', 'javascript'].includes(params?.type)
+      ) {
+        let genericEntry = new GenericLogEntry(
+          params.level,
+          params.text,
+          params.timestamp,
+          params.type,
+          params.stackTrace
+        )
+
+        if (filterBy != undefined) {
+          if (params?.level === filterBy.getLevel()) {
+            callback(genericEntry)
+          }
+          return
+        }
+
+        callback(genericEntry)
+      }
+    })
+  }
+
+  /**
+   * Unsubscribe to log event
+   * @returns {Promise<void>}
+   */
+  async close () {
+    await this.bidi.unsubscribe('log.entryAdded', this._browsingContextIds)
+  }
+}
+
+/**
+ * initiate inspector instance and return
+ * @param driver
+ * @param browsingContextIds
+ * @returns {Promise<LogInspector>}
+ */
+async function getLogInspectorInstance (driver, browsingContextIds) {
+  let instance = new LogInspector(driver, browsingContextIds)
+  await instance.init()
+  return instance
+}
+
+/**
+ * API
+ * @type {function(*, *): Promise<LogInspector>}
+ */
+module.exports = getLogInspectorInstance

package/chromium.js

@@ -310,6 +310,15 @@ class Options extends Capabilities {
   }
 
   /**
+   * @deprecated Use {@link Options#addArguments} instead.
+   * @example
+   * options.addArguments('--headless=chrome'); (or)
+   * options.addArguments('--headless');
+   * @example
+   *
+   * Recommended to use '--headless=chrome' as argument for browsers v94-108.
+   * Recommended to use '--headless=new' as argument for browsers v109+.
+   *
    * Configures the driver to start the browser in headless mode.
    *
    * > __NOTE:__ Resizing the browser window in headless mode is only supported
@@ -600,6 +609,14 @@ class Options extends Capabilities {
     }
     return this
   }
+
+  /**
+   * Enable bidi connection
+   * @returns {!Capabilities}
+   */
+  enableBidi() {
+    return this.set('webSocketUrl', true)
+  }
 }
 
 /**

package/common/seleniumManager.js

@@ -30,7 +30,7 @@ const execSync = require('child_process').execSync
  * currently supported browsers for selenium-manager
  * @type {string[]}
  */
-const Browser = ['chrome', 'firefox', 'edge']
+const Browser = ['chrome', 'firefox', 'edge', 'iexplorer']
 
 /**
  * Determines the path of the correct Selenium Manager binary

package/devtools/CDPConnection.js

@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+const RESPONSE_TIMEOUT = 1000 * 30
 class CDPConnection {
   constructor(wsConnection) {
     this._wsConnection = wsConnection
@@ -35,6 +36,42 @@ class CDPConnection {
     const mergedMessage = Object.assign({ params: params }, message)
     this._wsConnection.send(JSON.stringify(mergedMessage), callback)
   }
+
+  async send(method, params) {
+    let cdp_id = this.cmd_id++
+    let message = {
+      method,
+      id: cdp_id,
+    }
+    if (this.sessionId) {
+      message['sessionId'] = this.sessionId
+    }
+
+    const mergedMessage = Object.assign({ params: params }, message)
+    this._wsConnection.send(JSON.stringify(mergedMessage))
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Request with id ${cdp_id} timed out`))
+        handler.off('message', listener)
+      }, RESPONSE_TIMEOUT)
+
+      const listener = (data) => {
+        try {
+          const payload = JSON.parse(data.toString())
+          if (payload.id === cdp_id) {
+            clearTimeout(timeoutId)
+            handler.off('message', listener)
+            resolve(payload)
+          }
+        } catch (err) {
+          console.error(`Failed parse message: ${err.message}`)
+        }
+      }
+
+      const handler = this._wsConnection.on('message', listener)
+    })
+  }
 }
 
 exports.CdpConnection = CDPConnection

package/firefox.js

@@ -299,6 +299,10 @@ class Options extends Capabilities {
   }
 
   /**
+   * @deprecated Use {@link Options#addArguments} instead.
+   * @example
+   * options.addArguments('-headless');
+   * @example
    * Configures the geckodriver to start Firefox in headless mode.
    *
    * @return {!Options} A self reference.
@@ -424,6 +428,14 @@ class Options extends Capabilities {
   enableDebugger() {
     return this.set('moz:debuggerAddress', true)
   }
+
+  /**
+   * Enable bidi connection
+   * @returns {!Capabilities}
+   */
+  enableBidi() {
+    return this.set('webSocketUrl', true)
+  }
 }
 
 /**

package/http/index.js

@@ -54,7 +54,7 @@ function getRequestOptions(aUrl) {
   options.search = null
   options.hash = null
   options.path = options.pathname
-  options.hostname = options.hostname === 'localhost' ? '127.0.0.1' : options.hostname // To support Node 17 and above. Refer https://github.com/nodejs/node/issues/40702 for details.
+ options.hostname = options.hostname === 'localhost' ? '127.0.0.1' : options.hostname // To support Node 17 and above. Refer https://github.com/nodejs/node/issues/40702 for details.
   return options
 }
 

package/ie.js

@@ -406,7 +406,7 @@ function createServiceFromCapabilities(capabilities) {
     )
 
     try {
-      exe = driverLocation(Browser.INTERNET_EXPLORER)
+      exe = driverLocation('iexplorer')
     } catch (err) {
       console.log(`Unable to obtain driver using Selenium Manager: ${err}`)
     }

package/index.js

@@ -39,6 +39,8 @@ const session = require('./lib/session')
 const until = require('./lib/until')
 const webdriver = require('./lib/webdriver')
 const select = require('./lib/select')
+const LogInspector = require('./bidi/logInspector')
+const BrowsingContext = require('./bidi/browsingContext')
 
 const Browser = capabilities.Browser
 const Capabilities = capabilities.Capabilities
@@ -795,3 +797,5 @@ exports.logging = logging
 exports.promise = promise
 exports.until = until
 exports.Select = select.Select
+exports.LogInspector = LogInspector
+exports.BrowsingContext = BrowsingContext

package/lib/http.js

@@ -182,14 +182,14 @@ class InternalTypeError extends TypeError {}
  * @param params
  * @return {!Command} The transformed command to execute.
  */
-function toExecuteAtomCommand(command, atom, ...params) {
+function toExecuteAtomCommand(command, atom, name, ...params) {
   if (typeof atom !== 'function') {
     throw new InternalTypeError('atom is not a function: ' + typeof atom)
   }
 
   return new cmd.Command(cmd.Name.EXECUTE_SCRIPT)
     .setParameter('sessionId', command.getParameter('sessionId'))
-    .setParameter('script', `return (${atom}).apply(null, arguments)`)
+    .setParameter('script', `/* ${name} */return (${atom}).apply(null, arguments)`)
     .setParameter(
       'args',
       params.map((param) => command.getParameter(param))
@@ -252,7 +252,7 @@ const W3C_COMMAND_MAP = new Map([
   [
     cmd.Name.FIND_ELEMENTS_RELATIVE,
     (cmd) => {
-      return toExecuteAtomCommand(cmd, Atom.FIND_ELEMENTS, 'args')
+      return toExecuteAtomCommand(cmd, Atom.FIND_ELEMENTS, 'findElements', 'args')
     },
   ],
   [
@@ -272,7 +272,7 @@ const W3C_COMMAND_MAP = new Map([
   [
     cmd.Name.GET_ELEMENT_ATTRIBUTE,
     (cmd) => {
-      return toExecuteAtomCommand(cmd, Atom.GET_ATTRIBUTE, 'id', 'name')
+      return toExecuteAtomCommand(cmd, Atom.GET_ATTRIBUTE, 'getAttribute', 'id', 'name')
     },
   ],
   [
@@ -308,7 +308,7 @@ const W3C_COMMAND_MAP = new Map([
   [
     cmd.Name.IS_ELEMENT_DISPLAYED,
     (cmd) => {
-      return toExecuteAtomCommand(cmd, Atom.IS_DISPLAYED, 'id')
+      return toExecuteAtomCommand(cmd, Atom.IS_DISPLAYED, 'isDisplayed', 'id')
     },
   ],
 

package/lib/pinnedScript.js

@@ -0,0 +1,59 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+const crypto = require('crypto')
+
+class PinnedScript {
+  constructor(script) {
+    this.scriptSource_ = script
+    this.scriptHandle_ = crypto.randomUUID().replace(/-/gi, '')
+  }
+
+  get handle() {
+    return this.scriptHandle_
+  }
+
+  get source() {
+    return this.scriptSource_
+  }
+
+  get scriptId() {
+    return this.scriptId_
+  }
+
+  set scriptId(id) {
+    this.scriptId_ = id
+  }
+
+  creationScript() {
+    return `function __webdriver_${this.scriptHandle_}(arguments) { ${this.scriptSource_} }`
+  }
+
+  executionScript() {
+    return `return __webdriver_${this.scriptHandle_}(arguments)`
+  }
+
+  removalScript() {
+    return `__webdriver_${this.scriptHandle_} = undefined`
+  }
+}
+
+// PUBLIC API
+
+module.exports = {
+  PinnedScript,
+}

package/lib/webdriver.js

@@ -40,6 +40,8 @@ const cdpTargets = ['page', 'browser']
 const { Credential } = require('./virtual_authenticator')
 const webElement = require('./webelement')
 const { isObject } = require('./util')
+const BIDI = require('../bidi')
+const { PinnedScript } = require('./pinnedScript')
 
 // Capability names that are defined in the W3C spec.
 const W3C_CAPABILITY_NAMES = new Set([
@@ -685,6 +687,8 @@ class WebDriver {
 
     /** @private {./virtual_authenticator}*/
     this.authenticatorId_ = null
+
+    this.pinnedScripts_ = {}
   }
 
   /**
@@ -794,6 +798,15 @@ class WebDriver {
     if (typeof script === 'function') {
       script = 'return (' + script + ').apply(null, arguments);'
     }
+
+    if (script && script instanceof PinnedScript) {
+      return this.execute(
+        new command.Command(command.Name.EXECUTE_SCRIPT)
+          .setParameter('script', script.executionScript())
+          .setParameter('args', args)
+      )
+    }
+
     return this.execute(
       new command.Command(command.Name.EXECUTE_SCRIPT)
         .setParameter('script', script)
@@ -806,6 +819,15 @@ class WebDriver {
     if (typeof script === 'function') {
       script = 'return (' + script + ').apply(null, arguments);'
     }
+
+    if (script && script instanceof PinnedScript) {
+      return this.execute(
+        new command.Command(command.Name.EXECUTE_ASYNC_SCRIPT)
+          .setParameter('script', script.executionScript())
+          .setParameter('args', args)
+      )
+    }
+
     return this.execute(
       new command.Command(command.Name.EXECUTE_ASYNC_SCRIPT)
         .setParameter('script', script)
@@ -1225,7 +1247,9 @@ class WebDriver {
     this._wsUrl = await this.getWsUrl(debuggerUrl, target, caps)
     return new Promise((resolve, reject) => {
       try {
-        this._wsConnection = new WebSocket(this._wsUrl)
+        this._wsConnection = new WebSocket(
+          this._wsUrl.replace('localhost', '127.0.0.1')
+        )
         this._cdpConnection = new cdp.CdpConnection(this._wsConnection)
       } catch (err) {
         reject(err)
@@ -1271,6 +1295,16 @@ class WebDriver {
     this._cdpConnection.execute('Target.getTargets')
   }
 
+  /**
+   * Initiates bidi connection using 'webSocketUrl'
+   * @returns {BIDI}
+   */
+  async getBidi() {
+    const caps = await this.getCapabilities()
+    let WebSocketUrl = caps['map_'].get('webSocketUrl')
+    return new BIDI(WebSocketUrl.replace('localhost', '127.0.0.1'))
+  }
+
   /**
    * Retrieves 'webSocketDebuggerUrl' by sending a http request using debugger address
    * @param {string} debuggerAddress
@@ -1521,6 +1555,74 @@ class WebDriver {
     })
   }
 
+  async pinScript(script) {
+    let pinnedScript = new PinnedScript(script)
+    let connection
+    if (Object.is(this._cdpConnection, undefined)) {
+      connection = await this.createCDPConnection('page')
+    } else {
+      connection = this._cdpConnection
+    }
+
+    await connection.execute('Page.enable', {}, null)
+
+    await connection.execute(
+      'Runtime.evaluate',
+      {
+        expression: pinnedScript.creationScript(),
+      },
+      null
+    )
+
+    let result = await connection.send(
+      'Page.addScriptToEvaluateOnNewDocument',
+      {
+        source: pinnedScript.creationScript(),
+      }
+    )
+
+    pinnedScript.scriptId = result['result']['identifier']
+
+    this.pinnedScripts_[pinnedScript.handle] = pinnedScript
+
+    return pinnedScript
+  }
+
+  async unpinScript(script) {
+    if (script && !(script instanceof PinnedScript)) {
+      throw Error(`Pass valid PinnedScript object. Received: ${script}`)
+    }
+
+    if (script.handle in this.pinnedScripts_) {
+      let connection
+      if (Object.is(this._cdpConnection, undefined)) {
+        connection = this.createCDPConnection('page')
+      } else {
+        connection = this._cdpConnection
+      }
+
+      await connection.execute('Page.enable', {}, null)
+
+      await connection.execute(
+        'Runtime.evaluate',
+        {
+          expression: script.removalScript(),
+        },
+        null
+      )
+
+      await connection.execute(
+        'Page.removeScriptToEvaluateOnLoad',
+        {
+          identifier: script.scriptId,
+        },
+        null
+      )
+
+      delete this.pinnedScripts_[script.handle]
+    }
+  }
+
   /**
    *
    * @returns The value of authenticator ID added
@@ -2142,6 +2244,37 @@ class Window {
       new command.Command(command.Name.FULLSCREEN_WINDOW)
     )
   }
+
+  /**
+   * Gets the width and height of the current window
+   * @param windowHandle
+   * @returns {Promise<{width: *, height: *}>}
+   */
+  async getSize(windowHandle = 'current') {
+    if (windowHandle !== 'current') {
+      console.warn(`Only 'current' window is supported for W3C compatible browsers.`);
+    }
+
+    const rect = await this.getRect();
+    return {height: rect.height, width: rect.width};
+  }
+
+  /**
+   * Sets the width and height of the current window. (window.resizeTo)
+   * @param x
+   * @param y
+   * @param width
+   * @param height
+   * @param windowHandle
+   * @returns {Promise<void>}
+   */
+  async setSize({x = 0, y = 0, width = 0, height = 0}, windowHandle = 'current') {
+    if (windowHandle !== 'current') {
+      console.warn(`Only 'current' window is supported for W3C compatible browsers.`);
+    }
+
+    await this.setRect({x, y, width, height});
+  }
 }
 
 /**
@@ -2863,7 +2996,7 @@ class WebElement {
    */
   submit() {
     const script =
-      'var form = arguments[0];\n' +
+      '/* submitForm */var form = arguments[0];\n' +
       'while (form.nodeName != "FORM" && form.parentNode) {\n' +
       '  form = form.parentNode;\n' +
       '}\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selenium-webdriver",
-  "version": "4.7.1",
+  "version": "4.8.1",
   "description": "The official WebDriver JavaScript bindings from the Selenium project",
   "license": "Apache-2.0",
   "keywords": [
@@ -25,17 +25,16 @@
   "dependencies": {
     "jszip": "^3.10.0",
     "tmp": "^0.2.1",
-    "ws": ">=8.7.0"
+    "ws": ">=8.11.0"
   },
   "devDependencies": {
-    "eslint": "^8.27.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint": "^8.31.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-no-only-tests": "^3.1.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.2.0",
+    "eslint-plugin-prettier": "^4.2.1",
     "express": "^4.18.2",
-    "jasmine": "^4.5.0",
-    "mocha": "^10.1.0",
+    "mocha": "^10.2.0",
     "multer": "^1.4.5-lts.1",
     "prettier": "^2.7.1",
     "serve-index": "^1.9.1",
@@ -44,7 +43,7 @@
   "scripts": {
     "lint": "eslint --ignore-pattern node_modules --ignore-pattern generator --fix --ext js lib/http.js \"**/*.js\"",
     "test": "npm run lint && mocha -t 600000 --recursive test",
-    "test-jasmine": "jasmine JASMINE_CONFIG_PATH=jasmine.json"
+    "test-jasmine": "bazel test //javascript/node/selenium-webdriver:tests"
   },
   "mocha": {
     "recursive": true,