webdriver-installer 1.0.0

package/LICENSE

@@ -0,0 +1,227 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+-----
+
+Contains code from https://github.com/mozilla/language-mapping-list
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Ali Al Dallal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# WebDriver Installer for NodeJS
+
+Install the right WebDriver version for your local browsers, automatically.
+
+This tool will check the versions of your local browsers, determine the correct
+version of each corresponding WebDriver binary, and download and install the
+driver binaries automatically.
+
+It can be run as a command-line tool, or as a Node module.
+
+
+## Installation
+
+To install the tool globally for CLI usage:
+
+```sh
+npm install -g webdriver-installer
+```
+
+
+## CLI Usage
+
+Here's an example of CLI usage:
+
+```sh
+webdriver-installer /path/to/webdriver-binaries/
+```
+
+
+## Module Usage
+
+```js
+const {installWebDrivers} = require('webdriver-installer');
+
+async function foo() {
+  const withLogging = true;
+  await installWebDrivers('/path/to/webdriver-binaries/', withLogging);
+}
+```

package/base.js

@@ -0,0 +1,60 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Throw an error if the subclass doesn't override an abstract method.
+ */
+function unimplemented(object, callee) {
+  throw new Error(
+      `Unimplemented: ${callee.name} in ${object.constructor.name}`);
+}
+
+/**
+ * An abstract base class for WebDriver installers.
+ */
+class WebDriverInstallerBase {
+  /** @return {string} */
+  getBrowserName() {
+    unimplemented(this, arguments.callee);
+  }
+
+  /** @return {string} */
+  getDriverName() {
+    unimplemented(this, arguments.callee);
+  }
+
+  /** @return {!Promise<?string>} */
+  async getInstalledBrowserVersion() {
+    unimplemented(this, arguments.callee);
+  }
+
+  /**
+   * @param {string} outputDirectory
+   * @return {!Promise<?string>}
+   */
+  async getInstalledDriverVersion(outputDirectory) {
+    unimplemented(this, arguments.callee);
+  }
+
+  /**
+   * @param {string} browserVersion
+   * @return {!Promise<string>}
+   */
+  async getBestDriverVersion(browserVersion) {
+    unimplemented(this, arguments.callee);
+  }
+
+  /**
+   * @param {string} driverVersion
+   * @param {string} outputDirectory
+   * @return {!Promise}
+   */
+  async install(driverVersion, outputDirectory) {
+    unimplemented(this, arguments.callee);
+  }
+}
+
+module.exports = {WebDriverInstallerBase};

package/chrome-android.js

@@ -0,0 +1,30 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {ChromeWebDriverInstaller} = require('./chrome.js');
+const {InstallerUtils} = require('./utils.js');
+
+/**
+ * An installer for chromedriver for Chrome on Android.
+ */
+class ChromeAndroidWebDriverInstaller extends ChromeWebDriverInstaller {
+  /** @return {string} */
+  getBrowserName() {
+    return 'Chrome on Android';
+  }
+
+  /** @return {string} */
+  getDriverName() {
+    return 'chromedriver-android';
+  }
+
+  /** @return {!Promise<?string>} */
+  async getInstalledBrowserVersion() {
+    return await InstallerUtils.getAndroidAppVersion('com.android.chrome');
+  }
+}
+
+module.exports = {ChromeAndroidWebDriverInstaller};

package/chrome.js

@@ -0,0 +1,111 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {WebDriverInstallerBase} = require('./base.js');
+const {InstallerUtils} = require('./utils.js');
+
+const os = require('os');
+const path = require('path');
+
+const CDN_URL = 'https://chromedriver.storage.googleapis.com';
+
+/**
+ * An installer for chromedriver for desktop Chrome.
+ */
+class ChromeWebDriverInstaller extends WebDriverInstallerBase {
+  /** @return {string} */
+  getBrowserName() {
+    return 'Chrome';
+  }
+
+  /** @return {string} */
+  getDriverName() {
+    return 'chromedriver';
+  }
+
+  /** @return {!Promise<?string>} */
+  async getInstalledBrowserVersion() {
+    if (os.platform() == 'linux') {
+      const output = await InstallerUtils.getCommandOutputOrNullIfMissing(
+          ['google-chrome', '--version']);
+      // Output is a string like "Google Chrome 96.0.4664.110\n"
+      return output ? output.trim().split(' ')[2] : null;
+    } else if (os.platform() == 'darwin') {
+      return await InstallerUtils.getMacAppVersion('Google Chrome');
+    } else if (os.platform() == 'win32') {
+      return await InstallerUtils.getWindowsRegistryVersion(
+          'HKEY_CURRENT_USER\\Software\\Google\\Chrome\\BLBeacon',
+          'version');
+    } else {
+      throw new Error(`Unrecognized platform: ${os.platform()}`);
+    }
+  }
+
+  /**
+   * @param {string} outputDirectory
+   * @return {!Promise<?string>}
+   */
+  async getInstalledDriverVersion(outputDirectory) {
+    // NOTE: Using path.join here would also normalize the path, which would
+    // turn something like "./chromedriver" into "chromedriver", which would
+    // fail to execute.
+    const outputPath = outputDirectory + path.sep + this.getDriverName();
+
+    const output = await InstallerUtils.getCommandOutputOrNullIfMissing(
+        [outputPath, '--version']);
+    // Output is a string like "ChromeDriver 98.0.4758.48 (gitref)\n"
+    return output ? output.trim().split(' ')[1] : null;
+  }
+
+  /**
+   * @param {string} browserVersion
+   * @return {!Promise<string>}
+   */
+  async getBestDriverVersion(browserVersion) {
+    const majorVersion = browserVersion.split('.')[0];
+    const versionUrl = `${CDN_URL}/LATEST_RELEASE_${majorVersion}`;
+    return await InstallerUtils.fetchVersionUrl(versionUrl);
+  }
+
+  /**
+   * @param {string} driverVersion
+   * @param {string} outputDirectory
+   * @param {string=} outputName
+   * @return {!Promise}
+   */
+  async install(driverVersion, outputDirectory) {
+    let platform;
+
+    if (os.platform() == 'linux') {
+      platform = 'linux64';
+    } else if (os.platform() == 'darwin') {
+      platform = 'mac64';
+    } else if (os.platform() == 'win32') {
+      platform = 'win32';
+    } else {
+      throw new Error(`Unrecognized platform: ${os.platform()}`);
+    }
+
+    const archiveUrl =
+        `${CDN_URL}/${driverVersion}/chromedriver_${platform}.zip`;
+
+    let binaryName = 'chromedriver';
+    if (os.platform() == 'win32') {
+      binaryName += '.exe';
+    }
+
+    let outputName = this.getDriverName();
+    if (os.platform() == 'win32') {
+      outputName += '.exe';
+    }
+
+    return await InstallerUtils.installBinary(
+        archiveUrl, binaryName, outputName,
+        outputDirectory, /* isZip= */ true);
+  }
+}
+
+module.exports = {ChromeWebDriverInstaller};

package/edge.js

@@ -0,0 +1,77 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {WebDriverInstallerBase} = require('./base.js');
+const {InstallerUtils} = require('./utils.js');
+
+const os = require('os');
+const path = require('path');
+
+const CDN_URL = 'https://msedgedriver.azureedge.net/';
+
+/**
+ * An installer for msedgedriver for desktop Edge.
+ */
+class EdgeWebDriverInstaller extends WebDriverInstallerBase {
+  /** @return {string} */
+  getBrowserName() {
+    return 'Edge';
+  }
+
+  /** @return {string} */
+  getDriverName() {
+    return 'msedgedriver';
+  }
+
+  /** @return {!Promise<?string>} */
+  async getInstalledBrowserVersion() {
+    return await InstallerUtils.getWindowsExeVersion(
+        'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe');
+  }
+
+  /**
+   * @param {string} outputDirectory
+   * @return {!Promise<?string>}
+   */
+  async getInstalledDriverVersion(outputDirectory) {
+    // NOTE: Using path.join here would also normalize the path, which would
+    // turn something like "./msedgedriver" into "msedgedriver", which would
+    // fail to execute.
+    const outputPath = outputDirectory + path.sep + this.getDriverName();
+
+    const output = await InstallerUtils.getCommandOutputOrNullIfMissing(
+        [outputPath, '--version']);
+    // Output is a string like "MSEdgeDriver 96.0.1054.62 (sha1)\n"
+    return output ? output.trim().split(' ')[1] : null;
+  }
+
+  /**
+   * @param {string} browserVersion
+   * @return {!Promise<string>}
+   */
+  async getBestDriverVersion(browserVersion) {
+    const majorVersion = browserVersion.split('.')[0];
+    const versionUrl = `${CDN_URL}/LATEST_RELEASE_${majorVersion}`;
+    return await InstallerUtils.fetchVersionUrl(versionUrl, 'UTF-16LE');
+  }
+
+  /**
+   * @param {string} driverVersion
+   * @param {string} outputDirectory
+   * @param {string=} outputName
+   * @return {!Promise}
+   */
+  async install(driverVersion, outputDirectory) {
+    const archiveUrl = `${CDN_URL}/${driverVersion}/edgedriver_win64.zip`;
+    const binaryName = 'msedgedriver.exe';
+    const outputName = this.getDriverName() + '.exe';
+    return await InstallerUtils.installBinary(
+        archiveUrl, binaryName, outputName,
+        outputDirectory, /* isZip= */ true);
+  }
+}
+
+module.exports = {EdgeWebDriverInstaller};

package/firefox.js

@@ -0,0 +1,124 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {WebDriverInstallerBase} = require('./base.js');
+const {InstallerUtils} = require('./utils.js');
+
+const os = require('os');
+const path = require('path');
+
+/**
+ * An installer for chromedriver for desktop Firefox.
+ */
+class FirefoxWebDriverInstaller extends WebDriverInstallerBase {
+  /** @return {string} */
+  getBrowserName() {
+    return 'Firefox';
+  }
+
+  /** @return {string} */
+  getDriverName() {
+    return 'geckodriver';
+  }
+
+  /** @return {!Promise<?string>} */
+  async getInstalledBrowserVersion() {
+    if (os.platform() == 'linux') {
+      const output = await InstallerUtils.getCommandOutputOrNullIfMissing(
+          ['firefox', '-v']);
+      // Output is a string like "Mozilla Firefox 96.0"
+      return output ? output.trim().split(' ')[2] : null;
+    } else if (os.platform() == 'darwin') {
+      return await InstallerUtils.getMacAppVersion('Firefox');
+    } else if (os.platform() == 'win32') {
+      return await InstallerUtils.getWindowsRegistryVersion(
+          'HKLM\\SOFTWARE\\Mozilla\\Mozilla Firefox',
+          'CurrentVersion')
+    } else {
+      throw new Error(`Unrecognized platform: ${os.platform()}`);
+    }
+  }
+
+  /**
+   * @param {string} outputDirectory
+   * @return {!Promise<?string>}
+   */
+  async getInstalledDriverVersion(outputDirectory) {
+    // NOTE: Using path.join here would also normalize the path, which would
+    // turn something like "./geckodriver" into "geckodriver", which would
+    // fail to execute.
+    const outputPath = outputDirectory + path.sep + this.getDriverName();
+
+    const output = await InstallerUtils.getCommandOutputOrNullIfMissing(
+        [outputPath, '--version']);
+    // Output is a string like "geckodriver 0.30.0 (sha1 date)\n"
+    return output ? output.trim().split(' ')[1] : null;
+  }
+
+  /**
+   * @param {string} browserVersion
+   * @return {!Promise<string>}
+   */
+  async getBestDriverVersion(browserVersion) {
+    // NOTE: geckodriver is currently independent of Firefox versions.
+    const tag =
+        await InstallerUtils.fetchLatestGitHubTag('mozilla/geckodriver');
+    // NOTE: tags start with "v", but the version number reported by the binary
+    // does not.  So that they can be directly compared, strip the "v" from the
+    // tag.
+    console.assert(tag[0] == 'v');
+    return tag.substr(1);
+  }
+
+  /**
+   * @param {string} driverVersion
+   * @param {string} outputDirectory
+   * @param {string=} outputName
+   * @return {!Promise}
+   */
+  async install(driverVersion, outputDirectory) {
+    let platform;
+    let extension;
+    let isZip;
+
+    if (os.platform() == 'linux') {
+      platform = 'linux64';
+      extension = 'tar.gz';
+      isZip = false;
+    } else if (os.platform() == 'darwin') {
+      platform = 'macos';
+      extension = 'tar.gz';
+      isZip = false;
+    } else if (os.platform() == 'win32') {
+      platform = 'win64';
+      extension = 'zip';
+      isZip = true;
+    } else {
+      throw new Error(`Unrecognized platform: ${os.platform()}`);
+    }
+
+    const archiveUrl =
+        'https://github.com/mozilla/geckodriver/releases/download' +
+        `/v${driverVersion}` +
+        `/geckodriver-v${driverVersion}-${platform}.${extension}`;
+
+    let binaryName = 'geckodriver';
+    if (os.platform() == 'win32') {
+      binaryName += '.exe';
+    }
+
+    let outputName = this.getDriverName();
+    if (os.platform() == 'win32') {
+      outputName += '.exe';
+    }
+
+    return await InstallerUtils.installBinary(
+        archiveUrl, binaryName, outputName,
+        outputDirectory, isZip);
+  }
+}
+
+module.exports = {FirefoxWebDriverInstaller};

package/main.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {ChromeWebDriverInstaller} = require('./chrome.js');
+const {ChromeAndroidWebDriverInstaller} = require('./chrome-android.js');
+const {FirefoxWebDriverInstaller} = require('./firefox.js');
+const {EdgeWebDriverInstaller} = require('./edge.js');
+
+const INSTALLER_CLASSES = [
+  ChromeWebDriverInstaller,
+  ChromeAndroidWebDriverInstaller,
+  FirefoxWebDriverInstaller,
+  EdgeWebDriverInstaller,
+];
+
+/**
+ * Install drivers to match all detected browsers.
+ *
+ * @param {string=} outputDirectory  Defaults to ./
+ * @param {boolean=} logging
+ * @return {!Promise}
+ */
+async function main(outputDirectory='.', logging=true) {
+  if (logging) {
+    console.log(`Installing binaries to ${outputDirectory}`);
+  }
+
+  for (const InstallerClass of INSTALLER_CLASSES) {
+    const installer = new InstallerClass();
+    const browserName = installer.getBrowserName();
+    const driverName = installer.getDriverName();
+    const browserVersion = await installer.getInstalledBrowserVersion();
+
+    if (browserVersion == null) {
+      if (logging) {
+        console.log(`${browserName} not found.`);
+      }
+    } else {
+      const installedDriverVersion =
+          await installer.getInstalledDriverVersion(outputDirectory);
+      const bestDriverVersion =
+          await installer.getBestDriverVersion(browserVersion);
+
+      if (installedDriverVersion == bestDriverVersion) {
+        if (logging) {
+          console.log(
+              `Version ${installedDriverVersion} of ${driverName} already` +
+              ` installed for ${browserName} version ${browserVersion}`);
+        }
+      } else {
+        await installer.install(bestDriverVersion, outputDirectory);
+        if (logging) {
+          console.log(
+              `Installed version ${bestDriverVersion} of ${driverName}` +
+              ` for ${browserName} version ${browserVersion}`);
+        }
+      }
+    }
+  }
+}
+
+if (require.main == module) {
+  // Skip argv[0], which is node, and argv[1], which is this script name.
+  const args = process.argv.slice(2);
+
+  const HELP_ARGS = ['--help', '-h', '-?'];
+  if (args.length > 1 || HELP_ARGS.includes(args[0])) {
+    process.stderr.write(`Usage: ${process.argv[1]} [OUTPUT_DIR]\n`);
+    process.exit(1);
+  }
+
+  main(args[0]);
+} else {
+  module.exports = {installWebDrivers: main};
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "webdriver-installer",
+  "version": "1.0.0",
+  "description": "Install the right WebDriver version for your local browsers, automatically.",
+  "main": "main.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joeyparrish/webdriver-installer"
+  },
+  "keywords": [
+    "webdriver",
+    "chrome",
+    "firefox",
+    "edge"
+  ],
+  "author": "Joey Parrish <joeyparrish@google.com>",
+  "dependencies": {
+    "node-fetch": "^2.6.7",
+    "tar-stream": "^2.2.0",
+    "yauzl": "^2.10.0"
+  },
+  "license": "Apache-2.0"
+}

package/utils.js

@@ -0,0 +1,360 @@
+/*! @license
+ * WebDriver Installer
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const childProcess = require('child_process');
+const fetch = require('node-fetch');
+const fs = require('fs');
+const fsPromises = require('fs/promises');
+const os = require('os');
+const path = require('path');
+const stream = require('stream');
+const tar = require('tar-stream');
+const util = require('util');
+const yauzl = require('yauzl');
+const zlib = require('zlib');
+
+const execFile = util.promisify(childProcess.execFile);
+const pipeline = util.promisify(stream.pipeline);
+const zipFromBuffer = util.promisify(yauzl.fromBuffer);
+
+/**
+ * A static utility class for driver installers to use for common operations.
+ */
+class InstallerUtils {
+  /**
+   * Execute an external command to get a result containing .stdout and .stderr.
+   * All output is interpretted as UTF-8.
+   *
+   * Throws if the command fails.  If the command does not exist, the thrown
+   * error has .code == 'ENOENT'.
+   *
+   * @param {!Array<string>} args
+   * @return {!Promise<!Object>} as returned by child_process.spawn
+   */
+  static async runCommand(args) {
+    return await execFile(args[0], args.slice(1), {encoding: 'utf8'});
+  }
+
+  /**
+   * Execute a command and return its stdout.  If the command is missing,
+   * returns null.  If the command fails, throws.
+   *
+   * @param {!Array<string>} args
+   * @return {!Promise<?string>}
+   */
+  static async getCommandOutputOrNullIfMissing(args) {
+    try {
+      const result = await InstallerUtils.runCommand(args);
+      // Success.  Return command's stdout.
+      return result.stdout;
+    } catch (error) {
+      if (error.code == 'ENOENT') {
+        // Command does not exist.
+        return null;
+      } else {
+        // Command exists, but failed.
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Fetch a URL, throwing if the HTTP status code is not 2XX.
+   *
+   * @param {string} url
+   * @return {!Promise<!Response>}
+   */
+  static async fetchUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+          `Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    return response;
+  }
+
+  /**
+   * Get a version number from the Windows registry.
+   *
+   * @param {string} path
+   * @param {string} key
+   * @return {!Promise<?string>}
+   */
+  static async getWindowsRegistryVersion(path, key) {
+    if (os.platform() != 'win32') {
+      return null;
+    }
+
+    const result = await InstallerUtils.runCommand([
+      'reg', 'query', path, '/v', key,
+    ]);
+
+    // Find the line with the key in it.  For "version", it would look something
+    // like this:
+    //     version    REG_SZ    94.0.4606.61
+    for (const line of result.stdout.split('\n')) {
+      if (line[0] == ' ' && line.includes(key)) {
+        // Find the section that starts with a number.
+        for (const section of line.split(' ')) {
+          if (section[0] >= '0' && section[0] <= '9') {
+            return section;
+          }
+        }
+      }
+    }
+
+    // Not found.
+    return null;
+  }
+
+  /**
+   * Test if a file exists.
+   *
+   * @param {path}
+   * @return {!Promise<boolean}
+   */
+  static async fileExists(path) {
+    try {
+      await fsPromises.stat(path);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get a version number from the metadata of a Windows executable.
+   *
+   * @param {string} path
+   * @return {!Promise<?string>}
+   */
+  static async getWindowsExeVersion(path) {
+    if (os.platform() != 'win32') {
+      return null;
+    }
+
+    if (!(await InstallerUtils.fileExists(path))) {
+      // No such file.  Avoid the need to parse "not found" errors from
+      // powershell output.
+      return null;
+    }
+
+    const result = await InstallerUtils.runCommand([
+      'powershell',
+      `(Get-Item "${path}").VersionInfo.ProductVersion`,
+    ]);
+
+    const output = result.stdout.trim();
+    if (output == '') {
+      // No such metadata found by powershell.
+      return null;
+    }
+
+    return output;
+  }
+
+  /**
+   * Get the version of an installed app on macOS.
+   *
+   * @param {string} appName
+   * @return {!Promise<?string>}
+   */
+  static async getMacAppVersion(appName) {
+    if (os.platform() != 'darwin') {
+      return null;
+    }
+
+    try {
+      const result = await InstallerUtils.runCommand([
+        'osascript', '-e', 
+        `tell application "${appName}" to get version`,
+      ]);
+      return result.stdout.trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get the version of an installed Android app on a connected device.
+   *
+   * @param {string} appReverseDomainName
+   * @return {!Promise<?string>}
+   */
+  static async getAndroidAppVersion(appReverseDomainName) {
+    let result;
+
+    try {
+      result = await InstallerUtils.runCommand([
+        'adb', 'shell', 'dumpsys', `package ${appReverseDomainName}`,
+      ]);
+    } catch (error) {
+      if (error.code == 'ENOENT') {
+        // No adb, so no Android connection.
+        return null;
+      } else if (error.code != 0) {
+        if (error.stderr.includes('no devices')) {
+          // No devices attached.
+          return null;
+        }
+
+        // Otherwise, print the error output and raise an error.
+        process.stderr.write(error.stderr);
+        throw new Error(`Failed to communicate with adb!`);
+      }
+    }
+
+    for (const line of result.stdout.split('\n')) {
+      // Something like:
+      //   versionName=1.2.3
+      if (line.includes('versionName')) {
+        return line.split('=')[1];
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Fetch a version number from a URL.  Both Chrome and Edge use this.
+   *
+   * @param {string} url
+   * @param {string=} encoding
+   * @return {!Promise<?string>}
+   */
+  static async fetchVersionUrl(url, encoding='utf8') {
+    const response = await InstallerUtils.fetchUrl(url);
+    const data = Buffer.from(await response.arrayBuffer());
+    // Decode the string, then remove any newlines.
+    return data.toString(encoding).trim();
+  }
+
+  /**
+   * Fetch the latest tag from a GitHub repo.
+   *
+   * @param {string} repo
+   * @return {?string}
+   */
+  static async fetchLatestGitHubTag(repo) {
+    const url = `https://api.github.com/repos/${repo}/releases/latest`;
+    const response = await InstallerUtils.fetchUrl(url);
+    const releaseMetadata = await response.json();
+    return releaseMetadata['tag_name'];
+  }
+
+  /**
+   * Find a specific entry in a zip file.
+   *
+   * @param {!YauzlZipFile} zipfile
+   * @param {string} nameInArchive
+   * @return {!Promise<!YauzlZipEntry>}
+   */
+  static findZipEntry(zipfile, nameInArchive) {
+    return new Promise((resolve, reject) => {
+      zipfile.on('entry', (entry) => {
+        if (entry.fileName == nameInArchive) {
+          // Found it!
+          resolve(entry);
+        } else {
+          // Read the next one.
+          zipfile.readEntry();
+        }
+      });
+      zipfile.on('end', () => {
+        // Reached the end without finding our target.
+        reject(new Error(`Failed to find ${nameInArchive} in zip file!`));
+      });
+      // Kick-start the reading process.
+      zipfile.readEntry();
+    });
+  }
+
+  /**
+   * Find a specific entry in a tar file.
+   *
+   * @param {!Buffer} buffer
+   * @param {string} nameInArchive
+   * @return {!Promise<!Stream>}
+   */
+  static findTarEntry(buffer, nameInArchive) {
+    return new Promise((resolve, reject) => {
+      const extract = tar.extract();
+
+      extract.on('entry', (entry, stream, next) => {
+        if (entry.name == nameInArchive) {
+          // Found it!
+          resolve(stream);
+        } else {
+          // Drain the stream so that tar parsing can continue.
+          stream.on('end', next);
+          stream.resume();
+        }
+      });
+
+      extract.on('finish', () => {
+        // Reached the end without finding our target.
+        reject(new Error(`Failed to find ${nameInArchive} in tar file!`));
+      });
+
+      // Push the buffer through the decompression and extraction pipeline.
+      const gunzip = zlib.createGunzip();
+      gunzip.pipe(extract);
+      gunzip.end(buffer);
+    });
+  }
+
+  /**
+   * Extract a file from an archive by URL.
+   *
+   * @param {string} url
+   * @param {string} nameInArchive
+   * @param {string} outputPath
+   * @param {boolean} isZip
+   */
+  static async extractFromNetworkArchive(
+      url, nameInArchive, outputPath, isZip) {
+    const response = await InstallerUtils.fetchUrl(url);
+    const buffer = Buffer.from(await response.arrayBuffer());
+
+    // If the output file already exists, remove it before overwriting it.
+    // This is important if it's a running executable.  Otherwise, we might get
+    // permission errors overwriting it.  Unlinking it first will ensure the
+    // newly-written file is a fresh filesystem inode that doesn't conflict
+    // with what's running.
+    if (await InstallerUtils.fileExists(path)) {
+      await fsPromises.unlink(outputPath);
+    }
+
+    if (isZip) {
+      const zipfile = await zipFromBuffer(buffer, {
+        lazyEntries: true,
+      });
+      const entry = await InstallerUtils.findZipEntry(zipfile, nameInArchive);
+      const openReadStream = util.promisify(
+          zipfile.openReadStream.bind(zipfile));
+      await pipeline(
+        await openReadStream(entry),
+        fs.createWriteStream(outputPath),
+      );
+    } else {
+      const stream = await InstallerUtils.findTarEntry(buffer, nameInArchive);
+      await pipeline(
+        stream,
+        fs.createWriteStream(outputPath),
+      );
+    }
+  }
+
+  static async installBinary(
+      url, nameInArchive, outputName, outputDirectory, isZip) {
+    const outputPath = path.join(outputDirectory, outputName);
+    await InstallerUtils.extractFromNetworkArchive(
+        url, nameInArchive, outputPath, isZip);
+    await fsPromises.chmod(outputPath, 0o755);
+  }
+}
+
+module.exports = {InstallerUtils};