browser-commander 0.25.0 → 0.26.1

package/src/browser/safari-support.js

@@ -0,0 +1,98 @@
+import { findBrowserSource } from './browser-sources.js';
+import { runCommand } from '../utilities/subprocess.js';
+
+/** Whether a channel (including aliases) selects an installed Safari. */
+export function isSafariChannel(channel) {
+  return findBrowserSource(channel)?.family === 'safari';
+}
+
+/** A requested operation unavailable in Safari's classic WebDriver. */
+export class SafariUnsupportedError extends Error {
+  constructor(feature) {
+    super(`${feature} is unsupported on safari`);
+    this.name = 'SafariUnsupportedError';
+    this.code = 'SAFARI_UNSUPPORTED';
+    this.feature = feature;
+  }
+}
+
+/** One-time setup failure with actionable instructions and a settings opener. */
+export class SafariSetupError extends Error {
+  constructor(cause, channel = 'safari') {
+    const driver = findBrowserSource(channel).executables.darwin[0];
+    super(
+      `Safari automation setup required: ${cause.message}. In Safari → Settings → Advanced enable "Show features for web developers", then Develop → "Allow Remote Automation". Run "${driver}" --enable once (an admin password may be required). Call error.openSettings() to open Safari's Advanced settings.`,
+      { cause }
+    );
+    this.name = 'SafariSetupError';
+    this.code = 'SAFARI_SETUP_REQUIRED';
+    this.channel = channel;
+  }
+  openSettings() {
+    return openSafariSettings({ channel: this.channel });
+  }
+}
+
+/** Translate only recognizable authorization failures; preserve other errors. */
+export function safariLaunchError(error, channel) {
+  return /allow\s+remote\s+automation|remote automation.*(?:disabled|enable)|(?:safaridriver|webdriver).*(?:--enable|authoriz|not enabled)|not authorized.*(?:safari|automation)/i.test(
+    error.message
+  )
+    ? new SafariSetupError(error, channel)
+    : error;
+}
+
+/** Open Advanced settings on explicit request; never change authorization. */
+export async function openSafariSettings({
+  channel = 'safari',
+  platform = process.platform,
+  run = runCommand,
+} = {}) {
+  if (platform !== 'darwin') {
+    throw new SafariUnsupportedError('Safari settings outside macOS');
+  }
+  const app =
+    findBrowserSource(channel)?.id === 'safari-technology-preview'
+      ? 'Safari Technology Preview'
+      : 'Safari';
+  return await run('osascript', [
+    '-e',
+    `tell application "${app}" to activate`,
+    '-e',
+    `tell application "${app}" to open location "x-safari-preferences:com.apple.Safari.preferences.Advanced"`,
+  ]);
+}
+
+/** Reject settings Safari cannot apply before touching disk or starting it. */
+export function validateSafariOptions(options) {
+  for (const name of [
+    'headless',
+    'userDataDir',
+    'attach',
+    'migrateFrom',
+    'remoteDebuggingPort',
+    'cdpEndpoint',
+    'wsEndpoint',
+    'fingerprint',
+    'colorScheme',
+    'downloads',
+    'bidi',
+    'preferences',
+    'localState',
+    'defaultBrowserCheck',
+    'firstRun',
+  ]) {
+    if (
+      options[name] !== undefined &&
+      options[name] !== null &&
+      options[name] !== false
+    ) {
+      throw new SafariUnsupportedError(name);
+    }
+  }
+  for (const name of ['args', 'extraArgs', 'restrictions']) {
+    if (options[name]?.length) {
+      throw new SafariUnsupportedError(name);
+    }
+  }
+}

package/src/browser/storage-state.js

@@ -31,27 +31,47 @@ function restoreOriginLocalStorage(origins) {
 }
 
 /** Restore classic WebDriver cookies; origin preload scripts require BiDi. */
-export async function restoreWebDriverStorageState({ page, storageState }) {
-  if (!storageState) {
+export async function restoreWebDriverStorageState({
+  page,
+  storageState,
+  seedCookies = [],
+}) {
+  storageState = await loadStorageState(storageState);
+  if (!storageState && !seedCookies.length) {
     return;
   }
-  const origins = storageState.origins ?? [];
+  const origins = storageState?.origins ?? [];
   if (origins.length) {
-    await page.evaluateOnNewDocument(restoreOriginLocalStorage, origins);
-    await page.evaluate(restoreOriginLocalStorage, origins);
+    if (!page.browserName?.toLowerCase().startsWith('safari')) {
+      await page.evaluateOnNewDocument(restoreOriginLocalStorage, origins);
+      await page.evaluate(restoreOriginLocalStorage, origins);
+    }
   }
   const originalUrl = page.url();
-  const cookies = storageState.cookies ?? [];
+  const cookies = [...(storageState?.cookies ?? []), ...seedCookies];
   try {
     for (const cookie of cookies) {
       const origin = cookie.url
         ? new URL(cookie.url).origin
-        : `${cookie.secure ? 'https' : 'http'}://${cookie.domain.replace(/^\./u, '')}`;
+        : (origins.find(
+            ({ origin }) =>
+              new URL(origin).hostname === cookie.domain?.replace(/^\./u, '')
+          )?.origin ??
+          `${cookie.secure ? 'https' : 'http'}://${cookie.domain.replace(/^\./u, '')}`);
       await page.goto(origin);
       await page.setCookie(cookie);
     }
+    if (page.browserName?.toLowerCase().startsWith('safari')) {
+      for (const { origin } of origins) {
+        await page.goto(origin);
+        await page.evaluate(restoreOriginLocalStorage, origins);
+      }
+    }
   } finally {
-    if (cookies.length) {
+    if (
+      cookies.length ||
+      (origins.length && page.browserName?.toLowerCase().startsWith('safari'))
+    ) {
       await page.goto(originalUrl);
     }
   }

package/src/browser/webdriver.js

@@ -28,6 +28,7 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 
 import { createWebDriverPage } from '../core/webdriver-page.js';
+import { isVerboseEnabled } from '../core/logger.js';
 import {
   runCommand as defaultRunCommand,
   startProcess as defaultStartProcess,
@@ -40,6 +41,13 @@ import {
 } from './profile-directory.js';
 import { buildRealBrowserArgs } from './real-browser.js';
 import { resolveRestrictions } from './restrictions.js';
+import { findBrowserSource } from './browser-sources.js';
+import {
+  isSafariChannel,
+  SafariUnsupportedError,
+  safariLaunchError,
+  validateSafariOptions,
+} from './safari-support.js';
 
 const require = createRequire(import.meta.url);
 const accessAsync = promisify(access);
@@ -76,6 +84,8 @@ export const CHROMEDRIVER_DEFAULT_SWITCHES = Object.freeze([
 const DRIVERS = Object.freeze({
   chrome: { name: 'chromedriver', builder: 'chrome' },
   firefox: { name: 'geckodriver', builder: 'firefox' },
+  safari: { name: 'safaridriver', builder: 'safari' },
+  'safari-technology-preview': { name: 'safaridriver', builder: 'safari' },
 });
 
 /**
@@ -102,7 +112,7 @@ export function loadSelenium(subpath) {
 function assertBrowser(browser) {
   if (!DRIVERS[browser]) {
     throw new Error(
-      `Unsupported WebDriver browser: ${browser}. Expected 'chrome' or 'firefox'`
+      `Unsupported WebDriver browser: ${browser}. Expected 'chrome', 'firefox' or 'safari'`
     );
   }
   return DRIVERS[browser];
@@ -182,6 +192,20 @@ export async function resolveWebDriverExecutable({
   managerPath,
 } = {}) {
   const { name } = assertBrowser(browser);
+  if (isSafariChannel(browser)) {
+    if (platform !== 'darwin') {
+      throw new SafariUnsupportedError('Safari launch outside macOS');
+    }
+    const file = driverPath ?? findBrowserSource(browser).executables.darwin[0];
+    if (!(await isExecutable(file, checkAccess))) {
+      throw new Error(`Safari WebDriver executable is not accessible: ${file}`);
+    }
+    return {
+      driverPath: file,
+      browserPath: null,
+      source: 'bundled-safaridriver',
+    };
+  }
   if (driverPath) {
     if (!(await isExecutable(driverPath, checkAccess))) {
       throw new Error(`WebDriver executable is not accessible: ${driverPath}`);
@@ -237,6 +261,9 @@ export async function resolveWebDriverExecutable({
  * @returns {string[]}
  */
 export function buildDriverServerArgs(browser, port) {
+  if (isSafariChannel(browser)) {
+    return ['--port', String(port)];
+  }
   if (assertBrowser(browser).name === 'geckodriver') {
     return ['--port', String(port), '--host', LOOPBACK_HOST];
   }
@@ -306,6 +333,16 @@ export function buildBrowserOptions({
 }) {
   let options;
   let browserArgs;
+  if (isSafariChannel(browser)) {
+    options = new selenium.webdriver.Capabilities();
+    options.set(
+      'browserName',
+      browser === 'safari-technology-preview'
+        ? 'Safari Technology Preview'
+        : 'safari'
+    );
+    return { options, args: [] };
+  }
   if (browser === 'chrome') {
     options = new selenium.chrome.Options();
     if (debuggerAddress) {
@@ -387,7 +424,9 @@ function buildSession({ selenium, serverUrl, browser, options }) {
   const builder = new selenium.webdriver.Builder()
     .usingServer(serverUrl)
     .forBrowser(DRIVERS[browser].builder);
-  if (browser === 'chrome') {
+  if (isSafariChannel(browser)) {
+    builder.withCapabilities(options);
+  } else if (browser === 'chrome') {
     builder.setChromeOptions(options);
   } else {
     builder.setFirefoxOptions(options);
@@ -446,6 +485,68 @@ async function teardown({
  * @returns {Promise<{driver: Object, page: Object, close: function(): Promise<void>, serverUrl: string, driverProcess: Object, driverPath: string, driverSource: string, browser: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, bidi: boolean}>}
  */
 export async function launchWebDriver(options = {}, dependencies = {}) {
+  if (!isSafariChannel(options.browser ?? 'chrome')) {
+    return await launchWebDriverOnce(options, dependencies);
+  }
+  const delay = dependencies.safariRetryDelay ?? SAFARI_RETRY_DELAY;
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await launchWebDriverOnce(options, dependencies);
+    } catch (error) {
+      if (
+        attempt >= SAFARI_LAUNCH_ATTEMPTS ||
+        !TRANSIENT_DRIVER_START_ERROR.test(error?.message ?? '')
+      ) {
+        throw error;
+      }
+      if (isVerboseEnabled()) {
+        console.warn(
+          `[webdriver] Safari launch attempt ${attempt} failed, retrying in ${delay}ms: ${error.message}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+
+/**
+ * safaridriver serves one Safari automation session at a time. Launched right
+ * after a previous session closed, CI saw a new driver exit with code 1 before
+ * it was ready, and a driver that was ready refuse the new-session request
+ * (issue #128). Both are start-up failures of a driver this process owns, so a
+ * Safari launch starts a fresh driver for them, a bounded number of times.
+ */
+const SAFARI_LAUNCH_ATTEMPTS = 3;
+const SAFARI_RETRY_DELAY = 1000;
+const TRANSIENT_DRIVER_START_ERROR =
+  /ECONNREFUSED|ECONNRESET|socket hang up|exited with code \d+ before it was ready/;
+
+/**
+ * Name the driver server behind a connection error from selenium, which only
+ * says which port refused: whether the server had exited, and its last output.
+ */
+function withDriverContext(error, { serverUrl, exitCode, output }) {
+  if (
+    !serverUrl ||
+    !/ECONNREFUSED|ECONNRESET|socket hang up/.test(error?.message ?? '')
+  ) {
+    return error;
+  }
+  const state =
+    exitCode === null || exitCode === undefined
+      ? 'was still running'
+      : `had exited with code ${exitCode}`;
+  const tail = output.trim();
+  return Object.assign(
+    new Error(
+      `${error.message} (WebDriver server at ${serverUrl} ${state}${tail ? `: ${tail}` : ''})`,
+      { cause: error }
+    ),
+    { code: error.code }
+  );
+}
+
+async function launchWebDriverOnce(options, dependencies) {
   const {
     browser = 'chrome',
     executablePath,
@@ -462,6 +563,10 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
     debuggerAddress,
   } = options;
   assertBrowser(browser);
+  const safari = isSafariChannel(browser);
+  if (safari) {
+    validateSafariOptions(options);
+  }
   if (debuggerAddress && browser !== 'chrome') {
     throw new Error('debuggerAddress is only supported by Chrome WebDriver');
   }
@@ -476,39 +581,36 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
   const startProcess = dependencies.startProcess ?? defaultStartProcess;
 
   const resolved = await resolveWebDriverExecutable({
+    ...dependencies,
     browser,
     driverPath: requestedDriverPath,
     executablePath,
-    runCommand: dependencies.runCommand ?? defaultRunCommand,
-    ...(dependencies.checkAccess
-      ? { checkAccess: dependencies.checkAccess }
-      : {}),
-    ...(dependencies.environment
-      ? { environment: dependencies.environment }
-      : {}),
-    ...(dependencies.platform ? { platform: dependencies.platform } : {}),
   });
 
-  const temporaryProfile = !debuggerAddress && !requestedUserDataDir;
-  const userDataDir = debuggerAddress
-    ? undefined
-    : await resolveProfile(browser, requestedUserDataDir);
+  const temporaryProfile = !safari && !debuggerAddress && !requestedUserDataDir;
+  const userDataDir =
+    safari || debuggerAddress
+      ? undefined
+      : await resolveProfile(browser, requestedUserDataDir);
   const childEnv = driverEnvironment(restrictions, env);
 
   let driverProcess;
   let driver;
+  let serverUrl;
+  let output = '';
   try {
     const port = await reservePort();
-    const serverUrl = `http://${LOOPBACK_HOST}:${port}`;
+    serverUrl = `http://${LOOPBACK_HOST}:${port}`;
     driverProcess = startProcess(
       resolved.driverPath,
       buildDriverServerArgs(browser, port),
       { env: childEnv, forwardOutput: verbose }
     );
-    let output = '';
-    driverProcess.stderr?.on('data', (chunk) => {
-      output = `${output}${chunk}`.slice(-4000);
-    });
+    for (const stream of [driverProcess.stdout, driverProcess.stderr]) {
+      stream?.on('data', (chunk) => {
+        output = `${output}${chunk}`.slice(-4000);
+      });
+    }
     await waitForDriverReady(serverUrl, {
       fetchImplementation: dependencies.fetch ?? fetch,
       timeout: startupTimeout,
@@ -536,7 +638,14 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
       browser,
       options: built.options,
     });
-    const page = await createWebDriverPage(driver, dependencies.pageOptions);
+    // Fresh Safari sessions can report an empty URL until first navigation.
+    if (safari) {
+      await driver.get('about:blank');
+    }
+    const page = await createWebDriverPage(driver, {
+      ...dependencies.pageOptions,
+      ...(safari ? { browserName: 'safari' } : {}),
+    });
 
     const close = memoize(() =>
       teardown({ page, driver, driverProcess, temporaryProfile, userDataDir })
@@ -557,8 +666,10 @@ export async function launchWebDriver(options = {}, dependencies = {}) {
       bidi,
     };
   } catch (error) {
+    const exitCode = driverProcess?.exitCode;
     await teardown({ driver, driverProcess, temporaryProfile, userDataDir });
-    throw error;
+    const failure = withDriverContext(error, { serverUrl, exitCode, output });
+    throw safari ? safariLaunchError(failure, browser) : failure;
   }
 }
 

package/src/cli/sessions.js

@@ -12,6 +12,9 @@ export const BROWSER_CHANNELS = Object.freeze({
   msedge: 'msedge',
   brave: 'brave',
   chromium: 'chromium',
+  safari: 'safari',
+  'safari-technology-preview': 'safari-technology-preview',
+  'safari-tp': 'safari-technology-preview',
 });
 
 const ENGINES = Object.freeze(['playwright', 'puppeteer', 'selenium']);
@@ -40,6 +43,7 @@ const LAUNCH_PASSTHROUGH = Object.freeze([
   'firstRun',
   'driverPath',
   'bidi',
+  'seedCookies',
 ]);
 
 /** Validate an engine name, defaulting to Playwright. */
@@ -118,6 +122,7 @@ export function buildLaunchOptions(params = {}) {
  * persistent context whose `browser()` is null. Puppeteer returns a Browser.
  */
 export function sessionFromLaunch(engine, launched) {
+  engine = launched.engine ?? engine;
   const playwright = engine === 'playwright';
   const handle = launched.browser;
   return {

package/src/core/webdriver-page.js

@@ -32,6 +32,7 @@ import {
   toWebDriverKey,
 } from './webdriver-conversions.js';
 import { createWebDriverEventBridge } from './webdriver-events.js';
+import { SafariUnsupportedError } from '../browser/safari-support.js';
 
 const require = createRequire(import.meta.url);
 
@@ -99,6 +100,7 @@ export class WebDriverPage extends EventEmitter {
     }
     this.driver = driver;
     this.engine = 'selenium';
+    this.browserName = options.browserName;
     this.isWebDriverPage = true;
     this._url = 'about:blank';
     this._closed = false;
@@ -358,6 +360,57 @@ export class WebDriverPage extends EventEmitter {
     return result;
   }
 
+  /** Execute an asynchronous function using W3C execute/async. */
+  async evaluateAsync(pageFunction, ...args) {
+    const script = buildEvaluateScript(pageFunction);
+    const result = await this.driver.executeAsyncScript(
+      `const done = arguments[arguments.length - 1]; const args = Array.from(arguments).slice(0, -1); Promise.resolve((function(){${script}}).apply(null, args)).then(value => done({value}), error => done({error: String(error)}));`,
+      ...args
+    );
+    if (result.error) {
+      throw new Error(result.error);
+    }
+    const [value, href] = result.value;
+    this._url = href;
+    return value;
+  }
+
+  /** Fail before subscribing or creating files for unsupported Safari features. */
+  requireFeature(feature) {
+    if (this.browserName?.toLowerCase().startsWith('safari')) {
+      throw new SafariUnsupportedError(feature);
+    }
+  }
+
+  setRequestInterception() {
+    return Promise.resolve().then(() => {
+      this.requireFeature('network interception');
+      throw new Error('Network interception requires a supporting engine');
+    });
+  }
+
+  route() {
+    return this.setRequestInterception();
+  }
+
+  /** W3C window handles include both tabs and windows. */
+  async windows() {
+    return await this.driver.getAllWindowHandles();
+  }
+
+  async newWindow(type = 'tab') {
+    await this.driver.switchTo().newWindow(type);
+    this._contextId = await this.driver.getWindowHandle();
+    await this.syncUrl();
+    return this._contextId;
+  }
+
+  async switchToWindow(handle) {
+    await this.driver.switchTo().window(handle);
+    this._contextId = handle;
+    await this.syncUrl();
+  }
+
   /**
    * Puppeteer's evaluateOnNewDocument, as a BiDi preload script.
    *
@@ -626,6 +679,7 @@ export class WebDriverPage extends EventEmitter {
    * @returns {Promise<Buffer>}
    */
   async pdf(options = {}) {
+    this.requireFeature('PDF');
     const buffer = Buffer.from(
       await this.driver.printPage(toPrintOptions(options)),
       'base64'
@@ -709,6 +763,14 @@ export class WebDriverPage extends EventEmitter {
  * @returns {Promise<WebDriverPage>}
  */
 export async function createWebDriverPage(driver, options = {}) {
+  if (!options.browserName) {
+    const capabilities = await driver.getCapabilities();
+    options = {
+      ...options,
+      browserName:
+        capabilities?.get?.('browserName') ?? capabilities?.browserName,
+    };
+  }
   const page = new WebDriverPage(driver, options);
   await page.contextId();
   await page.syncUrl();

package/src/elements/selectors.js

@@ -117,6 +117,31 @@ function isPlaywrightTextSelector(selector) {
   return selector.includes(':has-text(') || selector.includes(':text-is(');
 }
 
+/**
+ * Split `base:<pseudo>("text")` into its base selector and text.
+ *
+ * String operations rather than a regular expression: the former
+ * /^(.+?):has-text\("(.+?)"\)$/ backtracked quadratically on long selectors
+ * that do not match (CodeQL js/polynomial-redos). The base is everything before
+ * the first `:<pseudo>("`, as the lazy `(.+?)` made it; base and text must be
+ * non-empty.
+ * @param {string} selector - Selector to split
+ * @param {string} pseudo - Pseudo-class name, e.g. 'has-text'
+ * @returns {{baseSelector: string, text: string}|null} - Parts, or null
+ */
+function splitTextPseudo(selector, pseudo) {
+  const open = `:${pseudo}("`;
+  const start = selector.indexOf(open, 1);
+  if (start === -1 || !selector.endsWith('")')) {
+    return null;
+  }
+  const text = selector.slice(start + open.length, -2);
+  if (!text) {
+    return null;
+  }
+  return { baseSelector: selector.slice(0, start), text };
+}
+
 /**
  * Parse a Playwright text selector to extract base selector and text
  * @param {string} selector - Playwright text selector like 'a:has-text("text")'
@@ -124,22 +149,14 @@ function isPlaywrightTextSelector(selector) {
  */
 function parsePlaywrightTextSelector(selector) {
   // Match patterns like 'a:has-text("text")' or 'button:text-is("exact text")'
-  const hasTextMatch = selector.match(/^(.+?):has-text\("(.+?)"\)$/);
-  if (hasTextMatch) {
-    return {
-      baseSelector: hasTextMatch[1],
-      text: hasTextMatch[2],
-      exact: false,
-    };
+  const hasText = splitTextPseudo(selector, 'has-text');
+  if (hasText) {
+    return { ...hasText, exact: false };
   }
 
-  const textIsMatch = selector.match(/^(.+?):text-is\("(.+?)"\)$/);
-  if (textIsMatch) {
-    return {
-      baseSelector: textIsMatch[1],
-      text: textIsMatch[2],
-      exact: true,
-    };
+  const textIs = splitTextPseudo(selector, 'text-is');
+  if (textIs) {
+    return { ...textIs, exact: true };
   }
 
   return null;

package/src/exports.js

@@ -322,3 +322,9 @@ export {
   redactUrl,
   redactValue,
 } from './traces/redaction.js';
+
+export {
+  SafariSetupError,
+  SafariUnsupportedError,
+  openSafariSettings,
+} from './browser/safari-support.js';

package/src/parity/harness.js

@@ -109,8 +109,11 @@ export async function startProbeServer(probeSource) {
       });
     },
     async close() {
+      // Stop listening before dropping connections, so none can slip in
+      // between and keep close() waiting (issue #128).
+      const closed = new Promise((resolve) => server.close(resolve));
       server.closeAllConnections?.();
-      await new Promise((resolve) => server.close(resolve));
+      await closed;
     },
   };
 }

package/src/tests/index.js

@@ -176,7 +176,18 @@ function expandBrowserTestEntries(scenarios, engines) {
 }
 
 function sanitizeArtifactName(value) {
-  return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  const name = value.replace(/[^a-zA-Z0-9._-]+/g, '-');
+  // Trimmed by index: /^-+|-+$/g backtracks quadratically on a long run of
+  // inner dashes (CodeQL js/polynomial-redos).
+  let start = 0;
+  let end = name.length;
+  while (start < end && name[start] === '-') {
+    start++;
+  }
+  while (end > start && name[end - 1] === '-') {
+    end--;
+  }
+  return name.slice(start, end);
 }
 
 function closeBrowserLike(browser) {

package/src/traces/recorder.js

@@ -93,6 +93,7 @@ function validateLinksOptions(links) {
  * @returns {Promise<Object>} The running trace
  */
 export async function startTrace(options = {}) {
+  requireTraceSupport(options);
   const {
     commander,
     page = commander?.page,
@@ -468,3 +469,7 @@ export async function startTrace(options = {}) {
     },
   };
 }
+
+function requireTraceSupport(options) {
+  (options.page ?? options.commander?.page)?.requireFeature?.('tracing');
+}

package/tests/e2e/engine-matrix.e2e.test.js

@@ -5,6 +5,7 @@ import { createServer } from 'node:http';
 import { describe, it } from 'node:test';
 import { launchBrowser } from '../../src/browser/launcher.js';
 import { makeBrowserCommander } from '../../src/factory.js';
+import { closeServer } from '../helpers/fixture-server.js';
 import {
   CHROME_LAUNCH_OPTIONS,
   PARITY_CHROME,
@@ -50,7 +51,7 @@ describe('Common native engine API', { skip: !process.env.RUN_E2E }, () => {
         );
       } finally {
         await session?.close();
-        await new Promise((resolve) => server.close(resolve));
+        await closeServer(server);
       }
     }
   );