@appium/support 2.55.4 → 2.56.0

package/lib/npm.js

@@ -0,0 +1,335 @@
+// @ts-check
+
+import path from 'path';
+import semver from 'semver';
+import { exec } from 'teen_process';
+import { fs } from './fs';
+import * as util from './util';
+import * as system from './system';
+import resolveFrom from 'resolve-from';
+
+
+/**
+ * Relative path to directory containing any Appium internal files
+ * XXX: this is duplicated in `appium/lib/constants.js`.
+ */
+export const CACHE_DIR_RELATIVE_PATH = path.join(
+  'node_modules',
+  '.cache',
+  'appium',
+);
+
+/**
+ * Relative path to lockfile used when installing an extension via `appium`
+ */
+export const INSTALL_LOCKFILE_RELATIVE_PATH = path.join(
+  CACHE_DIR_RELATIVE_PATH,
+  '.install.lock',
+);
+
+/**
+ * Relative path to lockfile used when linking an extension via `appium`
+ */
+export const LINK_LOCKFILE_RELATIVE_PATH = path.join(
+  CACHE_DIR_RELATIVE_PATH,
+  '.link.lock',
+);
+
+/**
+ * XXX: This should probably be a singleton, but it isn't.  Maybe this module should just export functions?
+ */
+export class NPM {
+  /**
+   * Returns path to "install" lockfile
+   * @private
+   * @param {string} cwd
+   */
+  _getInstallLockfilePath (cwd) {
+    return path.join(cwd, INSTALL_LOCKFILE_RELATIVE_PATH);
+  }
+
+  /**
+   * Returns path to "link" lockfile
+   * @private
+   * @param {string} cwd
+   */
+  _getLinkLockfilePath (cwd) {
+    return path.join(cwd, LINK_LOCKFILE_RELATIVE_PATH);
+  }
+
+  /**
+   * Execute `npm` with given args.
+   *
+   * If the process exits with a nonzero code, the contents of `STDOUT` and `STDERR` will be in the
+   * `message` of the {@link TeenProcessExecError} rejected.
+   * @param {string} cmd
+   * @param {string[]} args
+   * @param {ExecOpts} opts
+   * @param {TeenProcessExecOpts} [execOpts]
+   */
+  async exec (cmd, args, opts, execOpts = {}) {
+    let { cwd, json, lockFile } = opts;
+
+    // make sure we perform the current operation in cwd
+    execOpts = {...execOpts, cwd};
+
+    args.unshift(cmd);
+    if (json) {
+      args.push('--json');
+    }
+    const npmCmd = system.isWindows() ? 'npm.cmd' : 'npm';
+    let runner = async () => await exec(npmCmd, args, execOpts);
+    if (lockFile) {
+      const acquireLock = util.getLockFileGuard(lockFile);
+      const _runner = runner;
+      runner = async () => await acquireLock(_runner);
+    }
+
+    let ret;
+    try {
+      const {stdout, stderr, code} = await runner();
+      ret = /** @type {TeenProcessExecResult} */({stdout, stderr, code});
+      // if possible, parse NPM's json output. During NPM install 3rd-party
+      // packages can write to stdout, so sometimes the json output can't be
+      // guaranteed to be parseable
+      try {
+        ret.json = JSON.parse(stdout);
+      } catch (ign) {}
+    } catch (e) {
+      const {stdout = '', stderr = '', code = null} = /** @type {TeenProcessExecError} */(e);
+      const err = new Error(`npm command '${args.join(' ')}' failed with code ${code}.\n\nSTDOUT:\n${stdout.trim()}\n\nSTDERR:\n${stderr.trim()}`);
+      throw err;
+    }
+    return ret;
+  }
+
+  /**
+   * @param {string} cwd
+   * @param {string} pkg
+   */
+  async getLatestVersion (cwd, pkg) {
+    return (await this.exec('view', [pkg, 'dist-tags'], {
+      json: true,
+      cwd
+    })).json?.latest;
+  }
+
+  /**
+   * @param {string} cwd
+   * @param {string} pkg
+   * @param {string} curVersion
+   */
+  async getLatestSafeUpgradeVersion (cwd, pkg, curVersion) {
+    const allVersions = (await this.exec('view', [pkg, 'versions'], {
+      json: true,
+      cwd
+    })).json;
+    return this.getLatestSafeUpgradeFromVersions(curVersion, allVersions);
+  }
+
+  /**
+   * Runs `npm ls`, optionally for a particular package.
+   * @param {string} cwd
+   * @param {string} [pkg]
+   */
+  async list (cwd, pkg) {
+    return (await this.exec('list', pkg ? [pkg] : [], {cwd, json: true})).json;
+  }
+
+  /**
+   * Given a current version and a list of all versions for a package, return the version which is
+   * the highest safely-upgradable version (meaning not crossing any major revision boundaries, and
+   * not including any alpha/beta/rc versions)
+   *
+   * @param {string} curVersion - the current version of a package
+   * @param {Array<string>} allVersions - a list of version strings
+   *
+   * @return {string|null} - the highest safely-upgradable version, or null if there isn't one
+   */
+  getLatestSafeUpgradeFromVersions (curVersion, allVersions) {
+    let safeUpgradeVer = null;
+    const curSemver = semver.parse(curVersion);
+    if (curSemver === null) {
+      throw new Error(`Could not parse current version '${curVersion}'`);
+    }
+    for (const testVer of allVersions) {
+      const testSemver = semver.parse(testVer);
+      if (testSemver === null) {
+        throw new Error(`Could not parse version to test against: '${testVer}'`);
+      }
+      // if the test version is a prerelease, ignore it
+      if (testSemver.prerelease.length > 0) {
+        continue;
+      }
+      // if the current version is later than the test version, skip this test version
+      if (curSemver.compare(testSemver) === 1) {
+        continue;
+      }
+      // if the test version is newer, but crosses a major revision boundary, also skip it
+      if (testSemver.major > curSemver.major) {
+        continue;
+      }
+      // otherwise this version is safe to upgrade to. But there might be multiple ones of this
+      // kind, so keep iterating and keeping the highest
+      if (safeUpgradeVer === null || testSemver.compare(safeUpgradeVer) === 1) {
+        safeUpgradeVer = testSemver;
+      }
+    }
+    if (safeUpgradeVer) {
+      safeUpgradeVer = safeUpgradeVer.format();
+    }
+    return safeUpgradeVer;
+  }
+
+  /**
+   * Installs a package w/ `npm`
+   * @param {string} cwd
+   * @param {string} pkgName
+   * @param {InstallPackageOpts} [opts]
+   * @returns {Promise<import('type-fest').PackageJson>}
+   */
+  async installPackage (cwd, pkgName, {pkgVer} = {}) {
+    // not only this, this directory needs a 'package.json' inside of it, otherwise, if any
+    // directory in the filesystem tree ABOVE cwd happens to have a package.json or a node_modules
+    // dir in it, NPM will install the module up there instead (silly NPM)
+    const dummyPkgJson = path.resolve(cwd, 'package.json');
+    if (!await fs.exists(dummyPkgJson)) {
+      await fs.writeFile(dummyPkgJson, '{}');
+    }
+
+    const res = await this.exec('install', [
+      '--no-save',
+      '--global-style',
+      '--no-package-lock',
+      pkgVer ? `${pkgName}@${pkgVer}` : pkgName
+    ], {
+      cwd,
+      json: true,
+      lockFile: this._getInstallLockfilePath(cwd)
+    });
+
+    if (res.json) {
+      // we parsed a valid json response, so if we got an error here, return that
+      // message straightaway
+      if (res.json.error) {
+        throw new Error(res.json.error);
+      }
+    }
+
+    // Now read package data from the installed package to return, and make sure
+    // everything got installed ok. Remember, pkgName might end up with a / in it due to an npm
+    // org, so if so, that will get correctly exploded into multiple directories, by path.resolve here
+    // (even on Windows!)
+    const pkgJsonPath = resolveFrom(cwd, `${pkgName}/package.json`);
+    try {
+      return require(pkgJsonPath);
+    } catch {
+      throw new Error('The package was not downloaded correctly; its package.json ' +
+                      'did not exist or was unreadable. We looked for it at ' +
+                      pkgJsonPath);
+    }
+  }
+
+  /**
+   * @todo: I think this can be an `install` instead of a `link`.
+   * @param {string} cwd
+   * @param {string} pkgPath
+   */
+  async linkPackage (cwd, pkgPath) {
+    // from the path alone we don't know the npm package name, so we need to
+    // look in package.json
+    let pkgName;
+    try {
+      pkgName = require(path.resolve(pkgPath, 'package.json')).name;
+    } catch {
+      throw new Error('Could not find package.json inside the package path ' +
+                      `provided: ${pkgPath}`);
+    }
+
+    // this is added to handle commands with relative paths
+    // ie: "node . driver install --source=local ../fake-driver"
+    pkgPath = path.resolve(process.cwd(), pkgPath);
+
+    // call link with --no-package-lock to ensure no corruption while installing local packages
+    const args = [
+      '--global-style',
+      '--no-package-lock',
+      pkgPath
+    ];
+    const res = await this.exec('link', args, {cwd, lockFile: this._getLinkLockfilePath(cwd)});
+    if (res.json && res.json.error) {
+      throw new Error(res.json.error);
+    }
+
+    // now ensure it was linked to the correct place
+    try {
+      return require(resolveFrom(cwd, `${pkgName}/package.json`));
+    } catch {
+      throw new Error('The package was not linked correctly; its package.json ' +
+                      'did not exist or was unreadable');
+    }
+  }
+
+  /**
+   * @param {string} cwd
+   * @param {string} pkg
+   */
+  async uninstallPackage (cwd, pkg) {
+    await this.exec('uninstall', [pkg], {
+      cwd,
+      lockFile: this._getInstallLockfilePath(cwd)
+    });
+  }
+}
+
+export const npm = new NPM();
+
+/**
+ * Options for {@link NPM.installPackage}
+ * @typedef InstallPackageOpts
+ * @property {string} [pkgVer] - the version of the package to install
+ */
+
+/**
+ * Options for {@link NPM.exec}
+ * @typedef ExecOpts
+ * @property {string} cwd - Current working directory
+ * @property {boolean} [json] - If `true`, supply `--json` flag to npm and resolve w/ parsed JSON
+ * @property {string} [lockFile] - Path to lockfile to use
+ */
+
+// THESE TYPES SHOULD BE IN TEEN PROCESS, NOT HERE
+
+/**
+ * Result from a non-zero-exit execution of `appium`
+ * @typedef TeenProcessExecResult
+ * @property {string} stdout - Stdout
+ * @property {string} stderr - Stderr
+ * @property {number?} code - Exit code
+ * @property {any} json - JSON parsed from stdout
+ */
+
+/**
+ * Extra props `teen_process.exec` adds to its error objects
+ * @typedef TeenProcessExecErrorProps
+ * @property {string} stdout - STDOUT
+ * @property {string} stderr - STDERR
+ * @property {number?} code - Exit code
+ */
+
+/**
+ * Options unique to `teen_process.exec`. I probably missed some
+ * @typedef TeenProcessExecExtraOpts
+ * @property {number} [maxStdoutBufferSize]
+ * @property {number} [maxStderrBufferSize]
+ */
+
+/**
+ * All options for `teen_process.exec`
+ * @typedef {import('child_process').SpawnOptions & TeenProcessExecExtraOpts} TeenProcessExecOpts
+ */
+
+/**
+ * Error thrown by `teen_process.exec`
+ * @typedef {Error & TeenProcessExecErrorProps} TeenProcessExecError
+ */

package/lib/tempdir.js

@@ -13,7 +13,7 @@ const RDWR_EXCL = cnst.O_CREAT | cnst.O_TRUNC | cnst.O_RDWR | cnst.O_EXCL;
  * - No `process.env.APPIUM_TMP_DIR`: `/var/folders/34/2222sh8n27d6rcp7jqlkw8km0000gn/T/xxxxxxxx.yyyy`
  * - With `process.env.APPIUM_TMP_DIR = '/path/to/root'`: `/path/to/root/xxxxxxxx.yyyy`
  *
- * @returns {string} A path to the temporary directory
+ * @returns {Promise<string>} A path to the temporary directory
  */
 async function tempDir () {
   const now = new Date();
@@ -33,7 +33,7 @@ async function tempDir () {
 }
 
 /**
- * @typedef {Object} Affixes
+ * @typedef Affixes
  * @property {string} prefix - prefix of the temp directory name
  * @property {string} suffix - suffix of the temp directory name
  */
@@ -44,7 +44,7 @@ async function tempDir () {
  *
  * @param {string|Affixes} rawAffixes
  * @param {?string} defaultPrefix
- * @returns {string}  A path to the temporary directory with rawAffixes and defaultPrefix
+ * @returns {Promise<string>}  A path to the temporary directory with rawAffixes and defaultPrefix
  */
 async function path (rawAffixes, defaultPrefix) {
   const affixes = parseAffixes(rawAffixes, defaultPrefix);
@@ -54,7 +54,7 @@ async function path (rawAffixes, defaultPrefix) {
 }
 
 /**
- * @typedef {Object} OpenedAffixes
+ * @typedef OpenedAffixes
  * @property {string} path - The path to file
  * @property {integer} fd - The file descriptor opened
  */
@@ -64,7 +64,7 @@ async function path (rawAffixes, defaultPrefix) {
  * with arbitrary prefix/suffix for the directory name and return it as open.
  *
  * @param {Affixes} affixes
- * @returns {OpenedAffixes}
+ * @returns {Promise<OpenedAffixes>}
  */
 async function open (affixes) {
   const filePath = await path(affixes, 'f-');
@@ -116,7 +116,7 @@ const openDir = tempDir;
 /**
  * Returns a path to a temporary directory whcih is defined as static in the same process
  *
- * @returns {string} A temp directory path whcih is defined as static in the same process
+ * @returns {Promise<string>} A temp directory path whcih is defined as static in the same process
  */
 async function staticDir () { // eslint-disable-line require-await
   return _static;

package/lib/util.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import B from 'bluebird';
 import _ from 'lodash';
 import os from 'os';
@@ -75,6 +77,7 @@ function localIp () {
   let ip = _.chain(os.networkInterfaces())
     .values()
     .flatten()
+    // @ts-ignore
     .filter(function (val) {
       return (val.family === 'IPv4' && val.internal === false);
     })
@@ -217,16 +220,16 @@ function filterObject (obj, predicate) {
  *                 if it is less than zero.
  */
 function toReadableSizeString (bytes) {
-  const intBytes = parseInt(bytes, 10);
+  const intBytes = parseInt(String(bytes), 10);
   if (isNaN(intBytes) || intBytes < 0) {
     throw new Error(`Cannot convert '${bytes}' to a readable size format`);
   }
   if (intBytes >= GiB) {
-    return `${parseFloat(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
+    return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
   } else if (intBytes >= MiB) {
-    return `${parseFloat(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
+    return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
   } else if (intBytes >= KiB) {
-    return `${parseFloat(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
+    return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
   }
   return `${intBytes} B`;
 }
@@ -260,7 +263,7 @@ function isSubPath (originalPath, root, forcePosix = null) {
  * @param {string} path1 - Absolute or relative path to a file/folder
  * @param {string} path2 - Absolute or relative path to a file/folder
  * @param {...string} pathN - Zero or more absolute or relative paths to files/folders
- * @returns {boolean} true if all paths are pointing to the same file system item
+ * @returns {Promise<boolean>} true if all paths are pointing to the same file system item
  */
 async function isSameDestination (path1, path2, ...pathN) {
   const allPaths = [path1, path2, ...pathN];
@@ -288,19 +291,20 @@ async function isSameDestination (path1, path2, ...pathN) {
 /**
  * Coerces the given number/string to a valid version string
  *
- * @param {string|number} ver - Version string to coerce
- * @param {boolean} strict [true] - If true then an exception will be thrown
+ * @template {boolean} [Strict=true]
+ * @param {string} ver - Version string to coerce
+ * @param {Strict} [strict] - If `true` then an exception will be thrown
  * if `ver` cannot be coerced
- * @returns {string} Coerced version number or null if the string cannot be
+ * @returns {Strict extends true ? string : string|null} Coerced version number or null if the string cannot be
  * coerced and strict mode is disabled
  * @throws {Error} if strict mode is enabled and `ver` cannot be coerced
  */
-function coerceVersion (ver, strict = true) {
+function coerceVersion (ver, strict = /** @type {Strict} */(true)) {
   const result = semver.valid(semver.coerce(`${ver}`));
   if (strict && !result) {
     throw new Error(`'${ver}' cannot be coerced to a valid version number`);
   }
-  return result;
+  return /** @type {Strict extends true ? string : string|null} */(result);
 }
 
 const SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];
@@ -308,9 +312,9 @@ const SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];
 /**
  * Compares two version strings
  *
- * @param {string|number} ver1 - The first version number to compare. Should be a valid
+ * @param {string} ver1 - The first version number to compare. Should be a valid
  * version number supported by semver parser.
- * @param {string|number} ver2 - The second version number to compare. Should be a valid
+ * @param {string} ver2 - The second version number to compare. Should be a valid
  * version number supported by semver parser.
  * @param {string} operator - One of supported version number operators:
  * ==, !=, >, <, <=, >=, =
@@ -333,7 +337,7 @@ function compareVersions (ver1, operator, ver2) {
  * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote
  * for more details
  *
- * @param {string|Array<string>} - The arguments that will be parsed
+ * @param {string|string[]} args - The arguments that will be parsed
  * @returns {string} - The arguments, quoted
  */
 function quote (args) {
@@ -354,8 +358,8 @@ function unleakString (s) {
 
 
 /**
- * @typedef {Object} PluralizeOptions
- * @property {?boolean} inclusive [false] - Whether to prefix with the number (e.g., 3 ducks)
+ * @typedef PluralizeOptions
+ * @property {boolean} [inclusive=false] - Whether to prefix with the number (e.g., 3 ducks)
  */
 
 /**
@@ -363,7 +367,7 @@ function unleakString (s) {
  *
  * @param {string} word - The word to pluralize
  * @param {number} count - How many of the word exist
- * @param {?PluralizeOptions|boolean} options|inclusive - options for word pluralization,
+ * @param {PluralizeOptions|boolean} options - options for word pluralization,
  *   or a boolean indicating the options.inclusive property
  * @returns {string} The word pluralized according to the number
  */
@@ -380,8 +384,8 @@ function pluralize (word, count, options = {}) {
 }
 
 /**
- * @typedef {Object} EncodingOptions
- * @property {number} maxSize [1073741824] The maximum size of
+ * @typedef EncodingOptions
+ * @property {number} [maxSize=1073741824] The maximum size of
  * the resulting buffer in bytes. This is set to 1GB by default, because
  * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
  * size must be enough to keep the resulting object (usually this size is
@@ -395,7 +399,7 @@ function pluralize (word, count, options = {}) {
  *
  * @param {string} srcPath The full path to the file being encoded
  * @param {EncodingOptions} opts
- * @returns {Buffer} base64-encoded content of the source file as memory buffer
+ * @returns {Promise<Buffer>} base64-encoded content of the source file as memory buffer
  * @throws {Error} if there was an error while reading the source file
  * or the source file is too
  */
@@ -445,9 +449,9 @@ async function toInMemoryBase64 (srcPath, opts = {}) {
 }
 
 /**
- * @typedef {Object} LockFileOptions
- * @property {number} timeout [120] The max time in seconds to wait for the lock
- * @property {boolean} tryRecovery [false] Whether to try lock recovery if
+ * @typedef LockFileOptions
+ * @property {number} [timeout=120] The max time in seconds to wait for the lock
+ * @property {boolean} [tryRecovery=false] Whether to try lock recovery if
  * the first attempt to acquire it timed out.
  */
 
@@ -458,7 +462,7 @@ async function toInMemoryBase64 (srcPath, opts = {}) {
  *
  * @param {string} lockFile The full path to the file used for the lock
  * @param {LockFileOptions} opts
- * @returns {AsyncFunction} async function that takes another async function defining the locked
+ * @returns {(behavior: () => Promise<void>) => Promise<void>} async function that takes another async function defining the locked
  * behavior
  */
 function getLockFileGuard (lockFile, opts = {}) {
@@ -467,7 +471,7 @@ function getLockFileGuard (lockFile, opts = {}) {
     tryRecovery = false,
   } = opts;
 
-  const lock = B.promisify(_lockfile.lock);
+  const lock = /** @type {(lockfile: string, opts: import('lockfile').Options)=>B<void>} */(B.promisify(_lockfile.lock));
   const check = B.promisify(_lockfile.check);
   const unlock = B.promisify(_lockfile.unlock);
 

package/lib/zip.js

@@ -4,7 +4,6 @@ import yauzl from 'yauzl';
 import archiver from 'archiver';
 import { createWriteStream } from 'fs';
 import path from 'path';
-import { mkdirp } from '../lib/mkdirp';
 import stream from 'stream';
 import fs from './fs';
 import { isWindows } from './system';
@@ -169,7 +168,7 @@ class ZipExtractor {
 
 
 /**
- * @typedef {Object} ExtractAllOptions
+ * @typedef ExtractAllOptions
  * @property {?string} fileNamesEncoding The encoding to use for extracted file names.
  * For ZIP archives created on MacOS it is usually expected to be `utf8`.
  * By default it is autodetected based on the entry metadata and is only needed to be set explicitly
@@ -261,11 +260,11 @@ async function _extractEntryTo (zipFile, entry, destDir) {
   // Create dest directory if doesn't exist already
   if (/\/$/.test(entry.fileName)) {
     if (!await fs.exists(dstPath)) {
-      await mkdirp(dstPath);
+      await fs.mkdirp(dstPath);
     }
     return;
   } else if (!await fs.exists(path.dirname(dstPath))) {
-    await mkdirp(path.dirname(dstPath));
+    await fs.mkdirp(path.dirname(dstPath));
   }
 
   // Create a write stream
@@ -294,7 +293,7 @@ async function _extractEntryTo (zipFile, entry, destDir) {
 }
 
 /**
- * @typedef {Object} ZipEntry
+ * @typedef ZipEntry
  * @property {yauzl.ZipEntry} entry The actual entry instance
  * @property {function} extractEntryTo An async function, which accepts one parameter.
  * This parameter contains the destination folder path to which this function is going to extract the entry.
@@ -335,7 +334,7 @@ async function readEntries (zipFilePath, onEntry) {
 }
 
 /**
- * @typedef {Object} ZipOptions
+ * @typedef ZipOptions
  * @property {boolean} encodeToBase64 [false] Whether to encode
  * the resulting archive to a base64-encoded string
  * @property {boolean} isMetered [true] Whether to log the actual
@@ -475,13 +474,13 @@ async function assertValidZip (filePath) {
 }
 
 /**
- * @typedef {Object} ZipCompressionOptions
+ * @typedef ZipCompressionOptions
  * @property {number} level [9] - Compression level in range 0..9
  * (greater numbers mean better compression, but longer processing time)
  */
 
 /**
- * @typedef {Object} ZipSourceOptions
+ * @typedef ZipSourceOptions
  * @property {!string} pattern ['**\/*'] - GLOB pattern for compression
  * @property {!string} cwd - The source root folder (the parent folder of
  * the destination file by default)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appium/support",
-  "version": "2.55.4",
+  "version": "2.56.0",
   "description": "Support libs used across appium packages",
   "keywords": [
     "automation",
@@ -12,12 +12,14 @@
     "firefoxos",
     "testing"
   ],
+  "homepage": "https://appium.io",
   "bugs": {
     "url": "https://github.com/appium/appium/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/appium/appium.git"
+    "url": "https://github.com/appium/appium.git",
+    "directory": "packages/support"
   },
   "license": "Apache-2.0",
   "author": "https://github.com/appium",
@@ -29,15 +31,23 @@
     "lib",
     "build"
   ],
+  "scripts": {
+    "build": "babel lib --root-mode=upward --delete-dir-on-start --out-dir=build/lib",
+    "dev": "npm run build -- --watch",
+    "fix": "npm run lint -- --fix",
+    "lint": "eslint -c ../../.eslintrc --ignore-path ../../.eslintignore .",
+    "test": "npm run test:unit",
+    "test:e2e": "mocha --require ../../test/setup-babel.js --timeout 20s --slow 10s \"./test/e2e/**/*.spec.js\"",
+    "test:unit": "mocha --require ../../test/setup-babel.js \"./test/unit/**/*.spec.js\""
+  },
   "dependencies": {
-    "@babel/runtime": "7.16.3",
+    "@babel/runtime": "7.17.8",
     "archiver": "5.3.0",
-    "axios": "0.24.0",
+    "axios": "0.26.1",
     "base64-stream": "1.0.0",
     "bluebird": "3.7.2",
     "bplist-creator": "0.1.0",
     "bplist-parser": "0.3.1",
-    "find-root": "1.1.0",
     "form-data": "4.0.0",
     "get-stream": "6.0.1",
     "glob": "7.2.0",
@@ -46,15 +56,16 @@
     "klaw": "3.0.0",
     "lockfile": "1.0.4",
     "lodash": "4.17.21",
-    "mkdirp": "1.0.4",
     "moment": "2.29.1",
     "mv": "2.1.1",
     "ncp": "2.0.0",
-    "npmlog": "5.0.1",
-    "opencv-bindings": "^4.5.5",
+    "npmlog": "6.0.1",
+    "opencv-bindings": "4.5.5",
+    "pkg-dir": "5.0.0",
     "plist": "3.0.4",
     "pluralize": "8.0.0",
     "pngjs": "6.0.0",
+    "read-pkg": "5.2.0",
     "rimraf": "3.0.2",
     "sanitize-filename": "1.6.3",
     "semver": "7.3.5",
@@ -72,6 +83,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "homepage": "https://appium.io",
-  "gitHead": "42f4a2de2d763d57cf0bdb6fb6c9a3bc9c3d232f"
+  "gitHead": "f5cce0f29d31699decea63ed94c4506f7af469df"
 }