appium-xcode 3.7.1 → 3.10.0

package/build/index.js

@@ -1,22 +1,46 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "xcode", {
-  enumerable: true,
-  get: function get() {
-    return _xcode.default;
-  }
-});
-exports.default = void 0;
+exports.default = exports.getClangVersion = exports.getMaxTVOSSDKWithoutRetry = exports.getMaxTVOSSDK = exports.getCommandLineToolsVersion = exports.getInstrumentsPath = exports.clearInternalCache = exports.getConnectedDevices = exports.getMaxIOSSDKWithoutRetry = exports.getAutomationTraceTemplatePathWithoutRetry = exports.getMaxIOSSDK = exports.getAutomationTraceTemplatePath = exports.getVersion = exports.getPath = void 0;
+
+require("source-map-support/register");
 
-var _xcode = _interopRequireDefault(require("./lib/xcode"));
+var xcode = _interopRequireWildcard(require("./lib/xcode"));
 
-var _default = _xcode.default;
+const {
+  getPath,
+  getVersion,
+  getAutomationTraceTemplatePath,
+  getMaxIOSSDK,
+  getAutomationTraceTemplatePathWithoutRetry,
+  getMaxIOSSDKWithoutRetry,
+  getConnectedDevices,
+  clearInternalCache,
+  getInstrumentsPath,
+  getCommandLineToolsVersion,
+  getMaxTVOSSDK,
+  getMaxTVOSSDKWithoutRetry,
+  getClangVersion
+} = xcode;
+exports.getClangVersion = getClangVersion;
+exports.getMaxTVOSSDKWithoutRetry = getMaxTVOSSDKWithoutRetry;
+exports.getMaxTVOSSDK = getMaxTVOSSDK;
+exports.getCommandLineToolsVersion = getCommandLineToolsVersion;
+exports.getInstrumentsPath = getInstrumentsPath;
+exports.clearInternalCache = clearInternalCache;
+exports.getConnectedDevices = getConnectedDevices;
+exports.getMaxIOSSDKWithoutRetry = getMaxIOSSDKWithoutRetry;
+exports.getAutomationTraceTemplatePathWithoutRetry = getAutomationTraceTemplatePathWithoutRetry;
+exports.getMaxIOSSDK = getMaxIOSSDK;
+exports.getAutomationTraceTemplatePath = getAutomationTraceTemplatePath;
+exports.getVersion = getVersion;
+exports.getPath = getPath;
+var _default = xcode;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbInhjb2RlIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7QUFFQTs7ZUFHZUEsYyIsInNvdXJjZXNDb250ZW50IjpbIi8vIHRyYW5zcGlsZTptYWluXG5cbmltcG9ydCB4Y29kZSBmcm9tICcuL2xpYi94Y29kZSc7XG5cbmV4cG9ydCB7IHhjb2RlIH07XG5leHBvcnQgZGVmYXVsdCB4Y29kZTtcbiJdLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi4ifQ==
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImdldFBhdGgiLCJnZXRWZXJzaW9uIiwiZ2V0QXV0b21hdGlvblRyYWNlVGVtcGxhdGVQYXRoIiwiZ2V0TWF4SU9TU0RLIiwiZ2V0QXV0b21hdGlvblRyYWNlVGVtcGxhdGVQYXRoV2l0aG91dFJldHJ5IiwiZ2V0TWF4SU9TU0RLV2l0aG91dFJldHJ5IiwiZ2V0Q29ubmVjdGVkRGV2aWNlcyIsImNsZWFySW50ZXJuYWxDYWNoZSIsImdldEluc3RydW1lbnRzUGF0aCIsImdldENvbW1hbmRMaW5lVG9vbHNWZXJzaW9uIiwiZ2V0TWF4VFZPU1NESyIsImdldE1heFRWT1NTREtXaXRob3V0UmV0cnkiLCJnZXRDbGFuZ1ZlcnNpb24iLCJ4Y29kZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFFQTs7QUFHQSxNQUFNO0FBQ0pBLEVBQUFBLE9BREk7QUFDS0MsRUFBQUEsVUFETDtBQUNpQkMsRUFBQUEsOEJBRGpCO0FBQ2lEQyxFQUFBQSxZQURqRDtBQUVKQyxFQUFBQSwwQ0FGSTtBQUV3Q0MsRUFBQUEsd0JBRnhDO0FBR0pDLEVBQUFBLG1CQUhJO0FBR2lCQyxFQUFBQSxrQkFIakI7QUFHcUNDLEVBQUFBLGtCQUhyQztBQUlKQyxFQUFBQSwwQkFKSTtBQUl3QkMsRUFBQUEsYUFKeEI7QUFJdUNDLEVBQUFBLHlCQUp2QztBQUtKQyxFQUFBQTtBQUxJLElBTUZDLEtBTko7Ozs7Ozs7Ozs7Ozs7O2VBZWVBLEsiLCJzb3VyY2VzQ29udGVudCI6WyIvLyB0cmFuc3BpbGU6bWFpblxuXG5pbXBvcnQgKiBhcyB4Y29kZSBmcm9tICcuL2xpYi94Y29kZSc7XG5cblxuY29uc3Qge1xuICBnZXRQYXRoLCBnZXRWZXJzaW9uLCBnZXRBdXRvbWF0aW9uVHJhY2VUZW1wbGF0ZVBhdGgsIGdldE1heElPU1NESyxcbiAgZ2V0QXV0b21hdGlvblRyYWNlVGVtcGxhdGVQYXRoV2l0aG91dFJldHJ5LCBnZXRNYXhJT1NTREtXaXRob3V0UmV0cnksXG4gIGdldENvbm5lY3RlZERldmljZXMsIGNsZWFySW50ZXJuYWxDYWNoZSwgZ2V0SW5zdHJ1bWVudHNQYXRoLFxuICBnZXRDb21tYW5kTGluZVRvb2xzVmVyc2lvbiwgZ2V0TWF4VFZPU1NESywgZ2V0TWF4VFZPU1NES1dpdGhvdXRSZXRyeSxcbiAgZ2V0Q2xhbmdWZXJzaW9uLFxufSA9IHhjb2RlO1xuXG5leHBvcnQge1xuICBnZXRQYXRoLCBnZXRWZXJzaW9uLCBnZXRBdXRvbWF0aW9uVHJhY2VUZW1wbGF0ZVBhdGgsIGdldE1heElPU1NESyxcbiAgZ2V0QXV0b21hdGlvblRyYWNlVGVtcGxhdGVQYXRoV2l0aG91dFJldHJ5LCBnZXRNYXhJT1NTREtXaXRob3V0UmV0cnksXG4gIGdldENvbm5lY3RlZERldmljZXMsIGNsZWFySW50ZXJuYWxDYWNoZSwgZ2V0SW5zdHJ1bWVudHNQYXRoLFxuICBnZXRDb21tYW5kTGluZVRvb2xzVmVyc2lvbiwgZ2V0TWF4VFZPU1NESywgZ2V0TWF4VFZPU1NES1dpdGhvdXRSZXRyeSxcbiAgZ2V0Q2xhbmdWZXJzaW9uLFxufTtcbmV4cG9ydCBkZWZhdWx0IHhjb2RlO1xuIl0sImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZVJvb3QiOiIuLiJ9

package/build/lib/xcode.js

@@ -5,9 +5,17 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+exports.getVersion = getVersion;
+exports.getAutomationTraceTemplatePathWithoutRetry = getAutomationTraceTemplatePathWithoutRetry;
+exports.getMaxIOSSDKWithoutRetry = getMaxIOSSDKWithoutRetry;
+exports.getConnectedDevices = getConnectedDevices;
+exports.clearInternalCache = clearInternalCache;
+exports.getCommandLineToolsVersion = getCommandLineToolsVersion;
+exports.getMaxTVOSSDKWithoutRetry = getMaxTVOSSDKWithoutRetry;
+exports.getClangVersion = getClangVersion;
+exports.getMaxTVOSSDK = exports.getInstrumentsPath = exports.getMaxIOSSDK = exports.getAutomationTraceTemplatePath = exports.getPath = void 0;
+
+require("source-map-support/register");
 
 var _appiumSupport = require("appium-support");
 
@@ -25,7 +33,7 @@ var _semver = _interopRequireDefault(require("semver"));
 
 const env = process.env;
 const XCRUN_TIMEOUT = 15000;
-const XCODE_SUBDIR = "/Contents/Developer";
+const XCODE_SUBDIR = '/Contents/Developer';
 const DEFAULT_NUMBER_OF_RETRIES = 3;
 
 const log = _appiumSupport.logger.getLogger('Xcode');
@@ -34,340 +42,307 @@ function hasExpectedSubDir(path) {
   return path.substring(path.length - XCODE_SUBDIR.length) === XCODE_SUBDIR;
 }
 
-function runXcrunCommand(_x) {
-  return _runXcrunCommand.apply(this, arguments);
-}
-
-function _runXcrunCommand() {
-  _runXcrunCommand = (0, _asyncToGenerator2.default)(function* (args, timeout = XCRUN_TIMEOUT) {
-    try {
-      return yield (0, _teen_process.exec)('xcrun', args, {
-        timeout
-      });
-    } catch (err) {
-      if (err.stderr) {
-        err.message = `${err.message}: ${err.stderr}`;
-      }
-
-      throw err;
-    }
-  });
-  return _runXcrunCommand.apply(this, arguments);
-}
-
-function getPathFromSymlink(_x2) {
-  return _getPathFromSymlink.apply(this, arguments);
-}
+async function runXcrunCommand(args, timeout = XCRUN_TIMEOUT) {
+  try {
+    const res = await (0, _teen_process.exec)('xcrun', args, {
+      timeout
+    });
 
-function _getPathFromSymlink() {
-  _getPathFromSymlink = (0, _asyncToGenerator2.default)(function* (failMessage) {
-    log.warn(`Finding XcodePath by symlink because ${failMessage}`);
-    const symlinkPath = "/var/db/xcode_select_link";
-    const legacySymlinkPath = "/usr/share/xcode-select/xcode_dir_link";
-    let xcodePath = null;
-
-    if (_appiumSupport.util.hasContent(env.DEVELOPER_DIR)) {
-      const customPath = hasExpectedSubDir(env.DEVELOPER_DIR) ? env.DEVELOPER_DIR : env.DEVELOPER_DIR + XCODE_SUBDIR;
-
-      if (yield _appiumSupport.fs.exists(customPath)) {
-        xcodePath = customPath;
-      } else {
-        let mesg = `Could not find path to Xcode, environment variable ` + `DEVELOPER_DIR set to: ${env.DEVELOPER_DIR} ` + `but no Xcode found`;
-        log.warn(mesg);
-        throw new Error(mesg);
-      }
-    } else if (yield _appiumSupport.fs.exists(symlinkPath)) {
-      xcodePath = yield _appiumSupport.fs.readlink(symlinkPath);
-    } else if (yield _appiumSupport.fs.exists(legacySymlinkPath)) {
-      xcodePath = yield _appiumSupport.fs.readlink(legacySymlinkPath);
+    if (_lodash.default.isUndefined(res)) {
+      throw new Error(`Nothing returned from trying to run 'xcrun ${args.join(' ')}'`);
     }
 
-    if (xcodePath) {
-      return xcodePath.replace(new RegExp("/$"), "").trim();
+    return res;
+  } catch (err) {
+    if (err.stderr) {
+      err.message = `${err.message}: ${err.stderr}`;
     }
 
-    let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;
-    log.warn(msg);
-    throw new Error(msg);
-  });
-  return _getPathFromSymlink.apply(this, arguments);
+    throw err;
+  }
 }
 
-function getPathFromXcodeSelect() {
-  return _getPathFromXcodeSelect.apply(this, arguments);
-}
-
-function _getPathFromXcodeSelect() {
-  _getPathFromXcodeSelect = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    let _ref = yield (0, _teen_process.exec)('xcode-select', ['--print-path'], {
-      timeout
-    }),
-        stdout = _ref.stdout;
-
-    const xcodeFolderPath = stdout.replace(/\/$/, '').trim();
+async function getPathFromSymlink(failMessage) {
+  log.warn(`Finding XcodePath by symlink because ${failMessage}`);
+  const symlinkPath = '/var/db/xcode_select_link';
+  const legacySymlinkPath = '/usr/share/xcode-select/xcode_dir_link';
+  let xcodePath = null;
 
-    if (!_appiumSupport.util.hasContent(xcodeFolderPath)) {
-      log.errorAndThrow('xcode-select returned an empty string');
-    }
+  if (_appiumSupport.util.hasContent(env.DEVELOPER_DIR)) {
+    const customPath = hasExpectedSubDir(env.DEVELOPER_DIR) ? env.DEVELOPER_DIR : env.DEVELOPER_DIR + XCODE_SUBDIR;
 
-    if (yield _appiumSupport.fs.exists(xcodeFolderPath)) {
-      return xcodeFolderPath;
+    if (await _appiumSupport.fs.exists(customPath)) {
+      xcodePath = customPath;
     } else {
-      const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;
-      log.errorAndThrow(msg);
+      let mesg = `Could not find path to Xcode, environment variable ` + `DEVELOPER_DIR set to: ${env.DEVELOPER_DIR} ` + `but no Xcode found`;
+      log.warn(mesg);
+      throw new Error(mesg);
     }
+  } else if (await _appiumSupport.fs.exists(symlinkPath)) {
+    xcodePath = await _appiumSupport.fs.readlink(symlinkPath);
+  } else if (await _appiumSupport.fs.exists(legacySymlinkPath)) {
+    xcodePath = await _appiumSupport.fs.readlink(legacySymlinkPath);
+  }
+
+  if (xcodePath) {
+    return xcodePath.replace(new RegExp('/$'), '').trim();
+  }
+
+  let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;
+  log.warn(msg);
+  throw new Error(msg);
+}
+
+async function getPathFromXcodeSelect(timeout = XCRUN_TIMEOUT) {
+  let {
+    stdout
+  } = await (0, _teen_process.exec)('xcode-select', ['--print-path'], {
+    timeout
   });
-  return _getPathFromXcodeSelect.apply(this, arguments);
+  const xcodeFolderPath = stdout.replace(/\/$/, '').trim();
+
+  if (!_appiumSupport.util.hasContent(xcodeFolderPath)) {
+    log.errorAndThrow('xcode-select returned an empty string');
+  }
+
+  if (await _appiumSupport.fs.exists(xcodeFolderPath)) {
+    return xcodeFolderPath;
+  } else {
+    const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;
+    log.errorAndThrow(msg);
+  }
 }
 
-const getPath = _lodash.default.memoize(function (timeout = XCRUN_TIMEOUT) {
+const getPath = _lodash.default.memoize(function getPath(timeout = XCRUN_TIMEOUT) {
   return getPathFromXcodeSelect(timeout).catch(getPathFromSymlink);
 });
 
-function getVersionWithoutRetry() {
-  return _getVersionWithoutRetry.apply(this, arguments);
-}
+exports.getPath = getPath;
 
-function _getVersionWithoutRetry() {
-  _getVersionWithoutRetry = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const xcodePath = yield getPath(timeout);
+async function getVersionWithoutRetry(timeout = XCRUN_TIMEOUT) {
+  const xcodePath = await getPath(timeout);
 
-    const plistPath = _path.default.resolve(xcodePath, "..", "Info.plist");
+  const plistPath = _path.default.resolve(xcodePath, '..', 'Info.plist');
 
-    if (!(yield _appiumSupport.fs.exists(plistPath))) {
-      throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);
-    }
+  if (!(await _appiumSupport.fs.exists(plistPath))) {
+    throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);
+  }
 
-    const version = yield _appiumSupport.plist.parsePlistFile(plistPath);
-    return _semver.default.coerce(version.CFBundleShortVersionString);
-  });
-  return _getVersionWithoutRetry.apply(this, arguments);
+  const version = await _appiumSupport.plist.parsePlistFile(plistPath);
+  return _semver.default.coerce(version.CFBundleShortVersionString);
 }
 
-const getVersionMemoized = _lodash.default.memoize(function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+const getVersionMemoized = _lodash.default.memoize(function getVersionMemoized(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getVersionWithoutRetry, timeout);
 });
 
-function getVersion() {
-  return _getVersion.apply(this, arguments);
-}
+async function getVersion(parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  const version = await getVersionMemoized(retries, timeout);
+  const versionString = version.patch > 0 ? version.version : `${version.major}.${version.minor}`;
+
+  if (!parse) {
+    return versionString;
+  }
 
-function _getVersion() {
-  _getVersion = (0, _asyncToGenerator2.default)(function* (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-    const version = yield getVersionMemoized(retries, timeout);
-    const versionString = version.patch > 0 ? version.version : `${version.major}.${version.minor}`;
+  return {
+    versionString,
+    versionFloat: parseFloat(versionString),
+    major: version.major,
+    minor: version.minor,
+    patch: version.patch > 0 ? version.patch : undefined,
 
-    if (!parse) {
+    toString() {
       return versionString;
     }
 
-    return {
-      versionString,
-      versionFloat: parseFloat(versionString),
-      major: version.major,
-      minor: version.minor,
-      patch: version.patch > 0 ? version.patch : undefined
-    };
-  });
-  return _getVersion.apply(this, arguments);
+  };
 }
 
-function getCommandLineToolsVersion() {
-  return _getCommandLineToolsVersion.apply(this, arguments);
-}
+async function getCommandLineToolsVersion() {
+  const getVersionFunctions = [async () => {
+    let pkg = (await (0, _teen_process.exec)('pkgutil', ['--pkgs=com.apple.pkg.DevSDK_.*'])).stdout;
+    return (await (0, _teen_process.exec)('pkgutil', [`--pkg-info=${pkg.trim()}`])).stdout;
+  }, async () => (await (0, _teen_process.exec)('pkgutil', [`--pkg-info=com.apple.pkg.CLTools_Executables`])).stdout, async () => (await (0, _teen_process.exec)('pkgutil', [`--pkg-info=com.apple.pkg.DeveloperToolsCLI`])).stdout];
+  let stdout;
 
-function _getCommandLineToolsVersion() {
-  _getCommandLineToolsVersion = (0, _asyncToGenerator2.default)(function* () {
-    const getVersionFunctions = [(0, _asyncToGenerator2.default)(function* () {
-      let pkg = (yield (0, _teen_process.exec)('pkgutil', ['--pkgs=com.apple.pkg.DevSDK_.*'])).stdout;
-      return (yield (0, _teen_process.exec)('pkgutil', [`--pkg-info=${pkg.trim()}`])).stdout;
-    }), (0, _asyncToGenerator2.default)(function* () {
-      return (yield (0, _teen_process.exec)('pkgutil', [`--pkg-info=com.apple.pkg.CLTools_Executables`])).stdout;
-    }), (0, _asyncToGenerator2.default)(function* () {
-      return (yield (0, _teen_process.exec)('pkgutil', [`--pkg-info=com.apple.pkg.DeveloperToolsCLI`])).stdout;
-    })];
-    let stdout;
-
-    for (var _i = 0; _i < getVersionFunctions.length; _i++) {
-      let getVersion = getVersionFunctions[_i];
-
-      try {
-        stdout = yield getVersion();
-        break;
-      } catch (ign) {
-        stdout = '';
-      }
+  for (let getVersion of getVersionFunctions) {
+    try {
+      stdout = await getVersion();
+      break;
+    } catch (ign) {
+      stdout = '';
     }
+  }
 
-    let match = /^version: (.+)$/m.exec(stdout);
-    return match ? match[1] : undefined;
-  });
-  return _getCommandLineToolsVersion.apply(this, arguments);
+  let match = /^version: (.+)$/m.exec(stdout);
+  return match ? match[1] : undefined;
 }
 
-function getAutomationTraceTemplatePathWithoutRetry() {
-  return _getAutomationTraceTemplatePathWithoutRetry.apply(this, arguments);
+async function getClangVersion() {
+  try {
+    await _appiumSupport.fs.which('clang');
+  } catch (e) {
+    log.info('Cannot find clang executable on the local system. ' + 'Are Xcode Command Line Tools installed?');
+    return null;
+  }
+
+  const {
+    stdout
+  } = await (0, _teen_process.exec)('clang', ['--version']);
+  const match = /clang-([0-9.]+)/.exec(stdout);
+
+  if (!match) {
+    log.info(`Cannot parse clang version from ${stdout}`);
+    return null;
+  }
+
+  return match[1];
 }
 
-function _getAutomationTraceTemplatePathWithoutRetry() {
-  _getAutomationTraceTemplatePathWithoutRetry = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const xcodePath = yield getPath(timeout);
-    const extensions = ['xrplugin', 'bundle'];
+async function getAutomationTraceTemplatePathWithoutRetry(timeout = XCRUN_TIMEOUT) {
+  const xcodePath = await getPath(timeout);
+  const extensions = ['xrplugin', 'bundle'];
 
-    const pathPrefix = _path.default.resolve(xcodePath, "../Applications/Instruments.app/Contents/PlugIns");
+  const pathPrefix = _path.default.resolve(xcodePath, '../Applications/Instruments.app/Contents/PlugIns');
 
-    const pathSuffix = "Contents/Resources/Automation.tracetemplate";
-    let automationTraceTemplatePaths = [_path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix), _path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)];
+  const pathSuffix = 'Contents/Resources/Automation.tracetemplate';
+  let automationTraceTemplatePaths = [_path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix), _path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)];
 
-    if (yield _appiumSupport.fs.exists(automationTraceTemplatePaths[0])) {
-      return automationTraceTemplatePaths[0];
-    }
+  if (await _appiumSupport.fs.exists(automationTraceTemplatePaths[0])) {
+    return automationTraceTemplatePaths[0];
+  }
 
-    if (yield _appiumSupport.fs.exists(automationTraceTemplatePaths[1])) {
-      return automationTraceTemplatePaths[1];
-    }
+  if (await _appiumSupport.fs.exists(automationTraceTemplatePaths[1])) {
+    return automationTraceTemplatePaths[1];
+  }
 
-    const msg = "Could not find Automation.tracetemplate in any of the following" + `locations ${automationTraceTemplatePaths.toString()}`;
-    log.error(msg);
-    throw new Error(msg);
-  });
-  return _getAutomationTraceTemplatePathWithoutRetry.apply(this, arguments);
+  const msg = 'Could not find Automation.tracetemplate in any of the following' + `locations ${automationTraceTemplatePaths.toString()}`;
+  log.error(msg);
+  throw new Error(msg);
 }
 
-const getAutomationTraceTemplatePath = _lodash.default.memoize(function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+const getAutomationTraceTemplatePath = _lodash.default.memoize(function getAutomationTraceTemplatePath(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);
 });
 
-function getMaxIOSSDKWithoutRetry() {
-  return _getMaxIOSSDKWithoutRetry.apply(this, arguments);
-}
+exports.getAutomationTraceTemplatePath = getAutomationTraceTemplatePath;
 
-function _getMaxIOSSDKWithoutRetry() {
-  _getMaxIOSSDKWithoutRetry = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const version = yield getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);
+async function getMaxIOSSDKWithoutRetry(timeout = XCRUN_TIMEOUT) {
+  const version = await getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);
 
-    if (version[0] === '4') {
-      return '6.1';
-    }
+  if (version[0] === '4') {
+    return '6.1';
+  }
 
-    const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];
+  const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];
+  const {
+    stdout
+  } = await runXcrunCommand(args, timeout);
+  const sdkVersion = stdout.trim();
+  const match = /\d.\d/.exec(stdout);
 
-    const _ref5 = yield runXcrunCommand(args, timeout),
-          stdout = _ref5.stdout;
-
-    const sdkVersion = stdout.trim();
-    const match = /\d.\d/.exec(stdout);
-
-    if (!match) {
-      throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);
-    }
+  if (!match) {
+    throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);
+  }
 
-    return sdkVersion;
-  });
-  return _getMaxIOSSDKWithoutRetry.apply(this, arguments);
+  return sdkVersion;
 }
 
-const getMaxIOSSDK = _lodash.default.memoize(function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-  return (0, _asyncbox.retry)(retries, getMaxIOSSDKWithoutRetry, timeout);
-});
-
-function getMaxTVOSSDKWithoutRetry() {
-  return _getMaxTVOSSDKWithoutRetry.apply(this, arguments);
+async function getMaxIOSSDKFromXcodeVersion(timeout = XCRUN_TIMEOUT) {
+  const version = await getVersion(true, DEFAULT_NUMBER_OF_RETRIES, timeout);
+  return `${version.major + 2}.${version.minor}`;
 }
 
-function _getMaxTVOSSDKWithoutRetry() {
-  _getMaxTVOSSDKWithoutRetry = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];
+const getMaxIOSSDK = _lodash.default.memoize(function getMaxIOSSDK(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  try {
+    return (0, _asyncbox.retry)(retries, getMaxIOSSDKWithoutRetry, timeout);
+  } catch (err) {
+    log.warn(`Unable to retrieve maximum iOS version: ${err.message}`);
+    log.warn('Guessing from Xcode version');
+    return getMaxIOSSDKFromXcodeVersion(timeout);
+  }
+});
 
-    const _ref6 = yield runXcrunCommand(args, timeout),
-          stdout = _ref6.stdout;
+exports.getMaxIOSSDK = getMaxIOSSDK;
 
-    const sdkVersion = stdout.trim();
+async function getMaxTVOSSDKWithoutRetry(timeout = XCRUN_TIMEOUT) {
+  const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];
+  const {
+    stdout
+  } = await runXcrunCommand(args, timeout);
+  const sdkVersion = stdout.trim();
 
-    if (isNaN(parseFloat(sdkVersion))) {
-      throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);
-    }
+  if (isNaN(parseFloat(sdkVersion))) {
+    throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);
+  }
 
-    return sdkVersion;
-  });
-  return _getMaxTVOSSDKWithoutRetry.apply(this, arguments);
+  return sdkVersion;
 }
 
-const getMaxTVOSSDK = _lodash.default.memoize(function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+const getMaxTVOSSDK = _lodash.default.memoize(function getMaxTVOSSDK(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getMaxTVOSSDKWithoutRetry, timeout);
 });
 
-function getConnectedDevices() {
-  return _getConnectedDevices.apply(this, arguments);
-}
+exports.getMaxTVOSSDK = getMaxTVOSSDK;
 
-function _getConnectedDevices() {
-  _getConnectedDevices = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const cmd = '/usr/sbin/system_profiler';
-    const args = ['-xml', 'SPUSBDataType'];
-
-    let _ref7 = yield (0, _teen_process.exec)(cmd, args, {
-      timeout
-    }),
-        stdout = _ref7.stdout;
-
-    let plistContent = (0, _plist.parse)(stdout);
-    let devicesFound = [];
-    let entriesToSearch = [plistContent[0]];
-
-    while (entriesToSearch.length > 0) {
-      let currentEntry = entriesToSearch.pop();
-
-      if (currentEntry instanceof Array) {
-        entriesToSearch = entriesToSearch.concat(currentEntry);
-      } else if (currentEntry._name && currentEntry._name.substring(0, 4) === "iPad" || currentEntry._name && currentEntry._name.substring(0, 6) === "iPhone" || currentEntry._name && _lodash.default.includes(currentEntry._name, "Apple TV")) {
-        let deviceInfo = {
-          name: currentEntry._name,
-          udid: currentEntry.serial_num,
-          productId: currentEntry.product_id,
-          deviceVersion: currentEntry.bcd_device
-        };
-        devicesFound.push(deviceInfo);
-      } else if (currentEntry._items) {
-        entriesToSearch = entriesToSearch.concat(currentEntry._items);
-      }
-    }
-
-    return devicesFound;
+async function getConnectedDevices(timeout = XCRUN_TIMEOUT) {
+  const cmd = '/usr/sbin/system_profiler';
+  const args = ['-xml', 'SPUSBDataType'];
+  let {
+    stdout
+  } = await (0, _teen_process.exec)(cmd, args, {
+    timeout
   });
-  return _getConnectedDevices.apply(this, arguments);
-}
+  let plistContent = (0, _plist.parse)(stdout);
+  let devicesFound = [];
+  let entriesToSearch = [plistContent[0]];
+
+  while (entriesToSearch.length > 0) {
+    let currentEntry = entriesToSearch.pop();
+
+    if (currentEntry instanceof Array) {
+      entriesToSearch = entriesToSearch.concat(currentEntry);
+    } else if (currentEntry._name && currentEntry._name.substring(0, 4) === 'iPad' || currentEntry._name && currentEntry._name.substring(0, 6) === 'iPhone' || currentEntry._name && _lodash.default.includes(currentEntry._name, 'Apple TV')) {
+      let deviceInfo = {
+        name: currentEntry._name,
+        udid: currentEntry.serial_num,
+        productId: currentEntry.product_id,
+        deviceVersion: currentEntry.bcd_device
+      };
+      devicesFound.push(deviceInfo);
+    } else if (currentEntry._items) {
+      entriesToSearch = entriesToSearch.concat(currentEntry._items);
+    }
+  }
 
-function getInstrumentsPathWithoutRetry() {
-  return _getInstrumentsPathWithoutRetry.apply(this, arguments);
+  return devicesFound;
 }
 
-function _getInstrumentsPathWithoutRetry() {
-  _getInstrumentsPathWithoutRetry = (0, _asyncToGenerator2.default)(function* (timeout = XCRUN_TIMEOUT) {
-    const args = ['-find', 'instruments'];
+async function getInstrumentsPathWithoutRetry(timeout = XCRUN_TIMEOUT) {
+  const args = ['-find', 'instruments'];
+  let {
+    stdout
+  } = await runXcrunCommand(args, timeout);
 
-    let _ref8 = yield runXcrunCommand(args, timeout),
-        stdout = _ref8.stdout;
+  if (!stdout) {
+    stdout = '';
+  }
 
-    if (!stdout) {
-      stdout = "";
-    }
+  let instrumentsPath = stdout.trim();
 
-    let instrumentsPath = stdout.trim();
+  if (!instrumentsPath) {
+    throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);
+  }
 
-    if (!instrumentsPath) {
-      throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);
-    }
-
-    return instrumentsPath;
-  });
-  return _getInstrumentsPathWithoutRetry.apply(this, arguments);
+  return instrumentsPath;
 }
 
-const getInstrumentsPath = _lodash.default.memoize(function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+const getInstrumentsPath = _lodash.default.memoize(function getInstrumentsPath(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getInstrumentsPathWithoutRetry, timeout);
 });
 
+exports.getInstrumentsPath = getInstrumentsPath;
+
 function clearInternalCache() {
   const memoized = [getPath, getVersionMemoized, getAutomationTraceTemplatePath, getMaxIOSSDK, getMaxTVOSSDK, getInstrumentsPath];
   memoized.forEach(f => {
@@ -375,23 +350,7 @@ function clearInternalCache() {
       f.cache = new _lodash.default.memoize.Cache();
     }
   });
-}
+}require('source-map-support').install();
+
 
-var _default = {
-  getPath,
-  getVersion,
-  getAutomationTraceTemplatePath,
-  getMaxIOSSDK,
-  getAutomationTraceTemplatePathWithoutRetry,
-  getMaxIOSSDKWithoutRetry,
-  getConnectedDevices,
-  clearInternalCache,
-  getInstrumentsPath,
-  getCommandLineToolsVersion,
-  getMaxTVOSSDK,
-  getMaxTVOSSDKWithoutRetry
-};
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/xcode.js"],"names":["env","process","XCRUN_TIMEOUT","XCODE_SUBDIR","DEFAULT_NUMBER_OF_RETRIES","log","logger","getLogger","hasExpectedSubDir","path","substring","length","runXcrunCommand","args","timeout","err","stderr","message","getPathFromSymlink","failMessage","warn","symlinkPath","legacySymlinkPath","xcodePath","util","hasContent","DEVELOPER_DIR","customPath","fs","exists","mesg","Error","readlink","replace","RegExp","trim","msg","getPathFromXcodeSelect","stdout","xcodeFolderPath","errorAndThrow","getPath","_","memoize","catch","getVersionWithoutRetry","plistPath","resolve","version","plist","parsePlistFile","semver","coerce","CFBundleShortVersionString","getVersionMemoized","retries","getVersion","parse","versionString","patch","major","minor","versionFloat","parseFloat","undefined","getCommandLineToolsVersion","getVersionFunctions","pkg","ign","match","exec","getAutomationTraceTemplatePathWithoutRetry","extensions","pathPrefix","pathSuffix","automationTraceTemplatePaths","toString","error","getAutomationTraceTemplatePath","getMaxIOSSDKWithoutRetry","sdkVersion","getMaxIOSSDK","getMaxTVOSSDKWithoutRetry","isNaN","getMaxTVOSSDK","getConnectedDevices","cmd","plistContent","devicesFound","entriesToSearch","currentEntry","pop","Array","concat","_name","includes","deviceInfo","name","udid","serial_num","productId","product_id","deviceVersion","bcd_device","push","_items","getInstrumentsPathWithoutRetry","instrumentsPath","join","getInstrumentsPath","clearInternalCache","memoized","forEach","f","cache","Cache"],"mappings":"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","sourcesContent":["import { util, fs, plist, logger } from 'appium-support';\nimport path from 'path';\nimport { retry } from 'asyncbox';\nimport _ from 'lodash';\nimport { parse as parsePlistData } from 'plist';\nimport { exec } from 'teen_process';\nimport semver from 'semver';\n\n\nconst env = process.env;\n\nconst XCRUN_TIMEOUT = 15000;\nconst XCODE_SUBDIR = \"/Contents/Developer\";\nconst DEFAULT_NUMBER_OF_RETRIES = 3;\n\nconst log = logger.getLogger('Xcode');\n\n\nfunction hasExpectedSubDir (path) {\n  return path.substring(path.length - XCODE_SUBDIR.length) === XCODE_SUBDIR;\n}\n\nasync function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {\n  try {\n    return await exec('xcrun', args, {timeout});\n  } catch (err) {\n    // the true error can be hidden within the stderr\n    if (err.stderr) {\n      err.message = `${err.message}: ${err.stderr}`;\n    }\n\n    throw err;\n  }\n}\n\nasync function getPathFromSymlink (failMessage) {\n  // Node's invocation of xcode-select sometimes flakes and returns an empty string.\n  // Not clear why. As a workaround, Appium can reliably deduce the version in use by checking\n  // the locations xcode-select uses to store the selected version's path. This should be 100%\n  // reliable so long as the link locations remain the same. However, since we're relying on\n  // hardcoded paths, this approach will break the next time Apple changes the symlink location.\n  log.warn(`Finding XcodePath by symlink because ${failMessage}`);\n\n  const symlinkPath = \"/var/db/xcode_select_link\";\n  const legacySymlinkPath = \"/usr/share/xcode-select/xcode_dir_link\"; //  Xcode < 5.x\n  let xcodePath = null;\n\n  // xcode-select allows users to override its settings with the DEVELOPER_DIR env var,\n  // so check that first\n  if (util.hasContent(env.DEVELOPER_DIR)) {\n    const customPath = hasExpectedSubDir(env.DEVELOPER_DIR)\n      ? env.DEVELOPER_DIR\n      : env.DEVELOPER_DIR + XCODE_SUBDIR;\n\n    if (await fs.exists(customPath)) {\n      xcodePath = customPath;\n    } else {\n      let mesg = `Could not find path to Xcode, environment variable ` +\n                 `DEVELOPER_DIR set to: ${env.DEVELOPER_DIR} ` +\n                 `but no Xcode found`;\n      log.warn(mesg);\n      throw new Error(mesg);\n    }\n  } else if (await fs.exists(symlinkPath)) {\n    xcodePath = await fs.readlink(symlinkPath);\n  } else if (await fs.exists(legacySymlinkPath)) {\n    xcodePath = await fs.readlink(legacySymlinkPath);\n  }\n\n  if (xcodePath) {\n    return xcodePath.replace(new RegExp(\"/$\"), \"\").trim();\n  }\n\n  // We should only get here is we failed to capture xcode-select's stdout and our\n  // other checks failed. Either Apple has moved the symlink to a new location or the user\n  // is not using the default install. 99.999% chance it's the latter, so issue a warning\n  // should we ever hit the edge case.\n  let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;\n  log.warn(msg);\n  throw new Error(msg);\n}\n\nasync function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {\n  let {stdout} = await exec('xcode-select', ['--print-path'], {timeout});\n\n  // trim and remove trailing slash\n  const xcodeFolderPath = stdout.replace(/\\/$/, '').trim();\n\n  if (!util.hasContent(xcodeFolderPath)) {\n    log.errorAndThrow('xcode-select returned an empty string');\n  }\n\n  if (await fs.exists(xcodeFolderPath)) {\n    return xcodeFolderPath;\n  } else {\n    const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;\n    log.errorAndThrow(msg);\n  }\n}\n\nconst getPath = _.memoize(function (timeout = XCRUN_TIMEOUT) {\n  // first we try using xcode-select to find the path\n  // then we try using the symlinks that Apple has by default\n  return getPathFromXcodeSelect(timeout).catch(getPathFromSymlink);\n});\n\n\n\nasync function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const xcodePath = await getPath(timeout);\n\n  // we want to read the CFBundleShortVersionString from Xcode's plist.\n  // It should be in /[root]/XCode.app/Contents/\n  const plistPath = path.resolve(xcodePath, \"..\", \"Info.plist\");\n\n  if (!await fs.exists(plistPath)) {\n    throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);\n  }\n\n  const version = await plist.parsePlistFile(plistPath);\n  return semver.coerce(version.CFBundleShortVersionString);\n}\n\nconst getVersionMemoized = _.memoize(\n  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getVersionWithoutRetry, timeout);\n  }\n);\n\nasync function getVersion (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n  const version = await getVersionMemoized(retries, timeout);\n  // xcode version strings are not exactly semver string: patch versions of 0\n  // are removed (e.g., '10.0.0' => '10.0')\n  const versionString = version.patch > 0 ? version.version : `${version.major}.${version.minor}`;\n  if (!parse) {\n    return versionString;\n  }\n\n  return {\n    versionString,\n    versionFloat: parseFloat(versionString),\n    major: version.major,\n    minor: version.minor,\n    patch: version.patch > 0 ? version.patch : undefined\n  };\n}\n\nasync function getCommandLineToolsVersion () {\n  // there are a number of different ways that the CLI tools version has been\n  // represented. Try them from most reliable to least, falling down the chain\n  const getVersionFunctions = [\n    async () => {\n      let pkg = (await exec('pkgutil', ['--pkgs=com.apple.pkg.DevSDK_.*'])).stdout;\n      return (await exec('pkgutil', [`--pkg-info=${pkg.trim()}`])).stdout;\n    },\n    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.CLTools_Executables`])).stdout,\n    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.DeveloperToolsCLI`])).stdout,\n  ];\n  let stdout;\n  for (let getVersion of getVersionFunctions) {\n    try {\n      stdout = await getVersion();\n      break;\n    } catch (ign) {\n      stdout = '';\n    }\n  }\n\n  // stdout should have a line like `version: 8.0.0.0.1.1472435881`\n  let match = /^version: (.+)$/m.exec(stdout); // https://regex101.com/r/HV3x4d/1\n  return match ? match[1] : undefined;\n}\n\nasync function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const xcodePath = await getPath(timeout);\n\n  // for ios 8 and up, the file extension for AutiomationInstrument changed.\n  // rather than waste time getting the iOSSDKVersion, just get both paths and see which one exists\n  const extensions = ['xrplugin', 'bundle'];\n  const pathPrefix = path.resolve(xcodePath, \"../Applications/Instruments.app/Contents/PlugIns\");\n  const pathSuffix = \"Contents/Resources/Automation.tracetemplate\";\n  let automationTraceTemplatePaths = [\n    path.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix),\n    path.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)\n  ];\n\n  if (await fs.exists(automationTraceTemplatePaths[0])) {\n    return automationTraceTemplatePaths[0];\n  }\n\n  if (await fs.exists(automationTraceTemplatePaths[1])) {\n    return automationTraceTemplatePaths[1];\n  }\n\n  const msg = \"Could not find Automation.tracetemplate in any of the following\" +\n              `locations ${automationTraceTemplatePaths.toString()}`;\n  log.error(msg);\n  throw new Error(msg);\n\n}\n\nconst getAutomationTraceTemplatePath = _.memoize(\n  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);\n  }\n);\n\nasync function getMaxIOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const version = await getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);\n  if (version[0] === '4') {\n    return '6.1';\n  }\n\n  const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n\n  const sdkVersion = stdout.trim();\n  const match = /\\d.\\d/.exec(stdout);\n\n  if (!match) {\n    throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);\n  }\n\n  return sdkVersion;\n}\n\nconst getMaxIOSSDK = _.memoize(\n  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getMaxIOSSDKWithoutRetry, timeout);\n  }\n);\n\nasync function getMaxTVOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n\n  const sdkVersion = stdout.trim();\n\n  if (isNaN(parseFloat(sdkVersion))) {\n    throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);\n  }\n\n  return sdkVersion;\n}\n\nconst getMaxTVOSSDK = _.memoize(\n  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getMaxTVOSSDKWithoutRetry, timeout);\n  }\n);\n\nasync function getConnectedDevices (timeout = XCRUN_TIMEOUT) {\n  const cmd = '/usr/sbin/system_profiler';\n  const args = ['-xml', 'SPUSBDataType'];\n  let {stdout} = await exec(cmd, args, {timeout});\n  let plistContent = parsePlistData(stdout);\n\n  let devicesFound = [];\n  let entriesToSearch = [plistContent[0]];\n  while (entriesToSearch.length > 0) {\n    let currentEntry = entriesToSearch.pop();\n    if (currentEntry instanceof Array) {\n      entriesToSearch = entriesToSearch.concat(currentEntry);\n    } else if ((currentEntry._name &&\n                currentEntry._name.substring(0, 4) === \"iPad\") ||\n               (currentEntry._name &&\n                currentEntry._name.substring(0, 6) === \"iPhone\") ||\n               (currentEntry._name && _.includes(currentEntry._name, \"Apple TV\"))) {\n      let deviceInfo = {\n        name: currentEntry._name,\n        udid: currentEntry.serial_num,\n        productId: currentEntry.product_id,\n        deviceVersion: currentEntry.bcd_device\n      };\n      devicesFound.push(deviceInfo);\n    } else if (currentEntry._items) {\n      entriesToSearch = entriesToSearch.concat(currentEntry._items);\n    }\n  }\n  return devicesFound;\n}\n\nasync function getInstrumentsPathWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['-find', 'instruments'];\n  let {stdout} = await runXcrunCommand(args, timeout);\n\n  if (!stdout) {\n    stdout = \"\";\n  }\n\n  let instrumentsPath = stdout.trim();\n\n  if (!instrumentsPath) {\n    throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);\n  }\n\n  return instrumentsPath;\n}\n\nconst getInstrumentsPath = _.memoize(\n  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getInstrumentsPathWithoutRetry, timeout);\n  }\n);\n\nfunction clearInternalCache () {\n\n  // memoized functions\n  const memoized = [\n    getPath, getVersionMemoized, getAutomationTraceTemplatePath, getMaxIOSSDK,\n    getMaxTVOSSDK, getInstrumentsPath,\n  ];\n\n  memoized.forEach((f) => {\n    if (f.cache) {\n      f.cache = new _.memoize.Cache();\n    }\n  });\n}\n\nexport default {\n  getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,\n  getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,\n  getConnectedDevices, clearInternalCache, getInstrumentsPath,\n  getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,\n};\n"],"file":"lib/xcode.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/xcode.js"],"names":["env","process","XCRUN_TIMEOUT","XCODE_SUBDIR","DEFAULT_NUMBER_OF_RETRIES","log","logger","getLogger","hasExpectedSubDir","path","substring","length","runXcrunCommand","args","timeout","res","_","isUndefined","Error","join","err","stderr","message","getPathFromSymlink","failMessage","warn","symlinkPath","legacySymlinkPath","xcodePath","util","hasContent","DEVELOPER_DIR","customPath","fs","exists","mesg","readlink","replace","RegExp","trim","msg","getPathFromXcodeSelect","stdout","xcodeFolderPath","errorAndThrow","getPath","memoize","catch","getVersionWithoutRetry","plistPath","resolve","version","plist","parsePlistFile","semver","coerce","CFBundleShortVersionString","getVersionMemoized","retries","getVersion","parse","versionString","patch","major","minor","versionFloat","parseFloat","undefined","toString","getCommandLineToolsVersion","getVersionFunctions","pkg","ign","match","exec","getClangVersion","which","e","info","getAutomationTraceTemplatePathWithoutRetry","extensions","pathPrefix","pathSuffix","automationTraceTemplatePaths","error","getAutomationTraceTemplatePath","getMaxIOSSDKWithoutRetry","sdkVersion","getMaxIOSSDKFromXcodeVersion","getMaxIOSSDK","getMaxTVOSSDKWithoutRetry","isNaN","getMaxTVOSSDK","getConnectedDevices","cmd","plistContent","devicesFound","entriesToSearch","currentEntry","pop","Array","concat","_name","includes","deviceInfo","name","udid","serial_num","productId","product_id","deviceVersion","bcd_device","push","_items","getInstrumentsPathWithoutRetry","instrumentsPath","getInstrumentsPath","clearInternalCache","memoized","forEach","f","cache","Cache"],"mappings":"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","sourcesContent":["import { util, fs, plist, logger } from 'appium-support';\nimport path from 'path';\nimport { retry } from 'asyncbox';\nimport _ from 'lodash';\nimport { parse as parsePlistData } from 'plist';\nimport { exec } from 'teen_process';\nimport semver from 'semver';\n\n\nconst env = process.env;\n\nconst XCRUN_TIMEOUT = 15000;\nconst XCODE_SUBDIR = '/Contents/Developer';\nconst DEFAULT_NUMBER_OF_RETRIES = 3;\n\nconst log = logger.getLogger('Xcode');\n\n\nfunction hasExpectedSubDir (path) {\n  return path.substring(path.length - XCODE_SUBDIR.length) === XCODE_SUBDIR;\n}\n\nasync function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {\n  try {\n    const res = await exec('xcrun', args, {timeout});\n    if (_.isUndefined(res)) {\n      throw new Error(`Nothing returned from trying to run 'xcrun ${args.join(' ')}'`);\n    }\n    return res;\n  } catch (err) {\n    // the true error can be hidden within the stderr\n    if (err.stderr) {\n      err.message = `${err.message}: ${err.stderr}`;\n    }\n\n    throw err;\n  }\n}\n\nasync function getPathFromSymlink (failMessage) {\n  // Node's invocation of xcode-select sometimes flakes and returns an empty string.\n  // Not clear why. As a workaround, Appium can reliably deduce the version in use by checking\n  // the locations xcode-select uses to store the selected version's path. This should be 100%\n  // reliable so long as the link locations remain the same. However, since we're relying on\n  // hardcoded paths, this approach will break the next time Apple changes the symlink location.\n  log.warn(`Finding XcodePath by symlink because ${failMessage}`);\n\n  const symlinkPath = '/var/db/xcode_select_link';\n  const legacySymlinkPath = '/usr/share/xcode-select/xcode_dir_link'; //  Xcode < 5.x\n  let xcodePath = null;\n\n  // xcode-select allows users to override its settings with the DEVELOPER_DIR env var,\n  // so check that first\n  if (util.hasContent(env.DEVELOPER_DIR)) {\n    const customPath = hasExpectedSubDir(env.DEVELOPER_DIR)\n      ? env.DEVELOPER_DIR\n      : env.DEVELOPER_DIR + XCODE_SUBDIR;\n\n    if (await fs.exists(customPath)) {\n      xcodePath = customPath;\n    } else {\n      let mesg = `Could not find path to Xcode, environment variable ` +\n                 `DEVELOPER_DIR set to: ${env.DEVELOPER_DIR} ` +\n                 `but no Xcode found`;\n      log.warn(mesg);\n      throw new Error(mesg);\n    }\n  } else if (await fs.exists(symlinkPath)) {\n    xcodePath = await fs.readlink(symlinkPath);\n  } else if (await fs.exists(legacySymlinkPath)) {\n    xcodePath = await fs.readlink(legacySymlinkPath);\n  }\n\n  if (xcodePath) {\n    return xcodePath.replace(new RegExp('/$'), '').trim();\n  }\n\n  // We should only get here is we failed to capture xcode-select's stdout and our\n  // other checks failed. Either Apple has moved the symlink to a new location or the user\n  // is not using the default install. 99.999% chance it's the latter, so issue a warning\n  // should we ever hit the edge case.\n  let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;\n  log.warn(msg);\n  throw new Error(msg);\n}\n\nasync function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {\n  let {stdout} = await exec('xcode-select', ['--print-path'], {timeout});\n\n  // trim and remove trailing slash\n  const xcodeFolderPath = stdout.replace(/\\/$/, '').trim();\n\n  if (!util.hasContent(xcodeFolderPath)) {\n    log.errorAndThrow('xcode-select returned an empty string');\n  }\n\n  if (await fs.exists(xcodeFolderPath)) {\n    return xcodeFolderPath;\n  } else {\n    const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;\n    log.errorAndThrow(msg);\n  }\n}\n\nconst getPath = _.memoize(function getPath (timeout = XCRUN_TIMEOUT) {\n  // first we try using xcode-select to find the path\n  // then we try using the symlinks that Apple has by default\n  return getPathFromXcodeSelect(timeout).catch(getPathFromSymlink);\n});\n\n\n\nasync function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const xcodePath = await getPath(timeout);\n\n  // we want to read the CFBundleShortVersionString from Xcode's plist.\n  // It should be in /[root]/XCode.app/Contents/\n  const plistPath = path.resolve(xcodePath, '..', 'Info.plist');\n\n  if (!await fs.exists(plistPath)) {\n    throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);\n  }\n\n  const version = await plist.parsePlistFile(plistPath);\n  return semver.coerce(version.CFBundleShortVersionString);\n}\n\nconst getVersionMemoized = _.memoize(\n  function getVersionMemoized (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getVersionWithoutRetry, timeout);\n  }\n);\n\nasync function getVersion (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n  const version = await getVersionMemoized(retries, timeout);\n  // xcode version strings are not exactly semver string: patch versions of 0\n  // are removed (e.g., '10.0.0' => '10.0')\n  const versionString = version.patch > 0 ? version.version : `${version.major}.${version.minor}`;\n  if (!parse) {\n    return versionString;\n  }\n\n  return {\n    versionString,\n    versionFloat: parseFloat(versionString),\n    major: version.major,\n    minor: version.minor,\n    patch: version.patch > 0 ? version.patch : undefined,\n    toString () {\n      return versionString;\n    },\n  };\n}\n\nasync function getCommandLineToolsVersion () {\n  // there are a number of different ways that the CLI tools version has been\n  // represented. Try them from most reliable to least, falling down the chain\n  const getVersionFunctions = [\n    async () => {\n      let pkg = (await exec('pkgutil', ['--pkgs=com.apple.pkg.DevSDK_.*'])).stdout;\n      return (await exec('pkgutil', [`--pkg-info=${pkg.trim()}`])).stdout;\n    },\n    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.CLTools_Executables`])).stdout,\n    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.DeveloperToolsCLI`])).stdout,\n  ];\n  let stdout;\n  for (let getVersion of getVersionFunctions) {\n    try {\n      stdout = await getVersion();\n      break;\n    } catch (ign) {\n      stdout = '';\n    }\n  }\n\n  // stdout should have a line like `version: 8.0.0.0.1.1472435881`\n  let match = /^version: (.+)$/m.exec(stdout); // https://regex101.com/r/HV3x4d/1\n  return match ? match[1] : undefined;\n}\n\n/**\n * Check https://trac.macports.org/wiki/XcodeVersionInfo\n * to see the actual mapping between clang and other components.\n *\n * @returns {?string} The actual Clang version in x.x.x.x or x.x.x format,\n * which is supplied with Command Line Tools. `null` is returned\n * if CLT are not installed.\n */\nasync function getClangVersion () {\n  try {\n    await fs.which('clang');\n  } catch (e) {\n    log.info('Cannot find clang executable on the local system. ' +\n      'Are Xcode Command Line Tools installed?');\n    return null;\n  }\n  const {stdout} = await exec('clang', ['--version']);\n  const match = /clang-([0-9.]+)/.exec(stdout);\n  if (!match) {\n    log.info(`Cannot parse clang version from ${stdout}`);\n    return null;\n  }\n  return match[1];\n}\n\nasync function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const xcodePath = await getPath(timeout);\n\n  // for ios 8 and up, the file extension for AutiomationInstrument changed.\n  // rather than waste time getting the iOSSDKVersion, just get both paths and see which one exists\n  const extensions = ['xrplugin', 'bundle'];\n  const pathPrefix = path.resolve(xcodePath, '../Applications/Instruments.app/Contents/PlugIns');\n  const pathSuffix = 'Contents/Resources/Automation.tracetemplate';\n  let automationTraceTemplatePaths = [\n    path.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix),\n    path.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)\n  ];\n\n  if (await fs.exists(automationTraceTemplatePaths[0])) {\n    return automationTraceTemplatePaths[0];\n  }\n\n  if (await fs.exists(automationTraceTemplatePaths[1])) {\n    return automationTraceTemplatePaths[1];\n  }\n\n  const msg = 'Could not find Automation.tracetemplate in any of the following' +\n              `locations ${automationTraceTemplatePaths.toString()}`;\n  log.error(msg);\n  throw new Error(msg);\n\n}\n\nconst getAutomationTraceTemplatePath = _.memoize(\n  function getAutomationTraceTemplatePath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);\n  }\n);\n\nasync function getMaxIOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const version = await getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);\n  if (version[0] === '4') {\n    return '6.1';\n  }\n\n  const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n\n  const sdkVersion = stdout.trim();\n  const match = /\\d.\\d/.exec(stdout);\n\n  if (!match) {\n    throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);\n  }\n\n  return sdkVersion;\n}\n\nasync function getMaxIOSSDKFromXcodeVersion (timeout = XCRUN_TIMEOUT) {\n  const version = await getVersion(true, DEFAULT_NUMBER_OF_RETRIES, timeout);\n  // as of now, the iOS version associated with an Xcode version is\n  // just the Xcode version + 2\n  return `${version.major + 2}.${version.minor}`;\n}\n\nconst getMaxIOSSDK = _.memoize(\n  function getMaxIOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    try {\n      return retry(retries, getMaxIOSSDKWithoutRetry, timeout);\n    } catch (err) {\n      log.warn(`Unable to retrieve maximum iOS version: ${err.message}`);\n      log.warn('Guessing from Xcode version');\n      return getMaxIOSSDKFromXcodeVersion(timeout);\n    }\n  }\n);\n\nasync function getMaxTVOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n\n  const sdkVersion = stdout.trim();\n\n  if (isNaN(parseFloat(sdkVersion))) {\n    throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);\n  }\n\n  return sdkVersion;\n}\n\nconst getMaxTVOSSDK = _.memoize(\n  function getMaxTVOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getMaxTVOSSDKWithoutRetry, timeout);\n  }\n);\n\nasync function getConnectedDevices (timeout = XCRUN_TIMEOUT) {\n  const cmd = '/usr/sbin/system_profiler';\n  const args = ['-xml', 'SPUSBDataType'];\n  let {stdout} = await exec(cmd, args, {timeout});\n  let plistContent = parsePlistData(stdout);\n\n  let devicesFound = [];\n  let entriesToSearch = [plistContent[0]];\n  while (entriesToSearch.length > 0) {\n    let currentEntry = entriesToSearch.pop();\n    if (currentEntry instanceof Array) {\n      entriesToSearch = entriesToSearch.concat(currentEntry);\n    } else if ((currentEntry._name &&\n                currentEntry._name.substring(0, 4) === 'iPad') ||\n               (currentEntry._name &&\n                currentEntry._name.substring(0, 6) === 'iPhone') ||\n               (currentEntry._name && _.includes(currentEntry._name, 'Apple TV'))) {\n      let deviceInfo = {\n        name: currentEntry._name,\n        udid: currentEntry.serial_num,\n        productId: currentEntry.product_id,\n        deviceVersion: currentEntry.bcd_device\n      };\n      devicesFound.push(deviceInfo);\n    } else if (currentEntry._items) {\n      entriesToSearch = entriesToSearch.concat(currentEntry._items);\n    }\n  }\n  return devicesFound;\n}\n\nasync function getInstrumentsPathWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['-find', 'instruments'];\n  let {stdout} = await runXcrunCommand(args, timeout);\n\n  if (!stdout) {\n    stdout = '';\n  }\n\n  let instrumentsPath = stdout.trim();\n\n  if (!instrumentsPath) {\n    throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);\n  }\n\n  return instrumentsPath;\n}\n\nconst getInstrumentsPath = _.memoize(\n  function getInstrumentsPath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getInstrumentsPathWithoutRetry, timeout);\n  }\n);\n\nfunction clearInternalCache () {\n\n  // memoized functions\n  const memoized = [\n    getPath, getVersionMemoized, getAutomationTraceTemplatePath, getMaxIOSSDK,\n    getMaxTVOSSDK, getInstrumentsPath,\n  ];\n\n  memoized.forEach((f) => {\n    if (f.cache) {\n      f.cache = new _.memoize.Cache();\n    }\n  });\n}\n\nexport {\n  getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,\n  getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,\n  getConnectedDevices, clearInternalCache, getInstrumentsPath,\n  getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,\n  getClangVersion,\n};\n"],"file":"lib/xcode.js","sourceRoot":"../.."}

package/index.js

@@ -1,6 +1,21 @@
 // transpile:main
 
-import xcode from './lib/xcode';
+import * as xcode from './lib/xcode';
 
-export { xcode };
+
+const {
+  getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,
+  getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,
+  getConnectedDevices, clearInternalCache, getInstrumentsPath,
+  getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,
+  getClangVersion,
+} = xcode;
+
+export {
+  getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,
+  getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,
+  getConnectedDevices, clearInternalCache, getInstrumentsPath,
+  getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,
+  getClangVersion,
+};
 export default xcode;

package/lib/xcode.js

@@ -10,7 +10,7 @@ import semver from 'semver';
 const env = process.env;
 
 const XCRUN_TIMEOUT = 15000;
-const XCODE_SUBDIR = "/Contents/Developer";
+const XCODE_SUBDIR = '/Contents/Developer';
 const DEFAULT_NUMBER_OF_RETRIES = 3;
 
 const log = logger.getLogger('Xcode');
@@ -22,7 +22,11 @@ function hasExpectedSubDir (path) {
 
 async function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {
   try {
-    return await exec('xcrun', args, {timeout});
+    const res = await exec('xcrun', args, {timeout});
+    if (_.isUndefined(res)) {
+      throw new Error(`Nothing returned from trying to run 'xcrun ${args.join(' ')}'`);
+    }
+    return res;
   } catch (err) {
     // the true error can be hidden within the stderr
     if (err.stderr) {
@@ -41,8 +45,8 @@ async function getPathFromSymlink (failMessage) {
   // hardcoded paths, this approach will break the next time Apple changes the symlink location.
   log.warn(`Finding XcodePath by symlink because ${failMessage}`);
 
-  const symlinkPath = "/var/db/xcode_select_link";
-  const legacySymlinkPath = "/usr/share/xcode-select/xcode_dir_link"; //  Xcode < 5.x
+  const symlinkPath = '/var/db/xcode_select_link';
+  const legacySymlinkPath = '/usr/share/xcode-select/xcode_dir_link'; //  Xcode < 5.x
   let xcodePath = null;
 
   // xcode-select allows users to override its settings with the DEVELOPER_DIR env var,
@@ -68,7 +72,7 @@ async function getPathFromSymlink (failMessage) {
   }
 
   if (xcodePath) {
-    return xcodePath.replace(new RegExp("/$"), "").trim();
+    return xcodePath.replace(new RegExp('/$'), '').trim();
   }
 
   // We should only get here is we failed to capture xcode-select's stdout and our
@@ -98,7 +102,7 @@ async function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {
   }
 }
 
-const getPath = _.memoize(function (timeout = XCRUN_TIMEOUT) {
+const getPath = _.memoize(function getPath (timeout = XCRUN_TIMEOUT) {
   // first we try using xcode-select to find the path
   // then we try using the symlinks that Apple has by default
   return getPathFromXcodeSelect(timeout).catch(getPathFromSymlink);
@@ -111,7 +115,7 @@ async function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {
 
   // we want to read the CFBundleShortVersionString from Xcode's plist.
   // It should be in /[root]/XCode.app/Contents/
-  const plistPath = path.resolve(xcodePath, "..", "Info.plist");
+  const plistPath = path.resolve(xcodePath, '..', 'Info.plist');
 
   if (!await fs.exists(plistPath)) {
     throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);
@@ -122,7 +126,7 @@ async function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {
 }
 
 const getVersionMemoized = _.memoize(
-  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  function getVersionMemoized (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getVersionWithoutRetry, timeout);
   }
 );
@@ -141,7 +145,10 @@ async function getVersion (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, t
     versionFloat: parseFloat(versionString),
     major: version.major,
     minor: version.minor,
-    patch: version.patch > 0 ? version.patch : undefined
+    patch: version.patch > 0 ? version.patch : undefined,
+    toString () {
+      return versionString;
+    },
   };
 }
 
@@ -171,14 +178,39 @@ async function getCommandLineToolsVersion () {
   return match ? match[1] : undefined;
 }
 
+/**
+ * Check https://trac.macports.org/wiki/XcodeVersionInfo
+ * to see the actual mapping between clang and other components.
+ *
+ * @returns {?string} The actual Clang version in x.x.x.x or x.x.x format,
+ * which is supplied with Command Line Tools. `null` is returned
+ * if CLT are not installed.
+ */
+async function getClangVersion () {
+  try {
+    await fs.which('clang');
+  } catch (e) {
+    log.info('Cannot find clang executable on the local system. ' +
+      'Are Xcode Command Line Tools installed?');
+    return null;
+  }
+  const {stdout} = await exec('clang', ['--version']);
+  const match = /clang-([0-9.]+)/.exec(stdout);
+  if (!match) {
+    log.info(`Cannot parse clang version from ${stdout}`);
+    return null;
+  }
+  return match[1];
+}
+
 async function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEOUT) {
   const xcodePath = await getPath(timeout);
 
   // for ios 8 and up, the file extension for AutiomationInstrument changed.
   // rather than waste time getting the iOSSDKVersion, just get both paths and see which one exists
   const extensions = ['xrplugin', 'bundle'];
-  const pathPrefix = path.resolve(xcodePath, "../Applications/Instruments.app/Contents/PlugIns");
-  const pathSuffix = "Contents/Resources/Automation.tracetemplate";
+  const pathPrefix = path.resolve(xcodePath, '../Applications/Instruments.app/Contents/PlugIns');
+  const pathSuffix = 'Contents/Resources/Automation.tracetemplate';
   let automationTraceTemplatePaths = [
     path.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix),
     path.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)
@@ -192,7 +224,7 @@ async function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEO
     return automationTraceTemplatePaths[1];
   }
 
-  const msg = "Could not find Automation.tracetemplate in any of the following" +
+  const msg = 'Could not find Automation.tracetemplate in any of the following' +
               `locations ${automationTraceTemplatePaths.toString()}`;
   log.error(msg);
   throw new Error(msg);
@@ -200,7 +232,7 @@ async function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEO
 }
 
 const getAutomationTraceTemplatePath = _.memoize(
-  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  function getAutomationTraceTemplatePath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);
   }
 );
@@ -224,9 +256,22 @@ async function getMaxIOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {
   return sdkVersion;
 }
 
+async function getMaxIOSSDKFromXcodeVersion (timeout = XCRUN_TIMEOUT) {
+  const version = await getVersion(true, DEFAULT_NUMBER_OF_RETRIES, timeout);
+  // as of now, the iOS version associated with an Xcode version is
+  // just the Xcode version + 2
+  return `${version.major + 2}.${version.minor}`;
+}
+
 const getMaxIOSSDK = _.memoize(
-  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-    return retry(retries, getMaxIOSSDKWithoutRetry, timeout);
+  function getMaxIOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+    try {
+      return retry(retries, getMaxIOSSDKWithoutRetry, timeout);
+    } catch (err) {
+      log.warn(`Unable to retrieve maximum iOS version: ${err.message}`);
+      log.warn('Guessing from Xcode version');
+      return getMaxIOSSDKFromXcodeVersion(timeout);
+    }
   }
 );
 
@@ -244,7 +289,7 @@ async function getMaxTVOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {
 }
 
 const getMaxTVOSSDK = _.memoize(
-  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  function getMaxTVOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getMaxTVOSSDKWithoutRetry, timeout);
   }
 );
@@ -262,10 +307,10 @@ async function getConnectedDevices (timeout = XCRUN_TIMEOUT) {
     if (currentEntry instanceof Array) {
       entriesToSearch = entriesToSearch.concat(currentEntry);
     } else if ((currentEntry._name &&
-                currentEntry._name.substring(0, 4) === "iPad") ||
+                currentEntry._name.substring(0, 4) === 'iPad') ||
                (currentEntry._name &&
-                currentEntry._name.substring(0, 6) === "iPhone") ||
-               (currentEntry._name && _.includes(currentEntry._name, "Apple TV"))) {
+                currentEntry._name.substring(0, 6) === 'iPhone') ||
+               (currentEntry._name && _.includes(currentEntry._name, 'Apple TV'))) {
       let deviceInfo = {
         name: currentEntry._name,
         udid: currentEntry.serial_num,
@@ -285,7 +330,7 @@ async function getInstrumentsPathWithoutRetry (timeout = XCRUN_TIMEOUT) {
   let {stdout} = await runXcrunCommand(args, timeout);
 
   if (!stdout) {
-    stdout = "";
+    stdout = '';
   }
 
   let instrumentsPath = stdout.trim();
@@ -298,7 +343,7 @@ async function getInstrumentsPathWithoutRetry (timeout = XCRUN_TIMEOUT) {
 }
 
 const getInstrumentsPath = _.memoize(
-  function (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+  function getInstrumentsPath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getInstrumentsPathWithoutRetry, timeout);
   }
 );
@@ -318,9 +363,10 @@ function clearInternalCache () {
   });
 }
 
-export default {
+export {
   getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,
   getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,
   getConnectedDevices, clearInternalCache, getInstrumentsPath,
   getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,
+  getClangVersion,
 };

package/package.json

@@ -6,7 +6,7 @@
     "ios",
     "xcode"
   ],
-  "version": "3.7.1",
+  "version": "3.10.0",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {
@@ -36,7 +36,7 @@
     "asyncbox": "^2.3.0",
     "lodash": "^4.17.4",
     "plist": "^3.0.1",
-    "semver": "^5.5.0",
+    "semver": "^7.0.0",
     "source-map-support": "^0.5.5",
     "teen_process": "^1.3.0"
   },
@@ -59,17 +59,12 @@
   ],
   "devDependencies": {
     "ajv": "^6.5.3",
-    "appium-gulp-plugins": "^3.1.0",
-    "babel-eslint": "^10.0.0",
+    "appium-gulp-plugins": "^5.0.0",
     "chai": "^4.1.2",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^5.2.0",
-    "eslint-config-appium": "^3.1.0",
-    "eslint-plugin-import": "^2.2.0",
-    "eslint-plugin-mocha": "^5.0.0",
-    "eslint-plugin-promise": "^4.0.0",
+    "eslint-config-appium": "^4.2.0",
     "gulp": "^4.0.0",
-    "mocha": "^5.1.1",
+    "mocha": "^7.0.1",
     "pre-commit": "^1.1.3"
   },
   "greenkeeper": {