farming-code 2.2.23 → 2.2.28

package/extensions/browser/backend/cdp-browser-runtime.js

@@ -0,0 +1,648 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { EventEmitter } = require('events');
+const { CdpClient } = require('./cdp-client');
+
+const DEFAULT_VIEWPORT = Object.freeze({ width: 1280, height: 800 });
+const MAX_VIEWPORT = Object.freeze({ width: 4096, height: 4096 });
+// A Viewer may itself be captured by another Browser Resource, including the
+// Browser it displays. Bound that video-feedback loop while retaining its last frame.
+const VIEWER_FRAME_INTERVAL_MS = 1_000 / 15;
+const ACTIONABLE_ROLES = new Set([
+  'button',
+  'checkbox',
+  'combobox',
+  'link',
+  'listbox',
+  'menuitem',
+  'option',
+  'radio',
+  'searchbox',
+  'slider',
+  'spinbutton',
+  'switch',
+  'tab',
+  'textbox',
+  'treeitem',
+]);
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function clampViewport(value = {}) {
+  const width = Math.round(Number(value.width));
+  const height = Math.round(Number(value.height));
+  return {
+    width: Number.isFinite(width) ? Math.min(MAX_VIEWPORT.width, Math.max(320, width)) : DEFAULT_VIEWPORT.width,
+    height: Number.isFinite(height) ? Math.min(MAX_VIEWPORT.height, Math.max(240, height)) : DEFAULT_VIEWPORT.height,
+  };
+}
+
+function processExitPromise(child) {
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
+  return new Promise(resolve => child.once('exit', resolve));
+}
+
+async function waitForExit(child, timeoutMs) {
+  let timer;
+  const timedOut = new Promise(resolve => {
+    timer = setTimeout(() => resolve(false), timeoutMs);
+    timer.unref?.();
+  });
+  const exited = processExitPromise(child).then(() => true);
+  const result = await Promise.race([exited, timedOut]);
+  clearTimeout(timer);
+  return result;
+}
+
+function signalBrowserProcess(child, signal) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    if (process.platform !== 'win32' && child.pid) process.kill(-child.pid, signal);
+    else child.kill(signal);
+  } catch (error) {
+    if (error?.code !== 'ESRCH') throw error;
+  }
+}
+
+async function stopBrowserProcess(child) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  signalBrowserProcess(child, 'SIGTERM');
+  if (await waitForExit(child, 3_000)) return;
+  signalBrowserProcess(child, 'SIGKILL');
+  if (!await waitForExit(child, 3_000)) {
+    throw new Error(`System browser process ${child.pid || '(unknown)'} did not exit`);
+  }
+}
+
+async function waitForDevToolsPort(profileDir, child, timeoutMs = 15_000) {
+  const portFile = path.join(profileDir, 'DevToolsActivePort');
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (child.farmingStartError) throw child.farmingStartError;
+    if (child.exitCode !== null || child.signalCode !== null) {
+      const detail = child.farmingStderr ? `: ${child.farmingStderr}` : '';
+      throw new Error(`System browser exited during startup (${child.exitCode ?? child.signalCode})${detail}`);
+    }
+    try {
+      const lines = fs.readFileSync(portFile, 'utf8').trim().split(/\r?\n/);
+      const port = Number(lines[0]);
+      if (Number.isInteger(port) && port > 0 && lines[1]?.startsWith('/')) {
+        return `ws://127.0.0.1:${port}${lines[1]}`;
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    await delay(50);
+  }
+  const detail = child.farmingStderr ? `: ${child.farmingStderr}` : '';
+  throw new Error(`System browser did not expose a CDP endpoint before startup timed out${detail}`);
+}
+
+function launchSystemBrowser(executablePath, profileDir, options = {}) {
+  fs.mkdirSync(profileDir, { recursive: true });
+  fs.rmSync(path.join(profileDir, 'DevToolsActivePort'), { force: true });
+  const platform = options.platform || process.platform;
+  const noSandbox = options.noSandbox === true
+    || (options.noSandbox === undefined && process.env.FARMING_BROWSER_NO_SANDBOX === '1');
+  const child = (options.spawn || spawn)(executablePath, [
+    '--headless=new',
+    '--remote-debugging-port=0',
+    `--user-data-dir=${profileDir}`,
+    `--window-size=${DEFAULT_VIEWPORT.width},${DEFAULT_VIEWPORT.height}`,
+    ...(platform === 'linux' ? ['--disable-dev-shm-usage'] : []),
+    ...(noSandbox ? ['--no-sandbox', '--disable-setuid-sandbox'] : []),
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-sync',
+    '--disable-background-networking',
+    '--disable-component-update',
+    '--disable-features=Translate,MediaRouter',
+    '--disable-popup-blocking',
+    'about:blank',
+  ], {
+    detached: process.platform !== 'win32',
+    stdio: ['ignore', 'ignore', 'pipe'],
+  });
+  return child;
+}
+
+function axValue(node, field) {
+  const value = node?.[field]?.value;
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function compactAxTree(nodes) {
+  const lines = [];
+  for (const node of nodes.slice(0, 500)) {
+    const role = axValue(node, 'role');
+    const name = axValue(node, 'name').replace(/\s+/g, ' ').trim();
+    if ((!role || role === 'generic' || role === 'none') && !name) continue;
+    const value = axValue(node, 'value').replace(/\s+/g, ' ').trim();
+    lines.push(`${role || 'node'}${name ? ` "${name.slice(0, 200)}"` : ''}${value ? ` value="${value.slice(0, 200)}"` : ''}`);
+  }
+  return lines.join('\n');
+}
+
+function keyDescription(input) {
+  const key = String(input.key || '');
+  const code = String(input.code || '');
+  const known = {
+    Enter: { code: 'Enter', windowsVirtualKeyCode: 13 },
+    Tab: { code: 'Tab', windowsVirtualKeyCode: 9 },
+    Escape: { code: 'Escape', windowsVirtualKeyCode: 27 },
+    Backspace: { code: 'Backspace', windowsVirtualKeyCode: 8 },
+    Delete: { code: 'Delete', windowsVirtualKeyCode: 46 },
+    ArrowLeft: { code: 'ArrowLeft', windowsVirtualKeyCode: 37 },
+    ArrowUp: { code: 'ArrowUp', windowsVirtualKeyCode: 38 },
+    ArrowRight: { code: 'ArrowRight', windowsVirtualKeyCode: 39 },
+    ArrowDown: { code: 'ArrowDown', windowsVirtualKeyCode: 40 },
+    Home: { code: 'Home', windowsVirtualKeyCode: 36 },
+    End: { code: 'End', windowsVirtualKeyCode: 35 },
+    PageUp: { code: 'PageUp', windowsVirtualKeyCode: 33 },
+    PageDown: { code: 'PageDown', windowsVirtualKeyCode: 34 },
+    ' ': { code: 'Space', windowsVirtualKeyCode: 32 },
+  }[key];
+  const upper = key.length === 1 ? key.toUpperCase() : '';
+  return {
+    key,
+    code: code || known?.code || (upper ? `Key${upper}` : key),
+    windowsVirtualKeyCode: known?.windowsVirtualKeyCode || (upper ? upper.charCodeAt(0) : 0),
+    nativeVirtualKeyCode: known?.windowsVirtualKeyCode || (upper ? upper.charCodeAt(0) : 0),
+    modifiers: Number(input.modifiers) || 0,
+  };
+}
+
+class CdpBrowserRuntime extends EventEmitter {
+  constructor(options) {
+    super();
+    this.id = options.id;
+    this.generation = options.generation;
+    this.executablePath = options.executablePath;
+    this.profileDir = options.profileDir;
+    this.launchBrowser = options.launchBrowser || launchSystemBrowser;
+    this.createClient = options.createClient || (() => new CdpClient());
+    this.child = null;
+    this.client = null;
+    this.sessionId = null;
+    this.targetId = null;
+    this.sessionListeners = [];
+    this.globalListeners = [];
+    this.refs = new Map();
+    this.viewport = { ...DEFAULT_VIEWPORT };
+    this.latestFrame = null;
+    this.closedByOwner = false;
+    this.closeComplete = false;
+    this.closePromise = null;
+    this.started = false;
+    this.targetChange = Promise.resolve();
+    this.screencastFrameTimer = null;
+    this.screencastFrameEpoch = 0;
+    this.pendingScreencastFrame = null;
+    this.lastScreencastFrameAt = null;
+    this.now = options.now || Date.now;
+    this.scheduleTimeout = options.scheduleTimeout || setTimeout;
+    this.cancelTimeout = options.cancelTimeout || clearTimeout;
+  }
+
+  async start(initialUrl) {
+    this.child = this.launchBrowser(this.executablePath, this.profileDir);
+    this.child.stderr?.on('data', chunk => {
+      const combined = `${this.child.farmingStderr || ''}${chunk.toString('utf8')}`;
+      this.child.farmingStderr = combined.slice(-8_192).trim();
+    });
+    this.child.once('error', error => {
+      this.child.farmingStartError = error;
+      if (this.started && !this.closedByOwner) this.emit('exit', `System browser failed: ${error.message}`);
+    });
+    this.child.once('exit', (code, signal) => {
+      if (this.closedByOwner) return;
+      this.emit('exit', `System browser exited (${code ?? signal ?? 'unknown'})`);
+    });
+    try {
+      const wsUrl = await waitForDevToolsPort(this.profileDir, this.child);
+      this.client = this.createClient();
+      await this.client.connect(wsUrl);
+      this.globalListeners.push(this.client.onClose(error => {
+        if (this.closedByOwner) return;
+        this.emit('exit', error?.message || 'CDP connection closed');
+      }));
+      this.globalListeners.push(this.client.on('Target.targetCreated', event => {
+        const target = event.targetInfo;
+        if (!this.started || target?.type !== 'page' || target.targetId === this.targetId) return;
+        this.targetChange = this.targetChange
+          .catch(() => {})
+          .then(() => this.setActiveTarget(target.targetId))
+          .catch(error => this.emit('error', error));
+      }));
+      this.globalListeners.push(this.client.on('Target.targetDestroyed', event => {
+        if (!this.started || event.targetId !== this.targetId || this.closedByOwner) return;
+        this.emit('exit', 'Browser page closed');
+      }));
+      await this.client.send('Target.setDiscoverTargets', { discover: true });
+      const { targetInfos = [] } = await this.client.send('Target.getTargets');
+      const target = targetInfos.find(candidate => candidate.type === 'page');
+      if (!target) throw new Error('System browser did not create a page target');
+      await this.setActiveTarget(target.targetId);
+      this.started = true;
+      if (initialUrl && initialUrl !== 'about:blank') await this.navigate(initialUrl);
+      return await this.metadata();
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+
+  async setActiveTarget(targetId) {
+    if (!this.client || targetId === this.targetId) return;
+    await this.detachActiveTarget();
+    const { sessionId } = await this.client.send('Target.attachToTarget', {
+      targetId,
+      flatten: true,
+    });
+    this.sessionId = sessionId;
+    this.targetId = targetId;
+    this.refs.clear();
+    const session = sessionId;
+    this.sessionListeners.push(
+      this.client.on('Page.screencastFrame', event => {
+        void this.client?.send('Page.screencastFrameAck', { sessionId: event.sessionId }, session).catch(() => {});
+        const frame = {
+          type: 'browser-frame',
+          generation: this.generation,
+          data: event.data,
+          metadata: event.metadata,
+        };
+        this.latestFrame = frame;
+        this.publishScreencastFrame(frame, session);
+      }, session),
+      this.client.on('Page.frameNavigated', event => {
+        if (event.frame?.parentId) return;
+        void this.publishMetadata();
+      }, session),
+      this.client.on('Page.loadEventFired', () => {
+        void this.publishMetadata();
+      }, session),
+    );
+    await Promise.all([
+      this.client.send('Page.enable', {}, session),
+      this.client.send('Runtime.enable', {}, session),
+      this.client.send('DOM.enable', {}, session),
+      this.client.send('Accessibility.enable', {}, session),
+    ]);
+    await this.resize(this.viewport);
+    await this.client.send('Page.startScreencast', {
+      format: 'jpeg',
+      quality: 80,
+      maxWidth: MAX_VIEWPORT.width,
+      maxHeight: MAX_VIEWPORT.height,
+      everyNthFrame: 1,
+    }, session);
+    await this.captureViewerFrame();
+    await this.publishMetadata();
+  }
+
+  publishScreencastFrame(frame, targetSession) {
+    const waitMs = this.lastScreencastFrameAt === null
+      ? 0
+      : Math.ceil(Math.max(0, VIEWER_FRAME_INTERVAL_MS - (this.now() - this.lastScreencastFrameAt)));
+    if (waitMs > 0) {
+      this.pendingScreencastFrame = frame;
+      if (this.screencastFrameTimer) return;
+      const epoch = this.screencastFrameEpoch;
+      this.screencastFrameTimer = this.scheduleTimeout(() => {
+        this.screencastFrameTimer = null;
+        if (epoch !== this.screencastFrameEpoch || targetSession !== this.sessionId) return;
+        const pending = this.pendingScreencastFrame;
+        this.pendingScreencastFrame = null;
+        if (!pending) return;
+        this.lastScreencastFrameAt = this.now();
+        this.emit('frame', pending);
+      }, waitMs);
+      return;
+    }
+    this.lastScreencastFrameAt = this.now();
+    this.emit('frame', frame);
+  }
+
+  async detachActiveTarget() {
+    const session = this.sessionId;
+    this.sessionId = null;
+    this.targetId = null;
+    if (this.screencastFrameTimer) this.cancelTimeout(this.screencastFrameTimer);
+    this.screencastFrameTimer = null;
+    this.screencastFrameEpoch += 1;
+    this.pendingScreencastFrame = null;
+    this.lastScreencastFrameAt = null;
+    for (const off of this.sessionListeners.splice(0)) off();
+    if (!this.client || !session) return;
+    await this.client.send('Page.stopScreencast', {}, session).catch(() => {});
+    await this.client.send('Target.detachFromTarget', { sessionId: session }).catch(() => {});
+  }
+
+  requireSession() {
+    if (!this.client || !this.sessionId) throw new Error('Browser page is not attached');
+    return { client: this.client, sessionId: this.sessionId };
+  }
+
+  async evaluate(expression, options = {}) {
+    const { client, sessionId } = this.requireSession();
+    const result = await client.send('Runtime.evaluate', {
+      expression,
+      awaitPromise: true,
+      returnByValue: options.returnByValue !== false,
+      userGesture: true,
+    }, sessionId);
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.exception?.description || result.exceptionDetails.text || 'Browser evaluation failed');
+    }
+    return result.result;
+  }
+
+  async metadata() {
+    const result = await this.evaluate(`({
+      url: location.href,
+      title: document.title
+    })`);
+    return {
+      url: String(result.value?.url || 'about:blank'),
+      title: String(result.value?.title || ''),
+    };
+  }
+
+  async publishMetadata() {
+    try {
+      this.emit('metadata', await this.metadata());
+    } catch {
+      // Navigation may briefly replace the execution context.
+    }
+  }
+
+  async navigate(url) {
+    const { client, sessionId } = this.requireSession();
+    const result = await client.send('Page.navigate', { url }, sessionId);
+    if (result.errorText) throw new Error(result.errorText);
+    await delay(50);
+    const metadata = await this.metadata().catch(() => ({ url, title: '' }));
+    await this.captureViewerFrame();
+    this.emit('metadata', metadata);
+    return metadata;
+  }
+
+  async goBack() {
+    return this.navigateHistory(-1);
+  }
+
+  async goForward() {
+    return this.navigateHistory(1);
+  }
+
+  async navigateHistory(delta) {
+    const { client, sessionId } = this.requireSession();
+    const history = await client.send('Page.getNavigationHistory', {}, sessionId);
+    const target = history.entries?.[history.currentIndex + delta];
+    if (!target) return this.metadata();
+    await client.send('Page.navigateToHistoryEntry', { entryId: target.id }, sessionId);
+    await delay(50);
+    const metadata = await this.metadata().catch(() => ({ url: target.url, title: target.title || '' }));
+    await this.captureViewerFrame();
+    this.emit('metadata', metadata);
+    return metadata;
+  }
+
+  async reload() {
+    const { client, sessionId } = this.requireSession();
+    await client.send('Page.reload', { ignoreCache: false }, sessionId);
+    await delay(50);
+    await this.captureViewerFrame();
+    return this.metadata();
+  }
+
+  async resize(value) {
+    this.viewport = clampViewport(value);
+    if (!this.client || !this.sessionId) return;
+    await this.client.send('Emulation.setDeviceMetricsOverride', {
+      ...this.viewport,
+      deviceScaleFactor: 1,
+      mobile: false,
+      screenWidth: this.viewport.width,
+      screenHeight: this.viewport.height,
+    }, this.sessionId);
+  }
+
+  async screenshot() {
+    const { client, sessionId } = this.requireSession();
+    const result = await client.send('Page.captureScreenshot', {
+      format: 'png',
+      fromSurface: true,
+    }, sessionId);
+    return { mimeType: 'image/png', data: result.data };
+  }
+
+  async captureViewerFrame() {
+    const { client, sessionId } = this.requireSession();
+    const result = await client.send('Page.captureScreenshot', {
+      format: 'jpeg',
+      quality: 80,
+      fromSurface: true,
+      captureBeyondViewport: false,
+    }, sessionId);
+    if (sessionId !== this.sessionId || !result.data) return;
+    const frame = {
+      type: 'browser-frame',
+      generation: this.generation,
+      data: result.data,
+    };
+    this.latestFrame = frame;
+    this.publishScreencastFrame(frame, sessionId);
+  }
+
+  async snapshot() {
+    const { client, sessionId } = this.requireSession();
+    const { nodes = [] } = await client.send('Accessibility.getFullAXTree', {}, sessionId);
+    this.refs.clear();
+    const elements = [];
+    for (const node of nodes) {
+      const role = axValue(node, 'role');
+      if (!ACTIONABLE_ROLES.has(role) || !node.backendDOMNodeId || elements.length >= 200) continue;
+      const ref = `e${elements.length + 1}`;
+      this.refs.set(ref, node.backendDOMNodeId);
+      elements.push({
+        ref,
+        role,
+        name: axValue(node, 'name').replace(/\s+/g, ' ').trim().slice(0, 240),
+        value: axValue(node, 'value').replace(/\s+/g, ' ').trim().slice(0, 240),
+        disabled: Boolean(node.properties?.find(property => property.name === 'disabled')?.value?.value),
+      });
+    }
+    const metadata = await this.metadata();
+    return {
+      ...metadata,
+      elements,
+      accessibilityTree: compactAxTree(nodes),
+    };
+  }
+
+  async resolveElement(input) {
+    const { client, sessionId } = this.requireSession();
+    const ref = String(input.ref || '').trim();
+    const selector = String(input.selector || '').trim();
+    if (ref) {
+      const backendNodeId = this.refs.get(ref);
+      if (!backendNodeId) throw new Error(`Browser ref ${ref} is stale or unknown; take a new snapshot`);
+      const { object } = await client.send('DOM.resolveNode', { backendNodeId }, sessionId);
+      if (!object?.objectId) throw new Error(`Browser ref ${ref} no longer resolves to an element`);
+      return object.objectId;
+    }
+    if (!selector) throw new Error('ref or selector is required');
+    const result = await this.evaluate(`document.querySelector(${JSON.stringify(selector)})`, { returnByValue: false });
+    if (!result.objectId || result.subtype === 'null') throw new Error(`No element matches selector: ${selector}`);
+    return result.objectId;
+  }
+
+  async callOnElement(objectId, functionDeclaration, args = [], returnByValue = true) {
+    const { client, sessionId } = this.requireSession();
+    try {
+      const result = await client.send('Runtime.callFunctionOn', {
+        objectId,
+        functionDeclaration,
+        arguments: args.map(value => ({ value })),
+        returnByValue,
+        awaitPromise: true,
+        userGesture: true,
+      }, sessionId);
+      if (result.exceptionDetails) {
+        throw new Error(result.exceptionDetails.exception?.description || result.exceptionDetails.text || 'Element action failed');
+      }
+      return result.result;
+    } finally {
+      await client.send('Runtime.releaseObject', { objectId }, sessionId).catch(() => {});
+    }
+  }
+
+  async focusElement(input, clear = false) {
+    const objectId = await this.resolveElement(input);
+    return this.callOnElement(objectId, `function(clear) {
+      if (!(this instanceof Element)) throw new Error('Target is not an element');
+      if (typeof this.scrollIntoView === 'function') this.scrollIntoView({ block: 'center', inline: 'center' });
+      if (typeof this.focus === 'function') this.focus();
+      if (clear) {
+        if ('value' in this) {
+          this.value = '';
+          this.dispatchEvent(new Event('input', { bubbles: true }));
+        } else if (this.isContentEditable) {
+          this.textContent = '';
+          this.dispatchEvent(new Event('input', { bubbles: true }));
+        }
+      }
+      const rect = this.getBoundingClientRect();
+      return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+    }`, [clear]);
+  }
+
+  async click(input) {
+    const position = await this.focusElement(input);
+    await this.pointer({ action: 'move', ...position.value });
+    await this.pointer({ action: 'down', button: 'left', ...position.value });
+    await this.pointer({ action: 'up', button: 'left', ...position.value });
+    return { ok: true };
+  }
+
+  async type(input, clear) {
+    await this.focusElement(input, clear);
+    const { client, sessionId } = this.requireSession();
+    await client.send('Input.insertText', { text: String(input.text ?? '') }, sessionId);
+    await this.captureViewerFrame();
+    return { ok: true };
+  }
+
+  async press(input) {
+    const { client, sessionId } = this.requireSession();
+    const description = keyDescription(input);
+    if (!description.key) throw new Error('key is required');
+    await client.send('Input.dispatchKeyEvent', { type: 'rawKeyDown', ...description }, sessionId);
+    await client.send('Input.dispatchKeyEvent', { type: 'keyUp', ...description }, sessionId);
+    await this.captureViewerFrame();
+    return { ok: true };
+  }
+
+  async pointer(input) {
+    const { client, sessionId } = this.requireSession();
+    const x = Number(input.x);
+    const y = Number(input.y);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+    const actionTypes = {
+      move: 'mouseMoved',
+      down: 'mousePressed',
+      up: 'mouseReleased',
+    };
+    const type = actionTypes[input.action];
+    if (!type) return;
+    await client.send('Input.dispatchMouseEvent', {
+      type,
+      x,
+      y,
+      button: input.button || 'none',
+      buttons: Number(input.buttons) || 0,
+      clickCount: input.action === 'move' ? 0 : 1,
+      modifiers: Number(input.modifiers) || 0,
+    }, sessionId);
+    if (input.action === 'up') await this.captureViewerFrame();
+  }
+
+  async wheel(input) {
+    const { client, sessionId } = this.requireSession();
+    const x = Number(input.x);
+    const y = Number(input.y);
+    await client.send('Input.dispatchMouseEvent', {
+      type: 'mouseWheel',
+      x: Number.isFinite(x) ? x : this.viewport.width / 2,
+      y: Number.isFinite(y) ? y : this.viewport.height / 2,
+      deltaX: Number(input.deltaX) || 0,
+      deltaY: Number(input.deltaY) || 0,
+      modifiers: Number(input.modifiers) || 0,
+    }, sessionId);
+    await this.captureViewerFrame();
+  }
+
+  async insertText(text) {
+    const { client, sessionId } = this.requireSession();
+    await client.send('Input.insertText', { text: String(text || '') }, sessionId);
+    await this.captureViewerFrame();
+  }
+
+  async close() {
+    if (this.closeComplete) return;
+    if (this.closePromise) return this.closePromise;
+    this.closedByOwner = true;
+    this.closePromise = (async () => {
+      for (const off of this.globalListeners.splice(0)) off();
+      await this.detachActiveTarget();
+      if (this.client) {
+        await this.client.send('Browser.close').catch(() => {});
+        this.client.close();
+        this.client = null;
+      }
+      if (this.child && !await waitForExit(this.child, 3_000)) {
+        await stopBrowserProcess(this.child);
+      }
+      this.child = null;
+      this.closeComplete = true;
+    })().finally(() => {
+      this.closePromise = null;
+    });
+    return this.closePromise;
+  }
+}
+
+module.exports = {
+  CdpBrowserRuntime,
+  DEFAULT_VIEWPORT,
+  MAX_VIEWPORT,
+  clampViewport,
+  launchSystemBrowser,
+  stopBrowserProcess,
+  waitForDevToolsPort,
+};