@eyeo/get-browser-binary 0.2.0 → 0.4.0

package/src/browsers.js

@@ -16,9 +16,10 @@
  */
 
 import path from "path";
-import {exec, execFile} from "child_process";
+import {exec, execFile, spawn} from "child_process";
 import {promisify} from "util";
 import fs from "fs";
+import fsExtra from "fs-extra";
 
 import got from "got";
 import webdriver from "selenium-webdriver";
@@ -27,8 +28,8 @@ import firefox from "selenium-webdriver/firefox.js";
 import command from "selenium-webdriver/lib/command.js";
 import extractZip from "extract-zip";
 
-import {download, extractTar, extractDmg, runWinInstaller, getBrowserVersion}
-  from "./utils.js";
+import {download, extractTar, extractDmg, getBrowserVersion, killDriverProcess,
+        wait} from "./utils.js";
 
 /**
  * Root folder where browser and webdriver binaries get downloaded.
@@ -37,9 +38,9 @@ import {download, extractTar, extractDmg, runWinInstaller, getBrowserVersion}
 export let snapshotsBaseDir = path.join(process.cwd(), "browser-snapshots");
 
 let {until, By} = webdriver;
-const ERROR_INCOGNITO_NOT_SUPPORTED = "Incognito mode is not supported";
 const ERROR_DOWNLOAD_NOT_SUPPORTED =
   "Downloading this browser is not supported";
+let platform = `${process.platform}-${process.arch}`;
 
 /**
  * Base class for browser download functionality. Please see subclasses for
@@ -49,7 +50,9 @@ const ERROR_DOWNLOAD_NOT_SUPPORTED =
 class Browser {
   /**
    * @typedef {Object} BrowserBinary
-   * @property {string} binary - The path to the Chromium binary.
+   * @property {string} binary - The path to the browser binary.
+   * @property {string} versionNumber - The version number of the browser
+   *   binary.
    */
 
   /**
@@ -62,6 +65,25 @@ class Browser {
     throw new Error(ERROR_DOWNLOAD_NOT_SUPPORTED);
   }
 
+  /**
+   * Gets the installed version returned by the browser binary.
+   * @param {string} binary - The path to the browser binary.
+   * @return {string} Installed browser version.
+   */
+  static async getInstalledVersion(binary) {
+    let stdout;
+    if (process.platform == "win32") {
+      ({stdout} = await promisify(exec)(
+        `(Get-ItemProperty ${binary}).VersionInfo.ProductVersion`,
+        {shell: "powershell.exe"})
+      );
+    }
+    else {
+      ({stdout} = await promisify(execFile)(binary, ["--version"]));
+    }
+    return stdout;
+  }
+
   /**
    * @typedef {Object} webdriver
    * @see https://www.selenium.dev/selenium/docs/api/javascript/index.html
@@ -89,6 +111,7 @@ class Browser {
    *   no effect.
    * @param {driverOptions?} options - Options to start the browser with.
    * @return {webdriver}
+   * @throws {Error} Unsupported webdriver version.
    */
   static async getDriver(version, options = {}) {
     // to be implemented by the subclass
@@ -102,7 +125,10 @@ class Browser {
    * @return {webdriver}
    */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    throw new Error(ERROR_INCOGNITO_NOT_SUPPORTED);
+    // Allowing the extension in incognito mode can't happen programmatically:
+    // https://stackoverflow.com/questions/57419654
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1729315
+    // That is done through the UI, to be implemented by the subclass
   }
 }
 
@@ -159,17 +185,13 @@ class Chromium extends Browser {
 
     let revision = parseInt(chromiumRevision, 10);
     let startingRevision = revision;
-    let platform = `${process.platform}-${process.arch}`;
-
-    let buildTypes = {
+    let [platformDir, fileName] = {
       "win32-ia32": ["Win", "chrome-win.zip"],
       "win32-x64": ["Win_x64", "chrome-win.zip"],
       "linux-x64": ["Linux_x64", "chrome-linux.zip"],
       "darwin-x64": ["Mac", "chrome-mac.zip"],
       "dawrin-arm64": ["Mac_Arm", "chrome-mac.zip"]
-    };
-
-    let [platformDir, fileName] = buildTypes[platform];
+    }[platform];
     let archive = null;
     let browserDir = null;
     let snapshotsDir = path.join(snapshotsBaseDir, "chromium");
@@ -225,19 +247,17 @@ class Chromium extends Browser {
       ({version, base} = await Chromium.#getLatestVersion(version));
 
     let {binary, revision} = await Chromium.#downloadChromium(base);
-    return {binary, downloadedVersion: version, revision};
+    return {binary, versionNumber: version, revision};
   }
 
   static async #installDriver(revision, version) {
-    let platform = `${process.platform}-${process.arch}`;
-    let buildTypes = {
+    let [dir, zip, driver] = {
       "win32-ia32": ["Win", "chromedriver_win32.zip", "chromedriver.exe"],
       "win32-x64": ["Win_x64", "chromedriver_win32.zip", "chromedriver.exe"],
       "linux-x64": ["Linux_x64", "chromedriver_linux64.zip", "chromedriver"],
       "darwin-x64": ["Mac", "chromedriver_mac64.zip", "chromedriver"],
       "darwin-arm64": ["Mac_Arm", "chromedriver_mac64.zip", "chromedriver"]
-    };
-    let [dir, zip, driver] = buildTypes[platform];
+    }[platform];
 
     let cacheDir = path.join(snapshotsBaseDir, "chromium", "cache", version);
     let destinationDir = path.join(process.cwd(), "node_modules",
@@ -247,28 +267,19 @@ class Chromium extends Browser {
     await download(`https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${revision}/${zip}`,
                    archive);
     await extractZip(archive, {dir: cacheDir});
+    await killDriverProcess(Chromium.#DRIVER);
     await fs.promises.mkdir(destinationDir, {recursive: true});
-    try {
-      await fs.promises.copyFile(path.join(cacheDir, zip.split(".")[0], driver),
-                                 path.join(destinationDir, driver));
-    }
-    catch (err) {
-      // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/3
-      if (!err.toString().includes("copyfile"))
-        throw err;
-    }
+    await fs.promises.copyFile(path.join(cacheDir, zip.split(".")[0], driver),
+                               path.join(destinationDir, driver));
   }
 
   /** @see Browser.getDriver */
   static async getDriver(version, {headless = true, extensionPaths = [],
                                    incognito = false, insecure = false,
                                    extraArgs = []} = {}) {
-    if (incognito)
-      throw new Error(ERROR_INCOGNITO_NOT_SUPPORTED);
-
-    let {binary, revision, downloadedVersion} =
+    let {binary, revision, versionNumber} =
       await Chromium.downloadBinary(version);
-    await Chromium.#installDriver(revision, downloadedVersion);
+    await Chromium.#installDriver(revision, versionNumber);
 
     let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
     if (extensionPaths.length > 0)
@@ -277,6 +288,8 @@ class Chromium extends Browser {
       options.headless();
     if (insecure)
       options.addArguments("ignore-certificate-errors");
+    if (incognito)
+      options.addArguments("incognito");
     options.setChromeBinaryPath(binary);
 
     let builder = new webdriver.Builder();
@@ -285,6 +298,42 @@ class Chromium extends Browser {
 
     return builder.build();
   }
+
+  /** @see Browser.enableExtensionInIncognito */
+  static async enableExtensionInIncognito(driver, extensionTitle) {
+    let version = await getBrowserVersion(driver);
+    // Webdriver capabilities don't include a browser version for Opera
+    if (version && version < 75)
+      // The UI workaround needs a chromedriver >= 75
+      throw new Error(`Only supported on Chromium >= 75. Current version: ${version}`);
+
+    await driver.navigate().to("chrome://extensions");
+    await driver.executeScript(`
+      let enable = () => document.querySelector("extensions-manager").shadowRoot
+        .querySelector("extensions-detail-view").shadowRoot
+        .getElementById("allow-incognito").shadowRoot
+        .getElementById("crToggle").click();
+
+      let extensions = document.querySelector("extensions-manager").shadowRoot
+        .getElementById("items-list").shadowRoot
+        .querySelectorAll("extensions-item");
+
+      return new Promise((resolve, reject) => {
+        let extensionDetails;
+        for (let {shadowRoot} of extensions) {
+          if (shadowRoot.getElementById("name").innerHTML != arguments[0])
+            continue;
+
+          extensionDetails = shadowRoot.getElementById("detailsButton");
+        }
+
+        if (!extensionDetails)
+          reject("Extension was not found");
+
+        extensionDetails.click();
+        setTimeout(() => resolve(enable()), 100);
+      });`, extensionTitle);
+  }
 }
 
 /**
@@ -292,7 +341,7 @@ class Chromium extends Browser {
  * @hideconstructor
  * @extends Browser
  */
-class Firefox {
+class Firefox extends Browser {
   static async #getLatestVersion(branch) {
     let data = await got("https://product-details.mozilla.org/1.0/firefox_versions.json").json();
     return branch == "beta" ?
@@ -315,7 +364,9 @@ class Firefox {
   static #extractFirefoxArchive(archive, dir) {
     switch (process.platform) {
       case "win32":
-        return runWinInstaller(archive, dir);
+        // Procedure inspired from mozinstall:
+        // https://hg.mozilla.org/mozilla-central/file/tip/testing/mozbase/mozinstall/mozinstall/mozinstall.py
+        return promisify(exec)(`"${archive}" /extractdir=${dir}`);
       case "linux":
         return extractTar(archive, dir);
       case "darwin":
@@ -326,18 +377,18 @@ class Firefox {
   }
 
   static async #downloadFirefox(version) {
-    let {platform} = process;
-    if (platform == "win32")
-      platform += "-" + process.arch;
-    let buildTypes = {
+    let [buildPlatform, fileName] = {
       "win32-ia32": ["win32", `Firefox Setup ${version}.exe`],
       "win32-x64": ["win64", `Firefox Setup ${version}.exe`],
-      "linux": ["linux-x86_64", `firefox-${version}.tar.bz2`],
-      "darwin": ["mac", `Firefox ${version}.dmg`]
-    };
+      "linux-x64": ["linux-x86_64", `firefox-${version}.tar.bz2`],
+      "darwin-x64": ["mac", `Firefox ${version}.dmg`],
+      "darwin-arm64": ["mac", `Firefox ${version}.dmg`]
+    }[platform];
 
     let snapshotsDir = path.join(snapshotsBaseDir, "firefox");
     let browserDir = path.join(snapshotsDir, `firefox-${platform}-${version}`);
+    let archive = path.join(snapshotsDir, "cache", fileName);
+
     try {
       await fs.promises.access(browserDir);
       return Firefox.#getFirefoxBinary(browserDir);
@@ -345,10 +396,6 @@ class Firefox {
     catch (e) {}
 
     await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
-
-    let [buildPlatform, fileName] = buildTypes[platform];
-    let archive = path.join(snapshotsDir, "cache", fileName);
-
     try {
       await fs.promises.access(archive);
     }
@@ -372,7 +419,7 @@ class Firefox {
       version = await Firefox.#getLatestVersion(version);
 
     let binary = await Firefox.#downloadFirefox(version);
-    return {binary};
+    return {binary, versionNumber: version};
   }
 
   /** @see Browser.getDriver */
@@ -392,10 +439,23 @@ class Firefox {
       options.addArguments(...extraArgs);
     options.setBinary(binary);
 
-    let driver = await new webdriver.Builder()
-      .forBrowser("firefox")
-      .setFirefoxOptions(options)
-      .build();
+    let driver;
+    // The OS may be low on resources, that's why building the driver is retried
+    // https://github.com/mozilla/geckodriver/issues/1560
+    await wait(async() => {
+      try {
+        driver = await new webdriver.Builder()
+          .forBrowser("firefox")
+          .setFirefoxOptions(options)
+          .build();
+        return true;
+      }
+      catch (err) {
+        if (err.message != "Failed to decode response from marionette")
+          throw err;
+        await killDriverProcess("geckodriver");
+      }
+    }, 30000, "geckodriver didn't start, likely due to low OS resources", 1000);
 
     for (let extensionPath of extensionPaths) {
       await driver.execute(
@@ -409,14 +469,10 @@ class Firefox {
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    // Allowing the extension in private browsing can't happen programmatically:
-    // https://bugzilla.mozilla.org/show_bug.cgi?id=1729315
-    // Therefore, that is done through the UI
     let version = await getBrowserVersion(driver);
-    if (version < 87) {
+    if (version < 87)
       // The UI workaround assumes web elements only present on Firefox >= 87
       throw new Error(`Only supported on Firefox >= 87. Current version: ${version}`);
-    }
 
     await driver.navigate().to("about:addons");
     await driver.wait(until.elementLocated(By.name("extension")), 1000).click();
@@ -438,41 +494,94 @@ class Firefox {
  * @hideconstructor
  * @extends Browser
  */
-class Edge {
+class Edge extends Browser {
   static #DRIVER = "msedgedriver";
 
-  static async #installDriver() {
-    let stdout;
-    if (process.platform == "win32") {
-      let cmd = "(Get-ItemProperty ${Env:ProgramFiles(x86)}\\Microsoft\\" +
-                "Edge\\Application\\msedge.exe).VersionInfo.ProductVersion";
-      ({stdout} = await promisify(exec)(cmd, {shell: "powershell.exe"}));
+  static async #getVersionForChannel(version) {
+    if (!["latest", "beta", "dev"].includes(version))
+      return {versionNumber: version, channel: "stable"};
+
+    let channel = version == "latest" ? "stable" : version;
+    let {body} = await got(`https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}`);
+    let regex = /href="microsoft-edge-(stable|beta|dev)_(.*?)-1_/gm;
+    let matches;
+    let versionNumbers = [];
+    while ((matches = regex.exec(body)) !== null)
+      versionNumbers.push(matches[2]);
+
+    let compareVersions = (v1, v2) =>
+      parseInt(v1.split(".")[0], 10) < parseInt(v2.split(".")[0], 10) ? 1 : -1;
+    let versionNumber = versionNumbers.sort(compareVersions)[0];
+
+    return {versionNumber, channel};
+  }
+
+  /**
+   * Downloads the browser binary file.
+   * @param {string} version - Either "latest", "beta", "dev" or a full version
+   *   number (i.e. "95.0.1020.53"). Defaults to "latest". This is only
+   *   available on Linux.
+   * @return {BrowserBinary}
+   */
+  static async downloadBinary(version = "latest") {
+    if (process.platform != "linux")
+      throw new Error("Edge download is only supported on Linux");
+
+    let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
+
+    let snapshotsDir = path.join(snapshotsBaseDir, "edge");
+    let filename = `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`;
+    let archive = path.join(snapshotsDir, "cache", filename);
+    let binary = {
+      stable: "microsoft-edge",
+      beta: "microsoft-edge-beta",
+      dev: "microsoft-edge-dev"
+    }[channel];
+
+    try {
+      if (await Edge.#getInstalledVersionNumber(binary) == versionNumber)
+        return {binary, versionNumber};
     }
-    else if (process.platform == "darwin") {
-      ({stdout} = await promisify(execFile)(
-        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-        ["--version"]
-      ));
+    catch (e) {}
+
+    try {
+      await download(
+        `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`,
+        archive
+      );
     }
-    else if (process.platform == "linux") {
-      ({stdout} = await promisify(execFile)("microsoft-edge", ["--version"]));
+    catch (err) {
+      throw new Error(`Edge download failed: ${err}`);
     }
+    await promisify(exec)(`dpkg -i ${archive}`);
 
-    let version = stdout.trim().replace(/.*\s/, "");
+    return {binary, versionNumber};
+  }
+
+  static async #getInstalledVersionNumber(binary) {
+    let installedVersion = await Edge.getInstalledVersion(binary);
+    return installedVersion.replace("beta", "").replace("dev", "")
+      .trim().replace(/.*\s/, "");
+  }
+
+  static async #installDriver() {
+    let binary = {
+      win32:
+        "${Env:ProgramFiles(x86)}\\Microsoft\\Edge\\Application\\msedge.exe",
+      darwin: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      linux: "microsoft-edge"
+    }[process.platform];
+    let version = await Edge.#getInstalledVersionNumber(binary);
     if (!version)
       throw new Error("Edge is not installed");
 
-    // Based on "node_modules/msedgedriver/install.js", adding a fallback
-    // mechanism when msedgedriver doesn't exist for the latest Edge version.
-    let platform = `${process.platform}-${process.arch}`;
-    let buildTypes = {
+    let [zip, driver] = {
       "win32-ia32": ["edgedriver_win32.zip", "msedgedriver.exe"],
       "win32-x64": ["edgedriver_win64.zip", "msedgedriver.exe"],
       "linux-x64": ["edgedriver_linux64.zip", "msedgedriver"],
       "darwin-x64": ["edgedriver_mac64.zip", "msedgedriver"],
       "darwin-arm64": ["edgedriver_arm64.zip", "msedgedriver"]
-    };
-    let [zip, driver] = buildTypes[platform];
+    }[platform];
     let cacheDir = path.join(snapshotsBaseDir, "edge", "cache");
     let driverBinDir = path.join(process.cwd(), "node_modules", Edge.#DRIVER,
                                  "bin");
@@ -498,17 +607,11 @@ class Edge {
       throw new Error(`msedgedriver was not found for Edge ${version}`);
 
     await extractZip(archive, {dir: cacheDir});
+    await killDriverProcess(Edge.#DRIVER);
     for (let destinationDir of [driverBinDir, driverLibDir]) {
       await fs.promises.mkdir(destinationDir, {recursive: true});
-      try {
-        await fs.promises.copyFile(path.join(cacheDir, driver),
-                                   path.join(destinationDir, driver));
-      }
-      catch (err) {
-        // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/3
-        if (!err.toString().includes("copyfile"))
-          throw err;
-      }
+      await fs.promises.copyFile(path.join(cacheDir, driver),
+                                 path.join(destinationDir, driver));
     }
   }
 
@@ -516,8 +619,8 @@ class Edge {
   static async getDriver(version, {headless = true, extensionPaths = [],
                                    incognito = false, insecure = false,
                                    extraArgs = []} = {}) {
-    if (incognito)
-      throw new Error(ERROR_INCOGNITO_NOT_SUPPORTED);
+    if (process.platform == "linux")
+      await Edge.downloadBinary(version);
 
     await Edge.#installDriver();
 
@@ -526,6 +629,8 @@ class Edge {
       args.push("headless");
     if (extensionPaths.length > 0)
       args.push(`load-extension=${extensionPaths.join(",")}`);
+    if (incognito)
+      args.push("incognito");
 
     let builder = new webdriver.Builder();
     builder.forBrowser("MicrosoftEdge");
@@ -538,8 +643,245 @@ class Edge {
 
     return builder.build();
   }
+
+  /** @see Browser.enableExtensionInIncognito */
+  static async enableExtensionInIncognito(driver, extensionTitle) {
+    let version = await getBrowserVersion(driver);
+    if (version < 79)
+      // The UI workaround needs a chromium based msedgedriver
+      throw new Error(`Only supported on Edge >= 79. Current version: ${version}`);
+
+    await driver.navigate().to("edge://extensions/");
+    for (let elem of await driver.findElements(By.css("[role=listitem]"))) {
+      let text = await elem.getAttribute("innerHTML");
+      if (!text.includes(extensionTitle))
+        continue;
+
+      for (let button of await elem.findElements(By.css("button"))) {
+        text = await elem.getAttribute("innerHTML");
+        if (!text.includes("Details"))
+          continue;
+
+        await button.click();
+        return await driver.findElement(By.id("itemAllowIncognito")).click();
+      }
+      throw new Error("Details button not found");
+    }
+    throw new Error(`Extension "${extensionTitle}" not found`);
+  }
 }
 
+/**
+ * Download functionality for Opera. This class can be used statically.
+ * @hideconstructor
+ * @extends Browser
+ */
+class Opera extends Browser {
+  static async #getVersionForChannel(version) {
+    let channelPath = "opera/desktop";
+    let filePrefix = "Opera";
+    if (version != "latest")
+      return {versionNumber: version, channelPath, filePrefix};
+
+    let {body} = await got(`https://ftp.opera.com/pub/${channelPath}`);
+    let regex = /href="(\d.*)\/"/gm;
+    let matches = body.match(regex);
+    let versionNumber = regex.exec(matches[matches.length - 1])[1];
+
+    return {versionNumber, channelPath, filePrefix};
+  }
+
+  static #getOperaBinary(dir) {
+    switch (process.platform) {
+      case "win32":
+        return path.join(dir, "launcher.exe");
+      case "linux":
+        return path.join("/", "usr", "bin", "opera");
+      case "darwin":
+        return path.join(dir, "Opera.app", "Contents", "MacOS", "Opera");
+      default:
+        throw new Error(`Unexpected platform: ${process.platform}`);
+    }
+  }
+
+  static async #extractDeb(archive) {
+    let child = spawn("dpkg", ["-i", archive]);
+
+    child.stdout.on("data", data => {
+      if (data.toString().startsWith("Do you want to update Opera")) {
+        process.stdin.pipe(child.stdin);
+        child.stdin.write("no\r\n");
+      }
+    });
+
+    child.stderr.on("data", data => {
+      let expectedWarnings = [
+        "debconf: unable to initialize frontend",
+        "dpkg: warning: downgrading opera-stable",
+        "update-alternatives",
+        "using /usr/bin/opera",
+        "skip creation of",
+        "\r\n"
+      ];
+      if (!expectedWarnings.find(err => data.toString().includes(err.trim())))
+        console.error(`stderr: ${data.toString()}`);
+    });
+
+    await new Promise((resolve, reject) => child.on("close", code => {
+      if (code != 0)
+        reject(`dpkg process exited with code ${code}`);
+
+      resolve();
+    }));
+  }
+
+  static async #installOnWindows(archive, dir, filename) {
+    let archiveCopy = path.join(dir, filename);
+    await fsExtra.copy(archive, archiveCopy);
+    await promisify(exec)(`"${archiveCopy}"`);
+  }
+
+  static #extractOperaArchive(archive, dir, filename) {
+    switch (process.platform) {
+      case "win32":
+        return Opera.#installOnWindows(archive, dir, filename);
+      case "linux":
+        return Opera.#extractDeb(archive, dir);
+      case "darwin":
+        return extractTar(archive, dir);
+      default:
+        throw new Error(`Unexpected platform: ${process.platform}`);
+    }
+  }
+
+  /**
+   * Downloads the browser binary file.
+   * @param {string} version - Either "latest" or a full version number
+   *   (i.e. "64.0.3417.92"). Defaults to "latest".
+   * @return {BrowserBinary}
+   */
+  static async downloadBinary(version = "latest") {
+    let {versionNumber, channelPath, filePrefix} =
+      await Opera.#getVersionForChannel(version);
+
+    let [platformDir, fileSuffix] = {
+      "win32-ia32": ["win", "Autoupdate.exe"],
+      "win32-x64": ["win", "Autoupdate_x64.exe"],
+      "linux-x64": ["linux", "amd64.deb"],
+      "darwin-x64": ["mac", "Autoupdate.tar.xz"],
+      "dawrin-arm64": ["mac", "Autoupdate_arm64.tar.xz"]
+    }[platform];
+
+    let snapshotsDir = path.join(snapshotsBaseDir, "opera");
+    let browserDir = path.join(snapshotsDir, `opera-${platform}-${versionNumber}`);
+    let filename = `${filePrefix}_${versionNumber}_${fileSuffix}`;
+    let archive = path.join(snapshotsDir, "cache", filename);
+
+    let binary = Opera.#getOperaBinary(browserDir);
+    try {
+      await fs.promises.access(browserDir);
+      return {binary, versionNumber};
+    }
+    catch (e) {}
+
+    await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
+    try {
+      await fs.promises.access(archive);
+    }
+    catch (e) {
+      await download(
+        `https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}/${filename}`,
+        archive
+      );
+    }
+
+    await Opera.#extractOperaArchive(archive, browserDir, filename);
+    return {binary, versionNumber};
+  }
+
+  static async #installDriver(version, originalVersion) {
+    let [zip, driver] = {
+      "win32-ia32": ["operadriver_win32.zip", "operadriver.exe"],
+      "win32-x64": ["operadriver_win64.zip", "operadriver.exe"],
+      "linux-x64": ["operadriver_linux64.zip", "operadriver"],
+      "darwin-x64": ["operadriver_mac64.zip", "operadriver"],
+      "darwin-arm64": ["operadriver_mac64.zip", "operadriver"]
+    }[platform];
+
+    let {versionNumber} = await Opera.#getVersionForChannel(version);
+    versionNumber = versionNumber.split(".")[0];
+
+    let cacheDir = path.join(snapshotsBaseDir, "opera", "cache",
+                             `driver-for-opera-${versionNumber}`);
+    let archive = path.join(cacheDir, zip);
+
+    let {body} = await got(`https://github.com/operasoftware/operachromiumdriver/releases?q=Opera+${versionNumber}&expanded=true`);
+    let regex = /release-card[\s\S]*Link--primary.*>(.*)<\/a/gm;
+    let matches = body.match(regex);
+    if (!matches || matches.length == 0)
+      throw new Error(`Driver for Opera ${version} was not found`);
+    let driverVersion = regex.exec(matches[matches.length - 1])[1];
+
+    try {
+      await download(`https://github.com/operasoftware/operachromiumdriver/releases/download/v.${driverVersion}/${zip}`,
+                     archive);
+    }
+    catch (err) {
+      throw new Error(`Downloading operadriver failed: ${err}`);
+    }
+
+    await killDriverProcess("operadriver");
+    let driverPath = path.join(cacheDir, zip.split(".")[0], driver);
+    try {
+      await fs.promises.rm(driverPath, {recursive: true});
+    }
+    catch (e) {} // file does not exist
+    await extractZip(archive, {dir: cacheDir});
+    await fs.promises.chmod(driverPath, 577);
+
+    return driverPath;
+  }
+
+  /** @see Browser.getDriver */
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
+    let {binary, versionNumber} = await Opera.downloadBinary(version);
+    let driverPath = await Opera.#installDriver(versionNumber, version);
+    // operadriver uses chrome as a service builder:
+    // https://github.com/operasoftware/operachromiumdriver/blob/master/docs/desktop.md
+    let serviceBuilder = new chrome.ServiceBuilder(driverPath);
+    let service = serviceBuilder.build();
+    await service.start();
+
+    let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
+    if (extensionPaths.length > 0)
+      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
+    if (headless)
+      options.headless();
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
+    if (incognito)
+      options.addArguments("incognito");
+    options.setChromeBinaryPath(binary);
+    // https://github.com/operasoftware/operachromiumdriver/issues/61#issuecomment-579331657
+    options.addArguments("remote-debugging-port=9222");
+
+    let builder = new webdriver.Builder();
+    builder.forBrowser("chrome");
+    builder.setChromeOptions(options);
+    builder.setChromeService(serviceBuilder);
+
+    return builder.build();
+  }
+
+  /** @see Browser.enableExtensionInIncognito */
+  static async enableExtensionInIncognito(driver, extensionTitle) {
+    // Extensions page in Opera has the same web elements as Chromium
+    await Chromium.enableExtensionInIncognito(driver, extensionTitle);
+  }
+}
 
 /**
  * @type {Object}
@@ -550,5 +892,6 @@ class Edge {
 export const BROWSERS = {
   chromium: Chromium,
   firefox: Firefox,
-  edge: Edge
+  edge: Edge,
+  opera: Opera
 };