@eyeo/get-browser-binary 0.3.0 → 0.5.0

package/src/browsers.js

@@ -16,19 +16,21 @@
  */
 
 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";
 import chrome from "selenium-webdriver/chrome.js";
 import firefox from "selenium-webdriver/firefox.js";
+import edge from "selenium-webdriver/edge.js";
 import command from "selenium-webdriver/lib/command.js";
 import extractZip from "extract-zip";
 
-import {download, extractTar, extractDmg, runWinInstaller, getBrowserVersion,
-        killDriverProcess} from "./utils.js";
+import {download, extractTar, extractDmg, getBrowserVersion, killDriverProcess,
+        wait} from "./utils.js";
 
 /**
  * Root folder where browser and webdriver binaries get downloaded.
@@ -37,10 +39,17 @@ import {download, extractTar, extractDmg, runWinInstaller, getBrowserVersion,
 export let snapshotsBaseDir = path.join(process.cwd(), "browser-snapshots");
 
 let {until, By} = webdriver;
-const ERROR_DOWNLOAD_NOT_SUPPORTED =
-  "Downloading this browser is not supported";
 let platform = `${process.platform}-${process.arch}`;
 
+function checkVersion(version, minVersion, channels) {
+  if (channels.includes(version))
+    return;
+
+  let mainVersion = parseInt(version && version.split(".")[0], 10);
+  if (mainVersion < minVersion)
+    throw new Error(`Unsupported browser version: ${version}`);
+}
+
 /**
  * Base class for browser download functionality. Please see subclasses for
  * browser specific details.
@@ -49,7 +58,9 @@ let platform = `${process.platform}-${process.arch}`;
 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.
    */
 
   /**
@@ -57,9 +68,29 @@ class Browser {
    * @param {string} version - Either full version number or channel/release.
    *   Please find examples on the subclasses.
    * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version.
    */
   static async downloadBinary(version) {
-    throw new Error(ERROR_DOWNLOAD_NOT_SUPPORTED);
+    // to be implemented by the subclass
+  }
+
+  /**
+   * 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.trim();
   }
 
   /**
@@ -85,11 +116,10 @@ class Browser {
    * Installs the webdriver matching the browser version and runs the
    * browser. If needed, the browser binary is also installed.
    * @param {string} version - Either full version number or channel/release.
-   *   Please find examples on the subclasses. On Edge this parameter has
-   *   no effect.
+   *   Please find examples on the subclasses.
    * @param {driverOptions?} options - Options to start the browser with.
    * @return {webdriver}
-   * @throws {Error} Unsupported webdriver version.
+   * @throws {Error} Unsupported browser version.
    */
   static async getDriver(version, options = {}) {
     // to be implemented by the subclass
@@ -101,6 +131,7 @@ class Browser {
    * @param {webdriver} driver - The driver controlling the browser.
    * @param {string} extensionTitle - Title of the extebsion to be enabled.
    * @return {webdriver}
+   * @throws {Error} Unsupported browser version.
    */
   static async enableExtensionInIncognito(driver, extensionTitle) {
     // Allowing the extension in incognito mode can't happen programmatically:
@@ -123,28 +154,30 @@ class Chromium extends Browser {
     return data.chromium_base_position;
   }
 
-  static async #getLatestVersion(channel = "stable") {
-    let os = process.platform;
-    if (os == "win32")
-      os = process.arch == "x64" ? "win64" : "win";
-    else if (os == "darwin")
-      os = process.arch == "arm64" ? "mac_arm64" : "mac";
+  static async #getVersionForChannel(channel) {
+    if (channel == "latest")
+      channel = "stable";
 
+    let os = {
+      "win32-ia32": "win",
+      "win32-x64": "win64",
+      "linux-x64": "linux",
+      "darwin-x64": "mac",
+      "dawrin-arm64": "mac_arm64"
+    }[platform];
     let data = await got(`https://omahaproxy.appspot.com/all.json?os=${os}`).json();
     let release = data[0].versions.find(ver => ver.channel == channel);
-    let {current_version: version, branch_base_position: base} = release;
+    let {current_version: version} = release;
 
-    if (release.true_branch && release.true_branch.includes("_")) {
+    if (release.true_branch && release.true_branch.includes("_"))
       // A wrong base may be caused by a mini-branch (patched) release
       // In that case, the base is taken from the unpatched version
       version = [...version.split(".").slice(0, 3), "0"].join(".");
-      base = await Chromium.#getBranchBasePosition(version);
-    }
 
-    return {version, base};
+    return version;
   }
 
-  static #getChromiumBinary(dir) {
+  static #getBinaryPath(dir) {
     switch (process.platform) {
       case "win32":
         return path.join(dir, "chrome-win", "chrome.exe");
@@ -179,7 +212,7 @@ class Chromium extends Browser {
 
       try {
         await fs.promises.access(browserDir);
-        return {binary: Chromium.#getChromiumBinary(browserDir), revision};
+        return {binary: Chromium.#getBinaryPath(browserDir), revision};
       }
       catch (e) {}
 
@@ -208,7 +241,7 @@ class Chromium extends Browser {
     }
 
     await extractZip(archive, {dir: browserDir});
-    return {binary: Chromium.#getChromiumBinary(browserDir), revision};
+    return {binary: Chromium.#getBinaryPath(browserDir), revision};
   }
 
   /**
@@ -217,15 +250,19 @@ class Chromium extends Browser {
    *   number (i.e. "77.0.3865.0"). Defaults to "latest".
    * @return {BrowserBinary}
    */
-  static async downloadBinary(version) {
-    let base;
-    if (version && !(version == "beta" || version == "dev"))
-      base = await Chromium.#getBranchBasePosition(version);
-    else
-      ({version, base} = await Chromium.#getLatestVersion(version));
+  static async downloadBinary(version = "latest") {
+    const MIN_VERSION = 75;
+    const CHANNELS = ["latest", "beta", "dev"];
+
+    checkVersion(version, MIN_VERSION, CHANNELS);
+
+    let versionNumber = CHANNELS.includes(version) ?
+      await Chromium.#getVersionForChannel(version) : version;
+
+    let base = await Chromium.#getBranchBasePosition(versionNumber);
 
     let {binary, revision} = await Chromium.#downloadChromium(base);
-    return {binary, downloadedVersion: version, revision};
+    return {binary, versionNumber, revision};
   }
 
   static async #installDriver(revision, version) {
@@ -245,7 +282,6 @@ class Chromium extends Browser {
     await download(`https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${revision}/${zip}`,
                    archive);
     await extractZip(archive, {dir: cacheDir});
-    // avoid driver copy failing if the file would be locked
     await killDriverProcess(Chromium.#DRIVER);
     await fs.promises.mkdir(destinationDir, {recursive: true});
     await fs.promises.copyFile(path.join(cacheDir, zip.split(".")[0], driver),
@@ -253,12 +289,13 @@ class Chromium extends Browser {
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
-    let {binary, revision, downloadedVersion} =
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
+    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)
@@ -280,13 +317,8 @@ class Chromium extends Browser {
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    let version = await getBrowserVersion(driver);
-    if (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(`
+    await driver.executeScript((...args) => {
       let enable = () => document.querySelector("extensions-manager").shadowRoot
         .querySelector("extensions-detail-view").shadowRoot
         .getElementById("allow-incognito").shadowRoot
@@ -299,7 +331,7 @@ class Chromium extends Browser {
       return new Promise((resolve, reject) => {
         let extensionDetails;
         for (let {shadowRoot} of extensions) {
-          if (shadowRoot.getElementById("name").innerHTML != arguments[0])
+          if (shadowRoot.getElementById("name").innerHTML != args[0])
             continue;
 
           extensionDetails = shadowRoot.getElementById("detailsButton");
@@ -310,7 +342,8 @@ class Chromium extends Browser {
 
         extensionDetails.click();
         setTimeout(() => resolve(enable()), 100);
-      });`, extensionTitle);
+      });
+    }, extensionTitle);
   }
 }
 
@@ -319,14 +352,14 @@ class Chromium extends Browser {
  * @hideconstructor
  * @extends Browser
  */
-class Firefox {
-  static async #getLatestVersion(branch) {
+class Firefox extends Browser {
+  static async #getVersionForChannel(branch) {
     let data = await got("https://product-details.mozilla.org/1.0/firefox_versions.json").json();
     return branch == "beta" ?
       data.LATEST_FIREFOX_DEVEL_VERSION : data.LATEST_FIREFOX_VERSION;
   }
 
-  static #getFirefoxBinary(dir) {
+  static #getBinaryPath(dir) {
     switch (process.platform) {
       case "win32":
         return path.join(dir, "core", "firefox.exe");
@@ -342,7 +375,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":
@@ -367,7 +402,7 @@ class Firefox {
 
     try {
       await fs.promises.access(browserDir);
-      return Firefox.#getFirefoxBinary(browserDir);
+      return Firefox.#getBinaryPath(browserDir);
     }
     catch (e) {}
 
@@ -381,7 +416,7 @@ class Firefox {
     }
 
     await Firefox.#extractFirefoxArchive(archive, browserDir);
-    return Firefox.#getFirefoxBinary(browserDir);
+    return Firefox.#getBinaryPath(browserDir);
   }
 
   /**
@@ -390,18 +425,24 @@ class Firefox {
    *   number (i.e. "68.0"). Defaults to "latest".
    * @return {BrowserBinary}
    */
-  static async downloadBinary(version) {
-    if (!version || version == "beta")
-      version = await Firefox.#getLatestVersion(version);
+  static async downloadBinary(version = "latest") {
+    const MIN_VERSION = 60;
+    const CHANNELS = ["latest", "beta"];
+
+    checkVersion(version, MIN_VERSION, CHANNELS);
+
+    let versionNumber = CHANNELS.includes(version) ?
+      await Firefox.#getVersionForChannel(version) : version;
 
-    let binary = await Firefox.#downloadFirefox(version);
-    return {binary};
+    let binary = await Firefox.#downloadFirefox(versionNumber);
+    return {binary, versionNumber};
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
     let {binary} = await Firefox.downloadBinary(version);
 
     let options = new firefox.Options();
@@ -415,10 +456,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(
@@ -457,32 +511,129 @@ 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};
+  }
+
+  static #getDarwinAppName(channel) {
+    let extra = channel == "stable" ?
+      "" : " " + channel.charAt(0).toUpperCase() + channel.slice(1);
+    return `Microsoft Edge${extra}`;
+  }
+
+  static #getBinaryPath(channel = "stable") {
+    switch (process.platform) {
+      case "win32":
+        return "${Env:ProgramFiles(x86)}\\Microsoft\\Edge\\Application\\" +
+          "msedge.exe";
+      case "linux":
+        return channel == "stable" ?
+          "microsoft-edge" : `microsoft-edge-${channel}`;
+      case "darwin":
+        let appName = Edge.#getDarwinAppName(channel);
+        return `${process.env.HOME}/Applications/${appName}.app/Contents/MacOS/${appName}`;
+      default:
+        throw new Error(`Unexpected platform: ${process.platform}`);
     }
-    else if (process.platform == "darwin") {
-      ({stdout} = await promisify(execFile)(
-        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-        ["--version"]
-      ));
+  }
+
+  /**
+   * 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 == "win32")
+      // Edge is mandatory on Windows, can't be uninstalled or downgraded
+      // https://support.microsoft.com/en-us/microsoft-edge/why-can-t-i-uninstall-microsoft-edge-ee150b3b-7d7a-9984-6d83-eb36683d526d
+      throw new Error("Edge download is not supported in Windows");
+
+    const MIN_VERSION = 95;
+    const CHANNELS = ["latest", "beta", "dev"];
+    checkVersion(version, MIN_VERSION, CHANNELS);
+    let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
+
+    let darwinName = {
+      stable: "MicrosoftEdge",
+      beta: "MicrosoftEdgeBeta",
+      dev: "MicrosoftEdgeDev"
+    }[channel];
+    let filename = {
+      linux: `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`,
+      darwin: `${darwinName}-${versionNumber}.pkg`
+    }[process.platform];
+    let darwinArch = process.arch == "arm64" ?
+      "03adf619-38c6-4249-95ff-4a01c0ffc962" :
+      "C1297A47-86C4-4C1F-97FA-950631F94777";
+    let downloadUrl = {
+      linux: `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`,
+      darwin: `https://officecdnmac.microsoft.com/pr/${darwinArch}/MacAutoupdate/${filename}`
+    }[process.platform];
+
+    let snapshotsDir = path.join(snapshotsBaseDir, "edge");
+    let archive = path.join(snapshotsDir, "cache", filename);
+    let binary = Edge.#getBinaryPath(channel);
+    try {
+      if (await Edge.#getInstalledVersionNumber(binary) == versionNumber)
+        return {binary, versionNumber};
+    }
+    catch (e) {}
+
+    try {
+      await download(downloadUrl, archive);
+    }
+    catch (err) {
+      throw new Error(`Edge download failed: ${err}`);
     }
-    else if (process.platform == "linux") {
-      ({stdout} = await promisify(execFile)("microsoft-edge", ["--version"]));
+
+    if (process.platform == "linux") {
+      await promisify(exec)(`dpkg -i ${archive}`);
+    }
+    else if (process.platform == "darwin") {
+      let appName = Edge.#getDarwinAppName(channel);
+      try {
+        await fs.promises.rm(`${process.env.HOME}/Applications/${appName}.app`, {recursive: true});
+      }
+      catch (e) {}
+      await promisify(exec)(`installer -pkg ${archive} -target CurrentUserHomeDirectory`);
     }
 
-    let version = stdout.trim().replace(/.*\s/, "");
-    if (!version)
+    return {binary, versionNumber};
+  }
+
+  static async #getInstalledVersionNumber(binary) {
+    let installedVersion = await Edge.getInstalledVersion(binary);
+    for (let word of ["beta", "dev", "Beta", "Dev"])
+      installedVersion = installedVersion.replace(word, "");
+    return installedVersion.trim().replace(/.*\s/, "");
+  }
+
+  static async #installDriver() {
+    let binary = Edge.#getBinaryPath();
+    let versionNumber = await Edge.#getInstalledVersionNumber(binary);
+    if (!versionNumber)
       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 [zip, driver] = {
       "win32-ia32": ["edgedriver_win32.zip", "msedgedriver.exe"],
       "win32-x64": ["edgedriver_win64.zip", "msedgedriver.exe"],
@@ -490,14 +641,11 @@ class Edge {
       "darwin-x64": ["edgedriver_mac64.zip", "msedgedriver"],
       "darwin-arm64": ["edgedriver_arm64.zip", "msedgedriver"]
     }[platform];
-    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache");
-    let driverBinDir = path.join(process.cwd(), "node_modules", Edge.#DRIVER,
-                                 "bin");
-    let driverLibDir = path.join(process.cwd(), "node_modules", Edge.#DRIVER,
-                                 "lib", Edge.#DRIVER);
-    let archive = path.join(cacheDir, `${version}-${zip}`);
-
-    let vSplit = version.split(".");
+    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache",
+                             `edgedriver-${versionNumber}`);
+    let archive = path.join(cacheDir, `${versionNumber}-${zip}`);
+
+    let vSplit = versionNumber.split(".");
     let lastNum = parseInt(vSplit[3], 10);
     while (lastNum >= 0) {
       try {
@@ -512,51 +660,50 @@ class Edge {
     }
 
     if (lastNum < 0)
-      throw new Error(`msedgedriver was not found for Edge ${version}`);
+      throw new Error(`msedgedriver was not found for Edge ${versionNumber}`);
 
-    await extractZip(archive, {dir: cacheDir});
-    // avoid driver copy failing if the file would be locked
     await killDriverProcess(Edge.#DRIVER);
-    for (let destinationDir of [driverBinDir, driverLibDir]) {
-      await fs.promises.mkdir(destinationDir, {recursive: true});
-      await fs.promises.copyFile(path.join(cacheDir, driver),
-                                 path.join(destinationDir, driver));
+    let driverPath = path.join(cacheDir, driver);
+    try {
+      await fs.promises.rm(driverPath, {recursive: true});
     }
+    catch (e) {} // file does not exist
+    await extractZip(archive, {dir: cacheDir});
+
+    return driverPath;
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
-    await Edge.#installDriver();
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
+    if (process.platform == "linux" || process.platform == "darwin")
+      await Edge.downloadBinary(version);
+
+    let driverPath = await Edge.#installDriver();
+    let serviceBuilder = new edge.ServiceBuilder(driverPath);
 
-    let args = ["no-sandbox", ...extraArgs];
+    let options = new edge.Options().addArguments("no-sandbox", ...extraArgs);
     if (headless)
-      args.push("headless");
+      options.headless();
     if (extensionPaths.length > 0)
-      args.push(`load-extension=${extensionPaths.join(",")}`);
+      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
     if (incognito)
-      args.push("incognito");
+      options.addArguments("incognito");
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
 
     let builder = new webdriver.Builder();
     builder.forBrowser("MicrosoftEdge");
-    builder.withCapabilities({
-      "browserName": "MicrosoftEdge",
-      "ms:edgeChromium": true,
-      "ms:edgeOptions": {args},
-      "acceptInsecureCerts": insecure
-    });
+    builder.setEdgeOptions(options);
+    builder.setEdgeService(serviceBuilder);
 
     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");
@@ -577,6 +724,241 @@ class Edge {
   }
 }
 
+/**
+ * Download functionality for Opera. This class can be used statically.
+ * @hideconstructor
+ * @extends Browser
+ */
+class Opera extends Browser {
+  static async #getVersionForChannel(version, platformDir) {
+    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;
+    while (matches.length > 0) {
+      let result = regex.exec(matches.pop());
+      if (!result)
+        continue;
+
+      versionNumber = result[1];
+      try {
+        await got(`https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}`);
+        break;
+      }
+      catch (e) {}
+    }
+
+    return {versionNumber, channelPath, filePrefix};
+  }
+
+  static #getBinaryPath(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().includes("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") {
+    const MIN_VERSION = 62;
+    const CHANNELS = ["latest"];
+
+    checkVersion(version, MIN_VERSION, CHANNELS);
+
+    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 {versionNumber, channelPath, filePrefix} =
+      await Opera.#getVersionForChannel(version, platformDir);
+
+    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.#getBinaryPath(browserDir);
+    try {
+      if (process.platform == "linux" &&
+          await Opera.getInstalledVersion("opera") == versionNumber)
+        return {binary, versionNumber};
+
+      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) {
+      let url = `https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}/${filename}`;
+      try {
+        await download(url, archive);
+      }
+      catch (err) {
+        throw new Error(`Browser download unavailable at ${url}\n${err}`);
+      }
+    }
+
+    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",
+                             `operadriver-${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}
@@ -587,5 +969,6 @@ class Edge {
 export const BROWSERS = {
   chromium: Chromium,
   firefox: Firefox,
-  edge: Edge
+  edge: Edge,
+  opera: Opera
 };