gst-atom-xcuitest-driver/build/lib/commands/file-movement.js

ATOM driver for iOS using XCUITest for backend

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getAvailableBundleIds = getAvailableBundleIds;
exports.parseContainerPath = parseContainerPath;
exports.default = exports.commands = void 0;

require("source-map-support/register");

var _lodash = _interopRequireDefault(require("lodash"));

var _appiumSupport = require("appium-support");

var _path = _interopRequireDefault(require("path"));

var _gstAtomIosDriver = require("gst-atom-ios-driver");

var _logger = _interopRequireDefault(require("../logger"));

var _teen_process = require("teen_process");

var _bluebird = _interopRequireDefault(require("bluebird"));

var _gstAtomIosDevice = require("gst-atom-ios-device");

const CONTAINER_PATH_MARKER = '@';
const CONTAINER_PATH_PATTERN = new RegExp(`^${CONTAINER_PATH_MARKER}([^/]+)/(.*)`);
const CONTAINER_TYPE_SEPARATOR = ':';
const IFUSE_CONTAINER_DOCUMENTS = 'documents';
const CONTAINER_DOCUMENTS_PATH = 'Documents';
const IO_TIMEOUT = 60000;
const OBJECT_NOT_FOUND_ERROR_MESSAGE = 'OBJECT_NOT_FOUND';
const MAX_PULL_CHUNK_SIZE = 5;
let commands = _gstAtomIosDriver.iosCommands.file;
exports.commands = commands;

function verifyIsSubPath(originalPath, root) {
  const normalizedRoot = _path.default.normalize(root);

  const normalizedPath = _path.default.normalize(_path.default.dirname(originalPath));

  if (normalizedRoot !== originalPath && !normalizedPath.startsWith(normalizedRoot)) {
    _logger.default.errorAndThrow(`'${normalizedPath}' is expected to be a subpath of '${normalizedRoot}'`);
  }
}

async function createAfcClient(udid, bundleId, containerType, opts) {
  opts.udid = udid;

  if (!bundleId) {
    return await _gstAtomIosDevice.services.startAfcService(opts);
  }

  const service = await _gstAtomIosDevice.services.startHouseArrestService(opts);

  if (isDocuments(containerType)) {
    return await service.vendDocuments(bundleId);
  } else {
    return await service.vendContainer(bundleId);
  }
}

function isDocuments(containerType) {
  return _lodash.default.toLower(containerType) === IFUSE_CONTAINER_DOCUMENTS;
}

async function mkdirpDevice(service, dir) {
  if (dir === '.' || dir === '/') {
    return;
  }

  try {
    await service.listDirectory(dir);
    return;
  } catch (e) {
    await mkdirpDevice(service, _path.default.dirname(dir));
  }

  await service.createDirectory(dir);
}

async function createService(udid, remotePath, opts) {
  if (CONTAINER_PATH_PATTERN.test(remotePath)) {
    const {
      bundleId,
      pathInContainer,
      containerType
    } = await parseContainerPath(remotePath);
    const service = await createAfcClient(udid, bundleId, containerType, opts);
    const relativePath = isDocuments(containerType) ? _path.default.join(CONTAINER_DOCUMENTS_PATH, pathInContainer) : pathInContainer;
    return {
      service,
      relativePath
    };
  } else {
    const service = await createAfcClient(udid, null, null, opts);
    const relativePath = remotePath;
    return {
      service,
      relativePath
    };
  }
}

async function pullFileFromRealDevice(service, relativePath) {
  const stream = await service.createReadStream(relativePath, {
    autoDestroy: true
  });
  const pullPromise = new _bluebird.default((resolve, reject) => {
    stream.on('close', resolve);
    stream.on('error', reject);
  });
  const buffers = [];
  stream.on('data', data => buffers.push(data));

  try {
    await pullPromise.timeout(IO_TIMEOUT);
  } catch (e) {
    throw new Error(`Couldn't pull the file '${relativePath}' ` + `within the given timeout ${IO_TIMEOUT}ms. Original error: ${e.message}`);
  }

  return Buffer.concat(buffers).toString('base64');
}

async function pullFolderFromRealDevice(service, relativePath) {
  const tmpFolder = await _appiumSupport.tempDir.openDir();

  try {
    const folderPath = _path.default.join(tmpFolder, relativePath);

    await (0, _appiumSupport.mkdirp)(folderPath);
    const pullPromises = [];

    const waitForPullChunks = async () => {
      if (_lodash.default.isEmpty(pullPromises)) {
        return;
      }

      try {
        await _bluebird.default.all(pullPromises).timeout(IO_TIMEOUT);
      } catch (e) {
        throw new Error(`Couldn't pull all items in the folder '${relativePath}' ` + `within the given timeout ${IO_TIMEOUT}ms. Original error: ${e.message}`);
      }
    };

    await service.walkDir(relativePath, true, async (itemPath, isDir) => {
      const pathOnServer = _path.default.join(tmpFolder, itemPath);

      if (isDir) {
        await _appiumSupport.fs.mkdir(pathOnServer);
        return;
      }

      const readStream = await service.createReadStream(itemPath, {
        autoDestroy: true
      });

      const writeStream = _appiumSupport.fs.createWriteStream(pathOnServer, {
        autoClose: true
      });

      pullPromises.push(new _bluebird.default((resolve, reject) => {
        writeStream.on('close', resolve);

        const onStreamingError = e => {
          readStream.unpipe(writeStream);
          reject(e);
        };

        writeStream.on('error', onStreamingError);
        readStream.on('error', onStreamingError);
      }));
      readStream.pipe(writeStream);

      if (pullPromises.length % MAX_PULL_CHUNK_SIZE === 0) {
        await waitForPullChunks();
      }
    });
    await waitForPullChunks();
    return (await _appiumSupport.zip.toInMemoryZip(folderPath, {
      encodeToBase64: true
    })).toString();
  } finally {
    await _appiumSupport.fs.rimraf(tmpFolder);
  }
}

async function parseContainerPath(remotePath, containerRootSupplier) {
  const match = CONTAINER_PATH_PATTERN.exec(remotePath);

  if (!match) {
    _logger.default.errorAndThrow(`It is expected that package identifier ` + `starts with '${CONTAINER_PATH_MARKER}' and is separated from the ` + `relative path with a single slash. '${remotePath}' is given instead`);
  }

  let [, bundleId, relativePath] = match;
  let containerType = null;
  const typeSeparatorPos = bundleId.indexOf(CONTAINER_TYPE_SEPARATOR);

  if (typeSeparatorPos > 0 && typeSeparatorPos < bundleId.length - 1) {
    containerType = bundleId.substring(typeSeparatorPos + 1);

    _logger.default.debug(`Parsed container type: ${containerType}`);

    bundleId = bundleId.substring(0, typeSeparatorPos);
  }

  if (_lodash.default.isNil(containerRootSupplier)) {
    const pathInContainer = relativePath;
    return {
      bundleId,
      pathInContainer,
      containerType
    };
  }

  const containerRoot = _lodash.default.isFunction(containerRootSupplier) ? await containerRootSupplier(bundleId, containerType) : containerRootSupplier;

  const pathInContainer = _path.default.posix.resolve(containerRoot, relativePath);

  verifyIsSubPath(pathInContainer, containerRoot);
  return {
    bundleId,
    pathInContainer,
    containerType
  };
}

async function pushFileToSimulator(device, remotePath, base64Data) {
  const buffer = Buffer.from(base64Data, 'base64');

  if (CONTAINER_PATH_PATTERN.test(remotePath)) {
    const {
      bundleId,
      pathInContainer: dstPath
    } = await parseContainerPath(remotePath, async (appBundle, containerType) => await device.simctl.getAppContainer(appBundle, containerType));

    _logger.default.info(`Parsed bundle identifier '${bundleId}' from '${remotePath}'. ` + `Will put the data into '${dstPath}'`);

    if (!(await _appiumSupport.fs.exists(_path.default.dirname(dstPath)))) {
      _logger.default.debug(`The destination folder '${_path.default.dirname(dstPath)}' does not exist. Creating...`);

      await (0, _appiumSupport.mkdirp)(_path.default.dirname(dstPath));
    }

    await _appiumSupport.fs.writeFile(dstPath, buffer);
    return;
  }

  const dstFolder = await _appiumSupport.tempDir.openDir();

  const dstPath = _path.default.resolve(dstFolder, _path.default.basename(remotePath));

  try {
    await _appiumSupport.fs.writeFile(dstPath, buffer);
    await device.simctl.addMedia(dstPath);
  } finally {
    await _appiumSupport.fs.rimraf(dstFolder);
  }
}

async function pushFileToRealDevice(device, remotePath, base64Data, opts) {
  const {
    service,
    relativePath
  } = await createService(device.udid, remotePath, opts);

  try {
    await mkdirpDevice(service, _path.default.dirname(relativePath));
    const stream = await service.createWriteStream(relativePath, {
      autoDestroy: true
    });
    let pushError = null;
    const pushPromise = new _bluebird.default((resolve, reject) => {
      stream.on('error', e => {
        pushError = e;
      });
      stream.on('close', () => {
        if (pushError) {
          reject(pushError);
        } else {
          resolve();
        }
      });
    });
    stream.write(Buffer.from(base64Data, 'base64'));
    stream.end();

    try {
      await pushPromise.timeout(IO_TIMEOUT);
    } catch (e) {
      throw new Error(`Could not push the file within the given timeout ${IO_TIMEOUT}ms. ` + `Original error: ${e.message}`);
    }
  } finally {
    service.close();
  }
}

async function pullFromSimulator(device, remotePath, isFile) {
  let pathOnServer;

  if (CONTAINER_PATH_PATTERN.test(remotePath)) {
    const {
      bundleId,
      pathInContainer: dstPath
    } = await parseContainerPath(remotePath, async (appBundle, containerType) => await device.simctl.getAppContainer(appBundle, containerType));

    _logger.default.info(`Parsed bundle identifier '${bundleId}' from '${remotePath}'. ` + `Will get the data from '${dstPath}'`);

    pathOnServer = dstPath;
  } else {
    const simRoot = device.getDir();
    pathOnServer = _path.default.posix.join(simRoot, remotePath);
    verifyIsSubPath(pathOnServer, simRoot);

    _logger.default.info(`Got the full item path: ${pathOnServer}`);
  }

  if (!(await _appiumSupport.fs.exists(pathOnServer))) {
    _logger.default.errorAndThrow(`The remote ${isFile ? 'file' : 'folder'} at '${pathOnServer}' does not exist`);
  }

  const buffer = isFile ? await _appiumSupport.util.toInMemoryBase64(pathOnServer) : await _appiumSupport.zip.toInMemoryZip(pathOnServer, {
    encodeToBase64: true
  });
  return buffer.toString();
}

async function pullFromRealDevice(device, remotePath, isFile, opts) {
  const {
    service,
    relativePath
  } = await createService(device.udid, remotePath, opts);

  try {
    const fileInfo = await service.getFileInfo(relativePath);

    if (isFile && fileInfo.isDirectory()) {
      throw new Error(`The requested path is not a file. Path: '${remotePath}'`);
    }

    if (!isFile && !fileInfo.isDirectory()) {
      throw new Error(`The requested path is not a folder. Path: '${remotePath}'`);
    }

    if (fileInfo.isFile()) {
      return await pullFileFromRealDevice(service, relativePath);
    } else {
      return await pullFolderFromRealDevice(service, relativePath);
    }
  } catch (e) {
    if (e.message.includes(OBJECT_NOT_FOUND_ERROR_MESSAGE)) {
      throw new Error(`Path '${remotePath}' does not exist on the device`);
    }

    throw e;
  } finally {
    service.close();
  }
}

async function deleteFromSimulator(device, remotePath) {
  let pathOnServer;

  if (CONTAINER_PATH_PATTERN.test(remotePath)) {
    const {
      bundleId,
      pathInContainer: dstPath
    } = await parseContainerPath(remotePath, async (appBundle, containerType) => await device.simctl.getAppContainer(appBundle, containerType));

    _logger.default.info(`Parsed bundle identifier '${bundleId}' from '${remotePath}'. ` + `'${dstPath}' will be deleted`);

    pathOnServer = dstPath;
  } else {
    const simRoot = device.getDir();
    pathOnServer = _path.default.posix.join(simRoot, remotePath);
    verifyIsSubPath(pathOnServer, simRoot);

    _logger.default.info(`Got the full path: ${pathOnServer}`);
  }

  if (!(await _appiumSupport.fs.exists(pathOnServer))) {
    _logger.default.errorAndThrow(`The remote path at '${pathOnServer}' does not exist`);
  }

  await _appiumSupport.fs.rimraf(pathOnServer);
}

async function deleteFromRealDevice(device, remotePath, opts) {
  const {
    service,
    relativePath
  } = await createService(device.udid, remotePath, opts);

  try {
    await service.deleteDirectory(relativePath);
  } catch (e) {
    if (e.message.includes(OBJECT_NOT_FOUND_ERROR_MESSAGE)) {
      throw new Error(`Path '${remotePath}' does not exist on the device`);
    }

    throw e;
  } finally {
    service.close();
  }
}

async function getAvailableBundleIds(udid, opts) {
  opts.udid = udid;
  const service = await _gstAtomIosDevice.services.startInstallationProxyService(opts);

  try {
    const applications = await service.listApplications({
      applicationType: 'User'
    });
    const bundleIds = [];

    for (const [key, value] of Object.entries(applications)) {
      if (!value.UIFileSharingEnabled) {
        continue;
      }

      bundleIds.push(key);
    }

    return bundleIds;
  } finally {
    service.close();
  }
}

commands.pushFile = async function pushFile(remotePath, base64Data, opts) {
  if (remotePath.endsWith('/')) {
    _logger.default.errorAndThrow(`It is expected that remote path points to a file and not to a folder. ` + `'${remotePath}' is given instead`);
  }

  if (_lodash.default.isArray(base64Data)) {
    base64Data = Buffer.from(base64Data).toString('utf8');
  }

  return this.isSimulator() ? await pushFileToSimulator(this.opts.device, remotePath, base64Data) : await pushFileToRealDevice(this.opts.device, remotePath, base64Data, opts);
};

commands.pullFile = async function pullFile(remotePath) {
  if (remotePath.endsWith('/')) {
    _logger.default.errorAndThrow(`It is expected that remote path points to a file and not to a folder. ` + `'${remotePath}' is given instead`);
  }

  return this.isSimulator() ? await pullFromSimulator(this.opts.device, remotePath, true) : await pullFromRealDevice(this.opts.device, remotePath, true, opts);
};

async function deleteFileOrFolder(device, remotePath, isSimulator) {
  return isSimulator ? await deleteFromSimulator(device, remotePath) : await deleteFromRealDevice(device, remotePath, opts);
}

commands.mobileDeleteFolder = async function mobileDeleteFolder(opts = {}) {
  let {
    remotePath
  } = opts;

  if (!remotePath.endsWith('/')) {
    remotePath = `${remotePath}/`;
  }

  return await deleteFileOrFolder(this.opts.device, remotePath, this.isSimulator());
};

commands.mobileDeleteFile = async function mobileDeleteFile(opts = {}) {
  const {
    remotePath
  } = opts;

  if (remotePath.endsWith('/')) {
    _logger.default.errorAndThrow(`It is expected that remote path points to a file and not to a folder. ` + `'${remotePath}' is given instead`);
  }

  return await deleteFileOrFolder(this.opts.device, remotePath, this.isSimulator());
};

commands.getSimFileFullPath = async function getSimFileFullPath(remotePath) {
  let basePath = this.opts.device.getDir();
  let appName = null;

  if (this.opts.app) {
    let appNameRegex = new RegExp(`\\${_path.default.sep}([\\w-]+\\.app)`);
    let appNameMatches = appNameRegex.exec(this.opts.app);

    if (appNameMatches) {
      appName = appNameMatches[1];
    }
  }

  if (_appiumSupport.system.isWindows()) {
    if (remotePath.indexof('://') === 1) {
      remotePath = remotePath.slice(4);
    }
  } else {
    if (remotePath.indexOf('/') === 0) {
      remotePath = remotePath.slice(1);
    }
  }

  if (remotePath.startsWith(appName)) {
    let findPath = basePath;

    if (!this.opts.platformVersion || _appiumSupport.util.compareVersions(this.opts.platformVersion, '>=', '8.0')) {
      findPath = _path.default.resolve(basePath, 'Containers', 'Bundle');
    }

    findPath = findPath.replace(/\s/g, '\\ ');
    let {
      stdout
    } = await (0, _teen_process.exec)('find', [findPath, '-name', appName]);
    let appRoot = stdout.replace(/\n$/, '');
    let subPath = remotePath.substring(appName.length + 1);

    let fullPath = _path.default.resolve(appRoot, subPath);

    _logger.default.debug(`Finding app-relative file: '${fullPath}'`);

    return fullPath;
  }

  let fullPath = _path.default.resolve(basePath, remotePath);

  _logger.default.debug(`Finding sim-relative file: ${fullPath}`);

  return fullPath;
};

commands.pullFolder = async function pullFolder(remotePath) {
  if (!remotePath.endsWith('/')) {
    remotePath = `${remotePath}/`;
  }

  return this.isSimulator() ? await pullFromSimulator(this.opts.device, remotePath, false) : await pullFromRealDevice(this.opts.device, remotePath, false, opts);
};

var _default = commands;
exports.default = _default;require('source-map-support').install();


//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/commands/file-movement.js"],"names":["CONTAINER_PATH_MARKER","CONTAINER_PATH_PATTERN","RegExp","CONTAINER_TYPE_SEPARATOR","IFUSE_CONTAINER_DOCUMENTS","CONTAINER_DOCUMENTS_PATH","IO_TIMEOUT","OBJECT_NOT_FOUND_ERROR_MESSAGE","MAX_PULL_CHUNK_SIZE","commands","iosCommands","file","verifyIsSubPath","originalPath","root","normalizedRoot","path","normalize","normalizedPath","dirname","startsWith","log","errorAndThrow","createAfcClient","udid","bundleId","containerType","opts","services","startAfcService","service","startHouseArrestService","isDocuments","vendDocuments","vendContainer","_","toLower","mkdirpDevice","dir","listDirectory","e","createDirectory","createService","remotePath","test","pathInContainer","parseContainerPath","relativePath","join","pullFileFromRealDevice","stream","createReadStream","autoDestroy","pullPromise","B","resolve","reject","on","buffers","data","push","timeout","Error","message","Buffer","concat","toString","pullFolderFromRealDevice","tmpFolder","tempDir","openDir","folderPath","pullPromises","waitForPullChunks","isEmpty","all","walkDir","itemPath","isDir","pathOnServer","fs","mkdir","readStream","writeStream","createWriteStream","autoClose","onStreamingError","unpipe","pipe","length","zip","toInMemoryZip","encodeToBase64","rimraf","containerRootSupplier","match","exec","typeSeparatorPos","indexOf","substring","debug","isNil","containerRoot","isFunction","posix","pushFileToSimulator","device","base64Data","buffer","from","dstPath","appBundle","simctl","getAppContainer","info","exists","writeFile","dstFolder","basename","addMedia","pushFileToRealDevice","pushError","pushPromise","write","end","close","pullFromSimulator","isFile","simRoot","getDir","util","toInMemoryBase64","pullFromRealDevice","fileInfo","getFileInfo","isDirectory","includes","deleteFromSimulator","deleteFromRealDevice","deleteDirectory","getAvailableBundleIds","startInstallationProxyService","applications","listApplications","applicationType","bundleIds","key","value","Object","entries","UIFileSharingEnabled","pushFile","endsWith","isArray","isSimulator","pullFile","deleteFileOrFolder","mobileDeleteFolder","mobileDeleteFile","getSimFileFullPath","basePath","appName","app","appNameRegex","sep","appNameMatches","system","isWindows","indexof","slice","findPath","platformVersion","compareVersions","replace","stdout","appRoot","subPath","fullPath","pullFolder"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { system, fs, tempDir, mkdirp, zip, util } from 'appium-support';\nimport path from 'path';\nimport { iosCommands } from 'gst-atom-ios-driver';\nimport log from '../logger';\nimport { exec } from 'teen_process';\nimport B from 'bluebird';\nimport { services } from 'gst-atom-ios-device';\n\nconst CONTAINER_PATH_MARKER = '@';\n// https://regex101.com/r/PLdB0G/2\nconst CONTAINER_PATH_PATTERN = new RegExp(`^${CONTAINER_PATH_MARKER}([^/]+)/(.*)`);\nconst CONTAINER_TYPE_SEPARATOR = ':';\nconst IFUSE_CONTAINER_DOCUMENTS = 'documents';\nconst CONTAINER_DOCUMENTS_PATH = 'Documents';\nconst IO_TIMEOUT = 60000;\nconst OBJECT_NOT_FOUND_ERROR_MESSAGE = 'OBJECT_NOT_FOUND';\nconst MAX_PULL_CHUNK_SIZE = 5;\n\nlet commands = iosCommands.file;\n\nfunction verifyIsSubPath (originalPath, root) {\n  const normalizedRoot = path.normalize(root);\n  const normalizedPath = path.normalize(path.dirname(originalPath));\n  // If originalPath is root, `/`, originalPath should equal to normalizedRoot\n  if (normalizedRoot !== originalPath && !normalizedPath.startsWith(normalizedRoot)) {\n    log.errorAndThrow(`'${normalizedPath}' is expected to be a subpath of '${normalizedRoot}'`);\n  }\n}\n\nasync function createAfcClient (udid, bundleId, containerType, opts) {\n  opts.udid = udid;\n  if (!bundleId) {\n    return await services.startAfcService(opts);\n  }\n  const service = await services.startHouseArrestService(opts);\n  if (isDocuments(containerType)) {\n    return await service.vendDocuments(bundleId);\n  } else {\n    return await service.vendContainer(bundleId);\n  }\n}\n\nfunction isDocuments (containerType) {\n  return _.toLower(containerType) === IFUSE_CONTAINER_DOCUMENTS;\n}\n\nasync function mkdirpDevice (service, dir) {\n  if (dir === '.' || dir === '/') {\n    return;\n  }\n  try {\n    await service.listDirectory(dir);\n    return;\n  } catch (e) {\n    // This means that the directory is missing and we got an object not found error. Therefore, we are going to the parent\n    await mkdirpDevice(service, path.dirname(dir));\n  }\n  await service.createDirectory(dir);\n}\n\nasync function createService (udid, remotePath, opts) {\n  if (CONTAINER_PATH_PATTERN.test(remotePath)) {\n    const {bundleId, pathInContainer, containerType} = await parseContainerPath(remotePath);\n    const service = await createAfcClient(udid, bundleId, containerType, opts);\n    const relativePath = isDocuments(containerType) ? path.join(CONTAINER_DOCUMENTS_PATH, pathInContainer) : pathInContainer;\n    return {service, relativePath};\n  } else {\n    const service = await createAfcClient(udid, null, null, opts);\n    const relativePath = remotePath;\n    return {service, relativePath};\n  }\n}\n\nasync function pullFileFromRealDevice (service, relativePath) {\n  const stream = await service.createReadStream(relativePath, { autoDestroy: true });\n  const pullPromise = new B((resolve, reject) => {\n    stream.on('close', resolve);\n    stream.on('error', reject);\n  });\n  const buffers = [];\n  stream.on('data', (data) => buffers.push(data));\n  try {\n    await pullPromise.timeout(IO_TIMEOUT);\n  } catch (e) {\n    throw new Error(`Couldn't pull the file '${relativePath}' ` +\n      `within the given timeout ${IO_TIMEOUT}ms. Original error: ${e.message}`);\n  }\n  return Buffer.concat(buffers).toString('base64');\n}\n\nasync function pullFolderFromRealDevice (service, relativePath) {\n  const tmpFolder = await tempDir.openDir();\n  try {\n    const folderPath = path.join(tmpFolder, relativePath);\n    await mkdirp(folderPath);\n    const pullPromises = [];\n    const waitForPullChunks = async () => {\n      if (_.isEmpty(pullPromises)) {\n        return;\n      }\n\n      try {\n        await B.all(pullPromises).timeout(IO_TIMEOUT);\n      } catch (e) {\n        throw new Error(`Couldn't pull all items in the folder '${relativePath}' ` +\n          `within the given timeout ${IO_TIMEOUT}ms. Original error: ${e.message}`);\n      }\n    };\n    await service.walkDir(relativePath, true, async (itemPath, isDir) => {\n      const pathOnServer = path.join(tmpFolder, itemPath);\n      if (isDir) {\n        await fs.mkdir(pathOnServer);\n        return;\n      }\n\n      const readStream = await service.createReadStream(itemPath, {autoDestroy: true});\n      const writeStream = fs.createWriteStream(pathOnServer, {autoClose: true});\n      pullPromises.push(new B((resolve, reject) => {\n        writeStream.on('close', resolve);\n        const onStreamingError = (e) => {\n          readStream.unpipe(writeStream);\n          reject(e);\n        };\n        writeStream.on('error', onStreamingError);\n        readStream.on('error', onStreamingError);\n      }));\n      readStream.pipe(writeStream);\n      if (pullPromises.length % MAX_PULL_CHUNK_SIZE === 0) {\n        await waitForPullChunks();\n      }\n    });\n    // Wait for the rest of the chunks\n    await waitForPullChunks();\n    return (await zip.toInMemoryZip(folderPath, {\n      encodeToBase64: true,\n    })).toString();\n  } finally {\n    await fs.rimraf(tmpFolder);\n  }\n}\n\n/**\n * @typedef {Object} ContainerObject\n *\n * @property {string} bundleId - The parsed bundle identifier\n * @property {string} pathInContainer - The absolute full path of the item on the local file system\n * @property {?string} containerType - The container type\n */\n\n/**\n * Parses the actual path and the bundle identifier from the given path string\n *\n * @param {string} remotePath - The given path string. The string should\n * match `CONTAINER_PATH_PATTERN` regexp, otherwise an error is going\n * to be thrown. A valid string example: `@bundle.identifier:container_type/relative_path_in_container`\n * @param {Function|string} containerRootSupplier - Either a string, that contains\n * full path to the mount root for real devices or a function, which accepts two parameters\n * (bundle identifier and optional container type) and returns full path to container\n * root folder on the local file system, for Simulator\n * @returns {ContainerObject}\n */\nasync function parseContainerPath (remotePath, containerRootSupplier) {\n  const match = CONTAINER_PATH_PATTERN.exec(remotePath);\n  if (!match) {\n    log.errorAndThrow(`It is expected that package identifier ` +\n      `starts with '${CONTAINER_PATH_MARKER}' and is separated from the ` +\n      `relative path with a single slash. '${remotePath}' is given instead`);\n  }\n  let [, bundleId, relativePath] = match;\n  let containerType = null;\n  const typeSeparatorPos = bundleId.indexOf(CONTAINER_TYPE_SEPARATOR);\n  // We only consider container type exists if its length is greater than zero\n  // not counting the colon\n  if (typeSeparatorPos > 0 && typeSeparatorPos < bundleId.length - 1) {\n    containerType = bundleId.substring(typeSeparatorPos + 1);\n    log.debug(`Parsed container type: ${containerType}`);\n    bundleId = bundleId.substring(0, typeSeparatorPos);\n  }\n  if (_.isNil(conta