@matware/e2e-runner 1.3.1 → 1.5.1

package/src/module-resolver.js

@@ -14,6 +14,7 @@
 import fs from 'fs';
 import path from 'path';
 import { KNOWN_ACTION_TYPES } from './actions.js';
+import { KNOWN_DRIVERS } from './pool.js';
 
 /**
  * Loads all module definitions from a directory.
@@ -170,8 +171,17 @@ function resolveActions(actions, registry, contextParams = {}, visited = new Set
       const moduleActions = moduleDef.actions || [];
       const substituted = moduleActions.map(a => {
         if (a.$use) {
-          // Nested $use — pass through for recursive resolution
-          return { ...a, params: { ...mergedParams, ...a.params } };
+          // Nested $use — resolve {{param}} placeholders in the nested call's
+          // params against THIS module's scope (its merged params + defaults)
+          // so a module can forward its own params/defaults to a module it
+          // $uses. Then merge over the inherited context params as fallback.
+          const nestedParams = {};
+          for (const [k, v] of Object.entries(a.params || {})) {
+            nestedParams[k] = typeof v === 'string'
+              ? substituteParams(v, mergedParams, moduleDef.params)
+              : v;
+          }
+          return { ...a, params: { ...mergedParams, ...nestedParams } };
         }
         return substituteActionParams(a, mergedParams, moduleDef.params, moduleName);
       });
@@ -307,4 +317,27 @@ export function validateActionTypes(data, context) {
     const details = unknown.map(u => `"${u.type}" in ${u.location}`).join(', ');
     throw new Error(`Unknown action type(s) in ${context}: ${details}`);
   }
+
+  // Validate per-test driver / fallbackDriver fields
+  const knownExceptAuto = [...KNOWN_DRIVERS].filter(d => d !== 'auto');
+  for (const test of data.tests || []) {
+    if (test.driver !== undefined && !knownExceptAuto.includes(test.driver)) {
+      throw new Error(
+        `Invalid driver "${test.driver}" in test "${test.name}" (${context}). ` +
+        `Allowed: ${knownExceptAuto.join(', ')}.`
+      );
+    }
+    if (test.fallbackDriver !== undefined && !knownExceptAuto.includes(test.fallbackDriver)) {
+      throw new Error(
+        `Invalid fallbackDriver "${test.fallbackDriver}" in test "${test.name}" (${context}). ` +
+        `Allowed: ${knownExceptAuto.join(', ')}.`
+      );
+    }
+    if (test.fallbackDriver !== undefined && test.driver === undefined) {
+      throw new Error(
+        `Test "${test.name}" (${context}) declares fallbackDriver without driver. ` +
+        `fallbackDriver only applies when driver is set.`
+      );
+    }
+  }
 }

package/src/narrate.js

@@ -36,20 +36,35 @@ export function narrateAction(action, result) {
       return `Typed "${masked}" into "${selector}"${time}`;
     }
 
-    case 'wait':
+    case 'wait': {
+      const goneTarget = typeof action.gone === 'string' ? action.gone : (action.gone === true ? (selector || (text ? `text "${text}"` : null)) : null);
+      if (goneTarget) return `Waited for ${goneTarget.startsWith('text ') ? goneTarget : `"${goneTarget}"`} to disappear${time}`;
       if (selector) return `Waited for "${selector}" to appear${time}`;
       if (text) return `Waited for text "${text}" to appear${time}`;
       return `Waited ${value}ms`;
+    }
 
     case 'screenshot':
       if (result.result?.screenshot) {
         return `Captured screenshot: ${result.result.screenshot}`;
       }
+      if (result.result?.skipped) {
+        const reason = result.result.skipped === 'blank-page'
+          ? 'page was blank'
+          : 'render looked blank';
+        return `Skipped screenshot (${reason})`;
+      }
       return `Captured screenshot${value ? `: ${value}` : ''}`;
 
     case 'assert_text':
       return `Verified text "${text}" is present on page${time}`;
 
+    case 'assert_no_text':
+      return `Verified text "${text}" is NOT present on page${time}`;
+
+    case 'assert_text_in':
+      return `Verified "${selector}" contains text "${text}"${value === 'exact' ? ' (exact)' : ''}${time}`;
+
     case 'assert_url':
       return `Verified URL contains "${value}"${time}`;
 
@@ -123,6 +138,9 @@ export function narrateAction(action, result) {
     case 'click_option':
       return `Clicked dropdown option "${text}"${time}`;
 
+    case 'select_combobox':
+      return `Selected "${text || action.option}" from combobox${action.filter ? ` (filtered "${action.filter}")` : ''}${time}`;
+
     case 'focus_autocomplete':
       return `Focused autocomplete labeled "${text}"${time}`;
 
@@ -174,6 +192,15 @@ export function narrateAction(action, result) {
       return `Visual comparison against "${value}": ${pct}${time}`;
     }
 
+    case 'gql': {
+      const query = (value || '').replace(/\s+/g, ' ').trim();
+      const snippet = query.length > 60 ? query.slice(0, 57) + '...' : query;
+      return `Executed GraphQL: ${snippet}${selector ? ' (asserted response)' : ''}${time}`;
+    }
+
+    case 'wait_network_idle':
+      return `Waited for network idle (${value || 500}ms)${time}`;
+
     case 'open_tab':
       return `Opened new tab${text ? ` "${text}"` : ''} → ${value}${time}`;
 
@@ -211,6 +238,8 @@ function describeIntent(action) {
       return           `Wait ${value}ms`;
     case 'screenshot': return 'Capture screenshot';
     case 'assert_text':           return `Assert text "${text}" present`;
+    case 'assert_no_text':        return `Assert text "${text}" NOT present`;
+    case 'assert_text_in':        return `Assert "${selector}" contains "${text}"`;
     case 'assert_url':            return `Assert URL contains "${value}"`;
     case 'assert_visible':        return `Assert "${selector}" visible`;
     case 'assert_count':          return `Assert "${selector}" count = ${value}`;
@@ -232,6 +261,7 @@ function describeIntent(action) {
     case 'type_react':            return `Type into React input "${selector}"`;
     case 'click_regex':           return `Click element matching /${text}/i`;
     case 'click_option':          return `Click option "${text}"`;
+    case 'select_combobox':       return `Select "${text || action.option}" from combobox`;
     case 'focus_autocomplete':    return `Focus autocomplete "${text}"`;
     case 'click_chip':            return `Click chip "${text}"`;
     case 'set_storage':            return `Set ${selector === 'session' ? 'sessionStorage' : 'localStorage'} key "${value?.split('=')[0] || value}"`;
@@ -246,6 +276,8 @@ function describeIntent(action) {
     case 'click_in_context':       return `Click "${selector}" in context of "${text}"`;
     case 'evaluate':   return 'Execute JS';
     case 'assert_visual':           return `Visual compare against "${value}"`;
+    case 'gql':                    return 'Execute GraphQL query';
+    case 'wait_network_idle':      return 'Wait for network idle';
     case 'open_tab':               return `Open new tab → ${value}`;
     case 'switch_tab':             return `Switch to tab "${value}"`;
     case 'close_tab':              return `Close tab${value ? ` "${value}"` : ''}`;

package/src/pool-manager.js

@@ -11,7 +11,7 @@
  * subsequent calls factor in connections that are in-flight.
  */
 
-import { getPoolStatus, connectToPool } from './pool.js';
+import { getPoolStatus, connectToPool, getCachedDriver } from './pool.js';
 import { log, colors as C } from './logger.js';
 
 function sleep(ms) {
@@ -201,6 +201,51 @@ export async function selectPool(poolUrls, pollIntervalMs = 2000, maxWaitMs = 60
   return poolUrls[0];
 }
 
+/**
+ * Filters pool URLs to those whose detected driver matches `driver`,
+ * with explicit opt-in fallback to `fallbackDriver`.
+ *
+ * Probes all pools once via getAllPoolStatuses() to warm the per-URL driver cache,
+ * then filters by getCachedDriver(url). Pools that are unreachable have a null
+ * detected driver and are excluded.
+ *
+ * Throws if no pool matches the requested driver and no usable fallback exists.
+ * Pool busyness is NOT a fallback trigger — selectPool() handles capacity waits
+ * inside the filtered set.
+ *
+ * @param {string[]} poolUrls
+ * @param {string} driver - Required driver name (e.g. 'obscura')
+ * @param {string|null} fallbackDriver - Explicit fallback driver, or null/undefined for hard error
+ * @param {object} options - { poolDriver, maxSessions } passed to getPoolStatus
+ * @returns {Promise<{urls: string[], driver: string, usedFallback: boolean}>}
+ */
+export async function resolvePoolsForTest(poolUrls, driver, fallbackDriver, options = {}) {
+  // Warm driver cache for all reachable pools
+  await getAllPoolStatuses(poolUrls, options);
+
+  const matching = poolUrls.filter(url => getCachedDriver(url) === driver);
+  if (matching.length > 0) {
+    return { urls: matching, driver, usedFallback: false };
+  }
+
+  if (fallbackDriver) {
+    const fallbackMatching = poolUrls.filter(url => getCachedDriver(url) === fallbackDriver);
+    if (fallbackMatching.length > 0) {
+      log('⚠️', `${C.yellow}No pool with driver=${driver}, falling back to ${fallbackDriver}${C.reset}`);
+      return { urls: fallbackMatching, driver: fallbackDriver, usedFallback: true };
+    }
+    throw new Error(
+      `No pool available for driver "${driver}" and fallback driver "${fallbackDriver}" also unavailable. ` +
+      `Reachable pools: ${poolUrls.map(u => `${u}=${getCachedDriver(u) || 'unreachable'}`).join(', ')}`
+    );
+  }
+
+  throw new Error(
+    `No pool available for driver "${driver}" and no fallbackDriver specified. ` +
+    `Reachable pools: ${poolUrls.map(u => `${u}=${getCachedDriver(u) || 'unreachable'}`).join(', ')}`
+  );
+}
+
 /** Convenience: selectPool + connectToPool in one call. */
 export async function selectAndConnect(config) {
   const poolUrls = getPoolUrls(config);

package/src/pool.js

@@ -4,9 +4,13 @@
  * Connectivity to browser pools and Docker Compose lifecycle.
  * Supports multiple pool drivers:
  *   - "browserless" — browserless/chrome with /pressure and /sessions HTTP API
- *   - "cdp"         — generic CDP pool (Lightpanda, raw Chrome, etc.) using /json/version health check
+ *   - "cdp"         — generic CDP pool (raw Chrome, etc.) using /json/version health check
+ *   - "lightpanda"  — Lightpanda browser (Zig-based, 9x faster, ~16x less memory) via CDP on port 9222
+ *   - "obscura"     — Obscura headless browser (Rust+V8, ~30 MB, anti-detect) via CDP on port 9222
  *   - "steel"       — Steel Browser with /v1/sessions REST API and session lifecycle
- *   - "auto"        — detect driver by probing endpoints: /pressure → browserless, /v1/sessions → steel, fallback → cdp
+ *   - "auto"        — detect driver by probing endpoints: /pressure → browserless, /v1/sessions → steel,
+ *                     /json/version with Browser=lightpanda → lightpanda, Browser=obscura → obscura,
+ *                     fallback → cdp
  */
 
 import puppeteer from 'puppeteer-core';
@@ -25,12 +29,25 @@ function sleep(ms) {
 
 // ── Driver detection cache ────────────────────────────────────────────────────
 
+/** Set of driver identifiers accepted by config, test JSON, and CLI overrides. */
+export const KNOWN_DRIVERS = new Set(['auto', 'browserless', 'cdp', 'lightpanda', 'obscura', 'steel']);
+
 /** Caches detected driver per pool URL to avoid re-probing on every status call. */
 const driverCache = new Map();
 
+/**
+ * Caches the canonical Puppeteer WS endpoint per pool URL, as advertised
+ * by /json/version → webSocketDebuggerUrl. Used by connectToPool so users
+ * can configure either http://host:port or ws://host:port for obscura,
+ * lightpanda, and generic cdp pools without needing to know the
+ * /devtools/browser suffix Obscura requires.
+ */
+const wsEndpointCache = new Map();
+
 /** Clears the driver cache (useful for tests or pool restarts). */
 export function clearDriverCache() {
   driverCache.clear();
+  wsEndpointCache.clear();
 }
 
 /** Returns the cached driver for a pool URL, or null if not yet detected. */
@@ -38,9 +55,16 @@ export function getCachedDriver(poolUrl) {
   return driverCache.get(poolUrl) || null;
 }
 
+/** Returns the cached webSocketDebuggerUrl for a pool URL, or null. */
+export function getCachedWsEndpoint(poolUrl) {
+  return wsEndpointCache.get(poolUrl) || null;
+}
+
 /**
  * Detects the pool driver by probing HTTP endpoints.
- * Probe order: /pressure (browserless) → /v1/sessions (steel) → fallback (cdp).
+ * Probe order: /pressure (browserless) → /v1/sessions (steel) →
+ *              /json/version with Browser=lightpanda → lightpanda, Browser=obscura → obscura,
+ *              fallback → cdp.
  */
 async function detectPoolDriver(poolUrl) {
   if (driverCache.has(poolUrl)) return driverCache.get(poolUrl);
@@ -71,18 +95,89 @@ async function detectPoolDriver(poolUrl) {
     }
   } catch { /* not steel */ }
 
-  // Fallback: generic CDP
+  // Probe Lightpanda / Obscura / generic CDP: /json/version
+  // Capture webSocketDebuggerUrl so connectToPool can use the canonical
+  // ws:// endpoint regardless of how the user spelled poolUrl.
+  try {
+    const res = await fetch(`${httpUrl}/json/version`, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const data = await res.json();
+      if (typeof data.webSocketDebuggerUrl === 'string' && data.webSocketDebuggerUrl) {
+        wsEndpointCache.set(poolUrl, rewriteWsHost(data.webSocketDebuggerUrl, poolUrl));
+      }
+      const browser = typeof data.Browser === 'string' ? data.Browser.toLowerCase() : '';
+      if (browser.includes('lightpanda')) {
+        driverCache.set(poolUrl, 'lightpanda');
+        return 'lightpanda';
+      }
+      if (browser.includes('obscura')) {
+        driverCache.set(poolUrl, 'obscura');
+        return 'obscura';
+      }
+      // /json/version answered with a Browser field but it isn't one we
+      // specifically recognize — treat as generic CDP.
+      driverCache.set(poolUrl, 'cdp');
+      return 'cdp';
+    }
+  } catch { /* not CDP-family or network error */ }
+
+  // Fallback: generic CDP (assume ws:// endpoint as-is)
   driverCache.set(poolUrl, 'cdp');
   return 'cdp';
 }
 
+/**
+ * Some CDP servers (notably Obscura when bound to 0.0.0.0) advertise an
+ * internal host in webSocketDebuggerUrl that does not match the URL the
+ * client used. Rewrite host:port to match the original poolUrl so the
+ * resulting ws:// is reachable from this machine.
+ */
+function rewriteWsHost(wsUrl, poolUrl) {
+  try {
+    const ws = new URL(wsUrl);
+    const ref = new URL(poolUrl.replace(/^ws/, 'http'));
+    ws.hostname = ref.hostname;
+    if (ref.port) ws.port = ref.port;
+    return ws.toString();
+  } catch {
+    return wsUrl;
+  }
+}
+
+/**
+ * Returns a Puppeteer-ready ws:// endpoint for a CDP-family pool URL.
+ * Uses the cache when available; otherwise probes /json/version on demand.
+ * Falls back to coercing the input http://→ws:// if discovery fails.
+ */
+async function resolveCdpWsEndpoint(poolUrl) {
+  const cached = wsEndpointCache.get(poolUrl);
+  if (cached) return cached;
+
+  const httpUrl = poolUrl.replace(/^ws:/, 'http:').replace(/^wss:/, 'https:');
+  try {
+    const res = await fetch(`${httpUrl}/json/version`, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const data = await res.json();
+      if (typeof data.webSocketDebuggerUrl === 'string' && data.webSocketDebuggerUrl) {
+        const ws = rewriteWsHost(data.webSocketDebuggerUrl, poolUrl);
+        wsEndpointCache.set(poolUrl, ws);
+        return ws;
+      }
+    }
+  } catch { /* fall through to coercion */ }
+
+  // No discovery — assume the input is already a usable ws endpoint.
+  return poolUrl.replace(/^http:/, 'ws:').replace(/^https:/, 'wss:');
+}
+
 /**
  * Resolves the effective driver string.
- * Maps config values: 'auto' → detect, 'lightpanda' → 'cdp', explicit → pass through.
+ * Maps config values: 'auto' → detect, explicit → cache and pass through.
  */
 async function resolveDriver(poolUrl, poolDriver) {
   if (!poolDriver || poolDriver === 'auto') return detectPoolDriver(poolUrl);
-  if (poolDriver === 'lightpanda') return 'cdp';
+  // Cache explicit driver so status calls and connect calls share the same value
+  driverCache.set(poolUrl, poolDriver);
   return poolDriver;
 }
 
@@ -111,7 +206,7 @@ function getCdpSessionCount(poolUrl) {
   return cdpSessions.get(poolUrl)?.size || 0;
 }
 
-async function getPoolStatusViaCDP(poolUrl, maxSessions) {
+async function getPoolStatusViaCDP(poolUrl, maxSessions, driverName = 'cdp') {
   const httpUrl = poolUrl.replace('ws://', 'http://').replace('wss://', 'https://');
   try {
     const res = await fetch(`${httpUrl}/json/version`, { signal: AbortSignal.timeout(3000) });
@@ -124,7 +219,7 @@ async function getPoolStatusViaCDP(poolUrl, maxSessions) {
       maxConcurrent: maxSessions,
       queued: 0,
       sessions: [],
-      driver: 'cdp',
+      driver: driverName,
     };
   } catch (error) {
     return {
@@ -134,7 +229,7 @@ async function getPoolStatusViaCDP(poolUrl, maxSessions) {
       maxConcurrent: maxSessions,
       queued: 0,
       sessions: [],
-      driver: 'cdp',
+      driver: driverName,
     };
   }
 }
@@ -143,9 +238,13 @@ async function getPoolStatusViaCDP(poolUrl, maxSessions) {
 
 async function getPoolStatusViaBrowserless(poolUrl) {
   const httpUrl = poolUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+  // FIX: add timeout. Without it, a hung browserless HTTP response (TCP
+  // open but no body) makes `fetch` wait indefinitely, which freezes
+  // `selectPool()` and looks downstream like a 0ms test timeout. Other
+  // drivers (CDP, Steel) already use AbortSignal.timeout(3000); match it.
   const [pressureRes, sessionsRes] = await Promise.all([
-    fetch(`${httpUrl}/pressure`),
-    fetch(`${httpUrl}/sessions`),
+    fetch(`${httpUrl}/pressure`, { signal: AbortSignal.timeout(3000) }),
+    fetch(`${httpUrl}/sessions`, { signal: AbortSignal.timeout(3000) }),
   ]);
 
   const pressure = pressureRes.ok ? await pressureRes.json() : null;
@@ -299,10 +398,19 @@ export async function connectToPool(poolUrl, retries = 3, delay = 2000) {
     return connectToSteelPool(poolUrl, retries, delay);
   }
 
+  // For CDP-family drivers, resolve the canonical webSocketDebuggerUrl from
+  // /json/version so users can configure either http://host:port or
+  // ws://host:port without knowing the driver-specific path
+  // (Obscura requires /devtools/browser; browserless does not).
+  let wsEndpoint = poolUrl;
+  if (driver === 'obscura' || driver === 'lightpanda' || driver === 'cdp') {
+    wsEndpoint = await resolveCdpWsEndpoint(poolUrl);
+  }
+
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
       return await puppeteer.connect({
-        browserWSEndpoint: poolUrl,
+        browserWSEndpoint: wsEndpoint,
         timeout: 30000,
       });
     } catch (error) {
@@ -331,14 +439,40 @@ export async function disconnectFromPool(browser, poolUrl) {
 /** Generates docker-compose.yml and starts the pool */
 export function startPool(config, cwd = null) {
   cwd = cwd || process.cwd();
+  const driver = config.poolDriver || 'auto';
+
+  // Obscura is a single Rust binary — no official image, no compose. Print install/run guidance.
+  if (driver === 'obscura') {
+    const port = config.poolPort || 9222;
+    log('ℹ️', 'Obscura is a local binary, not a Docker pool. Install it once:');
+    log('  ', '  # Linux x86_64');
+    log('  ', '  curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz');
+    log('  ', '  tar xzf obscura-x86_64-linux.tar.gz');
+    log('  ', '  # macOS Apple Silicon');
+    log('  ', '  curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-macos.tar.gz');
+    log('  ', '  # macOS Intel');
+    log('  ', '  curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-macos.tar.gz');
+    log('  ', '  # Arch Linux (AUR)');
+    log('  ', '  yay -S obscura-browser');
+    log('ℹ️', `Then run it (in another shell): obscura serve --port ${port} --stealth`);
+    log('ℹ️', `Set poolUrls in e2e.config.js (any of these works):`);
+    log('  ', `  ['http://127.0.0.1:${port}']                     # auto-discovers ws endpoint`);
+    log('  ', `  ['ws://127.0.0.1:${port}/devtools/browser']       # explicit ws endpoint`);
+    log('  ', `Or export CHROME_POOL_URL=http://127.0.0.1:${port}`);
+    return;
+  }
+
   const poolDir = path.join(cwd, '.e2e-pool');
 
   if (!fs.existsSync(poolDir)) {
     fs.mkdirSync(poolDir, { recursive: true });
   }
 
-  // Read template and interpolate variables
-  const templatePath = path.join(__dirname, '..', 'templates', 'docker-compose.yml');
+  // Select template based on poolDriver
+  const templateFile = driver === 'lightpanda'
+    ? 'docker-compose-lightpanda.yml'
+    : 'docker-compose.yml';
+  const templatePath = path.join(__dirname, '..', 'templates', templateFile);
   let template = fs.readFileSync(templatePath, 'utf-8');
   template = template.replace(/\$\{PORT\}/g, String(config.poolPort || 3333));
   template = template.replace(/\$\{MAX_SESSIONS\}/g, String(config.maxSessions || 5));
@@ -355,14 +489,37 @@ export function startPool(config, cwd = null) {
     }
   }
 
-  log('🐳', 'Starting Chrome Pool...');
-  execFileSync('docker', ['compose', '-f', composePath, 'up', '-d'], { stdio: 'inherit' });
-  log('✅', `Chrome Pool started on port ${config.poolPort || 3333}`);
+  const label = driver === 'lightpanda' ? 'Lightpanda Pool' : 'Chrome Pool';
+  log('🐳', `Starting ${label}...`);
+  const containerMatch = template.match(/container_name:\s*(\S+)/);
+  const containerName = containerMatch ? containerMatch[1].trim() : null;
+  try {
+    execFileSync('docker', ['compose', '-f', composePath, 'up', '-d'], { stdio: 'inherit' });
+  } catch (err) {
+    // Most common failure: a stopped container with the same name lingers from a
+    // previous run, so `up -d` errors with "container name is already in use".
+    // Recover by removing the stale container and recreating cleanly.
+    if (containerName) {
+      log('🔁', `Recovering: removing stale container ${containerName} and retrying...`);
+      try { execFileSync('docker', ['rm', '-f', containerName], { stdio: 'ignore' }); } catch { /* may not exist */ }
+      execFileSync('docker', ['compose', '-f', composePath, 'up', '-d'], { stdio: 'inherit' });
+    } else {
+      throw err;
+    }
+  }
+  log('✅', `${label} started on port ${config.poolPort || 3333}`);
 }
 
 /** Stops the pool */
 export function stopPool(config, cwd = null) {
   cwd = cwd || process.cwd();
+  const driver = config.poolDriver || 'auto';
+
+  if (driver === 'obscura') {
+    log('ℹ️', 'Obscura runs as a local process — stop it with Ctrl-C in its own shell.');
+    return;
+  }
+
   const composePath = path.join(cwd, '.e2e-pool', 'docker-compose.yml');
   if (!fs.existsSync(composePath)) {
     log('⚠️', '.e2e-pool/docker-compose.yml not found');
@@ -383,7 +540,7 @@ export function restartPool(config, cwd = null) {
 /**
  * Gets pool status using the appropriate driver.
  * @param {string} poolUrl - WebSocket URL of the pool
- * @param {object} [options] - { poolDriver: 'auto'|'browserless'|'lightpanda'|'cdp'|'steel', maxSessions: number }
+ * @param {object} [options] - { poolDriver: 'auto'|'browserless'|'cdp'|'lightpanda'|'obscura'|'steel', maxSessions: number }
  */
 export async function getPoolStatus(poolUrl, options = {}) {
   const { poolDriver = 'auto', maxSessions = 10 } = options;
@@ -394,8 +551,8 @@ export async function getPoolStatus(poolUrl, options = {}) {
     return getPoolStatusViaSteel(poolUrl, maxSessions);
   }
 
-  if (driver === 'cdp') {
-    return getPoolStatusViaCDP(poolUrl, maxSessions);
+  if (driver === 'lightpanda' || driver === 'obscura' || driver === 'cdp') {
+    return getPoolStatusViaCDP(poolUrl, maxSessions, driver);
   }
 
   // Browserless driver