appium-xcode 4.0.4 → 5.0.0

package/build/lib/xcode.js

@@ -1,152 +1,135 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.clearInternalCache = clearInternalCache;
-exports.getAutomationTraceTemplatePath = void 0;
-exports.getAutomationTraceTemplatePathWithoutRetry = getAutomationTraceTemplatePathWithoutRetry;
 exports.getClangVersion = getClangVersion;
-exports.getCommandLineToolsVersion = getCommandLineToolsVersion;
-exports.getConnectedDevices = getConnectedDevices;
-exports.getMaxIOSSDK = exports.getInstrumentsPath = void 0;
+exports.getMaxIOSSDK = void 0;
 exports.getMaxIOSSDKWithoutRetry = getMaxIOSSDKWithoutRetry;
 exports.getMaxTVOSSDK = void 0;
 exports.getMaxTVOSSDKWithoutRetry = getMaxTVOSSDKWithoutRetry;
 exports.getPath = void 0;
+exports.getPathFromDeveloperDir = getPathFromDeveloperDir;
+exports.getPathFromXcodeSelect = getPathFromXcodeSelect;
 exports.getVersion = getVersion;
+
 require("source-map-support/register");
+
 var _support = require("@appium/support");
+
 var _path = _interopRequireDefault(require("path"));
+
 var _asyncbox = require("asyncbox");
+
 var _lodash = _interopRequireDefault(require("lodash"));
-var _plist = require("plist");
+
 var _teen_process = require("teen_process");
+
 var _semver = _interopRequireDefault(require("semver"));
-const env = process.env;
-const XCRUN_TIMEOUT = 15000;
-const XCODE_SUBDIR = '/Contents/Developer';
-const DEFAULT_NUMBER_OF_RETRIES = 3;
+
+var _helpers = require("./helpers");
+
+const DEFAULT_NUMBER_OF_RETRIES = 2;
+const XCODE_BUNDLE_ID = 'com.apple.dt.Xcode';
+
 const log = _support.logger.getLogger('Xcode');
-function hasExpectedSubDir(path) {
-  return path.substring(path.length - XCODE_SUBDIR.length) === XCODE_SUBDIR;
-}
-async function runXcrunCommand(args, timeout = XCRUN_TIMEOUT) {
+
+async function getPathFromXcodeSelect(timeout = _helpers.XCRUN_TIMEOUT) {
+  const generateErrorMessage = async prefix => {
+    const xcodePaths = await (0, _helpers.findAppPaths)(XCODE_BUNDLE_ID);
+
+    if (_lodash.default.isEmpty(xcodePaths)) {
+      return `${prefix}. Consider installing Xcode to address this issue.`;
+    }
+
+    const proposals = xcodePaths.map(p => `    sudo xcode-select -s "${_path.default.join(p, 'Contents', 'Developer')}"`);
+    return `${prefix}. ` + `Consider running${proposals.length > 1 ? ' any of' : ''}:\n${'\n'.join(proposals)}\nto address this issue.`;
+  };
+
+  let stdout;
+
   try {
-    const res = await (0, _teen_process.exec)('xcrun', args, {
+    ({
+      stdout
+    } = await (0, _teen_process.exec)('xcode-select', ['--print-path'], {
       timeout
-    });
-    if (_lodash.default.isUndefined(res)) {
-      throw new Error(`Nothing returned from trying to run 'xcrun ${args.join(' ')}'`);
-    }
-    return res;
-  } catch (err) {
-    if (err.stderr) {
-      err.message = `${err.message}: ${err.stderr}`;
-    }
-    throw err;
+    }));
+  } catch (e) {
+    log.errorAndThrow(`Cannot determine the path to Xcode by running 'xcode-select -p' command. ` + `Original error: ${e.stderr || e.message}`);
   }
-}
-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 (_support.util.hasContent(env.DEVELOPER_DIR)) {
-    const customPath = hasExpectedSubDir(env.DEVELOPER_DIR) ? env.DEVELOPER_DIR : env.DEVELOPER_DIR + XCODE_SUBDIR;
-    if (await _support.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 (await _support.fs.exists(symlinkPath)) {
-    xcodePath = await _support.fs.readlink(symlinkPath);
-  } else if (await _support.fs.exists(legacySymlinkPath)) {
-    xcodePath = await _support.fs.readlink(legacySymlinkPath);
+
+  const developerRoot = stdout.replace(/\/$/, '').trim();
+
+  if (!developerRoot) {
+    log.errorAndThrow(await generateErrorMessage(`'xcode-select -p' returned an empty string`));
   }
-  if (xcodePath) {
-    return xcodePath.replace(new RegExp('/$'), '').trim();
+
+  const {
+    CFBundleIdentifier
+  } = await (0, _helpers.readXcodePlist)(developerRoot);
+
+  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {
+    return developerRoot;
   }
-  let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;
-  log.warn(msg);
-  throw new Error(msg);
+
+  log.errorAndThrow(await generateErrorMessage(`'${developerRoot}' is not a valid Xcode path`));
 }
-async function getPathFromXcodeSelect(timeout = XCRUN_TIMEOUT) {
-  let {
-    stdout
-  } = await (0, _teen_process.exec)('xcode-select', ['--print-path'], {
-    timeout
-  });
-  const xcodeFolderPath = stdout.replace(/\/$/, '').trim();
-  if (!_support.util.hasContent(xcodeFolderPath)) {
-    log.errorAndThrow('xcode-select returned an empty string');
-  }
-  if (await _support.fs.exists(xcodeFolderPath)) {
-    return xcodeFolderPath;
-  } else {
-    const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;
-    log.errorAndThrow(msg);
+
+async function getPathFromDeveloperDir() {
+  const developerRoot = process.env.DEVELOPER_DIR;
+  const {
+    CFBundleIdentifier
+  } = await (0, _helpers.readXcodePlist)(developerRoot);
+
+  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {
+    return developerRoot;
   }
+
+  log.errorAndThrow(`The path to Xcode Developer dir '${developerRoot}' provided in DEVELOPER_DIR ` + `environment variable is not a valid path`);
 }
-const getPath = _lodash.default.memoize(function getPath(timeout = XCRUN_TIMEOUT) {
-  return (async () => {
-    try {
-      return await getPathFromXcodeSelect(timeout);
-    } catch (e) {
-      return await getPathFromSymlink(e.message);
-    }
-  })();
+
+const getPath = _lodash.default.memoize(function getPath(timeout = _helpers.XCRUN_TIMEOUT) {
+  return process.env.DEVELOPER_DIR ? getPathFromDeveloperDir() : getPathFromXcodeSelect(timeout);
 });
+
 exports.getPath = getPath;
-async function getVersionWithoutRetry(timeout = XCRUN_TIMEOUT) {
-  const xcodePath = await getPath(timeout);
-  const plistPath = _path.default.resolve(xcodePath, '..', 'Info.plist');
-  if (!(await _support.fs.exists(plistPath))) {
-    throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);
-  }
-  const version = await _support.plist.parsePlistFile(plistPath);
-  return _semver.default.coerce(version.CFBundleShortVersionString);
+
+async function getVersionWithoutRetry(timeout = _helpers.XCRUN_TIMEOUT) {
+  const developerPath = await getPath(timeout);
+  const {
+    CFBundleShortVersionString
+  } = await (0, _helpers.readXcodePlist)(developerPath);
+  return _semver.default.coerce(CFBundleShortVersionString);
 }
-const getVersionMemoized = _lodash.default.memoize(function getVersionMemoized(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+
+const getVersionMemoized = _lodash.default.memoize(function getVersionMemoized(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = _helpers.XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getVersionWithoutRetry, timeout);
 });
-async function getVersion(parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+
+async function getVersion(parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = _helpers.XCRUN_TIMEOUT) {
   const version = await getVersionMemoized(retries, timeout);
   const versionString = version.patch > 0 ? version.version : `${version.major}.${version.minor}`;
+
   if (!parse) {
     return versionString;
   }
+
   return {
     versionString,
     versionFloat: parseFloat(versionString),
     major: version.major,
     minor: version.minor,
     patch: version.patch > 0 ? version.patch : undefined,
+
     toString() {
       return versionString;
     }
+
   };
 }
-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;
-  for (let getVersion of getVersionFunctions) {
-    try {
-      stdout = await getVersion();
-      break;
-    } catch (ign) {
-      stdout = '';
-    }
-  }
-  let match = /^version: (.+)$/m.exec(stdout);
-  return match ? match[1] : undefined;
-}
+
 async function getClangVersion() {
   try {
     await _support.fs.which('clang');
@@ -154,134 +137,58 @@ async function getClangVersion() {
     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];
 }
-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 pathSuffix = 'Contents/Resources/Automation.tracetemplate';
-  let automationTraceTemplatePaths = [_path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix), _path.default.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)];
-  if (await _support.fs.exists(automationTraceTemplatePaths[0])) {
-    return automationTraceTemplatePaths[0];
-  }
-  if (await _support.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);
-}
-const getAutomationTraceTemplatePath = _lodash.default.memoize(function getAutomationTraceTemplatePath(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-  return (0, _asyncbox.retry)(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);
-});
-exports.getAutomationTraceTemplatePath = getAutomationTraceTemplatePath;
-async function getMaxIOSSDKWithoutRetry(timeout = XCRUN_TIMEOUT) {
-  const version = await getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);
-  if (version[0] === '4') {
-    return '6.1';
-  }
+
+async function getMaxIOSSDKWithoutRetry(timeout = _helpers.XCRUN_TIMEOUT) {
   const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];
   const {
     stdout
-  } = await runXcrunCommand(args, timeout);
+  } = await (0, _helpers.runXcrunCommand)(args, timeout);
   const sdkVersion = stdout.trim();
   const match = /\d.\d/.exec(stdout);
+
   if (!match) {
     throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);
   }
+
   return sdkVersion;
 }
-async function getMaxIOSSDKFromXcodeVersion(timeout = XCRUN_TIMEOUT) {
-  const version = await getVersion(true, DEFAULT_NUMBER_OF_RETRIES, timeout);
-  return `${version.major + 2}.${version.minor}`;
-}
-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 getMaxIOSSDK = _lodash.default.memoize(function getMaxIOSSDK(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = _helpers.XCRUN_TIMEOUT) {
+  return (0, _asyncbox.retry)(retries, getMaxIOSSDKWithoutRetry, timeout);
 });
+
 exports.getMaxIOSSDK = getMaxIOSSDK;
-async function getMaxTVOSSDKWithoutRetry(timeout = XCRUN_TIMEOUT) {
+
+async function getMaxTVOSSDKWithoutRetry(timeout = _helpers.XCRUN_TIMEOUT) {
   const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];
   const {
     stdout
-  } = await runXcrunCommand(args, timeout);
+  } = await (0, _helpers.runXcrunCommand)(args, timeout);
   const sdkVersion = stdout.trim();
+
   if (isNaN(parseFloat(sdkVersion))) {
     throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);
   }
+
   return sdkVersion;
 }
-const getMaxTVOSSDK = _lodash.default.memoize(function getMaxTVOSSDK(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
+
+const getMaxTVOSSDK = _lodash.default.memoize(function getMaxTVOSSDK(retries = DEFAULT_NUMBER_OF_RETRIES, timeout = _helpers.XCRUN_TIMEOUT) {
   return (0, _asyncbox.retry)(retries, getMaxTVOSSDKWithoutRetry, timeout);
 });
+
 exports.getMaxTVOSSDK = getMaxTVOSSDK;
-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
-  });
-  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 getInstrumentsPathWithoutRetry(timeout = XCRUN_TIMEOUT) {
-  const args = ['-find', 'instruments'];
-  let {
-    stdout
-  } = await runXcrunCommand(args, timeout);
-  if (!stdout) {
-    stdout = '';
-  }
-  let instrumentsPath = stdout.trim();
-  if (!instrumentsPath) {
-    throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);
-  }
-  return instrumentsPath;
-}
-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 => {
-    if (f.cache) {
-      f.cache = new _lodash.default.memoize.Cache();
-    }
-  });
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["env","process","XCRUN_TIMEOUT","XCODE_SUBDIR","DEFAULT_NUMBER_OF_RETRIES","log","logger","getLogger","hasExpectedSubDir","path","substring","length","runXcrunCommand","args","timeout","res","exec","_","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","e","getVersionWithoutRetry","plistPath","resolve","version","plist","parsePlistFile","semver","coerce","CFBundleShortVersionString","getVersionMemoized","retries","retry","getVersion","parse","versionString","patch","major","minor","versionFloat","parseFloat","undefined","toString","getCommandLineToolsVersion","getVersionFunctions","pkg","ign","match","getClangVersion","which","info","getAutomationTraceTemplatePathWithoutRetry","extensions","pathPrefix","pathSuffix","automationTraceTemplatePaths","error","getAutomationTraceTemplatePath","getMaxIOSSDKWithoutRetry","sdkVersion","getMaxIOSSDKFromXcodeVersion","getMaxIOSSDK","getMaxTVOSSDKWithoutRetry","isNaN","getMaxTVOSSDK","getConnectedDevices","cmd","plistContent","parsePlistData","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"],"sources":["../../lib/xcode.js"],"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 (async () => {\n    try {\n      return await getPathFromXcodeSelect(timeout);\n    } catch (e) {\n      return await getPathFromSymlink(e.message);\n    }\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"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_NUMBER_OF_RETRIES","XCODE_BUNDLE_ID","log","logger","getLogger","getPathFromXcodeSelect","timeout","XCRUN_TIMEOUT","generateErrorMessage","prefix","xcodePaths","findAppPaths","_","isEmpty","proposals","map","p","path","join","length","stdout","exec","e","errorAndThrow","stderr","message","developerRoot","replace","trim","CFBundleIdentifier","readXcodePlist","getPathFromDeveloperDir","process","env","DEVELOPER_DIR","getPath","memoize","getVersionWithoutRetry","developerPath","CFBundleShortVersionString","semver","coerce","getVersionMemoized","retries","retry","getVersion","parse","version","versionString","patch","major","minor","versionFloat","parseFloat","undefined","toString","getClangVersion","fs","which","info","match","getMaxIOSSDKWithoutRetry","args","runXcrunCommand","sdkVersion","Error","getMaxIOSSDK","getMaxTVOSSDKWithoutRetry","isNaN","getMaxTVOSSDK"],"sources":["../../lib/xcode.js"],"sourcesContent":["import { fs, logger } from '@appium/support';\nimport path from 'path';\nimport { retry } from 'asyncbox';\nimport _ from 'lodash';\nimport { exec } from 'teen_process';\nimport semver from 'semver';\nimport {\n  runXcrunCommand, findAppPaths, XCRUN_TIMEOUT, readXcodePlist\n} from './helpers';\n\nconst DEFAULT_NUMBER_OF_RETRIES = 2;\nconst XCODE_BUNDLE_ID = 'com.apple.dt.Xcode';\n\nconst log = logger.getLogger('Xcode');\n\n/**\n * Retrieves the full path to Xcode Developer subfolder via xcode-select\n *\n * @param {number} timeout The maximum timeout for xcode-select execution\n * @returns {Promise<string>} Full path to Xcode Developer subfolder\n * @throws {Error} If it is not possible to retrieve a proper path\n */\nasync function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {\n  const generateErrorMessage = async (prefix) => {\n    const xcodePaths = await findAppPaths(XCODE_BUNDLE_ID);\n    if (_.isEmpty(xcodePaths)) {\n      return `${prefix}. Consider installing Xcode to address this issue.`;\n    }\n\n    const proposals = xcodePaths.map((p) => `    sudo xcode-select -s \"${path.join(p, 'Contents', 'Developer')}\"`);\n    return `${prefix}. ` +\n      `Consider running${proposals.length > 1 ? ' any of' : ''}:\\n${'\\n'.join(proposals)}\\nto address this issue.`;\n  };\n\n  let stdout;\n  try {\n    ({stdout} = await exec('xcode-select', ['--print-path'], {timeout}));\n  } catch (e) {\n    log.errorAndThrow(`Cannot determine the path to Xcode by running 'xcode-select -p' command. ` +\n      `Original error: ${e.stderr || e.message}`);\n  }\n  // trim and remove trailing slash\n  const developerRoot = stdout.replace(/\\/$/, '').trim();\n  if (!developerRoot) {\n    log.errorAndThrow(await generateErrorMessage(`'xcode-select -p' returned an empty string`));\n  }\n  // xcode-select might also return a path to command line tools\n  const {CFBundleIdentifier} = await readXcodePlist(developerRoot);\n  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {\n    return developerRoot;\n  }\n\n  log.errorAndThrow(await generateErrorMessage(`'${developerRoot}' is not a valid Xcode path`));\n}\n\n/**\n * Retrieves the full path to Xcode Developer subfolder via DEVELOPER_DIR environment variable\n *\n * @returns {Promise<string>} Full path to Xcode Developer subfolder\n * @throws {Error} If it is not possible to retrieve a proper path\n */\nasync function getPathFromDeveloperDir () {\n  const developerRoot = process.env.DEVELOPER_DIR;\n  const {CFBundleIdentifier} = await readXcodePlist(developerRoot);\n  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {\n    return developerRoot;\n  }\n\n  log.errorAndThrow(`The path to Xcode Developer dir '${developerRoot}' provided in DEVELOPER_DIR ` +\n    `environment variable is not a valid path`);\n}\n\n/**\n * Retrieves the full path to Xcode Developer subfolder.\n * If DEVELOPER_DIR environment variable is provided then its value has a priority.\n *\n * @property {number} timeout [15000] The maximum timeout for xcode-select execution\n * @returns {string} Full path to Xcode Developer subfolder\n * @throws {Error} If there was an error while retrieving the path.\n */\nconst getPath = _.memoize(function getPath (timeout = XCRUN_TIMEOUT) {\n  return process.env.DEVELOPER_DIR ? getPathFromDeveloperDir() : getPathFromXcodeSelect(timeout);\n});\n\n/**\n * Retrieves Xcode version\n *\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands.\n * @returns {Promise<import(\"semver\").SemVer | null>} Xcode version\n * @throws {Error} If there was a failure while retrieving the version\n */\nasync function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const developerPath = await getPath(timeout);\n  // we want to read the CFBundleShortVersionString from Xcode's plist.\n  const {CFBundleShortVersionString} = await readXcodePlist(developerPath);\n  return semver.coerce(CFBundleShortVersionString);\n}\n\n/**\n * Retrieves Xcode version or the cached one if called more than once\n *\n * @param {number} retries [2] How many retries to apply for version retrieval\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @returns {Promise<import(\"semver\").SemVer | null>} Xcode version\n * @throws {Error} If there was a failure while retrieving the version\n */\nconst getVersionMemoized = _.memoize(\n  function getVersionMemoized (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getVersionWithoutRetry, timeout);\n  }\n);\n\n/**\n * @typedef {Object} XcodeVersion\n * @property {string} versionString Xcode version as a string\n * @property {number} versionFloat Xcode version as a float number\n * @property {number} major Major number of Xcode version\n * @property {number} minor Minor number of Xcode version\n * @property {number?} patch Patch number of Xcode version (if exists)\n */\n\n/**\n * Retrieves Xcode version\n *\n * @param {boolean} parse [false] Whether to parse the version to a XcodeVersion version\n * @param {number} retries [2] How many retries to apply for getting the version number\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @returns {Promise<XcodeVersion | string>} Xcode version depending on the value of `parse` flag\n * @throws {Error} If there was a failure while retrieving the version\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\n/**\n * Check https://trac.macports.org/wiki/XcodeVersionInfo\n * to see the actual mapping between clang and other components.\n *\n * @returns {Promise<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\n/**\n * Retrieves the maximum version of iOS SDK supported by the installed Xcode\n *\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @returns {string} The SDK version\n * @throws {Error} If the SDK version number cannot be determined\n */\nasync function getMaxIOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n  const sdkVersion = stdout.trim();\n  const match = /\\d.\\d/.exec(stdout);\n  if (!match) {\n    throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);\n  }\n  return sdkVersion;\n}\n\n/**\n * Retrieves the maximum version of iOS SDK supported by the installed Xcode\n *\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @param {number} retries [2] The maximum number of retries\n * @returns {string} The SDK version\n * @throws {Error} If the SDK version number cannot be determined\n */\nconst getMaxIOSSDK = _.memoize(\n  function getMaxIOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getMaxIOSSDKWithoutRetry, timeout);\n  }\n);\n\n/**\n * Retrieves the maximum version of tvOS SDK supported by the installed Xcode\n *\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @returns {string} The SDK version\n * @throws {Error} If the SDK version number cannot be determined\n */\nasync function getMaxTVOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {\n  const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];\n  const {stdout} = await runXcrunCommand(args, timeout);\n  const sdkVersion = stdout.trim();\n  if (isNaN(parseFloat(sdkVersion))) {\n    throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);\n  }\n  return sdkVersion;\n}\n\n/**\n * Retrieves the maximum version of tvOS SDK supported by the installed Xcode\n *\n * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands\n * @param {number} retries [2] The maximum number of retries\n * @returns {string} The SDK version\n * @throws {Error} If the SDK version number cannot be determined\n */\nconst getMaxTVOSSDK = _.memoize(\n  function getMaxTVOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {\n    return retry(retries, getMaxTVOSSDKWithoutRetry, timeout);\n  }\n);\n\nexport {\n  getPath, getVersion, getMaxIOSSDK, getMaxIOSSDKWithoutRetry,\n  getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry, getClangVersion,\n  getPathFromDeveloperDir, getPathFromXcodeSelect,\n};\n"],"mappings":"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"}

package/index.js

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

package/lib/helpers.js

@@ -0,0 +1,72 @@
+import _ from 'lodash';
+import B from 'bluebird';
+import { exec } from 'teen_process';
+import { fs, plist } from '@appium/support';
+import path from 'path';
+
+export const XCRUN_TIMEOUT = 15000;
+
+/**
+ * Executes 'xcrun' command line utility
+ *
+ * @param {string[]} args xcrun arguments
+ * @param {number} timeout [15000] The maximum number of milliseconds to wait until xcrun exists
+ * @returns {Promise<import("teen_process").ExecResult>} The result of xcrun execution
+ * @throws {Error} If xcrun returned non-zero exit code or timed out
+ */
+export async function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {
+  try {
+    return await exec('xcrun', args, {timeout});
+  } catch (err) {
+    // the true error can be hidden within the stderr
+    if (err.stderr) {
+      err.message = `${err.message}: ${err.stderr}`;
+    }
+
+    throw err;
+  }
+}
+
+/**
+ * Uses macOS Spotlight service to detect where the given app is installed
+ *
+ * @param {string} bundleId Bundle identifier of the target app
+ * @returns {Promise<string[]>} Full paths to where the app with the given bundle id is present.
+ */
+export async function findAppPaths (bundleId) {
+  let stdout;
+  try {
+    ({stdout} = await exec('/usr/bin/mdfind', [
+      `kMDItemCFBundleIdentifier=${bundleId}`
+    ]));
+  } catch (e) {
+    return [];
+  }
+
+  const matchedPaths = _.trim(stdout)
+    .split('\n')
+    .map(_.trim)
+    .filter(Boolean);
+  if (_.isEmpty(matchedPaths)) {
+    return [];
+  }
+  const results = matchedPaths.map((p) => (async () => {
+    if (await fs.exists(p)) {
+      return p;
+    }
+  })());
+  return (await B.all(results)).filter(Boolean);
+}
+
+/**
+ * Finds and retrieves the content of the Xcode's Info.plist file
+ *
+ * @param {string} developerRoot Full path to the Contents/Developer folder under Xcode.app root
+ * @returns {Promise<object>} All plist entries as an object or an empty object if no plist was found
+ */
+export async function readXcodePlist (developerRoot) {
+  const plistPath = path.resolve(developerRoot, '..', 'Info.plist');
+  return await fs.exists(plistPath)
+    ? await plist.parsePlistFile(plistPath)
+    : {};
+}