browserless 14.0.33 → 14.1.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "browserless",
   "description": "The headless Chrome/Chromium driver on top of Puppeteer. Take screenshots, generate PDFs, extract text and HTML with a production-ready API.",
   "homepage": "https://browserless.js.org",
-  "version": "14.0.33",
+  "version": "14.1.2",
   "types": "index.d.ts",
   "main": "src/index.js",
   "author": {
@@ -36,14 +36,15 @@
   ],
   "dependencies": {
     "@browserless/errors": "14.0.22",
-    "@browserless/goto": "14.0.33",
-    "@browserless/pdf": "14.0.33",
-    "@browserless/screenshot": "14.0.33",
+    "@browserless/goto": "14.1.2",
+    "@browserless/pdf": "14.1.2",
+    "@browserless/screenshot": "14.1.2",
     "debug-logfmt": "~1.4.15",
     "kill-process-group": "~1.0.16",
     "p-reflect": "~2.1.0",
     "p-retry": "~4.6.1",
     "p-timeout": "~4.1.0",
+    "proxy-chain": "~3.0.1",
     "require-one-of": "~1.0.25",
     "superlock": "~1.4.2"
   },
@@ -69,5 +70,5 @@
     "timeout": "2m",
     "workerThreads": false
   },
-  "gitHead": "c1373eae5ddf96b49452076e4e184d4f2d2e08f3"
+  "gitHead": "700bbabadea0a16facf30d76ecf60ff9602e06f8"
 }

package/src/index.js

@@ -12,6 +12,7 @@ const pRetry = require('p-retry')
 
 const { AbortError } = pRetry
 
+const { forwardProxy, closeForwarder } = require('./proxy-forwarder')
 const driver = require('./driver')
 
 // Chrome can stop answering CDP while `connected` stays true, so the
@@ -33,9 +34,11 @@ module.exports = ({ timeout: globalTimeout = 30000, ...launchOpts } = {}) => {
   const { defaultViewport } = goto
 
   let isClosed = false
+  const forwarders = new Set()
 
-  const close = opts => {
+  const close = async opts => {
     isClosed = true
+    await Promise.all([...forwarders].map(closeForwarder))
     return browserProcessPromise.then(browserProcess => driver.close(browserProcess, opts))
   }
 
@@ -108,8 +111,15 @@ module.exports = ({ timeout: globalTimeout = 30000, ...launchOpts } = {}) => {
   }
 
   const createContext = async ({ retry = 2, timeout: contextTimeout, ...contextOpts } = {}) => {
-    let _contextPromise = createBrowserContext(contextOpts)
+    const forwardedContextOpts = isClosed
+      ? Promise.resolve(contextOpts)
+      : forwardProxy(contextOpts, { mode: launchOpts.mode })
+    forwarders.add(forwardedContextOpts)
+    const newBrowserContext = () => forwardedContextOpts.then(createBrowserContext)
+    const usesForwarder = () => forwardedContextOpts.then(opts => opts !== contextOpts)
+    let _contextPromise = newBrowserContext()
     let isDestroyedForced = false
+    let isDestroyed = false
     const pageMetadata = new WeakMap()
 
     const getBrowserContext = () => _contextPromise
@@ -194,13 +204,14 @@ module.exports = ({ timeout: globalTimeout = 30000, ...launchOpts } = {}) => {
               const isRetryable =
                 error.code === 'EBRWSRCONTEXTCONNRESET' || error.code === 'EPROTOCOL'
               if (!isRetryable) throw error
+              if (isDestroyed && (await usesForwarder())) throw new AbortError()
               const { message, attemptNumber, retriesLeft } = error
               // Every attempt builds its own page, so both codes are retryable
               // inside the existing context: `EBRWSRCONTEXTCONNRESET` covers a
               // closed page, a detached frame and a destroyed execution context,
               // which a fresh page recovers from.
               const previousContextPromise = _contextPromise
-              _contextPromise = createBrowserContext(contextOpts)
+              _contextPromise = newBrowserContext()
               await pReflect(previousContextPromise.then(ctx => ctx.close()))
               debug('retry', { attemptNumber, retriesLeft, message })
             }
@@ -237,14 +248,20 @@ module.exports = ({ timeout: globalTimeout = 30000, ...launchOpts } = {}) => {
     }
 
     const destroyContext = async ({ force = false } = {}) => {
+      isDestroyed = true
       if (force) isDestroyedForced = true
 
-      const [browserProcess, browserContext] = await Promise.all([
-        getBrowser(),
-        getBrowserContext()
-      ])
-      await pReflect(browserContext.close())
-      debug('destroyContext', { pid: driver.pid(browserProcess), force, id: browserContext.id })
+      try {
+        const [browserProcess, browserContext] = await Promise.all([
+          getBrowser(),
+          getBrowserContext()
+        ])
+        await pReflect(browserContext.close())
+        debug('destroyContext', { pid: driver.pid(browserProcess), force, id: browserContext.id })
+      } finally {
+        forwarders.delete(forwardedContextOpts)
+        await closeForwarder(forwardedContextOpts)
+      }
     }
 
     return {

package/src/proxy-forwarder.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { anonymizeProxy, closeAnonymizedProxy } = require('proxy-chain')
+
+const REDACTED = '***'
+const DEFAULT_SCHEME = 'http://'
+const CONNECT_MODE_ERROR =
+  "A proxyServer with credentials needs `mode: 'launch'`: a connected browser cannot reach the local forwarder"
+
+const forwardedProxyServers = new Set()
+
+const parseProxyServer = proxyServer =>
+  URL.parse(proxyServer.includes('://') ? proxyServer : `${DEFAULT_SCHEME}${proxyServer}`)
+
+const hasCredentials = proxyUrl => Boolean(proxyUrl?.username || proxyUrl?.password)
+
+const redactSecrets = (text, secrets) =>
+  secrets.reduce((redacted, secret) => redacted.replaceAll(secret, REDACTED), text)
+
+const withoutCredentials = (error, proxyUrl) => {
+  const redactedUrl = new URL(proxyUrl)
+  if (proxyUrl.username) redactedUrl.username = REDACTED
+  if (proxyUrl.password) redactedUrl.password = REDACTED
+  const secrets = [proxyUrl.username, proxyUrl.password].filter(Boolean)
+  error.message = error.message
+    .split(proxyUrl.href)
+    .map(part => redactSecrets(part, secrets))
+    .join(redactedUrl.href)
+  return error
+}
+
+const forwardProxy = async (contextOpts, { mode } = {}) => {
+  const proxyUrl = contextOpts.proxyServer && parseProxyServer(contextOpts.proxyServer)
+  if (!hasCredentials(proxyUrl)) return contextOpts
+  if (mode === 'connect') throw new TypeError(CONNECT_MODE_ERROR)
+  try {
+    const proxyServer = await anonymizeProxy(proxyUrl.href)
+    forwardedProxyServers.add(proxyServer)
+    return { ...contextOpts, proxyServer }
+  } catch (error) {
+    throw withoutCredentials(error, proxyUrl)
+  }
+}
+
+const closeForwarder = async contextOptsPromise => {
+  const { proxyServer } = await contextOptsPromise.catch(() => ({}))
+  if (forwardedProxyServers.delete(proxyServer)) await closeAnonymizedProxy(proxyServer, true)
+}
+
+module.exports = { forwardProxy, closeForwarder }