The code imports necessary modules for interacting with web browsers and defines constants and functions for managing Selenium sessions, including verifying individual sessions and retrieving active sessions. The getSessions function is exported as a module export, which can be used to retrieve and verify available Selenium sessions.

Run example

npm run import -- "list sessions"

list sessions

const {readSessions} = importer.import("selenium session")
const { WebDriver, Capabilities, Session } = require('selenium-webdriver')
const chrome = require('selenium-webdriver/chrome');
const createExecutor = importer.import("selenium executor")
const getClient = importer.import("webdriver client")

const LOCAL_URL = 'http://localhost:4444/wd/hub';

async function verifySession(driver, sessionId) {
  let driver2 = new chrome.Driver(
    new Session(sessionId[1], Capabilities.chrome()), createExecutor(Promise.resolve(LOCAL_URL)))

  try {
    let windows = await driver2.getAllWindowHandles()
    console.log('windows ', windows)
    //await driver.switchTo().window(window)
    //let status = await driver.getSession()
    return sessionId[1]
  } catch (e) {
    console.log(e)
  }
}

async function getSessions(driver, inactive = false) {
  const sessions = readSessions()
  if(!driver) {
    driver = await getClient()
  }
  //const session = await driver.getSession()
  //const original = session.getId()
  let active = [].concat(sessions)
      .filter(session => typeof session[1] !== 'undefined'
              && session[1] !== null && session[1].length > 0);
  //if(inactive) {
  //    active = active.filter(session => (new Date()).getTime() - session[0] > TIMEOUT);
  //}
  let cancelled = false;
  let available = []
  for(let i = 0; i < active.length; i++) {
    let r = await verifySession(driver, active[i])
    if(typeof r !== 'undefined') {
      available[available.length] = active[i]
    }
    if(inactive) {
      cancelled = true;
    } else {
    }
  }
  //session.id_ = original;

  return available
    .filter(sess => typeof sess !== 'undefined' && sess !== null)
    .filter((elem, pos, arr) => arr.indexOf(elem) === pos)
}


module.exports = getSessions

const { readSessions } = importer.import('selenium session');
const { WebDriver, Capabilities, Session } = require('selenium-webdriver');
const { Builder } = require('selenium-webdriver/chrome');
const createExecutor = importer.import('selenium executor');
const getClient = importer.import('webdriver client');

const LOCAL_URL = 'http://localhost:4444/wd/hub';

/**
 * Verifies a session by getting all window handles.
 * @param {Session} driver - The session to verify.
 * @param {string} sessionId - The ID of the session.
 * @returns {string} The ID of the verified session.
 */
async function verifySession(session, sessionId) {
  try {
    const driver = new Builder().forBrowser('chrome').setChromeOptions(Capabilities.chrome()).build();
    const windows = await driver.getAllWindowHandles();
    console.log('Windows: ', windows);
    driver.quit(); // Quit the driver after use to free up resources.
    return sessionId;
  } catch (error) {
    console.error(error);
  }
}

/**
 * Gets active or inactive sessions.
 * @param {Session} driver - The driver to use.
 * @param {boolean} inactive - Whether to get inactive sessions.
 * @returns {Array<string>} The IDs of the available sessions.
 */
async function getSessions(driver, inactive = false) {
  const sessions = readSessions();
  if (!driver) {
    driver = await getClient();
  }

  const activeSessions = sessions
   .filter((session) => Object.prototype.hasOwnProperty.call(session, 'id') && session.id!== null && session.id.length > 0);

  let availableSessions = activeSessions.map((session) => verifySession(null, session));

  if (inactive) {
    await Promise.all(availableSessions);
    availableSessions = availableSessions.filter((result) => result!== undefined);
  } else {
    await Promise.all(availableSessions);
    availableSessions = availableSessions.filter((result) => result!== undefined).map((result) => result);
  }

  return availableSessions.filter((session) => session!== undefined && session!== null).filter((value, index, array) => array.indexOf(value) === index);
}

module.exports = getSessions;

Code Breakdown

Imported Modules

The code imports the following modules:

• importer: a module for importing other modules
• selenium-webdriver: a Selenium Webdriver module for interacting with web browsers
• selenium-webdriver/chrome: a Chrome-specific module for Selenium Webdriver
• webdriver-client: a module for creating a WebDriver client

Constants

• LOCAL_URL: a constant for the local Selenium server URL (http://localhost:4444/wd/hub)

Functions

verifySession

• A function that takes a WebDriver instance and a session ID as input
• It creates a new Chrome driver instance with the given session ID and executor
• It attempts to get the window handles of the driver and logs them to the console
• It returns the session ID if the driver is successfully created and window handles are obtained
• It catches any errors that occur and logs them to the console

getSessions

• A function that takes an optional WebDriver instance and an inactive flag as input
• It reads sessions from the readSessions function and filters them to get active sessions (sessions with a non-null and non-empty session ID)
• It iterates over the active sessions, verifying each session using the verifySession function
• It returns an array of available sessions that were successfully verified

Exports

The getSessions function is exported as a module export.