chromedriver/install.js

'use strict';
// @ts-check

const fs = require('node:fs');
const helper = require('./lib/chromedriver');
const axios = require('axios').default;
const path = require('node:path');
const child_process = require('node:child_process');
const os = require('node:os');
const { ProxyAgent } = require('proxy-agent');
const { promisify } = require('node:util');
const { finished } = require('node:stream');
const extractZip = require('extract-zip');
const { getChromeVersion } = require('@testim/chrome-version');
const { compareVersions } = require('compare-versions');
const finishedAsync = promisify(finished);
const process = require('node:process');
const console = require('node:console');

class Installer {
  async install() {
    const skipDownload = (process.env.npm_config_chromedriver_skip_download || process.env.CHROMEDRIVER_SKIP_DOWNLOAD) === 'true';
    if (skipDownload) {
      console.log('Found CHROMEDRIVER_SKIP_DOWNLOAD variable, skipping installation.');
      process.exit(0);
    }
    const cdnUrl = (process.env.npm_config_chromedriver_cdnurl || process.env.CHROMEDRIVER_CDNURL || 'https://googlechromelabs.github.io').replace(/\/+$/, '');
    const legacyCdnUrl = (process.env.npm_config_chromedriver_legacy_cdnurl || process.env.CHROMEDRIVER_LEGACY_CDNURL || 'https://chromedriver.storage.googleapis.com').replace(/\/+$/, '');
    let chromedriverVersion = process.env.npm_config_chromedriver_version || process.env.CHROMEDRIVER_VERSION || helper.version;
    const detectChromedriverVersion = (process.env.npm_config_detect_chromedriver_version || process.env.DETECT_CHROMEDRIVER_VERSION) === 'true';
    try {
      if (detectChromedriverVersion) {
        const includeChromium = (process.env.npm_config_include_chromium || process.env.INCLUDE_CHROMIUM) === 'true';
        // Refer http://chromedriver.chromium.org/downloads/version-selection
        const chromeVersion = await getChromeVersion(includeChromium);
        console.log("Your Chrome version is " + chromeVersion);
        const versionMatch = /^(.*?)\.\d+$/.exec(chromeVersion);
        if (versionMatch) {
          chromedriverVersion = await this.getChromeDriverVersion(cdnUrl, legacyCdnUrl, parseInt(versionMatch[1]));
          console.log("Compatible ChromeDriver version is " + chromedriverVersion);
        }
      } else if (chromedriverVersion === 'LATEST') {
        chromedriverVersion = await this.getChromeDriverVersion(cdnUrl, legacyCdnUrl);
      } else {
        const latestReleaseForVersionMatch = chromedriverVersion.match(/LATEST_(\d+)/);
        if (latestReleaseForVersionMatch) {
          chromedriverVersion = await this.getChromeDriverVersion(cdnUrl, legacyCdnUrl, parseInt(latestReleaseForVersionMatch[1]));
        }
      }
      let tmpPath = this.findSuitableTempDirectory(chromedriverVersion);
      const extractDirectory = tmpPath;
      const majorVersion = parseInt(chromedriverVersion.split('.')[0]);
      const useLegacyMethod = majorVersion <= 114;
      const platform = this.getPlatform(chromedriverVersion);
      let downloadedFile = this.getDownloadFilePath(useLegacyMethod, tmpPath, platform);
      if (!useLegacyMethod)
        tmpPath = path.join(tmpPath, path.basename(downloadedFile, path.extname(downloadedFile)));
      const chromedriverBinaryFileName = process.platform === 'win32' ? 'chromedriver.exe' : 'chromedriver';
      const chromedriverBinaryFilePath = path.resolve(tmpPath, chromedriverBinaryFileName);
      const chromedriverIsAvailable = await this.verifyIfChromedriverIsAvailableAndHasCorrectVersion(chromedriverVersion, chromedriverBinaryFilePath);
      if (!chromedriverIsAvailable) {
        console.log('Current existing ChromeDriver binary is unavailable, proceeding with download and extraction.');
        const configuredfilePath = process.env.npm_config_chromedriver_filepath || process.env.CHROMEDRIVER_FILEPATH;
        if (configuredfilePath) {
          console.log('Using file: ', configuredfilePath);
          downloadedFile = configuredfilePath;
        } else {
          if (useLegacyMethod)
            await this.downloadFileLegacy(legacyCdnUrl, downloadedFile, chromedriverVersion);
          else
            await this.downloadFile(cdnUrl, downloadedFile, chromedriverVersion, platform);
        }
        await this.extractDownload(extractDirectory, chromedriverBinaryFilePath, downloadedFile);
      }
      const libPath = path.join(__dirname, 'lib', 'chromedriver');
      await this.copyIntoPlace(tmpPath, libPath);
      this.fixFilePermissions();
      console.log('Done. ChromeDriver binary available at', helper.path);
    } catch (err) {
      console.error('ChromeDriver installation failed', err);
      process.exit(1);
    }
  }

  /**
   * @param {string} chromedriverVersion
   */
  getPlatform(chromedriverVersion) {
    const thePlatform = process.platform;
    if (thePlatform === 'linux') {
      if (process.arch === 'arm64' || process.arch === 's390x' || process.arch === 'x64') {
        return 'linux64';
      } else {
        console.error('Only Linux 64 bits supported.');
        process.exit(1);
      }
    } else if (thePlatform === 'darwin' || thePlatform === 'freebsd') {
      const osxPlatform = this.getMacOsRealArch(chromedriverVersion);

      if (!osxPlatform) {
        console.error('Only Mac 64 bits supported.');
        process.exit(1);
      }

      return osxPlatform;
    } else if (thePlatform === 'win32') {
      if (compareVersions(chromedriverVersion, '115') < 0) {
        return 'win32';
      }
      return (process.arch === 'x64') ? 'win64' : 'win32';
    }
    console.error('Unexpected platform or architecture:', process.platform, process.arch);
    process.exit(1);
  }

  /**
   * @param {string} cdnUrl
   * @param {string} downloadedFile
   * @param {string} chromedriverVersion
   * @param {string} platform
   */
  async downloadFile(cdnUrl, downloadedFile, chromedriverVersion, platform) {
    const cdnBinariesUrl = (process.env.npm_config_chromedriver_cdnbinariesurl || process.env.CHROMEDRIVER_CDNBINARIESURL)?.replace(/\/+$/, '');
    const url = cdnBinariesUrl
      ? `${cdnBinariesUrl}/${chromedriverVersion}/${platform}/${path.basename(downloadedFile)}`
      : await this.getDownloadUrl(cdnUrl, chromedriverVersion, platform);
    if (!url) {
      console.error(`Download url could not be found for version ${chromedriverVersion} and platform '${platform}'`);
      process.exit(1);
    }
    console.log('Downloading from file: ', url);
    await this.requestBinary(this.getRequestOptions(url), downloadedFile);
  }

  /**
   * @param {string} cdnUrl
   * @param {string} downloadedFile
   * @param {string} chromedriverVersion
   */
  async downloadFileLegacy(cdnUrl, downloadedFile, chromedriverVersion) {
    const url = `${cdnUrl}/${chromedriverVersion}/${path.basename(downloadedFile)}`;
    console.log('Downloading from file: ', url);
    await this.requestBinary(this.getRequestOptions(url), downloadedFile);
  }

  /**
   * @param {any} useLegacyPath
   * @param {string} dirToLoadTo
   * @param {string} platform
   */
  getDownloadFilePath(useLegacyPath, dirToLoadTo, platform) {
    const fileName = useLegacyPath ? `chromedriver_${platform}.zip` : `chromedriver-${platform}.zip`;
    const downloadedFile = path.resolve(dirToLoadTo, fileName);
    console.log('Saving to file:', downloadedFile);
    return downloadedFile;
  }

  /**
   * @param {string} chromedriverVersion
   * @param {string} chromedriverBinaryFilePath
   */
  verifyIfChromedriverIsAvailableAndHasCorrectVersion(chromedriverVersion, chromedriverBinaryFilePath) {
    if (!fs.existsSync(chromedriverBinaryFilePath))
      return Promise.resolve(false);
    const forceDownload = process.env.npm_config_chromedriver_force_download === 'true' || process.env.CHROMEDRIVER_FORCE_DOWNLOAD === 'true';
    if (forceDownload)
      return Promise.resolve(false);
    console.log('ChromeDriver binary exists. Validating...');
    const deferred = new Deferred();
    try {
      fs.accessSync(chromedriverBinaryFilePath, fs.constants.X_OK);
      const cp = child_process.spawn(chromedriverBinaryFilePath, ['--version']);
      let str = '';
      cp.stdout.on('data', data => str += data);
      cp.on('error', () => deferred.resolve(false));
      cp.on('close', code => {
        if (code !== 0)
          return deferred.resolve(false);
        const parts = str.split(' ');
        if (parts.length < 3)
          return deferred.resolve(false);
        if (parts[1].startsWith(chromedriverVersion)) {
          console.log(`ChromeDriver is already available at '${chromedriverBinaryFilePath}'.`);
          return deferred.resolve(true);
        }
        deferred.resolve(false);
      });
    }
    catch (error) {
      deferred.resolve(false);
    }
    return deferred.promise;
  }

  /**
   * @param {string} chromedriverVersion
   */
  findSuitableTempDirectory(chromedriverVersion) {
    const now = Date.now();
    const candidateTmpDirs = [
      process.env.npm_config_tmp,
      process.env.XDG_CACHE_HOME,
      // Platform specific default, including TMPDIR/TMP/TEMP env
      os.tmpdir(),
      path.join(process.cwd(), 'tmp')
    ];

    for (const tempDir of candidateTmpDirs) {
      if (!tempDir) continue;
      const namespace = chromedriverVersion;
      const candidatePath = path.join(tempDir, namespace, 'chromedriver');
      try {
        fs.mkdirSync(candidatePath, { recursive: true });
        const testFile = path.join(candidatePath, now + '.tmp');
        fs.writeFileSync(testFile, 'test');
        fs.unlinkSync(testFile);
        return candidatePath;
      } catch (e) {
        console.log(candidatePath, 'is not writable:', e.message);
      }
    }
    console.error('Can not find a writable tmp directory, please report issue on https://github.com/giggio/chromedriver/issues/ with as much information as possible.');
    process.exit(1);
  }

  getRequestOptions(downloadPath) {
    /** @type import('axios').AxiosRequestConfig */
    const options = { url: downloadPath, method: "GET" };
    const urlParts = new URL(downloadPath);
    const isHttps = urlParts.protocol === 'https:';

    if (isHttps) {
      // Use certificate authority settings from npm
      let ca = process.env.npm_config_ca;
      if (ca)
        console.log('Using npmconf ca.');

      if (!ca && process.env.npm_config_cafile) {
        try {
          ca = fs.readFileSync(process.env.npm_config_cafile, { encoding: 'utf8' });
        } catch (e) {
          console.error('Could not read cafile', process.env.npm_config_cafile, e);
        }
        console.log('Using npmconf cafile.');
      }
      options.httpsAgent = new ProxyAgent({
        rejectUnauthorized: !!process.env.npm_config_strict_ssl,
        ca: ca
      });
      options.proxy = false;
    } else {
      const { getProxyForUrl } = require("proxy-from-env");
      const proxyUrl = getProxyForUrl(downloadPath);
      if (proxyUrl) {
        const proxyUrlParts = new URL(proxyUrl);
        if (proxyUrlParts.hostname && proxyUrlParts.protocol)
          options.proxy = {
            host: proxyUrlParts.hostname,
            port: proxyUrlParts.port ? parseInt(proxyUrlParts.port) : 80,
            protocol: proxyUrlParts.protocol
          };
      }
    }

    // Use specific User-Agent
    if (process.env.npm_config_user_agent) {
      options.headers = { 'User-Agent': process.env.npm_config_user_agent };
    }

    return options;
  }

  /**
   * @param {string} cdnUrl
   * @param {string} legacyCdnUrl
   * @param {number} [majorVersion]
   * @returns {Promise<string>}
   */
  async getChromeDriverVersion(cdnUrl, legacyCdnUrl, majorVersion) {
    if (majorVersion == null || majorVersion > 114) {
      console.log('Finding Chromedriver version.');
      let chromedriverVersion;
      if (majorVersion) {
        const requestOptions = this.getRequestOptions(`${cdnUrl}/chrome-for-testing/latest-versions-per-milestone.json`);
        const response = await axios.request(requestOptions);
        chromedriverVersion = response.data?.milestones[majorVersion.toString()]?.version;
      } else {
        const requestOptions = this.getRequestOptions(`${cdnUrl}/chrome-for-testing/last-known-good-versions.json`);
        const response = await axios.request(requestOptions);
        chromedriverVersion = response.data?.channels?.Stable?.version;
      }
      console.log(`Chromedriver version is ${chromedriverVersion}.`);
      return chromedriverVersion;
    } else {
      console.log('Finding Chromedriver version using legacy method.');
      const urlPath = majorVersion ? `LATEST_RELEASE_${majorVersion}` : 'LATEST_RELEASE';
      const requestOptions = this.getRequestOptions(`${legacyCdnUrl}/${urlPath}`);
      const response = await axios.request(requestOptions);
      const chromedriverVersion = response.data.trim();
      console.log(`Chromedriver version is ${chromedriverVersion}.`);
      return chromedriverVersion;
    }
  }

  /**
   * @param {string} cdnUrl
   * @param {string} version
   * @param {string} platform
   * @returns {Promise<[string]>}
   */
  async getDownloadUrl(cdnUrl, version, platform) {
    const getUrlUrl = `${cdnUrl}/chrome-for-testing/${version}.json`;
    const requestOptions = this.getRequestOptions(getUrlUrl);
    const response = await axios.request(requestOptions);
    const url = response.data?.downloads?.chromedriver?.find((/** @type {{ platform: string; }} */ c) => c.platform == platform)?.url;
    return url;
  }

  /**
   *
   * @param {import('axios').AxiosRequestConfig} requestOptions
   * @param {string} filePath
   */
  async requestBinary(requestOptions, filePath) {
    const outFile = fs.createWriteStream(filePath);
    let response;
    try {
      response = await axios.request({ responseType: 'stream', ...requestOptions });
    } catch (error) {
      let errorData = '';
      if (error && error.response) {
        if (error.response.status)
          console.error('Error status code:', error.response.status);
        if (error.response.data) {
          error.response.data.on('data', data => errorData += data.toString('utf8'));
          try {
            await finishedAsync(error.response.data);
          } catch (error) {
            console.error('Error downloading entire response:', error);
          }
        }
      }
      console.error(`Error with http(s) request:\n${error}\nError data:\n${errorData}`);
      process.exit(1);
    }
    let count = 0;
    let notifiedCount = 0;
    response.data.on('data', data => {
      count += data.length;
      if ((count - notifiedCount) > 1024 * 1024) {
        console.log('Received ' + Math.floor(count / 1024) + 'K...');
        notifiedCount = count;
      }
    });
    response.data.on('end', () => console.log('Received ' + Math.floor(count / 1024) + 'K total.'));
    const pipe = response.data.pipe(outFile);
    await new Promise((resolve, reject) => {
      pipe.on('finish', resolve);
      pipe.on('error', reject);
    });
  }

  /**
   * @param {string} dirToExtractTo
   * @param {string} chromedriverBinaryFilePath
   * @param {string} downloadedFile
   */
  async extractDownload(dirToExtractTo, chromedriverBinaryFilePath, downloadedFile) {
    if (path.extname(downloadedFile) !== '.zip') {
      fs.mkdirSync(path.dirname(chromedriverBinaryFilePath), { recursive: true });
      fs.copyFileSync(downloadedFile, chromedriverBinaryFilePath);
      console.log('Skipping zip extraction - binary file found.');
      return;
    }
    console.log(`Extracting zip contents to ${dirToExtractTo}.`);
    try {
      await extractZip(path.resolve(downloadedFile), { dir: dirToExtractTo });
    } catch (error) {
      console.error('Error extracting archive: ' + error);
      process.exit(1);
    }
  }

  /**
   * @param {string} originPath
   * @param {string} targetPath
   */
  async copyIntoPlace(originPath, targetPath) {
    fs.rmSync(targetPath, { recursive: true, force: true });
    console.log(`Copying from ${originPath} to target path ${targetPath}`);
    fs.mkdirSync(targetPath);

    // Look for the extracted directory, so we can rename it.
    const files = fs.readdirSync(originPath, { withFileTypes: true })
      .filter(dirent => dirent.isFile() && dirent.name.startsWith('chromedriver') && !dirent.name.endsWith(".debug") && !dirent.name.endsWith(".zip"))
      .map(dirent => dirent.name);
    const promises = files.map(name => {
      return /** @type {Promise<void>} */(new Promise((resolve) => {
        const file = path.join(originPath, name);
        const reader = fs.createReadStream(file);
        const targetFile = path.join(targetPath, name);
        const writer = fs.createWriteStream(targetFile);
        writer.on("close", () => resolve());
        reader.pipe(writer);
      }));
    });
    await Promise.all(promises);
  }


  fixFilePermissions() {
    // Check that the binary is user-executable and fix it if it isn't (problems with unzip library)
    if (process.platform != 'win32') {
      const stat = fs.statSync(helper.path);
      // 64 == 0100 (no octal literal in strict mode)
      if (!(stat.mode & 64)) {
        console.log('Fixing file permissions.');
        fs.chmodSync(helper.path, '755');
      }
    }
  }

  /**
   * @param {string} chromedriverVersion
   */
  getMacOsRealArch(chromedriverVersion) {
    if (process.arch === 'arm64' || this.isEmulatedRosettaEnvironment()) {
      return compareVersions(chromedriverVersion, '106.0.5249.61') < 0
        ? 'mac64_m1'
        : compareVersions(chromedriverVersion, '115') < 0 ? 'mac_arm64' : 'mac-arm64';
    }

    if (process.arch === 'x64') {
      return compareVersions(chromedriverVersion, '115') < 0 ? 'mac64' : 'mac-x64';
    }

    return null;
  }

  isEmulatedRosettaEnvironment() {
    const archName = child_process.spawnSync('uname', ['-m']).stdout.toString().trim();

    if (archName === 'x86_64') {
      const proc = child_process.spawnSync('sysctl', ['-in', 'sysctl.proc_translated']);

      // When run with `-in`, the return code is 0 even if there is no `sysctl.proc_translated`
      if (proc.status) {
        console.error('Unexpected return code from sysctl: ' + proc.status);
        process.exit(1);
      }

      // If there is no `sysctl.proc_translated` (i.e. not rosetta) then nothing is printed to
      // stdout
      if (!proc.stdout) {
        return false;
      }

      const processTranslated = proc.stdout.toString().trim();

      return processTranslated === '1';
    }

    return false;
  }

}

function Deferred() {
  this.resolve = null;
  this.reject = null;
  this.promise = new Promise(function (resolve, reject) {
    this.resolve = resolve;
    this.reject = reject;
  }.bind(this));
  Object.freeze(this);
}

if (require.main === module)
  new Installer().install();
else if (process.env.NODE_ENV === 'test')
  module.exports = Installer;