@eyeo/get-browser-binary 0.12.0 → 0.14.0

package/src/chromium.js

@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2006-present eyeo GmbH
+ *
+ * This module is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import path from "path";
+import fs from "fs";
+
+import got from "got";
+import webdriver from "selenium-webdriver";
+import chrome from "selenium-webdriver/chrome.js";
+import extractZip from "extract-zip";
+
+import {Browser} from "./browser.js";
+import {download, killDriverProcess, getMajorVersion, checkVersion,
+        checkPlatform, errMsg, snapshotsBaseDir, platformArch}
+  from "./utils.js";
+
+/**
+ * Browser and webdriver functionality for Chromium.
+ * @hideconstructor
+ * @extends Browser
+ */
+export class Chromium extends Browser {
+  static #CHANNELS = ["latest", "beta", "dev"];
+  static #MAX_VERSION_DECREMENTS = 200;
+
+  static async #getVersionForChannel(channel) {
+    if (!Chromium.#CHANNELS.includes(channel))
+      return channel;
+
+    if (channel == "latest")
+      channel = "stable";
+
+    let os = {
+      "win32-ia32": "win",
+      "win32-x64": "win64",
+      "linux-x64": "linux",
+      "darwin-x64": "mac",
+      "darwin-arm64": "mac_arm64"
+    }[platformArch];
+    let url = `https://versionhistory.googleapis.com/v1/chrome/platforms/${os}/channels/${channel}/versions/all/releases`;
+
+    let data;
+    try {
+      data = await got(url).json();
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
+    }
+    let version;
+    let fraction;
+    for ({version, fraction} of data.releases) {
+      // Versions having small fractions may not appear on Chromium Dash
+      if (fraction > 0.0025)
+        break;
+    }
+
+    return version;
+  }
+
+  static #getBinaryPath(dir) {
+    checkPlatform();
+    return {
+      win32: path.join(dir, "chrome-win", "chrome.exe"),
+      linux: path.join(dir, "chrome-linux", "chrome"),
+      darwin: path.join(dir, "chrome-mac", "Chromium.app", "Contents", "MacOS",
+                        "Chromium")
+    }[process.platform];
+  }
+
+  static async #getBase(chromiumVersion) {
+    let url;
+    let chromiumBase;
+    try {
+      // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/55
+      if (getMajorVersion(chromiumVersion) < 91) {
+        url = `https://omahaproxy.appspot.com/deps.json?version=${chromiumVersion}`;
+        ({chromium_base_position: chromiumBase} = await got(url).json());
+      }
+      else {
+        url = `https://chromiumdash.appspot.com/fetch_version?version=${chromiumVersion}`;
+        ({chromium_main_branch_position: chromiumBase} = await got(url).json());
+      }
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
+    }
+    return parseInt(chromiumBase, 10);
+  }
+
+  static async #getInstalledBrowserInfo(binary) {
+    let installedVersion = await Chromium.getInstalledVersion(binary);
+    // Linux example: "Chromium 112.0.5615.49 built on Debian 11.6"
+    // Windows example: "114.0.5735.0"
+    let versionNumber = installedVersion.split(" ")[1] || installedVersion;
+    let base = await Chromium.#getBase(versionNumber);
+    return {binary, versionNumber, base};
+  }
+
+  /**
+   * Installs the browser. The Chromium executable gets extracted in the
+   *   {@link snapshotsBaseDir} folder, ready to go.
+   * @param {string} [version=latest] Either "latest", "beta", "dev" or a full
+   *   version number (i.e. "77.0.3865.0").
+   * @param {number} [downloadTimeout=0] Allowed time in ms for the download of
+   *   install files to complete. When set to 0 there is no time limit.
+   * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version = "latest", downloadTimeout = 0) {
+    const MIN_VERSION = process.arch == "arm64" ? 92 : 77;
+
+    let binary;
+    let versionNumber;
+    let base;
+
+    // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/46
+    if (platformArch == "linux-arm64")
+      return await Chromium.#getInstalledBrowserInfo("/usr/bin/chromium");
+
+    checkVersion(version, MIN_VERSION, Chromium.#CHANNELS);
+    versionNumber = await Chromium.#getVersionForChannel(version);
+
+    base = await Chromium.#getBase(versionNumber);
+    let startBase = base;
+    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"],
+      "darwin-arm64": ["Mac_Arm", "chrome-mac.zip"]
+    }[platformArch];
+    let archive;
+    let browserDir;
+    let snapshotsDir = path.join(snapshotsBaseDir, "chromium");
+
+    while (true) {
+      browserDir = path.join(snapshotsDir, `chromium-${platformArch}-${base}`);
+      binary = Chromium.#getBinaryPath(browserDir);
+
+      try {
+        await fs.promises.access(browserDir);
+        return {binary, versionNumber, base};
+      }
+      catch (e) {}
+
+      await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
+
+      archive = path.join(snapshotsDir, "cache", `${base}-${fileName}`);
+      let url = `https://www.googleapis.com/download/storage/v1/b/chromium-browser-snapshots/o/${platformDir}%2F${base}%2F${fileName}?alt=media`;
+      try {
+        try {
+          await fs.promises.access(archive);
+        }
+        catch (e) {
+          await download(url, archive, downloadTimeout);
+        }
+        break;
+      }
+      catch (err) {
+        if (err.name == "HTTPError") {
+          // Chromium advises decrementing the branch_base_position when no
+          // matching build was found. See https://www.chromium.org/getting-involved/download-chromium
+          base--;
+          if (base <= startBase - Chromium.#MAX_VERSION_DECREMENTS)
+            throw new Error(`${errMsg.browserDownload}: Chromium base ${startBase}`);
+        }
+        else {
+          throw new Error(`${errMsg.browserDownload}: ${url}\n${err}`);
+        }
+      }
+    }
+    await extractZip(archive, {dir: browserDir});
+
+    return {binary, versionNumber, base};
+  }
+
+  static async #installDriver(startBase) {
+    let [dir, zip, driverBinary] = {
+      "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"],
+      "linux-arm64": ["", "", "chromedriver"],
+      "darwin-x64": ["Mac", "chromedriver_mac64.zip", "chromedriver"],
+      "darwin-arm64": ["Mac_Arm", "chromedriver_mac64.zip", "chromedriver"]
+    }[platformArch];
+
+    let cacheDir = path.join(snapshotsBaseDir, "chromium", "cache",
+                             "chromedriver");
+    let archive = path.join(cacheDir, `${startBase}-${zip}`);
+    try {
+      await fs.promises.access(archive);
+      await extractZip(archive, {dir: cacheDir});
+    }
+    catch (e) { // zip file is either not cached or corrupted
+      if (platformArch == "linux-arm64") {
+        // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/46
+        // It's unclear how electron releases match Chromium versions. Once that
+        // is figured out, the link below will depend on the Chromium version.
+        // https://stackoverflow.com/questions/38732822/compile-chromedriver-on-arm
+        let url = "https://github.com/electron/electron/releases/download/v26.2.0/chromedriver-v26.2.0-linux-arm64.zip";
+        try {
+          await download(url, archive);
+        }
+        catch (err) {
+          throw new Error(`${errMsg.driverDownload}: ${url}\n${err}`);
+        }
+      }
+      else {
+        let base = startBase;
+        while (true) {
+          let url = `https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${base}/${zip}`;
+          try {
+            await download(url, archive);
+            break;
+          }
+          catch (err) {
+            if (err.name == "HTTPError") {
+              base--;
+              archive = path.join(cacheDir, `${base}-${zip}`);
+              if (base <= startBase - Chromium.#MAX_VERSION_DECREMENTS)
+                throw new Error(`${errMsg.driverDownload}: Chromium base ${startBase}`);
+            }
+            else {
+              throw new Error(`${errMsg.driverDownload}: ${url}\n${err}`);
+            }
+          }
+        }
+      }
+      await extractZip(archive, {dir: cacheDir});
+    }
+
+    await killDriverProcess("chromedriver");
+    let driverPath = path.join(cacheDir, zip.split(".")[0], driverBinary);
+    if (platformArch == "linux-arm64")
+      driverPath = path.join(cacheDir, driverBinary);
+    await fs.promises.rm(driverPath, {force: true});
+    await extractZip(archive, {dir: cacheDir});
+
+    return driverPath;
+  }
+
+  /** @see Browser.getDriver */
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = [], customBrowserBinary
+  } = {}, downloadTimeout = 0) {
+    let {binary, versionNumber, base} = customBrowserBinary ?
+      await Chromium.#getInstalledBrowserInfo(customBrowserBinary) :
+      await Chromium.installBrowser(version, downloadTimeout);
+    let driverPath = await Chromium.#installDriver(base);
+    let serviceBuilder = new chrome.ServiceBuilder(driverPath);
+    let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
+    if (extensionPaths.length > 0)
+      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
+    if (headless) {
+      // New headless mode introduced in Chrome 111
+      // https://developer.chrome.com/articles/new-headless/
+      if (getMajorVersion(versionNumber) >= 111)
+        options.addArguments("headless=new");
+      else
+        options.headless();
+    }
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
+    if (incognito)
+      options.addArguments("incognito");
+    options.setChromeBinaryPath(binary);
+
+    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) {
+    let handle = await driver.getWindowHandle();
+
+    let version = getMajorVersion(
+      (await driver.getCapabilities()).getBrowserVersion());
+    if (version >= 115)
+      // On Chromium 115 opening chrome://extensions on the default tab causes
+      // WebDriverError: disconnected. Switching to a new window as a workaround
+      await driver.switchTo().newWindow("window");
+
+    await driver.navigate().to("chrome://extensions");
+    await driver.executeScript((...args) => {
+      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 != args[0])
+            continue;
+
+          extensionDetails = shadowRoot.getElementById("detailsButton");
+          break;
+        }
+        if (!extensionDetails)
+          reject(`${args[1]}: ${args[0]}`);
+
+        extensionDetails.click();
+        setTimeout(() => resolve(enable()), 100);
+      });
+    }, extensionTitle, errMsg.extensionNotFound);
+    if (version >= 115)
+      // Closing the previously opened new window
+      await driver.close();
+
+    await driver.switchTo().window(handle);
+  }
+}

package/src/edge.js

@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2006-present eyeo GmbH
+ *
+ * This module is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import path from "path";
+import {exec} from "child_process";
+import {promisify} from "util";
+import fs from "fs";
+
+import got from "got";
+import webdriver from "selenium-webdriver";
+import edge from "selenium-webdriver/edge.js";
+import extractZip from "extract-zip";
+
+import {Browser} from "./browser.js";
+import {download, killDriverProcess, wait, getMajorVersion, checkVersion,
+        checkPlatform, errMsg, snapshotsBaseDir, platformArch}
+  from "./utils.js";
+
+let {By} = webdriver;
+let {platform} = process;
+
+/**
+ * Browser and webdriver functionality for Edge.
+ * @hideconstructor
+ * @extends Browser
+ */
+export class Edge extends Browser {
+  static #CHANNELS = ["latest", "beta", "dev"];
+
+  static async #getVersionForChannel(version) {
+    let channel = "stable";
+    if (Edge.#CHANNELS.includes(version) && version != "latest")
+      channel = version;
+
+    let url = `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/`;
+    let body;
+    try {
+      ({body} = await got(url));
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
+    }
+    let versionNumber;
+    if (Edge.#CHANNELS.includes(version)) {
+      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) =>
+        getMajorVersion(v1) < getMajorVersion(v2) ? 1 : -1;
+      versionNumber = versionNumbers.sort(compareVersions)[0];
+    }
+    else {
+      let split = version.split(".");
+      let minorVersion = split.length == 4 ? parseInt(split.pop(), 10) : -1;
+      let majorVersion = split.join(".");
+      let found;
+      while (!found && minorVersion >= 0) {
+        versionNumber = `${majorVersion}.${minorVersion}`;
+        found = body.includes(versionNumber);
+        minorVersion--;
+      }
+      if (!found)
+        throw new Error(`${errMsg.unsupportedVersion}: ${version}`);
+    }
+
+    return {versionNumber, channel};
+  }
+
+  static #darwinApp = "Microsoft Edge";
+
+  static #getBinaryPath(channel = "stable") {
+    switch (platform) {
+      case "win32":
+        let programFiles = process.env["ProgramFiles(x86)"] ?
+          "${Env:ProgramFiles(x86)}" : "${Env:ProgramFiles}";
+        return `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe`;
+      case "linux":
+        return channel == "stable" ?
+          "microsoft-edge" : `microsoft-edge-${channel}`;
+      case "darwin":
+        return `${process.env.HOME}/Applications/${Edge.#darwinApp}.app/Contents/MacOS/${Edge.#darwinApp}`;
+      default:
+        checkPlatform();
+    }
+  }
+
+  /**
+   * Installs the browser. On Linux, Edge is installed as a system package,
+   *   which requires root permissions. On MacOS, Edge is installed as a user
+   *   app (not as a system app). Installing Edge on Windows is not supported.
+   * @param {string} [version=latest] Either "latest", "beta", "dev" or a full
+   *   version number (i.e. "95.0.1020.40").
+   * @param {number} [downloadTimeout=0] Allowed time in ms for the download of
+   *   install files to complete. When set to 0 there is no time limit.
+   * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version = "latest", downloadTimeout = 0) {
+    if (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(`${errMsg.unsupportedPlatform}: ${platform}`);
+
+    if (platform == "darwin" && version != "latest")
+      // Only latest Edge is supported on macOS
+      throw new Error(`${errMsg.unsupportedVersion}: ${version}. Only "latest" is supported`);
+
+    const MIN_VERSION = 95;
+    checkVersion(version, MIN_VERSION, Edge.#CHANNELS);
+    let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
+
+    let filename = {
+      linux: `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`,
+      darwin: `MicrosoftEdge-${versionNumber}.pkg`
+    }[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) {}
+
+    let url = `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`;
+    try {
+      if (platform == "darwin") {
+        let caskUrl = "https://formulae.brew.sh/api/cask/microsoft-edge.json";
+        let caskJson;
+        try {
+          caskJson = await got(caskUrl).json();
+        }
+        catch (err) {
+          throw new Error(`${errMsg.browserVersionCheck}: ${caskUrl}\n${err}`);
+        }
+        ({url} = process.arch == "arm64" ?
+          caskJson.variations.arm64_ventura : caskJson);
+      }
+      await download(url, archive, downloadTimeout);
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserDownload}: ${url}\n${err}`);
+    }
+
+    if (platform == "linux") {
+      await promisify(exec)(`dpkg -i ${archive}`);
+    }
+    else if (platform == "darwin") {
+      await fs.promises.rm(`${process.env.HOME}/Applications/${Edge.#darwinApp}.app`, {force: true, recursive: true});
+      await promisify(exec)(`installer -pkg ${archive} -target CurrentUserHomeDirectory`);
+    }
+
+    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(binary) {
+    async function extractEdgeZip(archive, cacheDir, driverPath) {
+      await killDriverProcess("msedgedriver");
+      await fs.promises.rm(driverPath, {force: true});
+      await extractZip(archive, {dir: cacheDir});
+    }
+
+    let binaryPath = binary || Edge.#getBinaryPath();
+    let versionNumber = await Edge.#getInstalledVersionNumber(binaryPath);
+    let [zip, driverBinary] = {
+      "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_mac64_m1.zip", "msedgedriver"]
+    }[platformArch];
+    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache",
+                             `edgedriver-${versionNumber}`);
+    let archive = path.join(cacheDir, `${versionNumber}-${zip}`);
+    let driverPath = path.join(cacheDir, driverBinary);
+
+    try {
+      await fs.promises.access(archive);
+      await extractEdgeZip(archive, cacheDir, driverPath);
+    }
+    catch (e) { // zip file is either not cached or corrupted
+      let vSplit = versionNumber.split(".");
+      let lastNum = parseInt(vSplit[3], 10);
+      while (lastNum >= 0) {
+        try {
+          let attempt = `${vSplit[0]}.${vSplit[1]}.${vSplit[2]}.${lastNum}`;
+          await download(`https://msedgedriver.azureedge.net/${attempt}/${zip}`,
+                         archive);
+          break;
+        }
+        catch (e2) {
+          lastNum--;
+        }
+      }
+      if (lastNum < 0)
+        throw new Error(`${errMsg.driverDownload}: Edge ${versionNumber}`);
+
+      await extractEdgeZip(archive, cacheDir, driverPath);
+    }
+    return driverPath;
+  }
+
+  /** @see Browser.getDriver */
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = [], customBrowserBinary
+  } = {}, downloadTimeout = 0) {
+    let binary;
+    let versionNumber;
+    if (!customBrowserBinary && (platform == "linux" || platform == "darwin")) {
+      ({binary, versionNumber} =
+        await Edge.installBrowser(version, downloadTimeout));
+    }
+    else {
+      binary = customBrowserBinary || Edge.#getBinaryPath();
+      versionNumber =
+        await Edge.#getInstalledVersionNumber(binary);
+    }
+
+    let driverPath = await Edge.#installDriver(binary);
+    let serviceBuilder = new edge.ServiceBuilder(driverPath);
+
+    let options = new edge.Options().addArguments("no-sandbox", ...extraArgs);
+    if (headless) {
+      if (versionNumber && getMajorVersion(versionNumber) >= 114)
+        options.addArguments("headless=new");
+      else
+        options.headless();
+    }
+    if (extensionPaths.length > 0)
+      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
+    if (incognito)
+      options.addArguments("inprivate");
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
+    if (platform == "linux")
+      options.setEdgeChromiumBinaryPath(`/usr/bin/${binary}`);
+
+    let builder = new webdriver.Builder();
+    builder.forBrowser("MicrosoftEdge");
+    builder.setEdgeOptions(options);
+    builder.setEdgeService(serviceBuilder);
+
+    let driver;
+    // On Windows CI, occasionally a SessionNotCreatedError is thrown, likely
+    // due to low OS resources, that's why building the driver is retried
+    await wait(async() => {
+      try {
+        driver = await builder.build();
+        return true;
+      }
+      catch (err) {
+        if (err.name != "SessionNotCreatedError")
+          throw err;
+        await killDriverProcess("msedgedriver");
+      }
+    }, 30000, `${errMsg.driverStart}: msedgedriver`, 1000);
+
+    return driver;
+  }
+
+  /** @see Browser.enableExtensionInIncognito */
+  static async enableExtensionInIncognito(driver, extensionTitle) {
+    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(`${errMsg.elemNotFound}: Details button`);
+    }
+    throw new Error(`${errMsg.extensionNotFound}: ${extensionTitle}`);
+  }
+}