browser-commander 0.23.0 → 0.25.0

package/src/browser/safari-profiles.js

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import { open } from 'node:fs/promises';
+import { findSafariCookieFile } from './safari-cookies.js';
+import { findSafariFile, withSafariAccess } from './safari-access.js';
+import { openSqliteDatabase } from './browser-cookie-database.js';
+
+/** SafariTabs supplies names; each UUID has separate Safari and WebKit stores. */
+export async function listSafariProfiles(browser, root) {
+  const profiles = [];
+  const defaultFile =
+    (await findSafariCookieFile(root)) ??
+    (await findSafariFile([
+      path.join(root, 'Safari/History.db'),
+      path.join(root, 'History.db'),
+      path.join(root, 'Safari/Bookmarks.plist'),
+      path.join(root, 'Bookmarks.plist'),
+    ]));
+  if (defaultFile) {
+    profiles.push({
+      browser,
+      name: 'Default',
+      displayName: 'Default',
+      path: root,
+      isDefault: true,
+    });
+  }
+  const tabs = await findSafariFile([
+    path.join(root, 'Safari/SafariTabs.db'),
+    path.join(root, 'SafariTabs.db'),
+  ]);
+  if (!tabs) {
+    return profiles;
+  }
+  let rows;
+  try {
+    rows = await withSafariAccess(tabs, async () => {
+      const file = await open(tabs, 'r');
+      await file.close();
+      const db = await openSqliteDatabase(tabs, {
+        readOnly: true,
+        fileMustExist: true,
+      });
+      try {
+        return db
+          .prepare(
+            "SELECT DISTINCT external_uuid,title FROM bookmarks WHERE subtype=2 AND external_uuid != 'DefaultProfile' ORDER BY external_uuid"
+          )
+          .all();
+      } finally {
+        db.close();
+      }
+    });
+  } catch (error) {
+    profiles.push({
+      browser,
+      name: 'Profiles',
+      displayName: 'Safari profile discovery',
+      path: root,
+      isDefault: false,
+      error: error.message,
+    });
+    return profiles;
+  }
+  for (const row of rows) {
+    if (
+      !/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu.test(
+        row.external_uuid ?? ''
+      )
+    ) {
+      continue;
+    }
+    const name = row.external_uuid.toUpperCase();
+    const profilePath = path.join(root, 'Safari/Profiles', name);
+    profiles.push({
+      browser,
+      name,
+      displayName: row.title ?? name,
+      path: profilePath,
+      isDefault: false,
+    });
+  }
+  return profiles;
+}

package/src/browser/storage-state.js

@@ -30,6 +30,33 @@ function restoreOriginLocalStorage(origins) {
   }
 }
 
+/** Restore classic WebDriver cookies; origin preload scripts require BiDi. */
+export async function restoreWebDriverStorageState({ page, storageState }) {
+  if (!storageState) {
+    return;
+  }
+  const origins = storageState.origins ?? [];
+  if (origins.length) {
+    await page.evaluateOnNewDocument(restoreOriginLocalStorage, origins);
+    await page.evaluate(restoreOriginLocalStorage, origins);
+  }
+  const originalUrl = page.url();
+  const cookies = storageState.cookies ?? [];
+  try {
+    for (const cookie of cookies) {
+      const origin = cookie.url
+        ? new URL(cookie.url).origin
+        : `${cookie.secure ? 'https' : 'http'}://${cookie.domain.replace(/^\./u, '')}`;
+      await page.goto(origin);
+      await page.setCookie(cookie);
+    }
+  } finally {
+    if (cookies.length) {
+      await page.goto(originalUrl);
+    }
+  }
+}
+
 /**
  * Apply Playwright-compatible storage state to a Puppeteer page.
  * @param {Object} options - Restore options

package/src/browser/system-browser.js

@@ -1,4 +1,10 @@
 import { constants } from 'node:fs';
+import { physicalPath } from './browser-profile-files.js';
+import {
+  BROWSER_SOURCES,
+  resolveBrowserRoots,
+  resolveBrowserExecutables,
+} from './browser-sources.js';
 import { access } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -9,18 +15,16 @@ import path from 'node:path';
  * to refuse a default profile; profile migration uses it to find the source.
  */
 
-export const CHANNEL_EXECUTABLE_NAMES = {
-  brave: ['brave-browser', 'brave-browser-stable', 'brave'],
-  chrome: ['google-chrome', 'google-chrome-stable', 'chrome'],
-  'chrome-beta': ['google-chrome-beta'],
-  'chrome-canary': ['google-chrome-canary'],
-  'chrome-dev': ['google-chrome-unstable'],
-  chromium: ['chromium', 'chromium-browser'],
-  msedge: ['microsoft-edge', 'microsoft-edge-stable', 'msedge'],
-  'msedge-beta': ['microsoft-edge-beta'],
-  'msedge-canary': ['microsoft-edge-canary'],
-  'msedge-dev': ['microsoft-edge-dev'],
-};
+export const CHANNEL_EXECUTABLE_NAMES = Object.freeze(
+  Object.fromEntries(
+    BROWSER_SOURCES.flatMap((browser) =>
+      [browser.id, ...(browser.aliases ?? [])].map((name) => [
+        name,
+        browser.executableNames ?? [],
+      ])
+    )
+  )
+);
 
 function platformPath(platform) {
   return platform === 'win32' ? path.win32 : path;
@@ -41,72 +45,13 @@ export function knownDefaultUserDataDirs({
   homeDir = os.homedir(),
   environment = process.env,
 } = {}) {
-  const pathApi = platformPath(platform);
-  if (platform === 'darwin') {
-    const applicationSupport = pathApi.join(
+  return BROWSER_SOURCES.flatMap((browser) =>
+    resolveBrowserRoots(browser.id, {
+      platform,
       homeDir,
-      'Library',
-      'Application Support'
-    );
-    return [
-      pathApi.join(applicationSupport, 'Google', 'Chrome'),
-      pathApi.join(applicationSupport, 'Google', 'Chrome Beta'),
-      pathApi.join(applicationSupport, 'Google', 'Chrome Canary'),
-      pathApi.join(applicationSupport, 'Google', 'Chrome Dev'),
-      pathApi.join(applicationSupport, 'Chromium'),
-      pathApi.join(applicationSupport, 'BraveSoftware', 'Brave-Browser'),
-      pathApi.join(applicationSupport, 'BraveSoftware', 'Brave-Browser-Beta'),
-      pathApi.join(
-        applicationSupport,
-        'BraveSoftware',
-        'Brave-Browser-Nightly'
-      ),
-      pathApi.join(applicationSupport, 'Microsoft Edge'),
-      pathApi.join(applicationSupport, 'Microsoft Edge Beta'),
-      pathApi.join(applicationSupport, 'Microsoft Edge Canary'),
-      pathApi.join(applicationSupport, 'Microsoft Edge Dev'),
-    ];
-  }
-  if (platform === 'win32') {
-    const localAppData =
-      environment.LOCALAPPDATA ?? pathApi.join(homeDir, 'AppData', 'Local');
-    return [
-      pathApi.join(localAppData, 'Google', 'Chrome', 'User Data'),
-      pathApi.join(localAppData, 'Google', 'Chrome Beta', 'User Data'),
-      pathApi.join(localAppData, 'Google', 'Chrome Dev', 'User Data'),
-      pathApi.join(localAppData, 'Google', 'Chrome SxS', 'User Data'),
-      pathApi.join(localAppData, 'Chromium', 'User Data'),
-      pathApi.join(localAppData, 'BraveSoftware', 'Brave-Browser', 'User Data'),
-      pathApi.join(
-        localAppData,
-        'BraveSoftware',
-        'Brave-Browser-Beta',
-        'User Data'
-      ),
-      pathApi.join(
-        localAppData,
-        'BraveSoftware',
-        'Brave-Browser-Nightly',
-        'User Data'
-      ),
-      pathApi.join(localAppData, 'Microsoft', 'Edge', 'User Data'),
-      pathApi.join(localAppData, 'Microsoft', 'Edge Beta', 'User Data'),
-      pathApi.join(localAppData, 'Microsoft', 'Edge Dev', 'User Data'),
-      pathApi.join(localAppData, 'Microsoft', 'Edge SxS', 'User Data'),
-    ];
-  }
-  return [
-    pathApi.join(homeDir, '.config', 'google-chrome'),
-    pathApi.join(homeDir, '.config', 'google-chrome-beta'),
-    pathApi.join(homeDir, '.config', 'google-chrome-unstable'),
-    pathApi.join(homeDir, '.config', 'chromium'),
-    pathApi.join(homeDir, '.config', 'BraveSoftware', 'Brave-Browser'),
-    pathApi.join(homeDir, '.config', 'BraveSoftware', 'Brave-Browser-Beta'),
-    pathApi.join(homeDir, '.config', 'BraveSoftware', 'Brave-Browser-Nightly'),
-    pathApi.join(homeDir, '.config', 'microsoft-edge'),
-    pathApi.join(homeDir, '.config', 'microsoft-edge-beta'),
-    pathApi.join(homeDir, '.config', 'microsoft-edge-dev'),
-  ];
+      environment,
+    })
+  );
 }
 
 /** Ensure Chrome is not asked to expose the user's default profile over CDP. */
@@ -117,12 +62,17 @@ export function assertDedicatedUserDataDir(userDataDir, platformOptions = {}) {
   const platform = platformOptions.platform ?? process.platform;
   const pathApi = platformPath(platform);
   const normalize = (value) => {
-    const resolved = pathApi.resolve(value).replace(/[\\/]+$/, '');
+    let resolved = pathApi.resolve(value).replace(/[\\/]+$/, '');
+    if (platform === process.platform) {
+      resolved = physicalPath(resolved);
+    }
     return platform === 'win32' ? resolved.toLowerCase() : resolved;
   };
   const requested = normalize(userDataDir);
   const isDefault = knownDefaultUserDataDirs(platformOptions).some(
-    (directory) => normalize(directory) === requested
+    (directory) =>
+      requested === normalize(directory) ||
+      requested.startsWith(`${normalize(directory)}${pathApi.sep}`)
   );
   if (isDefault) {
     throw new Error(
@@ -136,74 +86,12 @@ function browserInstallCandidates({
   platform = process.platform,
   environment = process.env,
 }) {
-  const candidates = [];
-  const names = CHANNEL_EXECUTABLE_NAMES[channel];
-  if (!names) {
+  if (!CHANNEL_EXECUTABLE_NAMES[channel]?.length) {
     throw new Error(
       `Unknown browser channel: ${channel}. Expected one of ${Object.keys(CHANNEL_EXECUTABLE_NAMES).join(', ')}`
     );
   }
-
-  if (platform === 'darwin') {
-    const applications = {
-      brave: 'Brave Browser.app/Contents/MacOS/Brave Browser',
-      chrome: 'Google Chrome.app/Contents/MacOS/Google Chrome',
-      'chrome-beta': 'Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
-      'chrome-canary':
-        'Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
-      'chrome-dev': 'Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev',
-      chromium: 'Chromium.app/Contents/MacOS/Chromium',
-      msedge: 'Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-      'msedge-beta':
-        'Microsoft Edge Beta.app/Contents/MacOS/Microsoft Edge Beta',
-      'msedge-canary':
-        'Microsoft Edge Canary.app/Contents/MacOS/Microsoft Edge Canary',
-      'msedge-dev': 'Microsoft Edge Dev.app/Contents/MacOS/Microsoft Edge Dev',
-    };
-    candidates.push(path.join('/Applications', applications[channel]));
-  } else if (platform === 'win32') {
-    const roots = [
-      environment.PROGRAMFILES,
-      environment['PROGRAMFILES(X86)'],
-      environment.LOCALAPPDATA,
-    ].filter(Boolean);
-    const relativePaths = {
-      brave: ['BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'],
-      chrome: ['Google', 'Chrome', 'Application', 'chrome.exe'],
-      'chrome-beta': ['Google', 'Chrome Beta', 'Application', 'chrome.exe'],
-      'chrome-canary': ['Google', 'Chrome SxS', 'Application', 'chrome.exe'],
-      'chrome-dev': ['Google', 'Chrome Dev', 'Application', 'chrome.exe'],
-      chromium: ['Chromium', 'Application', 'chrome.exe'],
-      msedge: ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
-      'msedge-beta': ['Microsoft', 'Edge Beta', 'Application', 'msedge.exe'],
-      'msedge-canary': ['Microsoft', 'Edge SxS', 'Application', 'msedge.exe'],
-      'msedge-dev': ['Microsoft', 'Edge Dev', 'Application', 'msedge.exe'],
-    };
-    for (const root of roots) {
-      candidates.push(path.win32.join(root, ...relativePaths[channel]));
-    }
-  } else {
-    for (const name of names) {
-      candidates.push(`/usr/bin/${name}`, `/usr/local/bin/${name}`);
-    }
-    if (channel === 'chrome') {
-      candidates.push('/opt/google/chrome/google-chrome');
-    }
-  }
-
-  const pathApi = platformPath(platform);
-  const delimiter = platform === 'win32' ? ';' : path.delimiter;
-  for (const directory of (environment.PATH ?? '').split(delimiter)) {
-    if (!directory) {
-      continue;
-    }
-    for (const name of names) {
-      candidates.push(
-        pathApi.join(directory, platform === 'win32' ? `${name}.exe` : name)
-      );
-    }
-  }
-  return [...new Set(candidates)];
+  return resolveBrowserExecutables(channel, { platform, environment });
 }
 
 /** Resolve a genuine installed Chrome-family browser executable. */

package/src/browser/webdriver.js

@@ -302,11 +302,20 @@ export function buildBrowserOptions({
   args,
   automationParity,
   bidi,
+  debuggerAddress,
 }) {
   let options;
   let browserArgs;
   if (browser === 'chrome') {
     options = new selenium.chrome.Options();
+    if (debuggerAddress) {
+      options.debuggerAddress(debuggerAddress);
+      if (bidi) {
+        options.set('webSocketUrl', true);
+        options.set('unhandledPromptBehavior', 'ignore');
+      }
+      return { options, args: [] };
+    }
     browserArgs = buildRealBrowserArgs({
       userDataDir,
       remoteDebuggingPort,
@@ -450,8 +459,12 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
     env,
     startupTimeout = 30_000,
     verbose = false,
+    debuggerAddress,
   } = options;
   assertBrowser(browser);
+  if (debuggerAddress && browser !== 'chrome') {
+    throw new Error('debuggerAddress is only supported by Chrome WebDriver');
+  }
   if (browser === 'firefox' && restrictions.length > 0) {
     throw new Error(
       'Launch restrictions are Chrome switches; not available for firefox'
@@ -476,8 +489,10 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
     ...(dependencies.platform ? { platform: dependencies.platform } : {}),
   });
 
-  const temporaryProfile = !requestedUserDataDir;
-  const userDataDir = await resolveProfile(browser, requestedUserDataDir);
+  const temporaryProfile = !debuggerAddress && !requestedUserDataDir;
+  const userDataDir = debuggerAddress
+    ? undefined
+    : await resolveProfile(browser, requestedUserDataDir);
   const childEnv = driverEnvironment(restrictions, env);
 
   let driverProcess;
@@ -513,6 +528,7 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
       args,
       automationParity,
       bidi,
+      debuggerAddress,
     });
     driver = await buildSession({
       selenium,

package/src/cli/args.js

@@ -31,12 +31,15 @@ const BROWSER_OPTIONS = Object.freeze({
   'local-state': STRINGS,
   'default-browser-check': FLAG,
   'first-run': FLAG,
+  'driver-path': STRING,
+  bidi: FLAG,
 });
 
 /** Options accepted by every page command. */
 const PAGE_OPTIONS = Object.freeze({
   ...BROWSER_OPTIONS,
   'cdp-endpoint': STRING,
+  'server-url': STRING,
   url: STRING,
 });
 
@@ -89,6 +92,8 @@ export const COMMANDS = Object.freeze({
       profile: STRING,
       'user-data-dir': STRING,
       'target-browser': STRING,
+      'password-csv': STRING,
+      'include-payment-cards': FLAG,
       to: STRING,
       include: STRING,
       domain: STRINGS,
@@ -248,6 +253,8 @@ export function launchParams(options) {
     localState: settings(options.localState, '--local-state'),
     defaultBrowserCheck: options.defaultBrowserCheck,
     firstRun: options.firstRun,
+    driverPath: options.driverPath,
+    bidi: options.bidi,
   };
   return Object.fromEntries(
     Object.entries(params).filter(([, value]) => value !== undefined)

package/src/cli/commands.js

@@ -75,12 +75,16 @@ async function withPageSession(parsed, io, work, { skipUrl = false } = {}) {
   const { options } = parsed;
   const dispatcher = createDispatcher({ dependencies: io.dependencies });
   try {
-    const opened = options.cdpEndpoint
-      ? await dispatcher.dispatch('session.connect', {
-          cdpEndpoint: options.cdpEndpoint,
-          engine: options.engine,
-        })
-      : await dispatcher.dispatch('session.launch', launchParams(options));
+    const opened =
+      options.cdpEndpoint || options.serverUrl
+        ? await dispatcher.dispatch('session.connect', {
+            cdpEndpoint: options.cdpEndpoint,
+            engine: options.engine,
+            ...(options.serverUrl ? { serverUrl: options.serverUrl } : {}),
+            ...(options.driverPath ? { driverPath: options.driverPath } : {}),
+            ...(options.bidi !== undefined ? { bidi: options.bidi } : {}),
+          })
+        : await dispatcher.dispatch('session.launch', launchParams(options));
     if (options.url && !skipUrl) {
       await dispatcher.dispatch('page.goto', {
         session: opened.session,
@@ -212,6 +216,8 @@ async function profileMigrate(parsed, io) {
       profile: options.profile,
       userDataDir: options.userDataDir,
       targetBrowser: options.targetBrowser,
+      passwordCsv: options.passwordCsv,
+      includePaymentCards: options.includePaymentCards,
       to: options.to,
       include: options.include
         ?.split(',')

package/src/cli/handle-methods.js

@@ -9,7 +9,7 @@
 import { decodeValue, describeObject, encodeValue } from './handles.js';
 import { invalidParams, requireString } from './rpc-error.js';
 
-const ENGINE_ROOTS = Object.freeze(['playwright', 'puppeteer']);
+const ENGINE_ROOTS = Object.freeze(['playwright', 'puppeteer', 'selenium']);
 
 function targetOf(state, params) {
   const handle = params.handle;
@@ -36,11 +36,14 @@ async function root(state, params) {
       browser: handleOrNull(state, session.browser),
       context: handleOrNull(state, session.context),
       page: handleOrNull(state, session.page),
+      ...(session.engine === 'selenium'
+        ? { driver: handleOrNull(state, session.driver) }
+        : {}),
     };
   }
   if (!ENGINE_ROOTS.includes(name)) {
     throw invalidParams(
-      `Unknown root "${name}"; expected playwright, puppeteer or session:<id>`
+      `Unknown root "${name}"; expected playwright, puppeteer, selenium or session:<id>`
     );
   }
   const module = await state.dependencies.loadEngine(name);
@@ -71,6 +74,19 @@ async function get(state, params) {
   );
 }
 
+/** Instantiate an engine constructor obtained through `handle.get`. */
+function construct(state, params) {
+  const target = targetOf(state, params);
+  const args = params.args ?? [];
+  if (typeof target !== 'function' || !Array.isArray(args)) {
+    throw invalidParams(
+      'handle.construct requires a constructor handle and an args array'
+    );
+  }
+  const result = Reflect.construct(target, decodeValue(args, state.handles));
+  return encodeValue(result, state.handles);
+}
+
 function dispose(state, params) {
   const id =
     typeof params.handle === 'object' && params.handle
@@ -129,6 +145,7 @@ export const HANDLE_METHODS = Object.freeze({
   'handle.root': root,
   'handle.call': call,
   'handle.get': get,
+  'handle.construct': construct,
   'handle.dispose': dispose,
   'handle.describe': describe,
   'events.subscribe': subscribe,

package/src/cli/high-level-methods.js

@@ -37,14 +37,27 @@ async function launchSession(state, params) {
 }
 
 async function connectSession(state, params) {
-  const cdpEndpoint = requireString(params, 'cdpEndpoint');
   const engine = resolveEngine(params.engine);
+  const endpoint =
+    engine === 'selenium' && params.serverUrl !== undefined
+      ? {
+          serverUrl: requireString(params, 'serverUrl'),
+          capabilities: params.capabilities,
+        }
+      : { cdpEndpoint: requireString(params, 'cdpEndpoint') };
   const connected = await state.dependencies.connectBrowser({
     engine,
-    cdpEndpoint,
+    ...endpoint,
+    ...(params.driverPath ? { driverPath: params.driverPath } : {}),
+    ...(params.bidi !== undefined ? { bidi: params.bidi } : {}),
   });
   const session = state.sessions.add(sessionFromConnect(engine, connected));
-  return { session, cdpEndpoint };
+  return {
+    session,
+    ...(endpoint.serverUrl
+      ? { serverUrl: endpoint.serverUrl }
+      : { cdpEndpoint: endpoint.cdpEndpoint }),
+  };
 }
 
 async function closeSession(state, params) {
@@ -70,6 +83,10 @@ async function fill(state, params) {
   const { engine, page } = sessionOf(state, params);
   if (engine === 'playwright') {
     await page.fill(selector, value);
+  } else if (engine === 'selenium') {
+    const element = await page.waitForSelector(selector, { visible: true });
+    await element.clear();
+    await element.sendKeys(value);
   } else {
     await page.locator(selector).fill(value);
   }
@@ -203,6 +220,8 @@ function migrateProfile(state, params) {
     include: params.include,
     domains: params.domains,
     targetBrowser: params.targetBrowser,
+    passwordCsv: params.passwordCsv,
+    includePaymentCards: params.includePaymentCards,
   });
 }
 

package/src/cli/modules.js

@@ -70,7 +70,11 @@ export const DEFAULT_DEPENDENCIES = Object.freeze({
     (await import('../browser/browser-profiles.js')).listBrowserProfiles(
       options
     ),
-  loadEngine: (name) => importOptional(name, `The ${name} engine`),
+  loadEngine: (name) =>
+    importOptional(
+      name === 'selenium' ? 'selenium-webdriver' : name,
+      `The ${name} engine`
+    ),
   openInUserBrowser: async (url) =>
     (
       await importOptional(

package/src/cli/sessions.js

@@ -14,7 +14,7 @@ export const BROWSER_CHANNELS = Object.freeze({
   chromium: 'chromium',
 });
 
-const ENGINES = Object.freeze(['playwright', 'puppeteer']);
+const ENGINES = Object.freeze(['playwright', 'puppeteer', 'selenium']);
 
 /**
  * Launch options that are forwarded to `launchBrowser()` as they are, so the
@@ -38,6 +38,8 @@ const LAUNCH_PASSTHROUGH = Object.freeze([
   'localState',
   'defaultBrowserCheck',
   'firstRun',
+  'driverPath',
+  'bidi',
 ]);
 
 /** Validate an engine name, defaulting to Playwright. */
@@ -85,13 +87,17 @@ export function buildLaunchOptions(params = {}) {
     engine: resolveEngine(params.engine),
     headless: params.headless === true,
   };
-  const channel = resolveChannel(params.browser);
+  const channel =
+    options.engine === 'selenium' ? undefined : resolveChannel(params.browser);
   const defined = {
     launch: params.launch,
     executablePath: params.executablePath,
     userDataDir: params.userDataDir,
     restrictions: params.restrictions,
     channel,
+    ...(options.engine === 'selenium' && params.browser !== undefined
+      ? { browser: params.browser }
+      : {}),
   };
   for (const name of LAUNCH_PASSTHROUGH) {
     defined[name] ??= params[name];
@@ -121,6 +127,7 @@ export function sessionFromLaunch(engine, launched) {
       : handle,
     context: playwright ? handle : (handle?.defaultBrowserContext?.() ?? null),
     page: launched.page,
+    driver: launched.driver ?? (engine === 'selenium' ? handle : null),
     args: launched.args ?? [],
     close: () => launched.close(),
     connected: false,
@@ -141,10 +148,15 @@ export function sessionFromConnect(engine, connected) {
       ? (page?.context?.() ?? null)
       : (browser?.defaultBrowserContext?.() ?? null),
     page,
+    driver: connected.driver ?? null,
     // Playwright's close() on a connectOverCDP browser disconnects;
     // Puppeteer's close() would quit the browser, disconnect() does not.
     close: async () => {
       await connected.downloads?.dispose?.();
+      if (engine === 'selenium') {
+        await connected.close();
+        return;
+      }
       await (playwright ? browser.close() : browser.disconnect());
     },
     connected: true,

package/src/tests/index.js

@@ -57,6 +57,7 @@ export {
 export const SUPPORTED_BROWSER_TEST_ENGINES = Object.freeze([
   'playwright',
   'puppeteer',
+  'selenium',
 ]);
 
 export const DEFAULT_TIMINGS_FILENAME = '.browser-commander-test-timings.json';