appium-xcuitest-driver 3.60.1 → 3.61.0

package/build/lib/device-log/ios-crash-log.js

@@ -21,9 +21,15 @@ var _path = _interopRequireDefault(require("path"));
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
+var _pyIosDeviceClient = _interopRequireDefault(require("../py-ios-device-client"));
+
+const REAL_DEVICE_MAGIC = '3620bbb0-fb9f-4b62-a668-896f2edc4d88';
+const MAGIC_SEP = '/';
+
 class IOSCrashLog {
   constructor(opts = {}) {
     this.udid = opts.udid;
+    this.pyideviceClient = this.udid ? new _pyIosDeviceClient.default(this.udid) : null;
     const logDir = opts.udid ? _path.default.resolve(process.env.HOME, 'Library', 'Logs', 'CrashReporter', 'MobileDevice') : _path.default.resolve(process.env.HOME, 'Library', 'Logs', 'DiagnosticReports');
     this.logDir = logDir || _path.default.resolve(process.env.HOME || '/', 'Library', 'Logs', 'DiagnosticReports');
     this.prevLogs = [];
@@ -32,7 +38,11 @@ class IOSCrashLog {
     this.sim = opts.sim;
   }
 
-  async getCrashes() {
+  async _gatherFromRealDevice() {
+    if (await this.pyideviceClient.assertExists(false)) {
+      return (await this.pyideviceClient.listCrashes()).map(x => `${REAL_DEVICE_MAGIC}${MAGIC_SEP}${x}`);
+    }
+
     let crashLogsRoot = this.logDir;
 
     if (this.udid) {
@@ -49,11 +59,19 @@ class IOSCrashLog {
     const foundFiles = await _appiumSupport.fs.glob(`${crashLogsRoot}/**/*.crash`, {
       strict: false
     });
+    return foundFiles;
+  }
 
-    if (this.udid) {
-      return foundFiles;
+  async _gatherFromSimulator() {
+    if (!(await _appiumSupport.fs.exists(this.logDir))) {
+      _logger.default.debug(`Crash reports root '${this.logDir}' does not exist. Got nothing to gather.`);
+
+      return [];
     }
 
+    const foundFiles = await _appiumSupport.fs.glob(`${this.logDir}/**/*.crash`, {
+      strict: false
+    });
     return await _bluebird.default.filter(foundFiles, async x => {
       try {
         const content = await _appiumSupport.fs.readFile(x, 'utf8');
@@ -64,6 +82,10 @@ class IOSCrashLog {
     });
   }
 
+  async getCrashes() {
+    return this.udid ? await this._gatherFromRealDevice() : await this._gatherFromSimulator();
+  }
+
   async startCapture() {
     this.prevLogs = await this.getCrashes();
   }
@@ -88,14 +110,34 @@ class IOSCrashLog {
   }
 
   async filesToJSON(paths) {
-    return await _bluebird.default.map(paths, async fullPath => {
-      const stat = await _appiumSupport.fs.stat(fullPath);
-      return {
-        timestamp: stat.ctime.getTime(),
-        level: 'ALL',
-        message: await _appiumSupport.fs.readFile(fullPath, 'utf8')
-      };
-    });
+    const tmpRoot = await _appiumSupport.tempDir.openDir();
+
+    try {
+      return (await _bluebird.default.map(paths, async fullPath => {
+        if (_lodash.default.includes(fullPath, REAL_DEVICE_MAGIC)) {
+          const fileName = _lodash.default.last(fullPath.split(MAGIC_SEP));
+
+          try {
+            await this.pyideviceClient.exportCrash(fileName, tmpRoot);
+          } catch (e) {
+            _logger.default.warn(`Cannot export the crash report '${fileName}'. Skipping it. ` + `Original error: ${e.message}`);
+
+            return;
+          }
+
+          fullPath = _path.default.join(tmpRoot, fileName);
+        }
+
+        const stat = await _appiumSupport.fs.stat(fullPath);
+        return {
+          timestamp: stat.ctime.getTime(),
+          level: 'ALL',
+          message: await _appiumSupport.fs.readFile(fullPath, 'utf8')
+        };
+      })).filter(Boolean);
+    } finally {
+      await _appiumSupport.fs.rimraf(tmpRoot);
+    }
   }
 
 }
@@ -105,4 +147,4 @@ var _default = IOSCrashLog;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/device-log/ios-crash-log.js"],"names":["REAL_DEVICE_MAGIC","MAGIC_SEP","IOSCrashLog","constructor","opts","udid","pyideviceClient","Pyidevice","logDir","path","resolve","process","env","HOME","prevLogs","logsSinceLastRequest","phoneName","sim","_gatherFromRealDevice","assertExists","listCrashes","map","x","crashLogsRoot","utilities","getDeviceName","fs","exists","log","debug","foundFiles","glob","strict","_gatherFromSimulator","B","filter","content","readFile","toUpperCase","includes","err","getCrashes","startCapture","stopCapture","getLogs","crashFiles","diff","_","difference","union","filesToJSON","getAllLogs","logFiles","paths","tmpRoot","tempDir","openDir","fullPath","fileName","last","split","exportCrash","e","warn","message","join","stat","timestamp","ctime","getTime","level","Boolean","rimraf"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA,MAAMA,iBAAiB,GAAG,sCAA1B;AACA,MAAMC,SAAS,GAAG,GAAlB;;AAGA,MAAMC,WAAN,CAAkB;AAChBC,EAAAA,WAAW,CAAEC,IAAI,GAAG,EAAT,EAAa;AACtB,SAAKC,IAAL,GAAYD,IAAI,CAACC,IAAjB;AACA,SAAKC,eAAL,GAAuB,KAAKD,IAAL,GAAY,IAAIE,0BAAJ,CAAc,KAAKF,IAAnB,CAAZ,GAAuC,IAA9D;AACA,UAAMG,MAAM,GAAGJ,IAAI,CAACC,IAAL,GACXI,cAAKC,OAAL,CAAaC,OAAO,CAACC,GAAR,CAAYC,IAAzB,EAA+B,SAA/B,EAA0C,MAA1C,EAAkD,eAAlD,EAAmE,cAAnE,CADW,GAEXJ,cAAKC,OAAL,CAAaC,OAAO,CAACC,GAAR,CAAYC,IAAzB,EAA+B,SAA/B,EAA0C,MAA1C,EAAkD,mBAAlD,CAFJ;AAGA,SAAKL,MAAL,GAAcA,MAAM,IACfC,cAAKC,OAAL,CAAaC,OAAO,CAACC,GAAR,CAAYC,IAAZ,IAAoB,GAAjC,EAAsC,SAAtC,EAAiD,MAAjD,EAAyD,mBAAzD,CADL;AAEA,SAAKC,QAAL,GAAgB,EAAhB;AACA,SAAKC,oBAAL,GAA4B,EAA5B;AACA,SAAKC,SAAL,GAAiB,IAAjB;AACA,SAAKC,GAAL,GAAWb,IAAI,CAACa,GAAhB;AACD;;AAE0B,QAArBC,qBAAqB,GAAI;AAC7B,QAAI,MAAM,KAAKZ,eAAL,CAAqBa,YAArB,CAAkC,KAAlC,CAAV,EAAoD;AAClD,aAAO,CAAC,MAAM,KAAKb,eAAL,CAAqBc,WAArB,EAAP,EACJC,GADI,CACCC,CAAD,IAAQ,GAAEtB,iBAAkB,GAAEC,SAAU,GAAEqB,CAAE,EAD5C,CAAP;AAED;;AAED,QAAIC,aAAa,GAAG,KAAKf,MAAzB;;AACA,QAAI,KAAKH,IAAT,EAAe;AACb,WAAKW,SAAL,GAAiB,KAAKA,SAAL,KAAkB,MAAMQ,2BAAUC,aAAV,CAAwB,KAAKpB,IAA7B,CAAxB,CAAjB;AACAkB,MAAAA,aAAa,GAAGd,cAAKC,OAAL,CAAaa,aAAb,EAA4B,KAAKP,SAAjC,CAAhB;AACD;;AACD,QAAI,EAAC,MAAMU,kBAAGC,MAAH,CAAUJ,aAAV,CAAP,CAAJ,EAAqC;AACnCK,sBAAIC,KAAJ,CAAW,uBAAsBN,aAAc,0CAA/C;;AACA,aAAO,EAAP;AACD;;AACD,UAAMO,UAAU,GAAG,MAAMJ,kBAAGK,IAAH,CAAS,GAAER,aAAc,aAAzB,EAAuC;AAC9DS,MAAAA,MAAM,EAAE;AADsD,KAAvC,CAAzB;AAGA,WAAOF,UAAP;AACD;;AAEyB,QAApBG,oBAAoB,GAAI;AAC5B,QAAI,EAAC,MAAMP,kBAAGC,MAAH,CAAU,KAAKnB,MAAf,CAAP,CAAJ,EAAmC;AACjCoB,sBAAIC,KAAJ,CAAW,uBAAsB,KAAKrB,MAAO,0CAA7C;;AACA,aAAO,EAAP;AACD;;AACD,UAAMsB,UAAU,GAAG,MAAMJ,kBAAGK,IAAH,CAAS,GAAE,KAAKvB,MAAO,aAAvB,EAAqC;AAC5DwB,MAAAA,MAAM,EAAE;AADoD,KAArC,CAAzB;AAIA,WAAO,MAAME,kBAAEC,MAAF,CAASL,UAAT,EAAqB,MAAOR,CAAP,IAAa;AAC7C,UAAI;AACF,cAAMc,OAAO,GAAG,MAAMV,kBAAGW,QAAH,CAAYf,CAAZ,EAAe,MAAf,CAAtB;AACA,eAAOc,OAAO,CAACE,WAAR,GAAsBC,QAAtB,CAA+B,KAAKtB,GAAL,CAASZ,IAAT,CAAciC,WAAd,EAA/B,CAAP;AACD,OAHD,CAGE,OAAOE,GAAP,EAAY;AACZ,eAAO,KAAP;AACD;AACF,KAPY,CAAb;AAQD;;AAEe,QAAVC,UAAU,GAAI;AAClB,WAAO,KAAKpC,IAAL,GACH,MAAM,KAAKa,qBAAL,EADH,GAEH,MAAM,KAAKe,oBAAL,EAFV;AAGD;;AAEiB,QAAZS,YAAY,GAAI;AACpB,SAAK5B,QAAL,GAAgB,MAAM,KAAK2B,UAAL,EAAtB;AACD;;AAEgB,QAAXE,WAAW,GAAI,CAEpB;;AAEY,QAAPC,OAAO,GAAI;AACf,QAAIC,UAAU,GAAG,MAAM,KAAKJ,UAAL,EAAvB;;AACA,QAAIK,IAAI,GAAGC,gBAAEC,UAAF,CAAaH,UAAb,EAAyB,KAAK/B,QAA9B,EAAwC,KAAKC,oBAA7C,CAAX;;AACA,SAAKA,oBAAL,GAA4BgC,gBAAEE,KAAF,CAAQ,KAAKlC,oBAAb,EAAmC+B,IAAnC,CAA5B;AACA,WAAO,MAAM,KAAKI,WAAL,CAAiBJ,IAAjB,CAAb;AACD;;AAEe,QAAVK,UAAU,GAAI;AAClB,QAAIN,UAAU,GAAG,MAAM,KAAKJ,UAAL,EAAvB;;AACA,QAAIW,QAAQ,GAAGL,gBAAEC,UAAF,CAAaH,UAAb,EAAyB,KAAK/B,QAA9B,CAAf;;AACA,WAAO,MAAM,KAAKoC,WAAL,CAAiBE,QAAjB,CAAb;AACD;;AAEgB,QAAXF,WAAW,CAAEG,KAAF,EAAS;AACxB,UAAMC,OAAO,GAAG,MAAMC,uBAAQC,OAAR,EAAtB;;AACA,QAAI;AACF,aAAO,CAAC,MAAMtB,kBAAEb,GAAF,CAAMgC,KAAN,EAAa,MAAOI,QAAP,IAAoB;AAC7C,YAAIV,gBAAER,QAAF,CAAWkB,QAAX,EAAqBzD,iBAArB,CAAJ,EAA6C;AAC3C,gBAAM0D,QAAQ,GAAGX,gBAAEY,IAAF,CAAOF,QAAQ,CAACG,KAAT,CAAe3D,SAAf,CAAP,CAAjB;;AACA,cAAI;AACF,kBAAM,KAAKK,eAAL,CAAqBuD,WAArB,CAAiCH,QAAjC,EAA2CJ,OAA3C,CAAN;AACD,WAFD,CAEE,OAAOQ,CAAP,EAAU;AACVlC,4BAAImC,IAAJ,CAAU,mCAAkCL,QAAS,kBAA5C,GACN,mBAAkBI,CAAC,CAACE,OAAQ,EAD/B;;AAEA;AACD;;AACDP,UAAAA,QAAQ,GAAGhD,cAAKwD,IAAL,CAAUX,OAAV,EAAmBI,QAAnB,CAAX;AACD;;AACD,cAAMQ,IAAI,GAAG,MAAMxC,kBAAGwC,IAAH,CAAQT,QAAR,CAAnB;AACA,eAAO;AACLU,UAAAA,SAAS,EAAED,IAAI,CAACE,KAAL,CAAWC,OAAX,EADN;AAELC,UAAAA,KAAK,EAAE,KAFF;AAGLN,UAAAA,OAAO,EAAE,MAAMtC,kBAAGW,QAAH,CAAYoB,QAAZ,EAAsB,MAAtB;AAHV,SAAP;AAKD,OAlBa,CAAP,EAkBHtB,MAlBG,CAkBIoC,OAlBJ,CAAP;AAmBD,KApBD,SAoBU;AACR,YAAM7C,kBAAG8C,MAAH,CAAUlB,OAAV,CAAN;AACD;AACF;;AA3Ge;;;eA+GHpD,W","sourcesContent":["import { fs, tempDir } from 'appium-support';\nimport B from 'bluebird';\nimport log from '../logger';\nimport { utilities } from 'appium-ios-device';\nimport path from 'path';\nimport _ from 'lodash';\nimport Pyidevice from '../py-ios-device-client';\n\nconst REAL_DEVICE_MAGIC = '3620bbb0-fb9f-4b62-a668-896f2edc4d88';\nconst MAGIC_SEP = '/';\n\n\nclass IOSCrashLog {\n  constructor (opts = {}) {\n    this.udid = opts.udid;\n    this.pyideviceClient = this.udid ? new Pyidevice(this.udid) : null;\n    const logDir = opts.udid\n      ? path.resolve(process.env.HOME, 'Library', 'Logs', 'CrashReporter', 'MobileDevice')\n      : path.resolve(process.env.HOME, 'Library', 'Logs', 'DiagnosticReports');\n    this.logDir = logDir\n      || path.resolve(process.env.HOME || '/', 'Library', 'Logs', 'DiagnosticReports');\n    this.prevLogs = [];\n    this.logsSinceLastRequest = [];\n    this.phoneName = null;\n    this.sim = opts.sim;\n  }\n\n  async _gatherFromRealDevice () {\n    if (await this.pyideviceClient.assertExists(false)) {\n      return (await this.pyideviceClient.listCrashes())\n        .map((x) => `${REAL_DEVICE_MAGIC}${MAGIC_SEP}${x}`);\n    }\n\n    let crashLogsRoot = this.logDir;\n    if (this.udid) {\n      this.phoneName = this.phoneName || await utilities.getDeviceName(this.udid);\n      crashLogsRoot = path.resolve(crashLogsRoot, this.phoneName);\n    }\n    if (!await fs.exists(crashLogsRoot)) {\n      log.debug(`Crash reports root '${crashLogsRoot}' does not exist. Got nothing to gather.`);\n      return [];\n    }\n    const foundFiles = await fs.glob(`${crashLogsRoot}/**/*.crash`, {\n      strict: false\n    });\n    return foundFiles;\n  }\n\n  async _gatherFromSimulator () {\n    if (!await fs.exists(this.logDir)) {\n      log.debug(`Crash reports root '${this.logDir}' does not exist. Got nothing to gather.`);\n      return [];\n    }\n    const foundFiles = await fs.glob(`${this.logDir}/**/*.crash`, {\n      strict: false\n    });\n    // For Simulator only include files, that contain current UDID\n    return await B.filter(foundFiles, async (x) => {\n      try {\n        const content = await fs.readFile(x, 'utf8');\n        return content.toUpperCase().includes(this.sim.udid.toUpperCase());\n      } catch (err) {\n        return false;\n      }\n    });\n  }\n\n  async getCrashes () {\n    return this.udid\n      ? await this._gatherFromRealDevice()\n      : await this._gatherFromSimulator();\n  }\n\n  async startCapture () {\n    this.prevLogs = await this.getCrashes();\n  }\n\n  async stopCapture () {\n    // needed for consistent API with other logs\n  }\n\n  async getLogs () {\n    let crashFiles = await this.getCrashes();\n    let diff = _.difference(crashFiles, this.prevLogs, this.logsSinceLastRequest);\n    this.logsSinceLastRequest = _.union(this.logsSinceLastRequest, diff);\n    return await this.filesToJSON(diff);\n  }\n\n  async getAllLogs () {\n    let crashFiles = await this.getCrashes();\n    let logFiles = _.difference(crashFiles, this.prevLogs);\n    return await this.filesToJSON(logFiles);\n  }\n\n  async filesToJSON (paths) {\n    const tmpRoot = await tempDir.openDir();\n    try {\n      return (await B.map(paths, async (fullPath) => {\n        if (_.includes(fullPath, REAL_DEVICE_MAGIC)) {\n          const fileName = _.last(fullPath.split(MAGIC_SEP));\n          try {\n            await this.pyideviceClient.exportCrash(fileName, tmpRoot);\n          } catch (e) {\n            log.warn(`Cannot export the crash report '${fileName}'. Skipping it. ` +\n              `Original error: ${e.message}`);\n            return;\n          }\n          fullPath = path.join(tmpRoot, fileName);\n        }\n        const stat = await fs.stat(fullPath);\n        return {\n          timestamp: stat.ctime.getTime(),\n          level: 'ALL',\n          message: await fs.readFile(fullPath, 'utf8')\n        };\n      })).filter(Boolean);\n    } finally {\n      await fs.rimraf(tmpRoot);\n    }\n  }\n}\n\nexport { IOSCrashLog };\nexport default IOSCrashLog;\n"],"file":"lib/device-log/ios-crash-log.js","sourceRoot":"../../.."}

package/build/lib/py-ios-device-client.js

@@ -45,6 +45,7 @@ class Pyidevice {
   async execute(args, opts = {}) {
     await this.assertExists();
     const {
+      cwd,
       format = 'json',
       logStdout = false
     } = opts;
@@ -59,7 +60,9 @@ class Pyidevice {
     _logger.default.debug(`Executing ${cmdStr}`);
 
     try {
-      const result = await (0, _teen_process.exec)(this.binaryPath, finalArgs);
+      const result = await (0, _teen_process.exec)(this.binaryPath, finalArgs, {
+        cwd
+      });
 
       if (logStdout) {
         _logger.default.debug(`Command output: ${result.stdout}`);
@@ -78,31 +81,29 @@ class Pyidevice {
     return JSON.parse(stdout);
   }
 
-  async installProfile(opts = {}) {
-    const {
-      profilePath,
-      payload
-    } = opts;
-
+  async installProfile({
+    profilePath,
+    payload
+  } = {}) {
     if (!profilePath && !payload) {
-      throw new TypeError('Profile must be defined');
+      throw new Error('Either the full path to the profile or its payload must be provided');
     }
 
-    if (profilePath) {
-      await this.execute(['profiles', 'install', '--path', profilePath], {
-        logStdout: true
-      });
-    } else {
-      const tmpRoot = await _appiumSupport.tempDir.openDir();
+    let tmpRoot;
+    let srcPath = profilePath;
 
-      const tmpProfilePath = _path.default.join(tmpRoot, 'cert.pem');
+    try {
+      if (!srcPath) {
+        tmpRoot = await _appiumSupport.tempDir.openDir();
+        srcPath = _path.default.join(tmpRoot, 'cert.pem');
+        await _appiumSupport.fs.writeFile(srcPath, payload, 'utf8');
+      }
 
-      try {
-        await _appiumSupport.fs.writeFile(tmpProfilePath, payload, 'utf8');
-        await this.execute(['profiles', 'install', '--path', tmpProfilePath], {
-          logStdout: true
-        });
-      } finally {
+      await this.execute(['profiles', 'install', '--path', srcPath], {
+        logStdout: true
+      });
+    } finally {
+      if (tmpRoot) {
         await _appiumSupport.fs.rimraf(tmpRoot);
       }
     }
@@ -114,6 +115,20 @@ class Pyidevice {
     });
   }
 
+  async listCrashes() {
+    const {
+      stdout
+    } = await this.execute(['crash', 'list']);
+    return JSON.parse(stdout.replace(/'/g, '"')).filter(x => !['.', '..'].includes(x));
+  }
+
+  async exportCrash(name, dstFolder) {
+    await this.execute(['crash', 'export', '--name', name], {
+      logStdout: true,
+      cwd: dstFolder
+    });
+  }
+
 }
 
 exports.Pyidevice = Pyidevice;
@@ -121,4 +136,4 @@ var _default = Pyidevice;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/py-ios-device-client.js"],"names":["BINARY_NAME","Pyidevice","constructor","udid","binaryPath","assertExists","isStrict","fs","which","e","Error","execute","args","opts","cwd","format","logStdout","finalArgs","push","cmdStr","util","quote","log","debug","result","stdout","stderr","message","listProfiles","JSON","parse","installProfile","profilePath","payload","tmpRoot","srcPath","tempDir","openDir","path","join","writeFile","rimraf","removeProfile","name","listCrashes","replace","filter","x","includes","exportCrash","dstFolder"],"mappings":"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","sourcesContent":["import { exec } from 'teen_process';\nimport { fs, util, tempDir } from 'appium-support';\nimport log from './logger';\nimport path from 'path';\n\n// https://github.com/YueChen-C/py-ios-device\n\nconst BINARY_NAME = 'pyidevice';\n\nclass Pyidevice {\n  constructor (udid) {\n    this.udid = udid;\n    this.binaryPath = null;\n  }\n\n  async assertExists (isStrict = true) {\n    if (this.binaryPath) {\n      return true;\n    }\n\n    try {\n      this.binaryPath = await fs.which(BINARY_NAME);\n      return true;\n    } catch (e) {\n      if (isStrict) {\n        throw new Error(`${BINARY_NAME} binary cannot be found in PATH. ` +\n          `Please make sure it is installed. Visit https://github.com/YueChen-C/py-ios-device for ` +\n          `more details.`);\n      }\n      return false;\n    }\n  }\n\n  async execute (args, opts = {}) {\n    await this.assertExists();\n    const {\n      cwd,\n      format = 'json',\n      logStdout = false,\n    } = opts;\n\n    const finalArgs = [...args, '--udid', this.udid];\n    if (format) {\n      finalArgs.push('--format', format);\n    }\n    const cmdStr = util.quote([this.binaryPath, ...finalArgs]);\n    log.debug(`Executing ${cmdStr}`);\n    try {\n      const result = await exec(this.binaryPath, finalArgs, {cwd});\n      if (logStdout) {\n        log.debug(`Command output: ${result.stdout}`);\n      }\n      return result;\n    } catch (e) {\n      throw new Error(`'${cmdStr}' failed. Original error: ${e.stderr || e.stdout || e.message}`);\n    }\n  }\n\n  async listProfiles () {\n    const {stdout} = await this.execute(['profiles', 'list']);\n    return JSON.parse(stdout);\n  }\n\n  async installProfile ({profilePath, payload} = {}) {\n    if (!profilePath && !payload) {\n      throw new Error('Either the full path to the profile or its payload must be provided');\n    }\n\n    let tmpRoot;\n    let srcPath = profilePath;\n    try {\n      if (!srcPath) {\n        tmpRoot = await tempDir.openDir();\n        srcPath = path.join(tmpRoot, 'cert.pem');\n        await fs.writeFile(srcPath, payload, 'utf8');\n      }\n      await this.execute(['profiles', 'install', '--path', srcPath], {\n        logStdout: true\n      });\n    } finally {\n      if (tmpRoot) {\n        await fs.rimraf(tmpRoot);\n      }\n    }\n  }\n\n  async removeProfile (name) {\n    await this.execute(['profiles', 'remove', name], {logStdout: true});\n  }\n\n  async listCrashes () {\n    const {stdout} = await this.execute(['crash', 'list']);\n    return JSON.parse(stdout.replace(/'/g, '\"')).filter((x) => !['.', '..'].includes(x));\n  }\n\n  async exportCrash (name, dstFolder) {\n    await this.execute(['crash', 'export', '--name', name], {\n      logStdout: true,\n      // The tool exports crash reports to the current working dir\n      cwd: dstFolder\n    });\n  }\n}\n\nexport { Pyidevice };\nexport default Pyidevice;\n"],"file":"lib/py-ios-device-client.js","sourceRoot":"../.."}

package/lib/device-log/ios-crash-log.js

@@ -1,14 +1,19 @@
-import { fs } from 'appium-support';
+import { fs, tempDir } from 'appium-support';
 import B from 'bluebird';
 import log from '../logger';
 import { utilities } from 'appium-ios-device';
 import path from 'path';
 import _ from 'lodash';
+import Pyidevice from '../py-ios-device-client';
+
+const REAL_DEVICE_MAGIC = '3620bbb0-fb9f-4b62-a668-896f2edc4d88';
+const MAGIC_SEP = '/';
 
 
 class IOSCrashLog {
   constructor (opts = {}) {
     this.udid = opts.udid;
+    this.pyideviceClient = this.udid ? new Pyidevice(this.udid) : null;
     const logDir = opts.udid
       ? path.resolve(process.env.HOME, 'Library', 'Logs', 'CrashReporter', 'MobileDevice')
       : path.resolve(process.env.HOME, 'Library', 'Logs', 'DiagnosticReports');
@@ -20,7 +25,12 @@ class IOSCrashLog {
     this.sim = opts.sim;
   }
 
-  async getCrashes () {
+  async _gatherFromRealDevice () {
+    if (await this.pyideviceClient.assertExists(false)) {
+      return (await this.pyideviceClient.listCrashes())
+        .map((x) => `${REAL_DEVICE_MAGIC}${MAGIC_SEP}${x}`);
+    }
+
     let crashLogsRoot = this.logDir;
     if (this.udid) {
       this.phoneName = this.phoneName || await utilities.getDeviceName(this.udid);
@@ -33,9 +43,17 @@ class IOSCrashLog {
     const foundFiles = await fs.glob(`${crashLogsRoot}/**/*.crash`, {
       strict: false
     });
-    if (this.udid) {
-      return foundFiles;
+    return foundFiles;
+  }
+
+  async _gatherFromSimulator () {
+    if (!await fs.exists(this.logDir)) {
+      log.debug(`Crash reports root '${this.logDir}' does not exist. Got nothing to gather.`);
+      return [];
     }
+    const foundFiles = await fs.glob(`${this.logDir}/**/*.crash`, {
+      strict: false
+    });
     // For Simulator only include files, that contain current UDID
     return await B.filter(foundFiles, async (x) => {
       try {
@@ -47,6 +65,12 @@ class IOSCrashLog {
     });
   }
 
+  async getCrashes () {
+    return this.udid
+      ? await this._gatherFromRealDevice()
+      : await this._gatherFromSimulator();
+  }
+
   async startCapture () {
     this.prevLogs = await this.getCrashes();
   }
@@ -69,14 +93,30 @@ class IOSCrashLog {
   }
 
   async filesToJSON (paths) {
-    return await B.map(paths, async (fullPath) => {
-      const stat = await fs.stat(fullPath);
-      return {
-        timestamp: stat.ctime.getTime(),
-        level: 'ALL',
-        message: await fs.readFile(fullPath, 'utf8')
-      };
-    });
+    const tmpRoot = await tempDir.openDir();
+    try {
+      return (await B.map(paths, async (fullPath) => {
+        if (_.includes(fullPath, REAL_DEVICE_MAGIC)) {
+          const fileName = _.last(fullPath.split(MAGIC_SEP));
+          try {
+            await this.pyideviceClient.exportCrash(fileName, tmpRoot);
+          } catch (e) {
+            log.warn(`Cannot export the crash report '${fileName}'. Skipping it. ` +
+              `Original error: ${e.message}`);
+            return;
+          }
+          fullPath = path.join(tmpRoot, fileName);
+        }
+        const stat = await fs.stat(fullPath);
+        return {
+          timestamp: stat.ctime.getTime(),
+          level: 'ALL',
+          message: await fs.readFile(fullPath, 'utf8')
+        };
+      })).filter(Boolean);
+    } finally {
+      await fs.rimraf(tmpRoot);
+    }
   }
 }
 

package/lib/py-ios-device-client.js

@@ -34,6 +34,7 @@ class Pyidevice {
   async execute (args, opts = {}) {
     await this.assertExists();
     const {
+      cwd,
       format = 'json',
       logStdout = false,
     } = opts;
@@ -45,7 +46,7 @@ class Pyidevice {
     const cmdStr = util.quote([this.binaryPath, ...finalArgs]);
     log.debug(`Executing ${cmdStr}`);
     try {
-      const result = await exec(this.binaryPath, finalArgs);
+      const result = await exec(this.binaryPath, finalArgs, {cwd});
       if (logStdout) {
         log.debug(`Command output: ${result.stdout}`);
       }
@@ -60,28 +61,24 @@ class Pyidevice {
     return JSON.parse(stdout);
   }
 
-  async installProfile (opts = {}) {
-    const {
-      profilePath,
-      payload,
-    } = opts;
+  async installProfile ({profilePath, payload} = {}) {
     if (!profilePath && !payload) {
-      throw new TypeError('Profile must be defined');
+      throw new Error('Either the full path to the profile or its payload must be provided');
     }
 
-    if (profilePath) {
-      await this.execute(['profiles', 'install', '--path', profilePath], {
+    let tmpRoot;
+    let srcPath = profilePath;
+    try {
+      if (!srcPath) {
+        tmpRoot = await tempDir.openDir();
+        srcPath = path.join(tmpRoot, 'cert.pem');
+        await fs.writeFile(srcPath, payload, 'utf8');
+      }
+      await this.execute(['profiles', 'install', '--path', srcPath], {
         logStdout: true
       });
-    } else {
-      const tmpRoot = await tempDir.openDir();
-      const tmpProfilePath = path.join(tmpRoot, 'cert.pem');
-      try {
-        await fs.writeFile(tmpProfilePath, payload, 'utf8');
-        await this.execute(['profiles', 'install', '--path', tmpProfilePath], {
-          logStdout: true
-        });
-      } finally {
+    } finally {
+      if (tmpRoot) {
         await fs.rimraf(tmpRoot);
       }
     }
@@ -90,6 +87,19 @@ class Pyidevice {
   async removeProfile (name) {
     await this.execute(['profiles', 'remove', name], {logStdout: true});
   }
+
+  async listCrashes () {
+    const {stdout} = await this.execute(['crash', 'list']);
+    return JSON.parse(stdout.replace(/'/g, '"')).filter((x) => !['.', '..'].includes(x));
+  }
+
+  async exportCrash (name, dstFolder) {
+    await this.execute(['crash', 'export', '--name', name], {
+      logStdout: true,
+      // The tool exports crash reports to the current working dir
+      cwd: dstFolder
+    });
+  }
 }
 
 export { Pyidevice };

package/package.json

@@ -8,7 +8,7 @@
     "xcuitest",
     "xctest"
   ],
-  "version": "3.60.1",
+  "version": "3.61.0",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {