Bump version 3.3.1

Fix HEADLESS=false in Windows binary
Fix for Cloudflare verify checkbox
2025-12-05 17:18:19 +01:00 · 2023-08-03 08:13:01 +02:00 · 2023-08-03 08:10:14 +02:00 · 2023-08-03 07:28:58 +02:00 · 2023-08-03 06:36:31 +02:00 · 2023-08-03 05:45:38 +02:00
31 changed files with 3117 additions and 1975 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -8,6 +8,13 @@ body:
    options:
      - label: I have checked the README
        required: true
+- type: checkboxes
+  attributes:
+    label: Have you followed our Troubleshooting?
+    description: Please follow our <a href="https://github.com/FlareSolverr/FlareSolverr/wiki/Troubleshooting">Troubleshooting</a>.
+    options:
+      - label: I have followed your Troubleshooting
+        required: true
 - type: checkboxes
  attributes:
    label: Is there already an issue for your problem?
@@ -32,7 +39,8 @@ body:
      - Operating system:
      - Are you using Docker: [yes/no]
      - FlareSolverr User-Agent (see log traces or / endpoint):
-      - Are you using a proxy or VPN: [yes/no]
+      - Are you using a VPN: [yes/no]
+      - Are you using a Proxy: [yes/no]
      - Are you using Captcha Solver: [yes/no]
      - If using captcha solver, which one:
      - URL to test this issue:
--- a/.github/workflows/autotag.yml
+++ b/.github/workflows/autotag.yml
@@ -6,12 +6,12 @@ on:
      - "master"

 jobs:
-  build:
+  tag-release:
    runs-on: ubuntu-latest
    steps:
      -
        name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
      -
        name: Auto Tag
        uses: Klemensas/action-autotag@stable
--- a/.github/workflows/release-docker.yml
+++ b/.github/workflows/release-docker.yml
@@ -6,44 +6,44 @@ on:
      - 'v*.*.*'

 jobs:
-  build:
-    runs-on: ubuntu-latest
+  build-docker-images:
+    runs-on: ubuntu-22.04
    steps:
      -
        name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
      -
        name: Downcase repo
        run: echo REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
      -
        name: Docker meta
        id: docker_meta
-        uses: crazy-max/ghaction-docker-meta@v1
+        uses: crazy-max/ghaction-docker-meta@v3
        with:
          images: ${{ env.REPOSITORY }},ghcr.io/${{ env.REPOSITORY }}
          tag-sha: false
      -
        name: Set up QEMU
-        uses: docker/setup-qemu-action@v1.0.1
+        uses: docker/setup-qemu-action@v2
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
      -
        name: Login to DockerHub
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      -
        name: Login to GitHub Container Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GH_PAT }}
      -
        name: Build and push
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
        with:
          context: .
          file: ./Dockerfile
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -6,26 +6,15 @@ on:
      - 'v*.*.*'

 jobs:
-  build:
+  create-release:
    name: Create release
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
    steps:
      - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # get all commits, branches and tags (required for the changelog)

-      - name: Setup Node
-        uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-
-      - name: Build artifacts
-        run: |
-          npm install
-          npm run build
-          npm run package
-
      - name: Build changelog
        id: github_changelog
        run: |
@@ -47,9 +36,60 @@ jobs:
          draft: false
          prerelease: false

+  build-linux-package:
+    name: Build Linux binary
+    needs: create-release
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # get all commits, branches and tags (required for the changelog)
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Build artifacts
+        run: |
+          python -m pip install -r requirements.txt
+          python -m pip install pyinstaller==5.13.0
+          cd src
+          python build_package.py
+
      - name: Upload release artifacts
-        uses: alexellis/upload-assets@0.2.2
+        uses: alexellis/upload-assets@0.4.0
        env:
          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
        with:
-          asset_paths: '["./bin/*.zip"]'
+          asset_paths: '["./dist/flaresolverr_*"]'
+
+  build-windows-package:
+    name: Build Windows binary
+    needs: create-release
+    runs-on: windows-2022
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # get all commits, branches and tags (required for the changelog)
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Build artifacts
+        run: |
+          python -m pip install -r requirements.txt
+          python -m pip install pyinstaller==5.13.0
+          cd src
+          python build_package.py
+
+      - name: Upload release artifacts
+        uses: alexellis/upload-assets@0.4.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+        with:
+          asset_paths: '["./dist/flaresolverr_*"]'
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@ __pycache__/
 build/
 develop-eggs/
 dist/
+dist_chrome/
 downloads/
 eggs/
 .eggs/
@@ -123,3 +124,6 @@ venv.bak/
 .mypy_cache/
 .dmypy.json
 dmypy.json
+
+# node
+node_modules/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,89 @@
 # Changelog

+## v3.3.1 (2023/08/03)
+
+* Fix for Cloudflare verify checkbox
+* Fix HEADLESS=false in Windows binary
+* Fix Prometheus exporter for management and health endpoints
+* Remove misleading stack trace when the verify checkbox is not found
+* Revert "Update base Docker image to Debian Bookworm" #849
+* Revert "Install Chromium 115 from Debian testing" #849
+
+## v3.3.0 (2023/08/02)
+
+* Fix for new Cloudflare detection. Thanks @cedric-bour for #845
+* Add support for proxy authentication username/password. Thanks @jacobprice808	for #807
+* Implement Prometheus metrics
+* Fix Chromium Driver for Chrome / Chromium version > 114
+* Use Chromium 115 in binary packages (Windows and Linux)
+* Install Chromium 115 from Debian testing (Docker)
+* Update base Docker image to Debian Bookworm
+* Update Selenium 4.11.2
+* Update pyinstaller 5.13.0
+* Add more traces in build_package.py
+
+## v3.2.2 (2023/07/16)
+
+* Workaround for updated 'verify you are human' check
+
+## v3.2.1 (2023/06/10)
+
+* Kill dead Chrome processes in Windows
+* Fix Chrome GL erros in ASUSTOR NAS
+
+## v3.2.0 (2023/05/23)
+
+* Support "proxy" param in requests and sessions
+* Support "cookies" param in requests
+* Fix Chromium exec permissions in Linux package
+* Update Python dependencies
+
+## v3.1.2 (2023/04/02)
+
+* Fix headless mode in macOS
+* Remove redundant artifact from Windows binary package
+* Bump Selenium dependency
+
+## v3.1.1 (2023/03/25)
+
+* Distribute binary executables in compressed package
+* Add icon for binary executable
+* Include information about supported architectures in the readme
+* Check Python version on start
+
+## v3.1.0 (2023/03/20)
+
+* Build binaries for Linux x64 and Windows x64
+* Sessions with auto-creation on fetch request and TTL
+* Fix error trace: Crash Reports/pending No such file or directory
+* Fix Waitress server error with asyncore_use_poll=true
+* Attempt to fix Docker ARM32 build
+* Print platform information on start up
+* Add Fairlane challenge selector
+* Update DDOS-GUARD title
+* Update dependencies
+
+## v3.0.4 (2023/03/07)
+
+* Click on the Cloudflare's 'Verify you are human' button if necessary
+
+## v3.0.3 (2023/03/06)
+
+* Update undetected_chromedriver version to 3.4.6
+
+## v3.0.2 (2023/01/08)
+
+* Detect Cloudflare blocked access
+* Check Chrome / Chromium web browser is installed correctly
+
+## v3.0.1 (2023/01/06)
+
+* Kill Chromium processes properly to avoid defunct/zombie processes
+* Update undetected-chromedriver
+* Disable Zygote sandbox in Chromium browser
+* Add more selectors to detect blocked access
+* Include procps (ps), curl and vim packages in the Docker image
+
 ## v3.0.0 (2023/01/04)

 * This is the first release of FlareSolverr v3. There are some breaking changes
--- a/21
+++ b/21
@@ -29,7 +29,8 @@ RUN dpkg -i /libgl1-mesa-dri.deb \
    && dpkg -i /adwaita-icon-theme.deb \
    # Install dependencies
    && apt-get update \
-    && apt-get install -y --no-install-recommends chromium chromium-common chromium-driver xvfb \
+    && apt-get install -y --no-install-recommends chromium chromium-common chromium-driver xvfb dumb-init \
+        procps curl vim xauth \
    # Remove temporary files and hardware decoding libraries
    && rm -rf /var/lib/apt/lists/* \
    && rm -f /usr/lib/x86_64-linux-gnu/libmfxhw* \
@@ -47,19 +48,31 @@ RUN pip install -r requirements.txt \

 USER flaresolverr

+RUN mkdir -p "/app/.config/chromium/Crash Reports/pending"
+
 COPY src .
 COPY package.json ../

 EXPOSE 8191
+EXPOSE 8192
+
+# dumb-init avoids zombie chromium processes
+ENTRYPOINT ["/usr/bin/dumb-init", "--"]

 CMD ["/usr/local/bin/python", "-u", "/app/flaresolverr.py"]

 # Local build
-# docker build -t ngosang/flaresolverr:3.0.0 .
-# docker run -p 8191:8191 ngosang/flaresolverr:3.0.0
+# docker build -t ngosang/flaresolverr:3.3.1 .
+# docker run -p 8191:8191 ngosang/flaresolverr:3.3.1

 # Multi-arch build
 # docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
 # docker buildx create --use
-# docker buildx build -t ngosang/flaresolverr:3.0.0 --platform linux/386,linux/amd64,linux/arm/v7,linux/arm64/v8 .
+# docker buildx build -t ngosang/flaresolverr:3.3.1 --platform linux/386,linux/amd64,linux/arm/v7,linux/arm64/v8 .
 #   add --push to publish in DockerHub
+
+# Test multi-arch build
+# docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+# docker buildx create --use
+# docker buildx build -t ngosang/flaresolverr:3.3.1 --platform linux/arm/v7 --load .
+# docker run -p 8191:8191 --platform linux/arm/v7 ngosang/flaresolverr:3.3.1
--- a/README.md
+++ b/README.md
@@ -64,16 +64,20 @@ Remember to restart the Docker daemon and the container after the update.

 ### Precompiled binaries

+> **Warning**
+> Precompiled binaries are only available for x64 architecture. For other architectures see Docker images.
+
 This is the recommended way for Windows users.
-* Download the [FlareSolverr zip](https://github.com/FlareSolverr/FlareSolverr/releases) from the release's assets. It is available for Windows and Linux.
-* Extract the zip file. FlareSolverr executable and firefox folder must be in the same directory.
+* Download the [FlareSolverr executable](https://github.com/FlareSolverr/FlareSolverr/releases) from the release's page. It is available for Windows x64 and Linux x64.
 * Execute FlareSolverr binary. In the environment variables section you can find how to change the configuration.

 ### From source code

-This is the recommended way for macOS users and for developers.
-* Install [Python 3.10](https://www.python.org/downloads/).
-* Install [Chrome](https://www.google.com/intl/en_us/chrome/) or [Chromium](https://www.chromium.org/getting-involved/download-chromium/) web browser.
+> **Warning**
+> Installing from source code only works for x64 architecture. For other architectures see Docker images.
+
+* Install [Python 3.11](https://www.python.org/downloads/).
+* Install [Chrome](https://www.google.com/intl/en_us/chrome/) (all OS) or [Chromium](https://www.chromium.org/getting-involved/download-chromium/) (just Linux, it doesn't work in Windows) web browser.
 * (Only in Linux / macOS) Install [Xvfb](https://en.wikipedia.org/wiki/Xvfb) package.
 * Clone this repository and open a shell in that path.
 * Run `pip install -r requirements.txt` command to install FlareSolverr dependencies.
@@ -106,10 +110,10 @@ cookies for the browser to use.

 This also speeds up the requests since it won't have to launch a new browser instance for every request.

-| Parameter | Notes                                                                                                                                                                                                                 |
-|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| session   | Optional. The session ID that you want to be assigned to the instance. If isn't set a random UUID will be assigned.                                                                                                   |
-| proxy     | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is not supported. |
+| Parameter | Notes                                                                                                                                                                                                                                                                                                            |
+|-----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| session   | Optional. The session ID that you want to be assigned to the instance. If isn't set a random UUID will be assigned.                                                                                                                                                                                              |
+| proxy     | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is supported. Eg: `"proxy": {"url": "http://127.0.0.1:8888", username": "testuser", "password": "testpass"}` |

 #### + `sessions.list`

@@ -140,16 +144,18 @@ session. When you no longer need to use a session you should make sure to close

 #### + `request.get`

-| Parameter         | Notes                                                                                                                                                                                                                                                                                                                                        |
-|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| url               | Mandatory                                                                                                                                                                                                                                                                                                                                    |
-| session           | Optional. Will send the request from and existing browser instance. If one is not sent it will create a temporary instance that will be destroyed immediately after the request is completed.                                                                                                                                                |
-| maxTimeout        | Optional, default value 60000. Max timeout to solve the challenge in milliseconds.                                                                                                                                                                                                                                                           |
-| cookies           | Optional. Will be used by the headless browser. Follow [this](https://github.com/puppeteer/puppeteer/blob/v3.3.0/docs/api.md#pagesetcookiecookies) format.                                                                                                                                                                                   |
-| returnOnlyCookies | Optional, default false. Only returns the cookies. Response data, headers and other parts of the response are removed.                                                                                                                                                                                                                       |
-| proxy             | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is not supported. (When the `session` parameter is set, the proxy is ignored; a session specific proxy can be set in `sessions.create`.) |
+| Parameter           | Notes                                                                                                                                                                                                                                                                                                                                        |
+|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| url                 | Mandatory                                                                                                                                                                                                                                                                                                                                    |
+| session             | Optional. Will send the request from and existing browser instance. If one is not sent it will create a temporary instance that will be destroyed immediately after the request is completed.                                                                                                                                                |
+| session_ttl_minutes | Optional. FlareSolverr will automatically rotate expired sessions based on the TTL provided in minutes.                                                                                                                                                                                                                                      |
+| maxTimeout          | Optional, default value 60000. Max timeout to solve the challenge in milliseconds.                                                                                                                                                                                                                                                           |
+| cookies             | Optional. Will be used by the headless browser. Eg: `"cookies": [{"name": "cookie1", "value": "value1"}, {"name": "cookie2", "value": "value2"}]`.                                                                                                                                                                                           |
+| returnOnlyCookies   | Optional, default false. Only returns the cookies. Response data, headers and other parts of the response are removed.                                                                                                                                                                                                                       |
+| proxy               | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is not supported. (When the `session` parameter is set, the proxy is ignored; a session specific proxy can be set in `sessions.create`.) |

-:warning: If you want to use Cloudflare clearance cookie in your scripts, make sure you use the FlareSolverr User-Agent too. If they don't match you will see the challenge.
+> **Warning**
+> If you want to use Cloudflare clearance cookie in your scripts, make sure you use the FlareSolverr User-Agent too. If they don't match you will see the challenge.

 Example response from running the `curl` above:

@@ -220,32 +226,61 @@ This is the same as `request.get` but it takes one more param:

 ## Environment variables

-| Name            | Default                | Notes                                                                                                                                                         |
-|-----------------|------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| LOG_LEVEL       | info                   | Verbosity of the logging. Use `LOG_LEVEL=debug` for more information.                                                                                         |
-| LOG_HTML        | false                  | Only for debugging. If `true` all HTML that passes through the proxy will be logged to the console in `debug` level.                                          |
-| CAPTCHA_SOLVER  | none                   | Captcha solving method. It is used when a captcha is encountered. See the Captcha Solvers section.                                                            |
-| TZ              | UTC                    | Timezone used in the logs and the web browser. Example: `TZ=Europe/London`.                                                                                   |
-| HEADLESS        | true                   | Only for debugging. To run the web browser in headless mode or visible.                                                                                       |
-| BROWSER_TIMEOUT | 40000                  | If you are experiencing errors/timeouts because your system is slow, you can try to increase this value. Remember to increase the `maxTimeout` parameter too. |
-| TEST_URL        | https://www.google.com | FlareSolverr makes a request on start to make sure the web browser is working. You can change that URL if it is blocked in your country.                      |
-| PORT            | 8191                   | Listening port. You don't need to change this if you are running on Docker.                                                                                   |
-| HOST            | 0.0.0.0                | Listening interface. You don't need to change this if you are running on Docker.                                                                              |
+| Name               | Default                | Notes                                                                                                                                                         |
+|--------------------|------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| LOG_LEVEL          | info                   | Verbosity of the logging. Use `LOG_LEVEL=debug` for more information.                                                                                         |
+| LOG_HTML           | false                  | Only for debugging. If `true` all HTML that passes through the proxy will be logged to the console in `debug` level.                                          |
+| CAPTCHA_SOLVER     | none                   | Captcha solving method. It is used when a captcha is encountered. See the Captcha Solvers section.                                                            |
+| TZ                 | UTC                    | Timezone used in the logs and the web browser. Example: `TZ=Europe/London`.                                                                                   |
+| HEADLESS           | true                   | Only for debugging. To run the web browser in headless mode or visible.                                                                                       |
+| BROWSER_TIMEOUT    | 40000                  | If you are experiencing errors/timeouts because your system is slow, you can try to increase this value. Remember to increase the `maxTimeout` parameter too. |
+| TEST_URL           | https://www.google.com | FlareSolverr makes a request on start to make sure the web browser is working. You can change that URL if it is blocked in your country.                      |
+| PORT               | 8191                   | Listening port. You don't need to change this if you are running on Docker.                                                                                   |
+| HOST               | 0.0.0.0                | Listening interface. You don't need to change this if you are running on Docker.                                                                              |
+| PROMETHEUS_ENABLED | false                  | Enable Prometheus exporter. See the Prometheus section below.                                                                                                 |
+| PROMETHEUS_PORT    | 8192                   | Listening port for Prometheus exporter. See the Prometheus section below.                                                                                     |

 Environment variables are set differently depending on the operating system. Some examples:
 * Docker: Take a look at the Docker section in this document. Environment variables can be set in the `docker-compose.yml` file or in the Docker CLI command.
 * Linux: Run `export LOG_LEVEL=debug` and then start FlareSolverr in the same shell.
 * Windows: Open `cmd.exe`, run `set LOG_LEVEL=debug` and then start FlareSolverr in the same shell.

+## Prometheus exporter
+
+The Prometheus exporter for FlareSolverr is disabled by default. It can be enabled with the environment variable `PROMETHEUS_ENABLED`. If you are using Docker make sure you expose the `PROMETHEUS_PORT`.
+
+Example metrics:
+```shell
+# HELP flaresolverr_request_total Total requests with result
+# TYPE flaresolverr_request_total counter
+flaresolverr_request_total{domain="nowsecure.nl",result="solved"} 1.0
+# HELP flaresolverr_request_created Total requests with result
+# TYPE flaresolverr_request_created gauge
+flaresolverr_request_created{domain="nowsecure.nl",result="solved"} 1.690141657157109e+09
+# HELP flaresolverr_request_duration Request duration in seconds
+# TYPE flaresolverr_request_duration histogram
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="0.0"} 0.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="10.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="25.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="50.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="+Inf"} 1.0
+flaresolverr_request_duration_count{domain="nowsecure.nl"} 1.0
+flaresolverr_request_duration_sum{domain="nowsecure.nl"} 5.858
+# HELP flaresolverr_request_duration_created Request duration in seconds
+# TYPE flaresolverr_request_duration_created gauge
+flaresolverr_request_duration_created{domain="nowsecure.nl"} 1.6901416571570296e+09
+```
+
 ## Captcha Solvers

-:warning: At this time none of the captcha solvers work. You can check the status in the open issues. Any help is welcome.
+> **Warning**
+> At this time none of the captcha solvers work. You can check the status in the open issues. Any help is welcome.

 Sometimes CloudFlare not only gives mathematical computations and browser tests, sometimes they also require the user to
 solve a captcha.
 If this is the case, FlareSolverr will return the error `Captcha detected but no automatic solver is configured.`

-FlareSolverr can be customized to solve the captchas automatically by setting the environment variable `CAPTCHA_SOLVER`
+FlareSolverr can be customized to solve the CAPTCHA automatically by setting the environment variable `CAPTCHA_SOLVER`
 to the file name of one of the adapters inside the [/captcha](src/captcha) directory.

 ## Related projects
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
  "name": "flaresolverr",
-  "version": "3.0.0",
+  "version": "3.3.1",
  "description": "Proxy server to bypass Cloudflare protection",
  "author": "Diego Heras (ngosang / ngosang@hotmail.es)",
  "license": "MIT"
-}
+}
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,9 +1,13 @@
-bottle==0.12.23
+bottle==0.12.25
 waitress==2.1.2
-selenium==4.4.3
+selenium==4.11.2
 func-timeout==4.3.5
+prometheus-client==0.17.1
 # required by undetected_chromedriver
-requests==2.28.1
-websockets==10.3
+requests==2.31.0
+certifi==2023.7.22
+websockets==11.0.3
 # only required for linux
 xvfbwrapper==0.2.9
+# only required for windows
+pefile==2023.2.7
--- a/resources/flaresolverr_logo.ico
+++ b/resources/flaresolverr_logo.ico
--- a/src/bottle_plugins/prometheus_plugin.py
+++ b/src/bottle_plugins/prometheus_plugin.py
@@ -0,0 +1,57 @@
+import logging
+import os
+import urllib.parse
+
+from dtos import V1ResponseBase
+from metrics import start_metrics_http_server, REQUEST_COUNTER, REQUEST_DURATION
+
+PROMETHEUS_ENABLED = os.environ.get('PROMETHEUS_ENABLED', 'false').lower() == 'true'
+PROMETHEUS_PORT = int(os.environ.get('PROMETHEUS_PORT', 8192))
+
+
+def setup():
+    if PROMETHEUS_ENABLED:
+        start_metrics_http_server(PROMETHEUS_PORT)
+
+
+def prometheus_plugin(callback):
+    """
+    Bottle plugin to expose Prometheus metrics
+    http://bottlepy.org/docs/dev/plugindev.html
+    """
+    def wrapper(*args, **kwargs):
+        actual_response = callback(*args, **kwargs)
+
+        if PROMETHEUS_ENABLED:
+            try:
+                export_metrics(actual_response)
+            except Exception as e:
+                logging.warning("Error exporting metrics: " + str(e))
+
+        return actual_response
+
+    def export_metrics(actual_response):
+        res = V1ResponseBase(actual_response)
+
+        if res.startTimestamp is None or res.endTimestamp is None:
+            # skip management and healthcheck endpoints
+            return
+
+        domain = "unknown"
+        if res.solution and res.solution.url:
+            parsed_url = urllib.parse.urlparse(res.solution.url)
+            domain = parsed_url.hostname
+
+        run_time = (res.endTimestamp - res.startTimestamp) / 1000
+        REQUEST_DURATION.labels(domain=domain).observe(run_time)
+
+        result = "unknown"
+        if res.message == "Challenge solved!":
+            result = "solved"
+        elif res.message == "Challenge not detected!":
+            result = "not_detected"
+        elif res.message.startswith("Error"):
+            result = "error"
+        REQUEST_COUNTER.labels(domain=domain, result=result).inc()
+
+    return wrapper
--- a/src/build_package.py
+++ b/src/build_package.py
@@ -0,0 +1,111 @@
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import zipfile
+
+import requests
+
+
+def clean_files():
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'build'))
+    except Exception:
+        pass
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist'))
+    except Exception:
+        pass
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist_chrome'))
+    except Exception:
+        pass
+
+
+def download_chromium():
+    # https://commondatastorage.googleapis.com/chromium-browser-snapshots/index.html?prefix=Linux_x64/
+    revision = "1140001" if os.name == 'nt' else '1140000'
+    arch = 'Win_x64' if os.name == 'nt' else 'Linux_x64'
+    dl_file = 'chrome-win' if os.name == 'nt' else 'chrome-linux'
+    dl_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist_chrome')
+    dl_path_folder = os.path.join(dl_path, dl_file)
+    dl_path_zip = dl_path_folder + '.zip'
+
+    # response = requests.get(
+    #     f'https://commondatastorage.googleapis.com/chromium-browser-snapshots/{arch}/LAST_CHANGE',
+    #     timeout=30)
+    # revision = response.text.strip()
+    print("Downloading revision: " + revision)
+
+    os.mkdir(dl_path)
+    with requests.get(
+            f'https://commondatastorage.googleapis.com/chromium-browser-snapshots/{arch}/{revision}/{dl_file}.zip',
+            stream=True) as r:
+        r.raise_for_status()
+        with open(dl_path_zip, 'wb') as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                f.write(chunk)
+    print("File downloaded: " + dl_path_zip)
+    with zipfile.ZipFile(dl_path_zip, 'r') as zip_ref:
+        zip_ref.extractall(dl_path)
+    os.remove(dl_path_zip)
+
+    chrome_path = os.path.join(dl_path, "chrome")
+    shutil.move(dl_path_folder, chrome_path)
+    print("Extracted in: " + chrome_path)
+
+    if os.name != 'nt':
+        # Give executable permissions for *nix
+        # file * | grep executable | cut -d: -f1
+        print("Giving executable permissions...")
+        execs = ['chrome', 'chrome_crashpad_handler', 'chrome_sandbox', 'chrome-wrapper', 'nacl_helper',
+                 'nacl_helper_bootstrap', 'nacl_irt_x86_64.nexe', 'xdg-mime', 'xdg-settings']
+        for exec_file in execs:
+            exec_path = os.path.join(chrome_path, exec_file)
+            os.chmod(exec_path, 0o755)
+
+
+def run_pyinstaller():
+    sep = ';' if os.name == 'nt' else ':'
+    result = subprocess.run([sys.executable, "-m", "PyInstaller",
+                             "--icon", "resources/flaresolverr_logo.ico",
+                             "--add-data", f"package.json{sep}.",
+                             "--add-data", f"{os.path.join('dist_chrome', 'chrome')}{sep}chrome",
+                             os.path.join("src", "flaresolverr.py")],
+                            cwd=os.pardir, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        print(result.stderr.decode('utf-8'))
+        raise Exception("Error running pyInstaller")
+
+
+def compress_package():
+    dist_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist')
+    package_folder = os.path.join(dist_folder, 'package')
+    shutil.move(os.path.join(dist_folder, 'flaresolverr'), os.path.join(package_folder, 'flaresolverr'))
+    print("Package folder: " + package_folder)
+
+    compr_format = 'zip' if os.name == 'nt' else 'gztar'
+    compr_file_name = 'flaresolverr_windows_x64' if os.name == 'nt' else 'flaresolverr_linux_x64'
+    compr_file_path = os.path.join(dist_folder, compr_file_name)
+    shutil.make_archive(compr_file_path, compr_format, package_folder)
+    print("Compressed file path: " + compr_file_path)
+
+
+if __name__ == "__main__":
+    print("Building package...")
+    print("Platform: " + platform.platform())
+
+    print("Cleaning previous build...")
+    clean_files()
+
+    print("Downloading Chromium...")
+    download_chromium()
+
+    print("Building pyinstaller executable... ")
+    run_pyinstaller()
+
+    print("Compressing package... ")
+    compress_package()
+
+# NOTE: python -m pip install pyinstaller
--- a/src/dtos.py
+++ b/src/dtos.py
@@ -33,6 +33,7 @@ class V1RequestBase(object):
    maxTimeout: int = None
    proxy: dict = None
    session: str = None
+    session_ttl_minutes: int = None
    headers: list = None  # deprecated v2.0.0, not used
    userAgent: str = None  # deprecated v2.0.0, not used

@@ -51,6 +52,8 @@ class V1ResponseBase(object):
    # V1ResponseBase
    status: str = None
    message: str = None
+    session: str = None
+    sessions: list[str] = None
    startTimestamp: int = None
    endTimestamp: int = None
    version: str = None
--- a/src/flaresolverr.py
+++ b/src/flaresolverr.py
@@ -3,11 +3,13 @@ import logging
 import os
 import sys

-from bottle import run, response, Bottle, request
+import certifi
+from bottle import run, response, Bottle, request, ServerAdapter

 from bottle_plugins.error_plugin import error_plugin
 from bottle_plugins.logger_plugin import logger_plugin
-from dtos import IndexResponse, V1RequestBase
+from bottle_plugins import prometheus_plugin
+from dtos import V1RequestBase
 import flaresolverr_service
 import utils

@@ -23,10 +25,6 @@ class JSONErrorBottle(Bottle):

 app = JSONErrorBottle()

-# plugin order is important
-app.install(logger_plugin)
-app.install(error_plugin)
-

@app.route('/')
 def index():
@@ -60,6 +58,22 @@ def controller_v1():


 if __name__ == "__main__":
+    # check python version
+    if sys.version_info < (3, 9):
+        raise Exception("The Python version is less than 3.9, a version equal to or higher is required.")
+
+    # fix for HEADLESS=false in Windows binary
+    # https://stackoverflow.com/a/27694505
+    if os.name == 'nt':
+        import multiprocessing
+        multiprocessing.freeze_support()
+
+    # fix ssl certificates for compiled binaries
+    # https://github.com/pyinstaller/pyinstaller/issues/7229
+    # https://stackoverflow.com/questions/55736855/how-to-change-the-cafile-argument-in-the-ssl-module-in-python3
+    os.environ["REQUESTS_CA_BUNDLE"] = certifi.where()
+    os.environ["SSL_CERT_FILE"] = certifi.where()
+
    # validate configuration
    log_level = os.environ.get('LOG_LEVEL', 'info').upper()
    log_html = utils.get_config_log_html()
@@ -90,6 +104,19 @@ if __name__ == "__main__":
    # test browser installation
    flaresolverr_service.test_browser_installation()

+    # start bootle plugins
+    # plugin order is important
+    app.install(logger_plugin)
+    app.install(error_plugin)
+    prometheus_plugin.setup()
+    app.install(prometheus_plugin.prometheus_plugin)
+
    # start webserver
    # default server 'wsgiref' does not support concurrent requests
-    run(app, host=server_host, port=server_port, quiet=True, server='waitress')
+    # https://github.com/FlareSolverr/FlareSolverr/issues/680
+    # https://github.com/Pylons/waitress/issues/31
+    class WaitressServerPoll(ServerAdapter):
+        def run(self, handler):
+            from waitress import serve
+            serve(handler, host=self.host, port=self.port, asyncore_use_poll=True)
+    run(app, host=server_host, port=server_port, quiet=True, server=WaitressServerPoll)
--- a/src/flaresolverr_service.py
+++ b/src/flaresolverr_service.py
@@ -1,42 +1,77 @@
 import logging
+import platform
+import sys
 import time
+from datetime import timedelta
 from urllib.parse import unquote

-from func_timeout import func_timeout, FunctionTimedOut
+from func_timeout import FunctionTimedOut, func_timeout
 from selenium.common import TimeoutException
 from selenium.webdriver.chrome.webdriver import WebDriver
 from selenium.webdriver.common.by import By
+from selenium.webdriver.support.expected_conditions import (
+    presence_of_element_located, staleness_of, title_is)
+from selenium.webdriver.common.action_chains import ActionChains
 from selenium.webdriver.support.wait import WebDriverWait
-from selenium.webdriver.support.expected_conditions import presence_of_element_located, staleness_of, title_is

-from dtos import V1RequestBase, V1ResponseBase, ChallengeResolutionT, ChallengeResolutionResultT, IndexResponse, \
-    HealthResponse, STATUS_OK, STATUS_ERROR
 import utils
+from dtos import (STATUS_ERROR, STATUS_OK, ChallengeResolutionResultT,
+                  ChallengeResolutionT, HealthResponse, IndexResponse,
+                  V1RequestBase, V1ResponseBase)
+from sessions import SessionsStorage

+ACCESS_DENIED_TITLES = [
+    # Cloudflare
+    'Access denied',
+    # Cloudflare http://bitturk.net/ Firefox
+    'Attention Required! | Cloudflare'
+]
 ACCESS_DENIED_SELECTORS = [
    # Cloudflare
-    'div.cf-error-title span.cf-code-label span'
+    'div.cf-error-title span.cf-code-label span',
+    # Cloudflare http://bitturk.net/ Firefox
+    '#cf-error-details div.cf-error-overview h1'
 ]
-CHALLENGE_TITLE = [
+CHALLENGE_TITLES = [
    # Cloudflare
    'Just a moment...',
    # DDoS-GUARD
-    'DDOS-GUARD',
+    'DDoS-Guard'
 ]
 CHALLENGE_SELECTORS = [
    # Cloudflare
    '#cf-challenge-running', '.ray_id', '.attack-box', '#cf-please-wait', '#challenge-spinner', '#trk_jschal_js',
    # Custom CloudFlare for EbookParadijs, Film-Paleis, MuziekFabriek and Puur-Hollands
-    'td.info #js_info'
+    'td.info #js_info',
+    # Fairlane / pararius.com
+    'div.vc div.text-box h2'
 ]
-SHORT_TIMEOUT = 10
+SHORT_TIMEOUT = 1
+SESSIONS_STORAGE = SessionsStorage()


 def test_browser_installation():
    logging.info("Testing web browser installation...")
+    logging.info("Platform: " + platform.platform())
+
+    chrome_exe_path = utils.get_chrome_exe_path()
+    if chrome_exe_path is None:
+        logging.error("Chrome / Chromium web browser not installed!")
+        sys.exit(1)
+    else:
+        logging.info("Chrome / Chromium path: " + chrome_exe_path)
+
+    chrome_major_version = utils.get_chrome_major_version()
+    if chrome_major_version == '':
+        logging.error("Chrome / Chromium version not detected!")
+        sys.exit(1)
+    else:
+        logging.info("Chrome / Chromium major version: " + chrome_major_version)
+
+    logging.info("Launching web browser...")
    user_agent = utils.get_user_agent()
    logging.info("FlareSolverr User-Agent: " + user_agent)
-    logging.info("Test successful")
+    logging.info("Test successful!")


 def index_endpoint() -> IndexResponse:
@@ -90,11 +125,11 @@ def _controller_v1_handler(req: V1RequestBase) -> V1ResponseBase:
    # execute the command
    res: V1ResponseBase
    if req.cmd == 'sessions.create':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_create(req)
    elif req.cmd == 'sessions.list':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_list(req)
    elif req.cmd == 'sessions.destroy':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_destroy(req)
    elif req.cmd == 'request.get':
        res = _cmd_request_get(req)
    elif req.cmd == 'request.post':
@@ -141,19 +176,115 @@ def _cmd_request_post(req: V1RequestBase) -> V1ResponseBase:
    return res


+def _cmd_sessions_create(req: V1RequestBase) -> V1ResponseBase:
+    logging.debug("Creating new session...")
+
+    session, fresh = SESSIONS_STORAGE.create(session_id=req.session, proxy=req.proxy)
+    session_id = session.session_id
+
+    if not fresh:
+        return V1ResponseBase({
+            "status": STATUS_OK,
+            "message": "Session already exists.",
+            "session": session_id
+        })
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "Session created successfully.",
+        "session": session_id
+    })
+
+
+def _cmd_sessions_list(req: V1RequestBase) -> V1ResponseBase:
+    session_ids = SESSIONS_STORAGE.session_ids()
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "",
+        "sessions": session_ids
+    })
+
+
+def _cmd_sessions_destroy(req: V1RequestBase) -> V1ResponseBase:
+    session_id = req.session
+    existed = SESSIONS_STORAGE.destroy(session_id)
+
+    if not existed:
+        raise Exception("The session doesn't exist.")
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "The session has been removed."
+    })
+
+
 def _resolve_challenge(req: V1RequestBase, method: str) -> ChallengeResolutionT:
    timeout = req.maxTimeout / 1000
    driver = None
    try:
-        driver = utils.get_webdriver()
+        if req.session:
+            session_id = req.session
+            ttl = timedelta(minutes=req.session_ttl_minutes) if req.session_ttl_minutes else None
+            session, fresh = SESSIONS_STORAGE.get(session_id, ttl)
+
+            if fresh:
+                logging.debug(f"new session created to perform the request (session_id={session_id})")
+            else:
+                logging.debug(f"existing session is used to perform the request (session_id={session_id}, "
+                              f"lifetime={str(session.lifetime())}, ttl={str(ttl)})")
+
+            driver = session.driver
+        else:
+            driver = utils.get_webdriver(req.proxy)
+            logging.debug('New instance of webdriver has been created to perform the request')
        return func_timeout(timeout, _evil_logic, (req, driver, method))
    except FunctionTimedOut:
        raise Exception(f'Error solving the challenge. Timeout after {timeout} seconds.')
    except Exception as e:
-        raise Exception('Error solving the challenge. ' + str(e))
+        raise Exception('Error solving the challenge. ' + str(e).replace('\n', '\\n'))
    finally:
-        if driver is not None:
+        if not req.session and driver is not None:
            driver.quit()
+            logging.debug('A used instance of webdriver has been destroyed')
+
+
+def click_verify(driver: WebDriver):
+    try:
+        logging.debug("Try to find the Cloudflare verify checkbox...")
+        iframe = driver.find_element(By.XPATH, "//iframe[@title='Widget containing a Cloudflare security challenge']")
+        driver.switch_to.frame(iframe)
+        checkbox = driver.find_element(
+            by=By.XPATH,
+            value='//*[@id="cf-stage"]//label[@class="ctp-checkbox-label"]/input',
+        )
+        if checkbox:
+            actions = ActionChains(driver)
+            actions.move_to_element_with_offset(checkbox, 5, 7)
+            actions.click(checkbox)
+            actions.perform()
+            logging.debug("Cloudflare verify checkbox found and clicked!")
+    except Exception:
+        logging.debug("Cloudflare verify checkbox not found on the page.")
+    finally:
+        driver.switch_to.default_content()
+
+    try:
+        logging.debug("Try to find the Cloudflare 'Verify you are human' button...")
+        button = driver.find_element(
+            by=By.XPATH,
+            value="//input[@type='button' and @value='Verify you are human']",
+        )
+        if button:
+            actions = ActionChains(driver)
+            actions.move_to_element_with_offset(button, 5, 7)
+            actions.click(button)
+            actions.perform()
+            logging.debug("The Cloudflare 'Verify you are human' button found and clicked!")
+    except Exception:
+        logging.debug("The Cloudflare 'Verify you are human' button not found on the page.")
+
+    time.sleep(2)


 def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> ChallengeResolutionT:
@@ -167,12 +298,32 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge
        _post_request(req, driver)
    else:
        driver.get(req.url)
-    if utils.get_config_log_html():
-        logging.debug(f"Response HTML:\n{driver.page_source}")
+        driver.start_session()  # required to bypass Cloudflare
+
+    # set cookies if required
+    if req.cookies is not None and len(req.cookies) > 0:
+        logging.debug(f'Setting cookies...')
+        for cookie in req.cookies:
+            driver.delete_cookie(cookie['name'])
+            driver.add_cookie(cookie)
+        # reload the page
+        if method == 'POST':
+            _post_request(req, driver)
+        else:
+            driver.get(req.url)
+            driver.start_session()  # required to bypass Cloudflare

    # wait for the page
+    if utils.get_config_log_html():
+        logging.debug(f"Response HTML:\n{driver.page_source}")
    html_element = driver.find_element(By.TAG_NAME, "html")
+    page_title = driver.title

+    # find access denied titles
+    for title in ACCESS_DENIED_TITLES:
+        if title == page_title:
+            raise Exception('Cloudflare has blocked this request. '
+                            'Probably your IP is banned for this site, check in your web browser.')
    # find access denied selectors
    for selector in ACCESS_DENIED_SELECTORS:
        found_elements = driver.find_elements(By.CSS_SELECTOR, selector)
@@ -182,11 +333,10 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge

    # find challenge by title
    challenge_found = False
-    page_title = driver.title
-    for title in CHALLENGE_TITLE:
-        if title == page_title:
+    for title in CHALLENGE_TITLES:
+        if title.lower() == page_title.lower():
            challenge_found = True
-            logging.info("Challenge detected. Title found: " + title)
+            logging.info("Challenge detected. Title found: " + page_title)
            break
    if not challenge_found:
        # find challenge by selectors
@@ -197,17 +347,19 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge
                logging.info("Challenge detected. Selector found: " + selector)
                break

+    attempt = 0
    if challenge_found:
        while True:
            try:
-                # wait until the title change
-                for title in CHALLENGE_TITLE:
-                    logging.debug("Waiting for title: " + title)
+                attempt = attempt + 1
+                # wait until the title changes
+                for title in CHALLENGE_TITLES:
+                    logging.debug("Waiting for title (attempt " + str(attempt) + "): " + title)
                    WebDriverWait(driver, SHORT_TIMEOUT).until_not(title_is(title))

                # then wait until all the selectors disappear
                for selector in CHALLENGE_SELECTORS:
-                    logging.debug("Waiting for selector: " + selector)
+                    logging.debug("Waiting for selector (attempt " + str(attempt) + "): " + selector)
                    WebDriverWait(driver, SHORT_TIMEOUT).until_not(
                        presence_of_element_located((By.CSS_SELECTOR, selector)))

@@ -216,6 +368,9 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge

            except TimeoutException:
                logging.debug("Timeout waiting for selector")
+
+                click_verify(driver)
+
                # update the html (cloudflare reloads the page every 5 s)
                html_element = driver.find_element(By.TAG_NAME, "html")

@@ -276,3 +431,4 @@ def _post_request(req: V1RequestBase, driver: WebDriver):
        </body>
        </html>"""
    driver.get("data:text/html;charset=utf-8," + html_content)
+    driver.start_session()  # required to bypass Cloudflare
--- a/src/metrics.py
+++ b/src/metrics.py
@@ -0,0 +1,32 @@
+import logging
+
+from prometheus_client import Counter, Histogram, start_http_server
+import time
+
+REQUEST_COUNTER = Counter(
+    name='flaresolverr_request',
+    documentation='Total requests with result',
+    labelnames=['domain', 'result']
+)
+REQUEST_DURATION = Histogram(
+    name='flaresolverr_request_duration',
+    documentation='Request duration in seconds',
+    labelnames=['domain'],
+    buckets=[0, 10, 25, 50]
+)
+
+
+def serve(port):
+    start_http_server(port=port)
+    while True:
+        time.sleep(600)
+
+
+def start_metrics_http_server(prometheus_port: int):
+    logging.info(f"Serving Prometheus exporter on http://0.0.0.0:{prometheus_port}/metrics")
+    from threading import Thread
+    Thread(
+        target=serve,
+        kwargs=dict(port=prometheus_port),
+        daemon=True,
+    ).start()
--- a/src/sessions.py
+++ b/src/sessions.py
@@ -0,0 +1,82 @@
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
+from uuid import uuid1
+
+from selenium.webdriver.chrome.webdriver import WebDriver
+
+import utils
+
+
+@dataclass
+class Session:
+    session_id: str
+    driver: WebDriver
+    created_at: datetime
+
+    def lifetime(self) -> timedelta:
+        return datetime.now() - self.created_at
+
+
+class SessionsStorage:
+    """SessionsStorage creates, stores and process all the sessions"""
+
+    def __init__(self):
+        self.sessions = {}
+
+    def create(self, session_id: Optional[str] = None, proxy: Optional[dict] = None,
+               force_new: Optional[bool] = False) -> Tuple[Session, bool]:
+        """create creates new instance of WebDriver if necessary,
+        assign defined (or newly generated) session_id to the instance
+        and returns the session object. If a new session has been created
+        second argument is set to True.
+
+        Note: The function is idempotent, so in case if session_id
+        already exists in the storage a new instance of WebDriver won't be created
+        and existing session will be returned. Second argument defines if 
+        new session has been created (True) or an existing one was used (False).
+        """
+        session_id = session_id or str(uuid1())
+
+        if force_new:
+            self.destroy(session_id)
+
+        if self.exists(session_id):
+            return self.sessions[session_id], False
+
+        driver = utils.get_webdriver(proxy)
+        created_at = datetime.now()
+        session = Session(session_id, driver, created_at)
+
+        self.sessions[session_id] = session
+
+        return session, True
+
+    def exists(self, session_id: str) -> bool:
+        return session_id in self.sessions
+
+    def destroy(self, session_id: str) -> bool:
+        """destroy closes the driver instance and removes session from the storage.
+        The function is noop if session_id doesn't exist.
+        The function returns True if session was found and destroyed,
+        and False if session_id wasn't found.
+        """
+        if not self.exists(session_id):
+            return False
+
+        session = self.sessions.pop(session_id)
+        session.driver.quit()
+        return True
+
+    def get(self, session_id: str, ttl: Optional[timedelta] = None) -> Tuple[Session, bool]:
+        session, fresh = self.create(session_id)
+
+        if ttl is not None and not fresh and session.lifetime() > ttl:
+            logging.debug(f'session\'s lifetime has expired, so the session is recreated (session_id={session_id})')
+            session, fresh = self.create(session_id, force_new=True)
+
+        return session, fresh
+
+    def session_ids(self) -> list[str]:
+        return list(self.sessions.keys())
--- a/src/tests.py
+++ b/src/tests.py
@@ -1,4 +1,5 @@
 import unittest
+from typing import Optional

 from webtest import TestApp

@@ -7,7 +8,7 @@ import flaresolverr
 import utils


-def _find_obj_by_key(key: str, value: str, _list: list) -> dict | None:
+def _find_obj_by_key(key: str, value: str, _list: list) -> Optional[dict]:
    for obj in _list:
        if obj[key] == value:
            return obj
@@ -23,10 +24,13 @@ class TestFlareSolverr(unittest.TestCase):
    cloudflare_url = "https://nowsecure.nl"
    cloudflare_url_2 = "https://idope.se/torrent-list/harry/"
    ddos_guard_url = "https://anidex.info/"
+    fairlane_url = "https://www.pararius.com/apartments/amsterdam"
    custom_cloudflare_url = "https://www.muziekfabriek.org"
    cloudflare_blocked_url = "https://cpasbiens3.fr/index.php?do=search&subaction=search"

    app = TestApp(flaresolverr.app)
+    # wait until the server is ready
+    app.get('/')

    def test_wrong_endpoint(self):
        res = self.app.get('/wrong', status=404)
@@ -64,7 +68,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Error: Request parameter 'cmd' = 'request.bad' is invalid.", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

    def test_v1_endpoint_request_get_no_cloudflare(self):
        res = self.app.post_json('/v1', {
@@ -78,7 +82,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Challenge not detected!", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

        solution = body.solution
        self.assertIn(self.google_url, solution.url)
@@ -100,7 +104,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Challenge solved!", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

        solution = body.solution
        self.assertIn(self.cloudflare_url, solution.url)
@@ -126,7 +130,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Challenge solved!", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

        solution = body.solution
        self.assertIn(self.cloudflare_url_2, solution.url)
@@ -152,7 +156,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Challenge solved!", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

        solution = body.solution
        self.assertIn(self.ddos_guard_url, solution.url)
@@ -166,6 +170,32 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertIsNotNone(cf_cookie, "DDOS-Guard cookie not found")
        self.assertGreater(len(cf_cookie["value"]), 10)

+    def test_v1_endpoint_request_get_fairlane_js(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.fairlane_url
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge solved!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.fairlane_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Rental Apartments Amsterdam</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+        cf_cookie = _find_obj_by_key("name", "fl_pass_v2_b", solution.cookies)
+        self.assertIsNotNone(cf_cookie, "Fairlane cookie not found")
+        self.assertGreater(len(cf_cookie["value"]), 50)
+
    def test_v1_endpoint_request_get_custom_cloudflare_js(self):
        res = self.app.post_json('/v1', {
            "cmd": "request.get",
@@ -178,7 +208,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual("Challenge solved!", body.message)
        self.assertGreater(body.startTimestamp, 10000)
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
-        self.assertEqual(utils.get_flaresolverr_version(), body.version) 
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

        solution = body.solution
        self.assertIn(self.custom_cloudflare_url, solution.url)
@@ -209,7 +239,45 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
        self.assertEqual(utils.get_flaresolverr_version(), body.version)

-    # todo: test Cmd 'request.get' should return OK with 'cookies' param
+    def test_v1_endpoint_request_get_cookies_param(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "cookies": [
+                {
+                    "name": "testcookie1",
+                    "value": "testvalue1"
+                },
+                {
+                    "name": "testcookie2",
+                    "value": "testvalue2"
+                }
+            ]
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 1)
+        self.assertIn("Chrome/", solution.userAgent)
+
+        user_cookie1 = _find_obj_by_key("name", "testcookie1", solution.cookies)
+        self.assertIsNotNone(user_cookie1, "User cookie 1 not found")
+        self.assertEqual("testvalue1", user_cookie1["value"])
+
+        user_cookie2 = _find_obj_by_key("name", "testcookie2", solution.cookies)
+        self.assertIsNotNone(user_cookie2, "User cookie 2 not found")
+        self.assertEqual("testvalue2", user_cookie2["value"])

    def test_v1_endpoint_request_get_returnOnlyCookies_param(self):
        res = self.app.post_json('/v1', {
@@ -234,10 +302,124 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertGreater(len(solution.cookies), 0)
        self.assertIn("Chrome/", solution.userAgent)

-    # todo: test Cmd 'request.get' should return OK with HTTP 'proxy' param
-    # todo: test Cmd 'request.get' should return OK with HTTP 'proxy' param with credentials
-    # todo: test Cmd 'request.get' should return OK with SOCKSv5 'proxy' param
-    # todo: test Cmd 'request.get' should fail with wrong 'proxy' param
+    def test_v1_endpoint_request_get_proxy_http_param(self):
+        """
+        To configure TinyProxy in local:
+           * sudo vim /etc/tinyproxy/tinyproxy.conf
+              * edit => LogFile "/tmp/tinyproxy.log"
+              * edit => Syslog Off
+           * sudo tinyproxy -d
+           * sudo tail -f /tmp/tinyproxy.log
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_http_param_with_credentials(self):
+        """
+        To configure TinyProxy in local:
+           * sudo vim /etc/tinyproxy/tinyproxy.conf
+              * edit => LogFile "/tmp/tinyproxy.log"
+              * edit => Syslog Off
+              * add => BasicAuth testuser testpass
+           * sudo tinyproxy -d
+           * sudo tail -f /tmp/tinyproxy.log
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_url,
+                "username": "testuser",
+                "password": "testpass"
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_socks_param(self):
+        """
+        To configure Dante in local:
+           * https://linuxhint.com/set-up-a-socks5-proxy-on-ubuntu-with-dante/
+           * sudo vim /etc/sockd.conf
+           * sudo systemctl restart sockd.service
+           * curl --socks5 socks5://127.0.0.1:1080 https://www.google.com
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_socks_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_wrong_param(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": "http://127.0.0.1:43210"
+            }
+        }, status=500)
+        self.assertEqual(res.status_code, 500)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_ERROR, body.status)
+        self.assertIn("Error: Error solving the challenge. Message: unknown error: net::ERR_PROXY_CONNECTION_FAILED",
+                      body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

    def test_v1_endpoint_request_get_fail_timeout(self):
        res = self.app.post_json('/v1', {
@@ -351,12 +533,99 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual(STATUS_OK, body.status)
        self.assertEqual("Challenge not detected!", body.message)

-    # todo: test Cmd 'sessions.create' should return OK
-    # todo: test Cmd 'sessions.create' should return OK with session
-    # todo: test Cmd 'sessions.list' should return OK
-    # todo: test Cmd 'sessions.destroy' should return OK
-    # todo: test Cmd 'sessions.destroy' should fail
-    # todo: test Cmd 'request.get' should use session
+    def test_v1_endpoint_sessions_create_without_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertIsNotNone(body.session)
+
+    def test_v1_endpoint_sessions_create_with_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_create_session"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertEqual(body.session, "test_create_session")
+
+    def test_v1_endpoint_sessions_create_with_proxy(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "proxy": {
+                "url": self.proxy_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertIsNotNone(body.session)
+
+    def test_v1_endpoint_sessions_list(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_list_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.list"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("", body.message)
+        self.assertGreaterEqual(len(body.sessions), 1)
+        self.assertIn("test_list_sessions", body.sessions)
+
+    def test_v1_endpoint_sessions_destroy_existing_session(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_destroy_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.destroy",
+            "session": "test_destroy_sessions"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("The session has been removed.", body.message)
+
+    def test_v1_endpoint_sessions_destroy_non_existing_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.destroy",
+            "session": "non_existing_session_name"
+        }, status=500)
+        self.assertEqual(res.status_code, 500)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_ERROR, body.status)
+        self.assertEqual("Error: The session doesn't exist.", body.message)
+
+    def test_v1_endpoint_request_get_with_session(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_request_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "session": "test_request_sessions",
+            "url": self.google_url
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)


 if __name__ == '__main__':
--- a/src/tests_sites.py
+++ b/src/tests_sites.py
@@ -39,6 +39,8 @@ def asset_cloudflare_solution(self, res, site_url, site_text):

 class TestFlareSolverr(unittest.TestCase):
    app = TestApp(flaresolverr.app)
+    # wait until the server is ready
+    app.get('/')

    def test_v1_endpoint_request_get_cloudflare(self):
        sites_get = [
--- a/src/undetected_chromedriver/init.py
+++ b/src/undetected_chromedriver/init.py
--- a/src/undetected_chromedriver/_compat.py
+++ b/src/undetected_chromedriver/_compat.py
@@ -1,259 +0,0 @@
-#!/usr/bin/env python3
-# this module is part of undetected_chromedriver
-
-
-"""
-
-         888                                                  888         d8b
-         888                                                  888         Y8P
-         888                                                  888
- .d8888b 88888b.  888d888 .d88b.  88888b.d88b.   .d88b.   .d88888 888d888 888 888  888  .d88b.  888d888
-d88P"    888 "88b 888P"  d88""88b 888 "888 "88b d8P  Y8b d88" 888 888P"   888 888  888 d8P  Y8b 888P"
-888      888  888 888    888  888 888  888  888 88888888 888  888 888     888 Y88  88P 88888888 888
-Y88b.    888  888 888    Y88..88P 888  888  888 Y8b.     Y88b 888 888     888  Y8bd8P  Y8b.     888
- "Y8888P 888  888 888     "Y88P"  888  888  888  "Y8888   "Y88888 888     888   Y88P    "Y8888  888   88888888
-
-by UltrafunkAmsterdam (https://github.com/ultrafunkamsterdam)
-
-"""
-
-import io
-import logging
-import os
-import random
-import re
-import string
-import sys
-import zipfile
-from distutils.version import LooseVersion
-from urllib.request import urlopen, urlretrieve
-
-from selenium.webdriver import Chrome as _Chrome, ChromeOptions as _ChromeOptions
-
-TARGET_VERSION = 0
-logger = logging.getLogger("uc")
-
-
-class Chrome:
-    def __new__(cls, *args, emulate_touch=False, **kwargs):
-
-        if not ChromeDriverManager.installed:
-            ChromeDriverManager(*args, **kwargs).install()
-        if not ChromeDriverManager.selenium_patched:
-            ChromeDriverManager(*args, **kwargs).patch_selenium_webdriver()
-        if not kwargs.get("executable_path"):
-            kwargs["executable_path"] = "./{}".format(
-                ChromeDriverManager(*args, **kwargs).executable_path
-            )
-        if not kwargs.get("options"):
-            kwargs["options"] = ChromeOptions()
-        instance = object.__new__(_Chrome)
-        instance.__init__(*args, **kwargs)
-
-        instance._orig_get = instance.get
-
-        def _get_wrapped(*args, **kwargs):
-            if instance.execute_script("return navigator.webdriver"):
-                instance.execute_cdp_cmd(
-                    "Page.addScriptToEvaluateOnNewDocument",
-                    {
-                        "source": """
-
-                                   Object.defineProperty(window, 'navigator', {
-                                       value: new Proxy(navigator, {
-                                       has: (target, key) => (key === 'webdriver' ? false : key in target),
-                                       get: (target, key) =>
-                                           key === 'webdriver'
-                                           ? undefined
-                                           : typeof target[key] === 'function'
-                                           ? target[key].bind(target)
-                                           : target[key]
-                                       })
-                                   });
-                                    
-                                                            
-                        """
-                    },
-                )
-            return instance._orig_get(*args, **kwargs)
-
-        instance.get = _get_wrapped
-        instance.get = _get_wrapped
-        instance.get = _get_wrapped
-
-        original_user_agent_string = instance.execute_script(
-            "return navigator.userAgent"
-        )
-        instance.execute_cdp_cmd(
-            "Network.setUserAgentOverride",
-            {
-                "userAgent": original_user_agent_string.replace("Headless", ""),
-            },
-        )
-        if emulate_touch:
-            instance.execute_cdp_cmd(
-                "Page.addScriptToEvaluateOnNewDocument",
-                {
-                    "source": """
-                                   Object.defineProperty(navigator, 'maxTouchPoints', {
-                                       get: () => 1
-                               })"""
-                },
-            )
-        logger.info(f"starting undetected_chromedriver.Chrome({args}, {kwargs})")
-        return instance
-
-
-class ChromeOptions:
-    def __new__(cls, *args, **kwargs):
-        if not ChromeDriverManager.installed:
-            ChromeDriverManager(*args, **kwargs).install()
-        if not ChromeDriverManager.selenium_patched:
-            ChromeDriverManager(*args, **kwargs).patch_selenium_webdriver()
-
-        instance = object.__new__(_ChromeOptions)
-        instance.__init__()
-        instance.add_argument("start-maximized")
-        instance.add_experimental_option("excludeSwitches", ["enable-automation"])
-        instance.add_argument("--disable-blink-features=AutomationControlled")
-        return instance
-
-
-class ChromeDriverManager(object):
-    installed = False
-    selenium_patched = False
-    target_version = None
-
-    DL_BASE = "https://chromedriver.storage.googleapis.com/"
-
-    def __init__(self, executable_path=None, target_version=None, *args, **kwargs):
-
-        _platform = sys.platform
-
-        if TARGET_VERSION:
-            # use global if set
-            self.target_version = TARGET_VERSION
-
-        if target_version:
-            # use explicitly passed target
-            self.target_version = target_version  # user override
-
-        if not self.target_version:
-            # none of the above (default) and just get current version
-            self.target_version = self.get_release_version_number().version[
-                0
-            ]  # only major version int
-
-        self._base = base_ = "chromedriver{}"
-
-        exe_name = self._base
-        if _platform in ("win32",):
-            exe_name = base_.format(".exe")
-        if _platform in ("linux",):
-            _platform += "64"
-            exe_name = exe_name.format("")
-        if _platform in ("darwin",):
-            _platform = "mac64"
-            exe_name = exe_name.format("")
-        self.platform = _platform
-        self.executable_path = executable_path or exe_name
-        self._exe_name = exe_name
-
-    def patch_selenium_webdriver(self_):
-        """
-        Patches selenium package Chrome, ChromeOptions classes for current session
-
-        :return:
-        """
-        import selenium.webdriver.chrome.service
-        import selenium.webdriver
-
-        selenium.webdriver.Chrome = Chrome
-        selenium.webdriver.ChromeOptions = ChromeOptions
-        logger.info("Selenium patched. Safe to import Chrome / ChromeOptions")
-        self_.__class__.selenium_patched = True
-
-    def install(self, patch_selenium=True):
-        """
-        Initialize the patch
-
-        This will:
-         download chromedriver if not present
-         patch the downloaded chromedriver
-         patch selenium package if <patch_selenium> is True (default)
-
-        :param patch_selenium: patch selenium webdriver classes for Chrome and ChromeDriver (for current python session)
-        :return:
-        """
-        if not os.path.exists(self.executable_path):
-            self.fetch_chromedriver()
-            if not self.__class__.installed:
-                if self.patch_binary():
-                    self.__class__.installed = True
-
-        if patch_selenium:
-            self.patch_selenium_webdriver()
-
-    def get_release_version_number(self):
-        """
-        Gets the latest major version available, or the latest major version of self.target_version if set explicitly.
-
-        :return: version string
-        """
-        path = (
-            "LATEST_RELEASE"
-            if not self.target_version
-            else f"LATEST_RELEASE_{self.target_version}"
-        )
-        return LooseVersion(urlopen(self.__class__.DL_BASE + path).read().decode())
-
-    def fetch_chromedriver(self):
-        """
-        Downloads ChromeDriver from source and unpacks the executable
-
-        :return: on success, name of the unpacked executable
-        """
-        base_ = self._base
-        zip_name = base_.format(".zip")
-        ver = self.get_release_version_number().vstring
-        if os.path.exists(self.executable_path):
-            return self.executable_path
-        urlretrieve(
-            f"{self.__class__.DL_BASE}{ver}/{base_.format(f'_{self.platform}')}.zip",
-            filename=zip_name,
-        )
-        with zipfile.ZipFile(zip_name) as zf:
-            zf.extract(self._exe_name)
-        os.remove(zip_name)
-        if sys.platform != "win32":
-            os.chmod(self._exe_name, 0o755)
-        return self._exe_name
-
-    @staticmethod
-    def random_cdc():
-        cdc = random.choices(string.ascii_lowercase, k=26)
-        cdc[-6:-4] = map(str.upper, cdc[-6:-4])
-        cdc[2] = cdc[0]
-        cdc[3] = "_"
-        return "".join(cdc).encode()
-
-    def patch_binary(self):
-        """
-        Patches the ChromeDriver binary
-
-        :return: False on failure, binary name on success
-        """
-        linect = 0
-        replacement = self.random_cdc()
-        with io.open(self.executable_path, "r+b") as fh:
-            for line in iter(lambda: fh.readline(), b""):
-                if b"cdc_" in line:
-                    fh.seek(-len(line), 1)
-                    newline = re.sub(b"cdc_.{22}", replacement, line)
-                    fh.write(newline)
-                    linect += 1
-            return linect
-
-
-def install(executable_path=None, target_version=None, *args, **kwargs):
-    ChromeDriverManager(executable_path, target_version, *args, **kwargs).install()
--- a/src/undetected_chromedriver/cdp.py
+++ b/src/undetected_chromedriver/cdp.py
@@ -1,112 +1,112 @@
-#!/usr/bin/env python3
-# this module is part of undetected_chromedriver
-
-import json
-import logging
-from collections.abc import Mapping, Sequence
-
-import requests
-import websockets
-
-log = logging.getLogger(__name__)
-
-
-class CDPObject(dict):
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        self.__dict__ = self
-        for k in self.__dict__:
-            if isinstance(self.__dict__[k], dict):
-                self.__dict__[k] = CDPObject(self.__dict__[k])
-            elif isinstance(self.__dict__[k], list):
-                for i in range(len(self.__dict__[k])):
-                    if isinstance(self.__dict__[k][i], dict):
-                        self.__dict__[k][i] = CDPObject(self)
-
-    def __repr__(self):
-        tpl = f"{self.__class__.__name__}(\n\t{{}}\n\t)"
-        return tpl.format("\n  ".join(f"{k} = {v}" for k, v in self.items()))
-
-
-class PageElement(CDPObject):
-    pass
-
-
-class CDP:
-    log = logging.getLogger("CDP")
-
-    endpoints = CDPObject(
-        {
-            "json": "/json",
-            "protocol": "/json/protocol",
-            "list": "/json/list",
-            "new": "/json/new?{url}",
-            "activate": "/json/activate/{id}",
-            "close": "/json/close/{id}",
-        }
-    )
-
-    def __init__(self, options: "ChromeOptions"):  # noqa
-        self.server_addr = "http://{0}:{1}".format(*options.debugger_address.split(":"))
-
-        self._reqid = 0
-        self._session = requests.Session()
-        self._last_resp = None
-        self._last_json = None
-
-        resp = self.get(self.endpoints.json)  # noqa
-        self.sessionId = resp[0]["id"]
-        self.wsurl = resp[0]["webSocketDebuggerUrl"]
-
-    def tab_activate(self, id=None):
-        if not id:
-            active_tab = self.tab_list()[0]
-            id = active_tab.id  # noqa
-            self.wsurl = active_tab.webSocketDebuggerUrl  # noqa
-        return self.post(self.endpoints["activate"].format(id=id))
-
-    def tab_list(self):
-        retval = self.get(self.endpoints["list"])
-        return [PageElement(o) for o in retval]
-
-    def tab_new(self, url):
-        return self.post(self.endpoints["new"].format(url=url))
-
-    def tab_close_last_opened(self):
-        sessions = self.tab_list()
-        opentabs = [s for s in sessions if s["type"] == "page"]
-        return self.post(self.endpoints["close"].format(id=opentabs[-1]["id"]))
-
-    async def send(self, method: str, params: dict):
-        self._reqid += 1
-        async with websockets.connect(self.wsurl) as ws:
-            await ws.send(
-                json.dumps({"method": method, "params": params, "id": self._reqid})
-            )
-            self._last_resp = await ws.recv()
-            self._last_json = json.loads(self._last_resp)
-            self.log.info(self._last_json)
-
-    def get(self, uri):
-        resp = self._session.get(self.server_addr + uri)
-        try:
-            self._last_resp = resp
-            self._last_json = resp.json()
-        except Exception:
-            return
-        else:
-            return self._last_json
-
-    def post(self, uri, data: dict = None):
-        if not data:
-            data = {}
-        resp = self._session.post(self.server_addr + uri, json=data)
-        try:
-            self._last_resp = resp
-            self._last_json = resp.json()
-        except Exception:
-            return self._last_resp
-
-    @property
-    def last_json(self):
-        return self._last_json
+#!/usr/bin/env python3
+# this module is part of undetected_chromedriver
+
+import json
+import logging
+
+import requests
+import websockets
+
+
+log = logging.getLogger(__name__)
+
+
+class CDPObject(dict):
+    def __init__(self, *a, **k):
+        super().__init__(*a, **k)
+        self.__dict__ = self
+        for k in self.__dict__:
+            if isinstance(self.__dict__[k], dict):
+                self.__dict__[k] = CDPObject(self.__dict__[k])
+            elif isinstance(self.__dict__[k], list):
+                for i in range(len(self.__dict__[k])):
+                    if isinstance(self.__dict__[k][i], dict):
+                        self.__dict__[k][i] = CDPObject(self)
+
+    def __repr__(self):
+        tpl = f"{self.__class__.__name__}(\n\t{{}}\n\t)"
+        return tpl.format("\n  ".join(f"{k} = {v}" for k, v in self.items()))
+
+
+class PageElement(CDPObject):
+    pass
+
+
+class CDP:
+    log = logging.getLogger("CDP")
+
+    endpoints = CDPObject(
+        {
+            "json": "/json",
+            "protocol": "/json/protocol",
+            "list": "/json/list",
+            "new": "/json/new?{url}",
+            "activate": "/json/activate/{id}",
+            "close": "/json/close/{id}",
+        }
+    )
+
+    def __init__(self, options: "ChromeOptions"):  # noqa
+        self.server_addr = "http://{0}:{1}".format(*options.debugger_address.split(":"))
+
+        self._reqid = 0
+        self._session = requests.Session()
+        self._last_resp = None
+        self._last_json = None
+
+        resp = self.get(self.endpoints.json)  # noqa
+        self.sessionId = resp[0]["id"]
+        self.wsurl = resp[0]["webSocketDebuggerUrl"]
+
+    def tab_activate(self, id=None):
+        if not id:
+            active_tab = self.tab_list()[0]
+            id = active_tab.id  # noqa
+            self.wsurl = active_tab.webSocketDebuggerUrl  # noqa
+        return self.post(self.endpoints["activate"].format(id=id))
+
+    def tab_list(self):
+        retval = self.get(self.endpoints["list"])
+        return [PageElement(o) for o in retval]
+
+    def tab_new(self, url):
+        return self.post(self.endpoints["new"].format(url=url))
+
+    def tab_close_last_opened(self):
+        sessions = self.tab_list()
+        opentabs = [s for s in sessions if s["type"] == "page"]
+        return self.post(self.endpoints["close"].format(id=opentabs[-1]["id"]))
+
+    async def send(self, method: str, params: dict):
+        self._reqid += 1
+        async with websockets.connect(self.wsurl) as ws:
+            await ws.send(
+                json.dumps({"method": method, "params": params, "id": self._reqid})
+            )
+            self._last_resp = await ws.recv()
+            self._last_json = json.loads(self._last_resp)
+            self.log.info(self._last_json)
+
+    def get(self, uri):
+        resp = self._session.get(self.server_addr + uri)
+        try:
+            self._last_resp = resp
+            self._last_json = resp.json()
+        except Exception:
+            return
+        else:
+            return self._last_json
+
+    def post(self, uri, data: dict = None):
+        if not data:
+            data = {}
+        resp = self._session.post(self.server_addr + uri, json=data)
+        try:
+            self._last_resp = resp
+            self._last_json = resp.json()
+        except Exception:
+            return self._last_resp
+
+    @property
+    def last_json(self):
+        return self._last_json
--- a/src/undetected_chromedriver/devtool.py
+++ b/src/undetected_chromedriver/devtool.py
@@ -1,191 +1,190 @@
-import asyncio
-import logging
-import time
-import traceback
-from collections.abc import Mapping
-from collections.abc import Sequence
-from typing import Any
-from typing import Awaitable
-from typing import Callable
-from typing import List
-from typing import Optional
-from contextlib import ExitStack
-import threading
-from functools import wraps, partial
-
-
-class Structure(dict):
-    """
-    This is a dict-like object structure, which you should subclass
-    Only properties defined in the class context are used on initialization.
-
-    See example
-    """
-
-    _store = {}
-
-    def __init__(self, *a, **kw):
-        """
-        Instantiate a new instance.
-
-        :param a:
-        :param kw:
-        """
-
-        super().__init__()
-
-        # auxiliar dict
-        d = dict(*a, **kw)
-        for k, v in d.items():
-            if isinstance(v, Mapping):
-                self[k] = self.__class__(v)
-            elif isinstance(v, Sequence) and not isinstance(v, (str, bytes)):
-                self[k] = [self.__class__(i) for i in v]
-            else:
-                self[k] = v
-        super().__setattr__("__dict__", self)
-
-    def __getattr__(self, item):
-        return getattr(super(), item)
-
-    def __getitem__(self, item):
-        return super().__getitem__(item)
-
-    def __setattr__(self, key, value):
-        self.__setitem__(key, value)
-
-    def __setitem__(self, key, value):
-        super().__setitem__(key, value)
-
-    def update(self, *a, **kw):
-        super().update(*a, **kw)
-
-    def __eq__(self, other):
-        return frozenset(other.items()) == frozenset(self.items())
-
-    def __hash__(self):
-        return hash(frozenset(self.items()))
-
-    @classmethod
-    def __init_subclass__(cls, **kwargs):
-        cls._store = {}
-
-    def _normalize_strings(self):
-        for k, v in self.copy().items():
-            if isinstance(v, (str)):
-                self[k] = v.strip()
-
-
-def timeout(seconds=3, on_timeout: Optional[Callable[[callable], Any]] = None):
-    def wrapper(func):
-        @wraps(func)
-        def wrapped(*args, **kwargs):
-            def function_reached_timeout():
-                if on_timeout:
-                    on_timeout(func)
-                else:
-                    raise TimeoutError("function call timed out")
-
-            t = threading.Timer(interval=seconds, function=function_reached_timeout)
-            t.start()
-            try:
-                return func(*args, **kwargs)
-            except:
-                t.cancel()
-                raise
-            finally:
-                t.cancel()
-
-        return wrapped
-
-    return wrapper
-
-
-def test():
-    import sys, os
-
-    sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-    import undetected_chromedriver as uc
-    import threading
-
-    def collector(
-        driver: uc.Chrome,
-        stop_event: threading.Event,
-        on_event_coro: Optional[Callable[[List[str]], Awaitable[Any]]] = None,
-        listen_events: Sequence = ("browser", "network", "performance"),
-    ):
-        def threaded(driver, stop_event, on_event_coro):
-            async def _ensure_service_started():
-                while (
-                    getattr(driver, "service", False)
-                    and getattr(driver.service, "process", False)
-                    and driver.service.process.poll()
-                ):
-                    print("waiting for driver service to come back on")
-                    await asyncio.sleep(0.05)
-                    # await asyncio.sleep(driver._delay or .25)
-
-            async def get_log_lines(typ):
-                await _ensure_service_started()
-                return driver.get_log(typ)
-
-            async def looper():
-                while not stop_event.is_set():
-                    log_lines = []
-                    try:
-                        for _ in listen_events:
-                            try:
-                                log_lines += await get_log_lines(_)
-                            except:
-                                if logging.getLogger().getEffectiveLevel() <= 10:
-                                    traceback.print_exc()
-                                continue
-                        if log_lines and on_event_coro:
-                            await on_event_coro(log_lines)
-                    except Exception as e:
-                        if logging.getLogger().getEffectiveLevel() <= 10:
-                            traceback.print_exc()
-
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            loop.run_until_complete(looper())
-
-        t = threading.Thread(target=threaded, args=(driver, stop_event, on_event_coro))
-        t.start()
-
-    async def on_event(data):
-        print("on_event")
-        print("data:", data)
-
-    def func_called(fn):
-        def wrapped(*args, **kwargs):
-            print(
-                "func called! %s  (args: %s, kwargs: %s)" % (fn.__name__, args, kwargs)
-            )
-            while driver.service.process and driver.service.process.poll() is not None:
-                time.sleep(0.1)
-            res = fn(*args, **kwargs)
-            print("func completed! (result: %s)" % res)
-            return res
-
-        return wrapped
-
-    logging.basicConfig(level=10)
-
-    options = uc.ChromeOptions()
-    options.set_capability(
-        "goog:loggingPrefs", {"performance": "ALL", "browser": "ALL", "network": "ALL"}
-    )
-
-    driver = uc.Chrome(version_main=96, options=options)
-
-    # driver.command_executor._request = timeout(seconds=1)(driver.command_executor._request)
-    driver.command_executor._request = func_called(driver.command_executor._request)
-    collector_stop = threading.Event()
-    collector(driver, collector_stop, on_event)
-
-    driver.get("https://nowsecure.nl")
-
-    time.sleep(10)
-
-    driver.quit()
+import asyncio
+from collections.abc import Mapping
+from collections.abc import Sequence
+from functools import wraps
+import logging
+import threading
+import time
+import traceback
+from typing import Any
+from typing import Awaitable
+from typing import Callable
+from typing import List
+from typing import Optional
+
+
+class Structure(dict):
+    """
+    This is a dict-like object structure, which you should subclass
+    Only properties defined in the class context are used on initialization.
+
+    See example
+    """
+
+    _store = {}
+
+    def __init__(self, *a, **kw):
+        """
+        Instantiate a new instance.
+
+        :param a:
+        :param kw:
+        """
+
+        super().__init__()
+
+        # auxiliar dict
+        d = dict(*a, **kw)
+        for k, v in d.items():
+            if isinstance(v, Mapping):
+                self[k] = self.__class__(v)
+            elif isinstance(v, Sequence) and not isinstance(v, (str, bytes)):
+                self[k] = [self.__class__(i) for i in v]
+            else:
+                self[k] = v
+        super().__setattr__("__dict__", self)
+
+    def __getattr__(self, item):
+        return getattr(super(), item)
+
+    def __getitem__(self, item):
+        return super().__getitem__(item)
+
+    def __setattr__(self, key, value):
+        self.__setitem__(key, value)
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+
+    def update(self, *a, **kw):
+        super().update(*a, **kw)
+
+    def __eq__(self, other):
+        return frozenset(other.items()) == frozenset(self.items())
+
+    def __hash__(self):
+        return hash(frozenset(self.items()))
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        cls._store = {}
+
+    def _normalize_strings(self):
+        for k, v in self.copy().items():
+            if isinstance(v, (str)):
+                self[k] = v.strip()
+
+
+def timeout(seconds=3, on_timeout: Optional[Callable[[callable], Any]] = None):
+    def wrapper(func):
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+            def function_reached_timeout():
+                if on_timeout:
+                    on_timeout(func)
+                else:
+                    raise TimeoutError("function call timed out")
+
+            t = threading.Timer(interval=seconds, function=function_reached_timeout)
+            t.start()
+            try:
+                return func(*args, **kwargs)
+            except:
+                t.cancel()
+                raise
+            finally:
+                t.cancel()
+
+        return wrapped
+
+    return wrapper
+
+
+def test():
+    import sys, os
+
+    sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+    import undetected_chromedriver as uc
+    import threading
+
+    def collector(
+        driver: uc.Chrome,
+        stop_event: threading.Event,
+        on_event_coro: Optional[Callable[[List[str]], Awaitable[Any]]] = None,
+        listen_events: Sequence = ("browser", "network", "performance"),
+    ):
+        def threaded(driver, stop_event, on_event_coro):
+            async def _ensure_service_started():
+                while (
+                    getattr(driver, "service", False)
+                    and getattr(driver.service, "process", False)
+                    and driver.service.process.poll()
+                ):
+                    print("waiting for driver service to come back on")
+                    await asyncio.sleep(0.05)
+                    # await asyncio.sleep(driver._delay or .25)
+
+            async def get_log_lines(typ):
+                await _ensure_service_started()
+                return driver.get_log(typ)
+
+            async def looper():
+                while not stop_event.is_set():
+                    log_lines = []
+                    try:
+                        for _ in listen_events:
+                            try:
+                                log_lines += await get_log_lines(_)
+                            except:
+                                if logging.getLogger().getEffectiveLevel() <= 10:
+                                    traceback.print_exc()
+                                continue
+                        if log_lines and on_event_coro:
+                            await on_event_coro(log_lines)
+                    except Exception as e:
+                        if logging.getLogger().getEffectiveLevel() <= 10:
+                            traceback.print_exc()
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(looper())
+
+        t = threading.Thread(target=threaded, args=(driver, stop_event, on_event_coro))
+        t.start()
+
+    async def on_event(data):
+        print("on_event")
+        print("data:", data)
+
+    def func_called(fn):
+        def wrapped(*args, **kwargs):
+            print(
+                "func called! %s  (args: %s, kwargs: %s)" % (fn.__name__, args, kwargs)
+            )
+            while driver.service.process and driver.service.process.poll() is not None:
+                time.sleep(0.1)
+            res = fn(*args, **kwargs)
+            print("func completed! (result: %s)" % res)
+            return res
+
+        return wrapped
+
+    logging.basicConfig(level=10)
+
+    options = uc.ChromeOptions()
+    options.set_capability(
+        "goog:loggingPrefs", {"performance": "ALL", "browser": "ALL", "network": "ALL"}
+    )
+
+    driver = uc.Chrome(version_main=96, options=options)
+
+    # driver.command_executor._request = timeout(seconds=1)(driver.command_executor._request)
+    driver.command_executor._request = func_called(driver.command_executor._request)
+    collector_stop = threading.Event()
+    collector(driver, collector_stop, on_event)
+
+    driver.get("https://nowsecure.nl")
+
+    time.sleep(10)
+
+    driver.quit()
--- a/src/undetected_chromedriver/dprocess.py
+++ b/src/undetected_chromedriver/dprocess.py
@@ -1,75 +1,76 @@
-import multiprocessing
-import os
-import platform
-import sys
-from subprocess import PIPE
-from subprocess import Popen
-import atexit
-import traceback
-import logging
-import signal
-
-CREATE_NEW_PROCESS_GROUP = 0x00000200
-DETACHED_PROCESS = 0x00000008
-
-REGISTERED = []
-
-
-def start_detached(executable, *args):
-    """
-    Starts a fully independent subprocess (with no parent)
-    :param executable: executable
-    :param args: arguments to the executable, eg: ['--param1_key=param1_val', '-vvv' ...]
-    :return: pid of the grandchild process
-    """
-
-    # create pipe
-    reader, writer = multiprocessing.Pipe(False)
-
-    # do not keep reference
-    multiprocessing.Process(
-        target=_start_detached,
-        args=(executable, *args),
-        kwargs={"writer": writer},
-        daemon=True,
-    ).start()
-    # receive pid from pipe
-    pid = reader.recv()
-    REGISTERED.append(pid)
-    # close pipes
-    writer.close()
-    reader.close()
-
-    return pid
-
-
-def _start_detached(executable, *args, writer: multiprocessing.Pipe = None):
-
-    # configure launch
-    kwargs = {}
-    if platform.system() == "Windows":
-        kwargs.update(creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP)
-    elif sys.version_info < (3, 2):
-        # assume posix
-        kwargs.update(preexec_fn=os.setsid)
-    else:  # Python 3.2+ and Unix
-        kwargs.update(start_new_session=True)
-
-    # run
-    p = Popen([executable, *args], stdin=PIPE, stdout=PIPE, stderr=PIPE, **kwargs)
-
-    # send pid to pipe
-    writer.send(p.pid)
-    sys.exit()
-
-
-def _cleanup():
-    for pid in REGISTERED:
-        try:
-            logging.getLogger(__name__).debug("cleaning up pid %d " % pid)
-            os.kill(pid, signal.SIGTERM)
-        except:  # noqa
-            pass
-
-
-atexit.register(_cleanup)
+import atexit
+import logging
+import multiprocessing
+import os
+import platform
+import signal
+from subprocess import PIPE
+from subprocess import Popen
+import sys
+
+
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+DETACHED_PROCESS = 0x00000008
+
+REGISTERED = []
+
+
+def start_detached(executable, *args):
+    """
+    Starts a fully independent subprocess (with no parent)
+    :param executable: executable
+    :param args: arguments to the executable, eg: ['--param1_key=param1_val', '-vvv' ...]
+    :return: pid of the grandchild process
+    """
+
+    # create pipe
+    reader, writer = multiprocessing.Pipe(False)
+
+    # do not keep reference
+    process = multiprocessing.Process(
+        target=_start_detached,
+        args=(executable, *args),
+        kwargs={"writer": writer},
+        daemon=True,
+    )
+    process.start()
+    process.join()
+    # receive pid from pipe
+    pid = reader.recv()
+    REGISTERED.append(pid)
+    # close pipes
+    writer.close()
+    reader.close()
+
+    return pid
+
+
+def _start_detached(executable, *args, writer: multiprocessing.Pipe = None):
+    # configure launch
+    kwargs = {}
+    if platform.system() == "Windows":
+        kwargs.update(creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP)
+    elif sys.version_info < (3, 2):
+        # assume posix
+        kwargs.update(preexec_fn=os.setsid)
+    else:  # Python 3.2+ and Unix
+        kwargs.update(start_new_session=True)
+
+    # run
+    p = Popen([executable, *args], stdin=PIPE, stdout=PIPE, stderr=PIPE, **kwargs)
+
+    # send pid to pipe
+    writer.send(p.pid)
+    sys.exit()
+
+
+def _cleanup():
+    for pid in REGISTERED:
+        try:
+            logging.getLogger(__name__).debug("cleaning up pid %d " % pid)
+            os.kill(pid, signal.SIGTERM)
+        except:  # noqa
+            pass
+
+
+atexit.register(_cleanup)
--- a/src/undetected_chromedriver/options.py
+++ b/src/undetected_chromedriver/options.py
@@ -1,70 +1,85 @@
-#!/usr/bin/env python3
-# this module is part of undetected_chromedriver
-
-
-import json
-import os
-
-from selenium.webdriver.chromium.options import ChromiumOptions as _ChromiumOptions
-
-
-class ChromeOptions(_ChromiumOptions):
-    _session = None
-    _user_data_dir = None
-
-    @property
-    def user_data_dir(self):
-        return self._user_data_dir
-
-    @user_data_dir.setter
-    def user_data_dir(self, path: str):
-        """
-        Sets the browser profile folder to use, or creates a new profile
-        at given <path>.
-
-        Parameters
-        ----------
-        path: str
-            the path to a chrome profile folder
-            if it does not exist, a new profile will be created at given location
-        """
-        apath = os.path.abspath(path)
-        self._user_data_dir = os.path.normpath(apath)
-
-    @staticmethod
-    def _undot_key(key, value):
-        """turn a (dotted key, value) into a proper nested dict"""
-        if "." in key:
-            key, rest = key.split(".", 1)
-            value = ChromeOptions._undot_key(rest, value)
-        return {key: value}
-
-    def handle_prefs(self, user_data_dir):
-        prefs = self.experimental_options.get("prefs")
-        if prefs:
-
-            user_data_dir = user_data_dir or self._user_data_dir
-            default_path = os.path.join(user_data_dir, "Default")
-            os.makedirs(default_path, exist_ok=True)
-
-            # undot prefs dict keys
-            undot_prefs = {}
-            for key, value in prefs.items():
-                undot_prefs.update(self._undot_key(key, value))
-
-            prefs_file = os.path.join(default_path, "Preferences")
-            if os.path.exists(prefs_file):
-                with open(prefs_file, encoding="latin1", mode="r") as f:
-                    undot_prefs.update(json.load(f))
-
-            with open(prefs_file, encoding="latin1", mode="w") as f:
-                json.dump(undot_prefs, f)
-
-            # remove the experimental_options to avoid an error
-            del self._experimental_options["prefs"]
-
-    @classmethod
-    def from_options(cls, options):
-        o = cls()
-        o.__dict__.update(options.__dict__)
-        return o
+#!/usr/bin/env python3
+# this module is part of undetected_chromedriver
+
+
+import json
+import os
+
+from selenium.webdriver.chromium.options import ChromiumOptions as _ChromiumOptions
+
+
+class ChromeOptions(_ChromiumOptions):
+    _session = None
+    _user_data_dir = None
+
+    @property
+    def user_data_dir(self):
+        return self._user_data_dir
+
+    @user_data_dir.setter
+    def user_data_dir(self, path: str):
+        """
+        Sets the browser profile folder to use, or creates a new profile
+        at given <path>.
+
+        Parameters
+        ----------
+        path: str
+            the path to a chrome profile folder
+            if it does not exist, a new profile will be created at given location
+        """
+        apath = os.path.abspath(path)
+        self._user_data_dir = os.path.normpath(apath)
+
+    @staticmethod
+    def _undot_key(key, value):
+        """turn a (dotted key, value) into a proper nested dict"""
+        if "." in key:
+            key, rest = key.split(".", 1)
+            value = ChromeOptions._undot_key(rest, value)
+        return {key: value}
+
+    @staticmethod
+    def _merge_nested(a, b):
+        """
+        merges b into a
+        leaf values in a are overwritten with values from b
+        """
+        for key in b:
+            if key in a:
+                if isinstance(a[key], dict) and isinstance(b[key], dict):
+                    ChromeOptions._merge_nested(a[key], b[key])
+                    continue
+            a[key] = b[key]
+        return a
+
+    def handle_prefs(self, user_data_dir):
+        prefs = self.experimental_options.get("prefs")
+        if prefs:
+            user_data_dir = user_data_dir or self._user_data_dir
+            default_path = os.path.join(user_data_dir, "Default")
+            os.makedirs(default_path, exist_ok=True)
+
+            # undot prefs dict keys
+            undot_prefs = {}
+            for key, value in prefs.items():
+                undot_prefs = self._merge_nested(
+                    undot_prefs, self._undot_key(key, value)
+                )
+
+            prefs_file = os.path.join(default_path, "Preferences")
+            if os.path.exists(prefs_file):
+                with open(prefs_file, encoding="latin1", mode="r") as f:
+                    undot_prefs = self._merge_nested(json.load(f), undot_prefs)
+
+            with open(prefs_file, encoding="latin1", mode="w") as f:
+                json.dump(undot_prefs, f)
+
+            # remove the experimental_options to avoid an error
+            del self._experimental_options["prefs"]
+
+    @classmethod
+    def from_options(cls, options):
+        o = cls()
+        o.__dict__.update(options.__dict__)
+        return o
--- a/src/undetected_chromedriver/patcher.py
+++ b/src/undetected_chromedriver/patcher.py
@@ -1,276 +1,348 @@
-#!/usr/bin/env python3
-# this module is part of undetected_chromedriver
-
-import io
-import logging
-import os
-import random
-import re
-import string
-import sys
-import time
-import zipfile
-from distutils.version import LooseVersion
-from urllib.request import urlopen, urlretrieve
-import secrets
-
-
-logger = logging.getLogger(__name__)
-
-IS_POSIX = sys.platform.startswith(("darwin", "cygwin", "linux"))
-
-
-class Patcher(object):
-    url_repo = "https://chromedriver.storage.googleapis.com"
-    zip_name = "chromedriver_%s.zip"
-    exe_name = "chromedriver%s"
-
-    platform = sys.platform
-    if platform.endswith("win32"):
-        zip_name %= "win32"
-        exe_name %= ".exe"
-    if platform.endswith("linux"):
-        zip_name %= "linux64"
-        exe_name %= ""
-    if platform.endswith("darwin"):
-        zip_name %= "mac64"
-        exe_name %= ""
-
-    if platform.endswith("win32"):
-        d = "~/appdata/roaming/undetected_chromedriver"
-    elif platform.startswith("linux"):
-        d = "~/.local/share/undetected_chromedriver"
-    elif platform.endswith("darwin"):
-        d = "~/Library/Application Support/undetected_chromedriver"
-    else:
-        d = "~/.undetected_chromedriver"
-    data_path = os.path.abspath(os.path.expanduser(d))
-
-    def __init__(self, executable_path=None, force=False, version_main: int = 0):
-        """
-
-        Args:
-            executable_path: None = automatic
-                             a full file path to the chromedriver executable
-            force: False
-                    terminate processes which are holding lock
-            version_main: 0 = auto
-                specify main chrome version (rounded, ex: 82)
-        """
-
-        self.force = force
-        self.executable_path = None
-        prefix = secrets.token_hex(8)
-
-        if not os.path.exists(self.data_path):
-            os.makedirs(self.data_path, exist_ok=True)
-
-        if not executable_path:
-            self.executable_path = os.path.join(
-                self.data_path, "_".join([prefix, self.exe_name])
-            )
-
-        if not IS_POSIX:
-            if executable_path:
-                if not executable_path[-4:] == ".exe":
-                    executable_path += ".exe"
-
-        self.zip_path = os.path.join(self.data_path, prefix)
-
-        if not executable_path:
-            self.executable_path = os.path.abspath(
-                os.path.join(".", self.executable_path)
-            )
-
-        self._custom_exe_path = False
-
-        if executable_path:
-            self._custom_exe_path = True
-            self.executable_path = executable_path
-        self.version_main = version_main
-        self.version_full = None
-
-    def auto(self, executable_path=None, force=False, version_main=None):
-        """"""
-        if executable_path:
-            self.executable_path = executable_path
-            self._custom_exe_path = True
-
-        if self._custom_exe_path:
-            ispatched = self.is_binary_patched(self.executable_path)
-            if not ispatched:
-                return self.patch_exe()
-            else:
-                return
-
-        if version_main:
-            self.version_main = version_main
-        if force is True:
-            self.force = force
-
-        try:
-            os.unlink(self.executable_path)
-        except PermissionError:
-            if self.force:
-                self.force_kill_instances(self.executable_path)
-                return self.auto(force=not self.force)
-            try:
-                if self.is_binary_patched():
-                    # assumes already running AND patched
-                    return True
-            except PermissionError:
-                pass
-            # return False
-        except FileNotFoundError:
-            pass
-
-        release = self.fetch_release_number()
-        self.version_main = release.version[0]
-        self.version_full = release
-        self.unzip_package(self.fetch_package())
-        return self.patch()
-
-    def patch(self):
-        self.patch_exe()
-        return self.is_binary_patched()
-
-    def fetch_release_number(self):
-        """
-        Gets the latest major version available, or the latest major version of self.target_version if set explicitly.
-        :return: version string
-        :rtype: LooseVersion
-        """
-        path = "/latest_release"
-        if self.version_main:
-            path += f"_{self.version_main}"
-        path = path.upper()
-        logger.debug("getting release number from %s" % path)
-        return LooseVersion(urlopen(self.url_repo + path).read().decode())
-
-    def parse_exe_version(self):
-        with io.open(self.executable_path, "rb") as f:
-            for line in iter(lambda: f.readline(), b""):
-                match = re.search(rb"platform_handle\x00content\x00([0-9.]*)", line)
-                if match:
-                    return LooseVersion(match[1].decode())
-
-    def fetch_package(self):
-        """
-        Downloads ChromeDriver from source
-
-        :return: path to downloaded file
-        """
-        u = "%s/%s/%s" % (self.url_repo, self.version_full.vstring, self.zip_name)
-        logger.debug("downloading from %s" % u)
-        # return urlretrieve(u, filename=self.data_path)[0]
-        return urlretrieve(u)[0]
-
-    def unzip_package(self, fp):
-        """
-        Does what it says
-
-        :return: path to unpacked executable
-        """
-        logger.debug("unzipping %s" % fp)
-        try:
-            os.unlink(self.zip_path)
-        except (FileNotFoundError, OSError):
-            pass
-
-        os.makedirs(self.zip_path, mode=0o755, exist_ok=True)
-        with zipfile.ZipFile(fp, mode="r") as zf:
-            zf.extract(self.exe_name, self.zip_path)
-        os.rename(os.path.join(self.zip_path, self.exe_name), self.executable_path)
-        os.remove(fp)
-        os.rmdir(self.zip_path)
-        os.chmod(self.executable_path, 0o755)
-        return self.executable_path
-
-    @staticmethod
-    def force_kill_instances(exe_name):
-        """
-        kills running instances.
-        :param: executable name to kill, may be a path as well
-
-        :return: True on success else False
-        """
-        exe_name = os.path.basename(exe_name)
-        if IS_POSIX:
-            r = os.system("kill -f -9 $(pidof %s)" % exe_name)
-        else:
-            r = os.system("taskkill /f /im %s" % exe_name)
-        return not r
-
-    @staticmethod
-    def gen_random_cdc():
-        cdc = random.choices(string.ascii_lowercase, k=26)
-        cdc[-6:-4] = map(str.upper, cdc[-6:-4])
-        cdc[2] = cdc[0]
-        cdc[3] = "_"
-        return "".join(cdc).encode()
-
-    def is_binary_patched(self, executable_path=None):
-        """simple check if executable is patched.
-
-        :return: False if not patched, else True
-        """
-        executable_path = executable_path or self.executable_path
-        with io.open(executable_path, "rb") as fh:
-            for line in iter(lambda: fh.readline(), b""):
-                if b"cdc_" in line:
-                    return False
-            else:
-                return True
-
-    def patch_exe(self):
-        """
-        Patches the ChromeDriver binary
-
-        :return: False on failure, binary name on success
-        """
-        logger.info("patching driver executable %s" % self.executable_path)
-
-        linect = 0
-        replacement = self.gen_random_cdc()
-        with io.open(self.executable_path, "r+b") as fh:
-            for line in iter(lambda: fh.readline(), b""):
-                if b"cdc_" in line:
-                    fh.seek(-len(line), 1)
-                    newline = re.sub(b"cdc_.{22}", replacement, line)
-                    fh.write(newline)
-                    linect += 1
-            return linect
-
-    def __repr__(self):
-        return "{0:s}({1:s})".format(
-            self.__class__.__name__,
-            self.executable_path,
-        )
-
-    def __del__(self):
-
-        if self._custom_exe_path:
-            # if the driver binary is specified by user
-            # we assume it is important enough to not delete it
-            return
-        else:
-            timeout = 3  # stop trying after this many seconds
-            t = time.monotonic()
-            while True:
-                now = time.monotonic()
-                if now - t > timeout:
-                    # we don't want to wait until the end of time
-                    logger.debug(
-                        "could not unlink %s in time (%d seconds)"
-                        % (self.executable_path, timeout)
-                    )
-                    break
-                try:
-                    os.unlink(self.executable_path)
-                    logger.debug("successfully unlinked %s" % self.executable_path)
-                    break
-                except (OSError, RuntimeError, PermissionError):
-                    time.sleep(0.1)
-                    continue
-                except FileNotFoundError:
-                    break
+#!/usr/bin/env python3
+# this module is part of undetected_chromedriver
+
+from distutils.version import LooseVersion
+import io
+import logging
+import os
+import pathlib
+import random
+import re
+import shutil
+import string
+import sys
+import time
+from urllib.request import urlopen
+from urllib.request import urlretrieve
+import zipfile
+from multiprocessing import Lock
+
+logger = logging.getLogger(__name__)
+
+IS_POSIX = sys.platform.startswith(("darwin", "cygwin", "linux", "linux2"))
+
+
+class Patcher(object):
+    lock = Lock()
+    url_repo = "https://chromedriver.storage.googleapis.com"
+    zip_name = "chromedriver_%s.zip"
+    exe_name = "chromedriver%s"
+
+    platform = sys.platform
+    if platform.endswith("win32"):
+        zip_name %= "win32"
+        exe_name %= ".exe"
+    if platform.endswith(("linux", "linux2")):
+        zip_name %= "linux64"
+        exe_name %= ""
+    if platform.endswith("darwin"):
+        zip_name %= "mac64"
+        exe_name %= ""
+
+    if platform.endswith("win32"):
+        d = "~/appdata/roaming/undetected_chromedriver"
+    elif "LAMBDA_TASK_ROOT" in os.environ:
+        d = "/tmp/undetected_chromedriver"
+    elif platform.startswith(("linux", "linux2")):
+        d = "~/.local/share/undetected_chromedriver"
+    elif platform.endswith("darwin"):
+        d = "~/Library/Application Support/undetected_chromedriver"
+    else:
+        d = "~/.undetected_chromedriver"
+    data_path = os.path.abspath(os.path.expanduser(d))
+
+    def __init__(
+        self,
+        executable_path=None,
+        force=False,
+        version_main: int = 0,
+        user_multi_procs=False,
+    ):
+        """
+        Args:
+            executable_path: None = automatic
+                             a full file path to the chromedriver executable
+            force: False
+                    terminate processes which are holding lock
+            version_main: 0 = auto
+                specify main chrome version (rounded, ex: 82)
+        """
+        self.force = force
+        self._custom_exe_path = False
+        prefix = "undetected"
+        self.user_multi_procs = user_multi_procs
+
+        if not os.path.exists(self.data_path):
+            os.makedirs(self.data_path, exist_ok=True)
+
+        if not executable_path:
+            self.executable_path = os.path.join(
+                self.data_path, "_".join([prefix, self.exe_name])
+            )
+
+        if not IS_POSIX:
+            if executable_path:
+                if not executable_path[-4:] == ".exe":
+                    executable_path += ".exe"
+
+        self.zip_path = os.path.join(self.data_path, prefix)
+
+        if not executable_path:
+            if not self.user_multi_procs:
+                self.executable_path = os.path.abspath(
+                    os.path.join(".", self.executable_path)
+                )
+
+        if executable_path:
+            self._custom_exe_path = True
+            self.executable_path = executable_path
+
+        self.version_main = version_main
+        self.version_full = None
+
+    def auto(self, executable_path=None, force=False, version_main=None, _=None):
+        """
+
+        Args:
+            executable_path:
+            force:
+            version_main:
+
+        Returns:
+
+        """
+        # if self.user_multi_procs and \
+        #         self.user_multi_procs != -1:
+        #     # -1 being a skip value used later in this block
+        #
+        p = pathlib.Path(self.data_path)
+        with Lock():
+            files = list(p.rglob("*chromedriver*?"))
+            for file in files:
+                if self.is_binary_patched(file):
+                    self.executable_path = str(file)
+                    return True
+
+        if executable_path:
+            self.executable_path = executable_path
+            self._custom_exe_path = True
+
+        if self._custom_exe_path:
+            ispatched = self.is_binary_patched(self.executable_path)
+            if not ispatched:
+                return self.patch_exe()
+            else:
+                return
+
+        if version_main:
+            self.version_main = version_main
+        if force is True:
+            self.force = force
+
+        try:
+            os.unlink(self.executable_path)
+        except PermissionError:
+            if self.force:
+                self.force_kill_instances(self.executable_path)
+                return self.auto(force=not self.force)
+            try:
+                if self.is_binary_patched():
+                    # assumes already running AND patched
+                    return True
+            except PermissionError:
+                pass
+            # return False
+        except FileNotFoundError:
+            pass
+
+        release = self.fetch_release_number()
+        self.version_main = release.version[0]
+        self.version_full = release
+        self.unzip_package(self.fetch_package())
+        return self.patch()
+
+    def driver_binary_in_use(self, path: str = None) -> bool:
+        """
+        naive test to check if a found chromedriver binary is
+        currently in use
+
+        Args:
+            path: a string or PathLike object to the binary to check.
+                  if not specified, we check use this object's executable_path
+        """
+        if not path:
+            path = self.executable_path
+        p = pathlib.Path(path)
+
+        if not p.exists():
+            raise OSError("file does not exist: %s" % p)
+        try:
+            with open(p, mode="a+b") as fs:
+                exc = []
+                try:
+
+                    fs.seek(0, 0)
+                except PermissionError as e:
+                    exc.append(e)  # since some systems apprently allow seeking
+                    # we conduct another test
+                try:
+                    fs.readline()
+                except PermissionError as e:
+                    exc.append(e)
+
+                if exc:
+
+                    return True
+                return False
+            # ok safe to assume this is in use
+        except Exception as e:
+            # logger.exception("whoops ", e)
+            pass
+
+    def cleanup_unused_files(self):
+        p = pathlib.Path(self.data_path)
+        items = list(p.glob("*undetected*"))
+        print(items)
+
+    def patch(self):
+        self.patch_exe()
+        return self.is_binary_patched()
+
+    def fetch_release_number(self):
+        """
+        Gets the latest major version available, or the latest major version of self.target_version if set explicitly.
+        :return: version string
+        :rtype: LooseVersion
+        """
+        path = "/latest_release"
+        if self.version_main:
+            path += f"_{self.version_main}"
+        path = path.upper()
+        logger.debug("getting release number from %s" % path)
+        return LooseVersion(urlopen(self.url_repo + path).read().decode())
+
+    def parse_exe_version(self):
+        with io.open(self.executable_path, "rb") as f:
+            for line in iter(lambda: f.readline(), b""):
+                match = re.search(rb"platform_handle\x00content\x00([0-9.]*)", line)
+                if match:
+                    return LooseVersion(match[1].decode())
+
+    def fetch_package(self):
+        """
+        Downloads ChromeDriver from source
+
+        :return: path to downloaded file
+        """
+        u = "%s/%s/%s" % (self.url_repo, self.version_full.vstring, self.zip_name)
+        logger.debug("downloading from %s" % u)
+        # return urlretrieve(u, filename=self.data_path)[0]
+        return urlretrieve(u)[0]
+
+    def unzip_package(self, fp):
+        """
+        Does what it says
+
+        :return: path to unpacked executable
+        """
+        logger.debug("unzipping %s" % fp)
+        try:
+            os.unlink(self.zip_path)
+        except (FileNotFoundError, OSError):
+            pass
+
+        os.makedirs(self.zip_path, mode=0o755, exist_ok=True)
+        with zipfile.ZipFile(fp, mode="r") as zf:
+            zf.extract(self.exe_name, self.zip_path)
+        os.rename(os.path.join(self.zip_path, self.exe_name), self.executable_path)
+        os.remove(fp)
+        os.rmdir(self.zip_path)
+        os.chmod(self.executable_path, 0o755)
+        return self.executable_path
+
+    @staticmethod
+    def force_kill_instances(exe_name):
+        """
+        kills running instances.
+        :param: executable name to kill, may be a path as well
+
+        :return: True on success else False
+        """
+        exe_name = os.path.basename(exe_name)
+        if IS_POSIX:
+            r = os.system("kill -f -9 $(pidof %s)" % exe_name)
+        else:
+            r = os.system("taskkill /f /im %s" % exe_name)
+        return not r
+
+    @staticmethod
+    def gen_random_cdc():
+        cdc = random.choices(string.ascii_letters, k=27)
+        return "".join(cdc).encode()
+
+    def is_binary_patched(self, executable_path=None):
+        executable_path = executable_path or self.executable_path
+        try:
+            with io.open(executable_path, "rb") as fh:
+                return fh.read().find(b"undetected chromedriver") != -1
+        except FileNotFoundError:
+            return False
+
+    def patch_exe(self):
+        start = time.perf_counter()
+        logger.info("patching driver executable %s" % self.executable_path)
+        with io.open(self.executable_path, "r+b") as fh:
+            content = fh.read()
+            # match_injected_codeblock = re.search(rb"{window.*;}", content)
+            match_injected_codeblock = re.search(rb"\{window\.cdc.*?;\}", content)
+            if match_injected_codeblock:
+                target_bytes = match_injected_codeblock[0]
+                new_target_bytes = (
+                    b'{console.log("undetected chromedriver 1337!")}'.ljust(
+                        len(target_bytes), b" "
+                    )
+                )
+                new_content = content.replace(target_bytes, new_target_bytes)
+                if new_content == content:
+                    logger.warning(
+                        "something went wrong patching the driver binary. could not find injection code block"
+                    )
+                else:
+                    logger.debug(
+                        "found block:\n%s\nreplacing with:\n%s"
+                        % (target_bytes, new_target_bytes)
+                    )
+                fh.seek(0)
+                fh.write(new_content)
+        logger.debug(
+            "patching took us {:.2f} seconds".format(time.perf_counter() - start)
+        )
+
+    def __repr__(self):
+        return "{0:s}({1:s})".format(
+            self.__class__.__name__,
+            self.executable_path,
+        )
+
+    def __del__(self):
+        if self._custom_exe_path:
+            # if the driver binary is specified by user
+            # we assume it is important enough to not delete it
+            return
+        else:
+            timeout = 3  # stop trying after this many seconds
+            t = time.monotonic()
+            now = lambda: time.monotonic()
+            while now() - t > timeout:
+                # we don't want to wait until the end of time
+                try:
+                    if self.user_multi_procs:
+                        break
+                    os.unlink(self.executable_path)
+                    logger.debug("successfully unlinked %s" % self.executable_path)
+                    break
+                except (OSError, RuntimeError, PermissionError):
+                    time.sleep(0.01)
+                    continue
+                except FileNotFoundError:
+                    break
--- a/src/undetected_chromedriver/reactor.py
+++ b/src/undetected_chromedriver/reactor.py
@@ -1,102 +1,99 @@
-#!/usr/bin/env python3
-# this module is part of undetected_chromedriver
-
-import asyncio
-import json
-import logging
-import threading
-
-logger = logging.getLogger(__name__)
-
-
-class Reactor(threading.Thread):
-    def __init__(self, driver: "Chrome"):
-        super().__init__()
-
-        self.driver = driver
-        self.loop = asyncio.new_event_loop()
-
-        self.lock = threading.Lock()
-        self.event = threading.Event()
-        self.daemon = True
-        self.handlers = {}
-
-    def add_event_handler(self, method_name, callback: callable):
-        """
-
-        Parameters
-        ----------
-        event_name: str
-            example "Network.responseReceived"
-
-        callback: callable
-            callable which accepts 1 parameter: the message object dictionary
-
-        Returns
-        -------
-
-        """
-        with self.lock:
-            self.handlers[method_name.lower()] = callback
-
-    @property
-    def running(self):
-        return not self.event.is_set()
-
-    def run(self):
-        try:
-            asyncio.set_event_loop(self.loop)
-            self.loop.run_until_complete(self.listen())
-        except Exception as e:
-            logger.warning("Reactor.run() => %s", e)
-
-    async def _wait_service_started(self):
-        while True:
-            with self.lock:
-                if (
-                    getattr(self.driver, "service", None)
-                    and getattr(self.driver.service, "process", None)
-                    and self.driver.service.process.poll()
-                ):
-                    await asyncio.sleep(self.driver._delay or 0.25)
-                else:
-                    break
-
-    async def listen(self):
-
-        while self.running:
-
-            await self._wait_service_started()
-            await asyncio.sleep(1)
-
-            try:
-                with self.lock:
-                    log_entries = self.driver.get_log("performance")
-
-                for entry in log_entries:
-
-                    try:
-
-                        obj_serialized: str = entry.get("message")
-                        obj = json.loads(obj_serialized)
-                        message = obj.get("message")
-                        method = message.get("method")
-
-                        if "*" in self.handlers:
-                            await self.loop.run_in_executor(
-                                None, self.handlers["*"], message
-                            )
-                        elif method.lower() in self.handlers:
-                            await self.loop.run_in_executor(
-                                None, self.handlers[method.lower()], message
-                            )
-
-                        # print(type(message), message)
-                    except Exception as e:
-                        raise e from None
-
-            except Exception as e:
-                if "invalid session id" in str(e):
-                    pass
-                else:
-                    logging.debug("exception ignored :", e)
+#!/usr/bin/env python3
+# this module is part of undetected_chromedriver
+
+import asyncio
+import json
+import logging
+import threading
+
+
+logger = logging.getLogger(__name__)
+
+
+class Reactor(threading.Thread):
+    def __init__(self, driver: "Chrome"):
+        super().__init__()
+
+        self.driver = driver
+        self.loop = asyncio.new_event_loop()
+
+        self.lock = threading.Lock()
+        self.event = threading.Event()
+        self.daemon = True
+        self.handlers = {}
+
+    def add_event_handler(self, method_name, callback: callable):
+        """
+
+        Parameters
+        ----------
+        event_name: str
+            example "Network.responseReceived"
+
+        callback: callable
+            callable which accepts 1 parameter: the message object dictionary
+
+        Returns
+        -------
+
+        """
+        with self.lock:
+            self.handlers[method_name.lower()] = callback
+
+    @property
+    def running(self):
+        return not self.event.is_set()
+
+    def run(self):
+        try:
+            asyncio.set_event_loop(self.loop)
+            self.loop.run_until_complete(self.listen())
+        except Exception as e:
+            logger.warning("Reactor.run() => %s", e)
+
+    async def _wait_service_started(self):
+        while True:
+            with self.lock:
+                if (
+                    getattr(self.driver, "service", None)
+                    and getattr(self.driver.service, "process", None)
+                    and self.driver.service.process.poll()
+                ):
+                    await asyncio.sleep(self.driver._delay or 0.25)
+                else:
+                    break
+
+    async def listen(self):
+        while self.running:
+            await self._wait_service_started()
+            await asyncio.sleep(1)
+
+            try:
+                with self.lock:
+                    log_entries = self.driver.get_log("performance")
+
+                for entry in log_entries:
+                    try:
+                        obj_serialized: str = entry.get("message")
+                        obj = json.loads(obj_serialized)
+                        message = obj.get("message")
+                        method = message.get("method")
+
+                        if "*" in self.handlers:
+                            await self.loop.run_in_executor(
+                                None, self.handlers["*"], message
+                            )
+                        elif method.lower() in self.handlers:
+                            await self.loop.run_in_executor(
+                                None, self.handlers[method.lower()], message
+                            )
+
+                        # print(type(message), message)
+                    except Exception as e:
+                        raise e from None
+
+            except Exception as e:
+                if "invalid session id" in str(e):
+                    pass
+                else:
+                    logging.debug("exception ignored :", e)
--- a/src/undetected_chromedriver/v2.py
+++ b/src/undetected_chromedriver/v2.py
@@ -1,4 +0,0 @@
-# for backward compatibility
-import sys
-
-sys.modules[__name__] = sys.modules[__package__]
--- a/src/undetected_chromedriver/webelement.py
+++ b/src/undetected_chromedriver/webelement.py
@@ -1,37 +1,86 @@
-import selenium.webdriver.remote.webelement
-
-
-class WebElement(selenium.webdriver.remote.webelement.WebElement):
-    """
-    Custom WebElement class which makes it easier to view elements when
-    working in an interactive environment.
-
-    standard webelement repr:
-    <selenium.webdriver.remote.webelement.WebElement (session="85ff0f671512fa535630e71ee951b1f2", element="6357cb55-92c3-4c0f-9416-b174f9c1b8c4")>
-
-    using this WebElement class:
-    <WebElement(<a class="mobile-show-inline-block mc-update-infos init-ok" href="#" id="main-cat-switcher-mobile">)>
-
-    """
-
-    @property
-    def attrs(self):
-        if not hasattr(self, "_attrs"):
-            self._attrs = self._parent.execute_script(
-                """
-                var items = {}; 
-                for (index = 0; index < arguments[0].attributes.length; ++index) 
-                {
-                 items[arguments[0].attributes[index].name] = arguments[0].attributes[index].value 
-                }; 
-                return items;
-                """,
-                self,
-            )
-        return self._attrs
-
-    def __repr__(self):
-        strattrs = " ".join([f'{k}="{v}"' for k, v in self.attrs.items()])
-        if strattrs:
-            strattrs = " " + strattrs
-        return f"{self.__class__.__name__} <{self.tag_name}{strattrs}>"
+from typing import List
+
+from selenium.webdriver.common.by import By
+import selenium.webdriver.remote.webelement
+
+
+class WebElement(selenium.webdriver.remote.webelement.WebElement):
+    def click_safe(self):
+        super().click()
+        self._parent.reconnect(0.1)
+
+    def children(
+        self, tag=None, recursive=False
+    ) -> List[selenium.webdriver.remote.webelement.WebElement]:
+        """
+        returns direct child elements of current element
+        :param tag: str,  if supplied, returns <tag> nodes only
+        """
+        script = "return [... arguments[0].children]"
+        if tag:
+            script += ".filter( node => node.tagName === '%s')" % tag.upper()
+        if recursive:
+            return list(_recursive_children(self, tag))
+        return list(self._parent.execute_script(script, self))
+
+
+class UCWebElement(WebElement):
+    """
+    Custom WebElement class which makes it easier to view elements when
+    working in an interactive environment.
+
+    standard webelement repr:
+    <selenium.webdriver.remote.webelement.WebElement (session="85ff0f671512fa535630e71ee951b1f2", element="6357cb55-92c3-4c0f-9416-b174f9c1b8c4")>
+
+    using this WebElement class:
+    <WebElement(<a class="mobile-show-inline-block mc-update-infos init-ok" href="#" id="main-cat-switcher-mobile">)>
+
+    """
+
+    def __init__(self, parent, id_):
+        super().__init__(parent, id_)
+        self._attrs = None
+
+    @property
+    def attrs(self):
+        if not self._attrs:
+            self._attrs = self._parent.execute_script(
+                """
+                var items = {}; 
+                for (index = 0; index < arguments[0].attributes.length; ++index) 
+                {
+                 items[arguments[0].attributes[index].name] = arguments[0].attributes[index].value 
+                }; 
+                return items;
+                """,
+                self,
+            )
+        return self._attrs
+
+    def __repr__(self):
+        strattrs = " ".join([f'{k}="{v}"' for k, v in self.attrs.items()])
+        if strattrs:
+            strattrs = " " + strattrs
+        return f"{self.__class__.__name__} <{self.tag_name}{strattrs}>"
+
+
+def _recursive_children(element, tag: str = None, _results=None):
+    """
+    returns all children of <element> recursively
+
+    :param element: `WebElement` object.
+            find children below this <element>
+
+    :param tag: str = None.
+            if provided, return only <tag> elements. example: 'a', or 'img'
+    :param _results: do not use!
+    """
+    results = _results or set()
+    for element in element.children():
+        if tag:
+            if element.tag_name == tag:
+                results.add(element)
+        else:
+            results.add(element)
+        results |= _recursive_children(element, tag, results)
+    return results
--- a/src/utils.py
+++ b/src/utils.py
@@ -3,11 +3,14 @@ import logging
 import os
 import re
 import shutil
+import urllib.parse
+import tempfile

 from selenium.webdriver.chrome.webdriver import WebDriver
 import undetected_chromedriver as uc

 FLARESOLVERR_VERSION = None
+CHROME_EXE_PATH = None
 CHROME_MAJOR_VERSION = None
 USER_AGENT = None
 XVFB_DISPLAY = None
@@ -28,12 +31,88 @@ def get_flaresolverr_version() -> str:
        return FLARESOLVERR_VERSION

    package_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'package.json')
+    if not os.path.isfile(package_path):
+        package_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'package.json')
    with open(package_path) as f:
        FLARESOLVERR_VERSION = json.loads(f.read())['version']
        return FLARESOLVERR_VERSION


-def get_webdriver() -> WebDriver:
+def create_proxy_extension(proxy: dict) -> str:
+    parsed_url = urllib.parse.urlparse(proxy['url'])
+    scheme = parsed_url.scheme
+    host = parsed_url.hostname
+    port = parsed_url.port
+    username = proxy['username']
+    password = proxy['password']
+    manifest_json = """
+    {
+        "version": "1.0.0",
+        "manifest_version": 2,
+        "name": "Chrome Proxy",
+        "permissions": [
+            "proxy",
+            "tabs",
+            "unlimitedStorage",
+            "storage",
+            "<all_urls>",
+            "webRequest",
+            "webRequestBlocking"
+        ],
+        "background": {"scripts": ["background.js"]},
+        "minimum_chrome_version": "76.0.0"
+    }
+    """
+
+    background_js = """
+    var config = {
+        mode: "fixed_servers",
+        rules: {
+            singleProxy: {
+                scheme: "%s",
+                host: "%s",
+                port: %d
+            },
+            bypassList: ["localhost"]
+        }
+    };
+
+    chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});
+
+    function callbackFn(details) {
+        return {
+            authCredentials: {
+                username: "%s",
+                password: "%s"
+            }
+        };
+    }
+
+    chrome.webRequest.onAuthRequired.addListener(
+        callbackFn,
+        { urls: ["<all_urls>"] },
+        ['blocking']
+    );
+    """ % (
+        scheme,
+        host,
+        port,
+        username,
+        password
+    )
+
+    proxy_extension_dir = tempfile.mkdtemp()
+
+    with open(os.path.join(proxy_extension_dir, "manifest.json"), "w") as f:
+        f.write(manifest_json)
+
+    with open(os.path.join(proxy_extension_dir, "background.js"), "w") as f:
+        f.write(background_js)
+
+    return proxy_extension_dir
+
+
+def get_webdriver(proxy: dict = None) -> WebDriver:
    global PATCHED_DRIVER_PATH
    logging.debug('Launching web browser...')

@@ -44,6 +123,27 @@ def get_webdriver() -> WebDriver:
    # todo: this param shows a warning in chrome head-full
    options.add_argument('--disable-setuid-sandbox')
    options.add_argument('--disable-dev-shm-usage')
+    # this option removes the zygote sandbox (it seems that the resolution is a bit faster)
+    options.add_argument('--no-zygote')
+    # attempt to fix Docker ARM32 build
+    options.add_argument('--disable-gpu-sandbox')
+    options.add_argument('--disable-software-rasterizer')
+    options.add_argument('--ignore-certificate-errors')
+    options.add_argument('--ignore-ssl-errors')
+    # fix GL errors in ASUSTOR NAS
+    # https://github.com/FlareSolverr/FlareSolverr/issues/782
+    # https://github.com/microsoft/vscode/issues/127800#issuecomment-873342069
+    # https://peter.sh/experiments/chromium-command-line-switches/#use-gl
+    options.add_argument('--use-gl=swiftshader')
+
+    proxy_extension_dir = None
+    if proxy and all(key in proxy for key in ['url', 'username', 'password']):
+        proxy_extension_dir = create_proxy_extension(proxy)
+        options.add_argument("--load-extension=%s" % os.path.abspath(proxy_extension_dir))
+    elif proxy and 'url' in proxy:
+        proxy_url = proxy['url']
+        logging.debug("Using webdriver proxy: %s", proxy_url)
+        options.add_argument('--proxy-server=%s' % proxy_url)

    # note: headless mode is detected (options.headless = True)
    # we launch the browser in head-full mode with the window hidden
@@ -62,18 +162,31 @@ def get_webdriver() -> WebDriver:
        driver_exe_path = "/app/chromedriver"
    else:
        version_main = get_chrome_major_version()
+        # Fix for Chrome 115
+        # https://github.com/seleniumbase/SeleniumBase/pull/1967
+        if int(version_main) > 114:
+            version_main = 114
        if PATCHED_DRIVER_PATH is not None:
            driver_exe_path = PATCHED_DRIVER_PATH

+    # detect chrome path
+    browser_executable_path = get_chrome_exe_path()
+
    # downloads and patches the chromedriver
    # if we don't set driver_executable_path it downloads, patches, and deletes the driver each time
-    driver = uc.Chrome(options=options, driver_executable_path=driver_exe_path, version_main=version_main,
-                       windows_headless=windows_headless)
+    driver = uc.Chrome(options=options, browser_executable_path=browser_executable_path,
+                       driver_executable_path=driver_exe_path, version_main=version_main,
+                       windows_headless=windows_headless, headless=windows_headless)

    # save the patched driver to avoid re-downloads
    if driver_exe_path is None:
        PATCHED_DRIVER_PATH = os.path.join(driver.patcher.data_path, driver.patcher.exe_name)
-        shutil.copy(driver.patcher.executable_path, PATCHED_DRIVER_PATH)
+        if PATCHED_DRIVER_PATH != driver.patcher.executable_path:
+            shutil.copy(driver.patcher.executable_path, PATCHED_DRIVER_PATH)
+
+    # clean up proxy extension directory
+    if proxy_extension_dir is not None:
+        shutil.rmtree(proxy_extension_dir)

    # selenium vanilla
    # options = webdriver.ChromeOptions()
@@ -86,23 +199,45 @@ def get_webdriver() -> WebDriver:
    return driver


+def get_chrome_exe_path() -> str:
+    global CHROME_EXE_PATH
+    if CHROME_EXE_PATH is not None:
+        return CHROME_EXE_PATH
+    # linux pyinstaller bundle
+    chrome_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'chrome', "chrome")
+    if os.path.exists(chrome_path):
+        if not os.access(chrome_path, os.X_OK):
+            raise Exception(f'Chrome binary "{chrome_path}" is not executable. '
+                            f'Please, extract the archive with "tar xzf <file.tar.gz>".')
+        CHROME_EXE_PATH = chrome_path
+        return CHROME_EXE_PATH
+    # windows pyinstaller bundle
+    chrome_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'chrome', "chrome.exe")
+    if os.path.exists(chrome_path):
+        CHROME_EXE_PATH = chrome_path
+        return CHROME_EXE_PATH
+    # system
+    CHROME_EXE_PATH = uc.find_chrome_executable()
+    return CHROME_EXE_PATH
+
+
 def get_chrome_major_version() -> str:
    global CHROME_MAJOR_VERSION
    if CHROME_MAJOR_VERSION is not None:
        return CHROME_MAJOR_VERSION

    if os.name == 'nt':
+        # Example: '104.0.5112.79'
        try:
-            stream = os.popen(
-                'reg query "HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Google Chrome"')
-            output = stream.read()
-            # Example: '104.0.5112.79'
-            complete_version = extract_version_registry(output)
+            complete_version = extract_version_nt_executable(get_chrome_exe_path())
        except Exception:
-            # Example: '104.0.5112.79'
-            complete_version = extract_version_folder()
+            try:
+                complete_version = extract_version_nt_registry()
+            except Exception:
+                # Example: '104.0.5112.79'
+                complete_version = extract_version_nt_folder()
    else:
-        chrome_path = uc.find_chrome_executable()
+        chrome_path = get_chrome_exe_path()
        process = os.popen(f'"{chrome_path}" --version')
        # Example 1: 'Chromium 104.0.5112.79 Arch Linux\n'
        # Example 2: 'Google Chrome 104.0.5112.79 Arch Linux\n'
@@ -110,24 +245,32 @@ def get_chrome_major_version() -> str:
        process.close()

    CHROME_MAJOR_VERSION = complete_version.split('.')[0].split(' ')[-1]
-    logging.info(f"Chrome major version: {CHROME_MAJOR_VERSION}")
    return CHROME_MAJOR_VERSION


-def extract_version_registry(output) -> str:
-    try:
-        google_version = ''
-        for letter in output[output.rindex('DisplayVersion    REG_SZ') + 24:]:
-            if letter != '\n':
-                google_version += letter
-            else:
-                break
-        return google_version.strip()
-    except TypeError:
-        return ''
+def extract_version_nt_executable(exe_path: str) -> str:
+    import pefile
+    pe = pefile.PE(exe_path, fast_load=True)
+    pe.parse_data_directories(
+        directories=[pefile.DIRECTORY_ENTRY["IMAGE_DIRECTORY_ENTRY_RESOURCE"]]
+    )
+    return pe.FileInfo[0][0].StringTable[0].entries[b"FileVersion"].decode('utf-8')


-def extract_version_folder() -> str:
+def extract_version_nt_registry() -> str:
+    stream = os.popen(
+        'reg query "HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Google Chrome"')
+    output = stream.read()
+    google_version = ''
+    for letter in output[output.rindex('DisplayVersion    REG_SZ') + 24:]:
+        if letter != '\n':
+            google_version += letter
+        else:
+            break
+    return google_version.strip()
+
+
+def extract_version_nt_folder() -> str:
    # Check if the Chrome folder exists in the x32 or x64 Program Files folders.
    for i in range(2):
        path = 'C:\\Program Files' + (' (x86)' if i else '') + '\\Google\\Chrome\\Application'
Author	SHA1	Message	Date
ngosang	644a843d89	Bump version 3.3.1	2023-08-03 08:13:01 +02:00
ngosang	82e1c94c6f	Fix HEADLESS=false in Windows binary	2023-08-03 08:10:14 +02:00
ngosang	fbc71516f5	Fix for Cloudflare verify checkbox	2023-08-03 07:28:58 +02:00
ngosang	40bd1cba4c	Fix Prometheus exporter for management and health endpoints	2023-08-03 06:36:31 +02:00
ngosang	d1588c1156	Remove misleading stack trace when a button is not found	2023-08-03 05:45:38 +02:00
ngosang	b4ad583baa	Revert "Update base Docker image to Debian Bookworm" This reverts commit `0edc50e271`.	2023-08-03 05:19:56 +02:00
ngosang	5d31e551cc	Revert "Install Chromium 115 from Debian testing" This reverts commit `2aa095ed5d`.	2023-08-03 05:19:27 +02:00
ngosang	d92845f34f	Bump version 3.3.0	2023-08-02 20:10:35 +02:00
ngosang	5d3b73ea9d	Add more traces in build_package.py	2023-08-02 20:05:42 +02:00
ngosang	2aa095ed5d	Install Chromium 115 from Debian testing	2023-08-02 19:30:39 +02:00
ngosang	687c8f75ae	Update pyinstaller 5.13.0	2023-08-02 19:30:03 +02:00
ngosang	22ed3d324b	Fix for new Cloudflare detection. Thanks @cedric-bour for #845	2023-08-02 19:29:44 +02:00
ngosang	5ba9ef03f3	Update Selenium 4.11.2	2023-08-02 19:23:08 +02:00
ngosang	d2e144ea12	Implement Prometheus metrics	2023-07-23 21:52:06 +02:00
ngosang	313fb2c14b	Add support for proxy authentication username/password. Thanks @jacobprice808	2023-07-23 19:46:46 +02:00
ngosang	6d69f40b58	Update Chromium 115 in binary packages	2023-07-23 19:46:18 +02:00
ngosang	a1c36f60d2	Fix for Chrome / Chromium version > 114	2023-07-23 19:46:18 +02:00
ngosang	0edc50e271	Update base Docker image to Debian Bookworm	2023-07-23 19:46:18 +02:00
ngosang	f4a4baa57c	Update Selenium 4.10.0	2023-07-23 19:46:18 +02:00
ngosang	f7e434c6e3	Simplify 'Verify you are human' resolver. Related #811	2023-07-23 19:46:15 +02:00
Maksim Kurnosenko	7728f2ab31	Update undetected_chromedriver to v3.5.0 (#803 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-07-17 18:46:43 +01:00
Garfield69	c920bea4ca	Update .gitignore	2023-07-17 13:50:11 +12:00
ilike2burnthing	a785f83034	Update CHANGELOG.md	2023-07-16 23:46:31 +01:00
ilike2burnthing	b42c22f5b1	Bump version 3.2.2	2023-07-16 23:46:25 +01:00
Tyler Hagstrom	9c62410a8b	Workaround for updated 'verify your are human' check (#816 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-07-16 23:42:41 +01:00
ngosang	b8768ae17d	Bump version 3.2.1	2023-06-10 19:27:55 +02:00
ngosang	9b2c602a1f	Kill dead Chrome processes in Windows	2023-06-10 19:26:28 +02:00
ngosang	8316350b98	Fix Chrome GL erros in ASUSTOR NAS	2023-06-10 18:49:09 +02:00
ilike2burnthing	33307ce461	bug_report: add troubleshooting check	2023-06-04 04:08:25 +01:00
ngosang	cedb7bc54e	Bump version 3.2.0	2023-05-23 23:13:31 +02:00
ngosang	6ecaf2362c	Support cookies param in request cmd	2023-05-23 22:39:07 +02:00
ngosang	3c97c9603a	Add integration tests for requests with proxy param	2023-05-23 22:13:52 +02:00
NyaMisty	efaa5f31b6	Support proxy in request and session cmds (#754 )	2023-05-23 21:53:13 +02:00
ngosang	4db85a2d0f	Update Python dependencies	2023-05-23 20:18:06 +02:00
ngosang	66b9db21e5	Fix Chromium exec permissions in Linux package	2023-05-21 21:09:06 +02:00
ngosang	ab0fe58d4a	Bump version 3.1.2	2023-04-02 21:06:52 +02:00
ngosang	f68ddb7573	Bump Selenium dependency	2023-04-02 21:05:07 +02:00
ngosang	ac77110578	Remove redundant artifact from Windows binary package	2023-04-02 21:04:34 +02:00
Rawand Ahmed Shaswar	a9d1a2de2d	Fix headless mode in mac OS (#750 )	2023-04-02 20:49:18 +02:00
ngosang	ab5f14d6c3	Bump version 3.1.1	2023-03-25 22:20:56 +01:00
ngosang	e0bf02fb8b	Distribute binary executables in compressed package	2023-03-25 22:19:26 +01:00
ilike2burnthing	82a1cd835a	Add icon for binary executable (#739 )	2023-03-25 21:35:37 +01:00
ngosang	7017715e21	Include information about supported architectures in the readme	2023-03-25 21:32:17 +01:00
ngosang	ae18559db1	Check Python version on start	2023-03-25 21:23:06 +01:00
ngosang	2680521008	Bump version 3.1.0	2023-03-20 23:17:05 +01:00
ngosang	2297bab185	Update changelog	2023-03-20 23:16:39 +01:00
ngosang	8d9bac9dd4	Build binaries for Linux x64 and Windows x64	2023-03-20 22:30:52 +01:00
ngosang	30ccf18e85	Several fixes in Sessions	2023-03-20 17:06:16 +01:00
ngosang	a15d041a0c	Fix Waitress server error with asyncore_use_poll=true. Resolves #680	2023-03-20 16:27:25 +01:00
Martino Mensio	c6c74e7c9d	Add Fairlane challenge selector (#723 )	2023-03-20 16:27:24 +01:00
Artemiy Ryabinkov	49fd1aacfc	Sessions with auto-creation on fetch request and TTL (#736 ) * Add support for sessions * Add tests for sessions * Missing return type * Don't re-create an existing session * Return success in case of session doesn't exists on destroy * Create session if necessary on get request * Add session TTL to the request.get method When fetching some webpage with a predefined session id, FlareSorverr is using existing instance of WebDriver. That allows user to not manage cookies explicitly and rely on WebDriver to maintain the session. However, if session has been created long time ago, CloudFlare might stop accepting the requests, so we want to recreate the session time to time. From the user perspective the easiest way of doing it is to define their expectation on the session duration. These changes add an option to define Time-to-live (TTL) for the session and FlareSorverr takes care about rotating the sessions. * Update message for session destroy in tests --------- Co-authored-by: Michel Roux <xefir@crystalyx.net>	2023-03-20 16:25:48 +01:00
Martino Mensio	f6879c70de	Add Fairlane challenge selector (#723 )	2023-03-20 16:13:21 +01:00
ngosang	24f59a39cb	Print platform information on start up	2023-03-20 15:07:12 +01:00
ngosang	4d16105176	Fix error trace: Crash Reports/pending No such file or directory	2023-03-20 15:07:12 +01:00
ngosang	5957b7b3bc	Update dependencies	2023-03-20 15:07:12 +01:00
ngosang	8de16058d0	Attempt to fix Docker ARM32 build	2023-03-20 15:07:12 +01:00
bilditup1	5fc4f966a5	Update ddos-guard title (#692 ) * update ddos-guard title (anidex.info) * make page_title test case-insensitive --------- Co-authored-by: bilditup1 <git@github.com>	2023-03-20 15:06:27 +01:00
ilike2burnthing	b903a5dd84	Bump version 3.0.4	2023-03-07 03:54:10 +00:00
ilike2burnthing	7e9d5f424f	Update changelog	2023-03-07 03:54:05 +00:00
ilike2burnthing	fc6d2d9095	Click on the Cloudflare's 'Verify you are human' button if necessary Co-authored-by: furdarius <furdarius@users.noreply.github.com> `69e023b946` minus screenshot function	2023-03-07 03:51:17 +00:00
ilike2burnthing	aef9b2d4d6	Update changelog	2023-03-06 14:02:56 +00:00
ilike2burnthing	6dc279a9d3	Bump version 3.0.3	2023-03-06 13:59:20 +00:00
Artemiy Ryabinkov	96fcd21174	Update undetected_chromedriver version to 3.4.6 (#715 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-03-06 13:57:38 +00:00
ngosang	3a6e8e0f92	Update GitHub bug report template	2023-01-28 18:00:57 +01:00
ilike2burnthing	2d97f88276	Update README.md	2023-01-09 21:51:49 +00:00
ngosang	ac5c64319e	Bump version 3.0.2	2023-01-08 20:48:20 +01:00
ngosang	c93834e2f0	Check Chrome / Chromium web browser is installed correctly	2023-01-08 20:46:11 +01:00
ngosang	e3b4200d94	Detect Cloudflare blocked access	2023-01-08 20:40:10 +01:00
ngosang	0941861f80	Update changelog	2023-01-06 18:49:05 +01:00
ngosang	8a10eb27a6	Bump version 3.0.1	2023-01-06 18:33:02 +01:00
ngosang	e9c08c84ef	Update GitHub actions	2023-01-06 18:32:34 +01:00
ngosang	2aa1744476	Add more selectors to detect blocked access	2023-01-06 18:12:26 +01:00
ngosang	a89679a52d	Disable Zygote sandbox in Chromium browser	2023-01-06 18:05:23 +01:00
ngosang	410ee7981f	Apply undetected-chromedriver patches * Hide Chrome window in Windows/NT * Not use subprocess by default (independent process) * Kill Chromium processes properly to avoid defunct/zombie processes	2023-01-06 17:50:52 +01:00
ngosang	e163019f28	Update undetected-chromedriver	2023-01-06 17:19:11 +01:00
ngosang	7d84f1b663	Kill Chromium processes properly to avoid defunct/zombie processes	2023-01-06 13:58:24 +01:00
ngosang	4807e9dbe2	Include procps (ps), curl and vim packages in the Docker image	2023-01-05 13:25:45 +01:00