appium-xcuitest-driver 10.10.0 → 10.11.0

package/build/lib/app-utils.js

@@ -12,31 +12,31 @@ exports.buildSafariPreferences = buildSafariPreferences;
 exports.onDownloadApp = onDownloadApp;
 exports.onPostConfigureApp = onPostConfigureApp;
 const lodash_1 = __importDefault(require("lodash"));
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const support_1 = require("appium/support");
-const logger_js_1 = __importDefault(require("./logger.js"));
+const logger_1 = require("./logger");
 const node_os_1 = __importDefault(require("node:os"));
 const teen_process_1 = require("teen_process");
 const bluebird_1 = __importDefault(require("bluebird"));
 const node_child_process_1 = require("node:child_process");
 const node_assert_1 = __importDefault(require("node:assert"));
-const utils_js_1 = require("./utils.js");
-const STRINGSDICT_RESOURCE = '.stringsdict';
-const STRINGS_RESOURCE = '.strings';
+const utils_1 = require("./utils");
 exports.SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 exports.APP_EXT = '.app';
 exports.IPA_EXT = '.ipa';
+exports.SUPPORTED_EXTENSIONS = [exports.IPA_EXT, exports.APP_EXT];
+const STRINGSDICT_RESOURCE = '.stringsdict';
+const STRINGS_RESOURCE = '.strings';
 const ZIP_EXT = '.zip';
-const SAFARI_OPTS_ALIASES_MAP = /** @type {const} */ ({
+const SAFARI_OPTS_ALIASES_MAP = {
     safariAllowPopups: [
         ['WebKitJavaScriptCanOpenWindowsAutomatically', 'JavaScriptCanOpenWindowsAutomatically'],
         (x) => Number(Boolean(x)),
     ],
     safariIgnoreFraudWarning: [['WarnAboutFraudulentWebsites'], (x) => Number(!x)],
     safariOpenLinksInBackground: [['OpenLinksInBackground'], (x) => Number(Boolean(x))],
-});
+};
 const MAX_ARCHIVE_SCAN_DEPTH = 1;
-exports.SUPPORTED_EXTENSIONS = [exports.IPA_EXT, exports.APP_EXT];
 const MACOS_RESOURCE_FOLDER = '__MACOSX';
 const SANITIZE_REPLACEMENT = '-';
 const INTEL_ARCH = 'x86_64';
@@ -44,9 +44,7 @@ const INTEL_ARCH = 'x86_64';
  * Verify whether the given application is compatible to the
  * platform where it is going to be installed and tested.
  *
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- * @throws {Error} If bundle architecture does not match the expected device architecture.
+ * @throws If bundle architecture does not match the expected device architecture.
  */
 async function verifyApplicationPlatform() {
     this.log.debug('Verifying application platform');
@@ -54,7 +52,7 @@ async function verifyApplicationPlatform() {
         return;
     }
     const supportedPlatforms = await this.appInfosCache.extractAppPlatforms(this.opts.app);
-    const isTvOS = (0, utils_js_1.isTvOs)(this.opts.platformName);
+    const isTvOS = (0, utils_1.isTvOs)(this.opts.platformName);
     const prefix = isTvOS ? 'AppleTV' : 'iPhone';
     const suffix = this.isSimulator() ? 'Simulator' : 'OS';
     const dstPlatform = `${prefix}${suffix}`;
@@ -65,7 +63,7 @@ async function verifyApplicationPlatform() {
     if (this.isRealDevice()) {
         return;
     }
-    const executablePath = path_1.default.resolve(this.opts.app, await this.appInfosCache.extractExecutableName(this.opts.app));
+    const executablePath = node_path_1.default.resolve(this.opts.app, await this.appInfosCache.extractExecutableName(this.opts.app));
     const [resFile, resUname] = await bluebird_1.default.all([
         (0, teen_process_1.exec)('lipo', ['-info', executablePath]),
         (0, teen_process_1.exec)('uname', ['-m']),
@@ -98,33 +96,8 @@ async function verifyApplicationPlatform() {
     throw new Error(`The ${this.opts.bundleId} application does not support the ${processArch} Simulator ` +
         `architecture:\n${bundleExecutableInfo}\n\n${advice}`);
 }
-/**
- *
- * @param {string} resourcePath
- * @returns {Promise<import('@appium/types').StringRecord>}
- */
-async function readResource(resourcePath) {
-    const data = await support_1.plist.parsePlistFile(resourcePath);
-    const result = {};
-    for (const [key, value] of lodash_1.default.toPairs(data)) {
-        result[key] = lodash_1.default.isString(value) ? value : JSON.stringify(value);
-    }
-    return result;
-}
-/**
- * @typedef {Object} LocalizableStringsOptions
- * @property {string} [app]
- * @property {string} [language='en']
- * @property {string} [localizableStringsDir]
- * @property {string} [stringFile]
- * @property {boolean} [strictMode]
- */
 /**
  * Extracts string resources from an app
- *
- * @this {XCUITestDriver}
- * @param {LocalizableStringsOptions} opts
- * @returns {Promise<import('@appium/types').StringRecord>}
  */
 async function parseLocalizableStrings(opts = {}) {
     const { app, language = 'en', localizableStringsDir, stringFile, strictMode } = opts;
@@ -144,14 +117,13 @@ async function parseLocalizableStrings(opts = {}) {
             tmpRoot = await support_1.tempDir.openDir();
             this.log.info(`Extracting '${app}' into a temporary location to parse its resources`);
             await support_1.zip.extractAllTo(app, tmpRoot);
-            const relativeBundleRoot = /** @type {string} */ (lodash_1.default.first(await findApps(tmpRoot, [exports.APP_EXT])));
+            const relativeBundleRoot = lodash_1.default.first(await findApps(tmpRoot, [exports.APP_EXT]));
             this.log.info(`Selecting '${relativeBundleRoot}'`);
-            bundleRoot = path_1.default.join(tmpRoot, relativeBundleRoot);
+            bundleRoot = node_path_1.default.join(tmpRoot, relativeBundleRoot);
         }
-        /** @type {string|undefined} */
         let lprojRoot;
         for (const subfolder of [`${language}.lproj`, localizableStringsDir, ''].filter(lodash_1.default.isString)) {
-            lprojRoot = path_1.default.resolve(bundleRoot, /** @type {string} */ (subfolder));
+            lprojRoot = node_path_1.default.resolve(bundleRoot, subfolder);
             if (await support_1.fs.exists(lprojRoot)) {
                 break;
             }
@@ -167,7 +139,7 @@ async function parseLocalizableStrings(opts = {}) {
         this.log.info(`Retrieving resource strings from '${lprojRoot}'`);
         const resourcePaths = [];
         if (stringFile) {
-            const dstPath = path_1.default.resolve(/** @type {string} */ (lprojRoot), stringFile);
+            const dstPath = node_path_1.default.resolve(lprojRoot, stringFile);
             if (await support_1.fs.exists(dstPath)) {
                 resourcePaths.push(dstPath);
             }
@@ -179,10 +151,10 @@ async function parseLocalizableStrings(opts = {}) {
                 this.log.info(message);
             }
         }
-        if (lodash_1.default.isEmpty(resourcePaths) && (await support_1.fs.exists(lprojRoot))) {
+        if (lodash_1.default.isEmpty(resourcePaths) && lprojRoot && (await support_1.fs.exists(lprojRoot))) {
             const resourceFiles = (await support_1.fs.readdir(lprojRoot))
                 .filter((name) => lodash_1.default.some([STRINGS_RESOURCE, STRINGSDICT_RESOURCE], (x) => name.endsWith(x)))
-                .map((name) => path_1.default.resolve(lprojRoot, name));
+                .map((name) => node_path_1.default.resolve(lprojRoot, name));
             resourcePaths.push(...resourceFiles);
         }
         this.log.info(`Got ${support_1.util.pluralize('resource file', resourcePaths.length, true)} in '${lprojRoot}'`);
@@ -190,7 +162,7 @@ async function parseLocalizableStrings(opts = {}) {
             return {};
         }
         const resultStrings = {};
-        const toAbsolutePath = (/** @type {string} */ p) => path_1.default.isAbsolute(p) ? p : path_1.default.resolve(process.cwd(), p);
+        const toAbsolutePath = (p) => node_path_1.default.isAbsolute(p) ? p : node_path_1.default.resolve(process.cwd(), p);
         for (const resourcePath of resourcePaths) {
             if (!support_1.util.isSubPath(toAbsolutePath(resourcePath), toAbsolutePath(bundleRoot))) {
                 // security precaution
@@ -214,36 +186,11 @@ async function parseLocalizableStrings(opts = {}) {
         }
     }
 }
-/**
- * Check whether the given path on the file system points to the .app bundle root
- *
- * @param {string} appPath Possible .app bundle root
- * @returns {Promise<boolean>} Whether the given path points to an .app bundle
- */
-async function isAppBundle(appPath) {
-    return (lodash_1.default.endsWith(lodash_1.default.toLower(appPath), exports.APP_EXT) &&
-        (await support_1.fs.stat(appPath)).isDirectory() &&
-        (await support_1.fs.exists(path_1.default.join(appPath, 'Info.plist'))));
-}
-/**
- * Check whether the given path on the file system points to the .ipa file
- *
- * @param {string} appPath Possible .ipa file
- * @returns {Promise<boolean>} Whether the given path points to an .ipa bundle
- */
-async function isIpaBundle(appPath) {
-    return lodash_1.default.endsWith(lodash_1.default.toLower(appPath), exports.IPA_EXT) && (await support_1.fs.stat(appPath)).isFile();
-}
-/**
- * @typedef {Object} UnzipInfo
- * @property {string} rootDir
- * @property {number} archiveSize
- */
 /**
  * Unzips a ZIP archive on the local file system.
  *
- * @param {string} archivePath Full path to a .zip archive
- * @returns {Promise<UnzipInfo>} temporary folder root where the archive has been extracted
+ * @param archivePath Full path to a .zip archive
+ * @returns temporary folder root where the archive has been extracted
  */
 async function unzipFile(archivePath) {
     const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;
@@ -270,9 +217,6 @@ async function unzipFile(archivePath) {
  * Uses bdstar tool for this purpose.
  * This allows to optimize the time needed to prepare the app under test
  * to MAX(download, unzip) instead of SUM(download, unzip)
- *
- * @param {import('node:stream').Readable} zipStream
- * @returns {Promise<UnzipInfo>}
  */
 async function unzipStream(zipStream) {
     const tmpRoot = await support_1.tempDir.openDir();
@@ -288,7 +232,7 @@ async function unzipStream(zipStream) {
     bsdtarProcess.stderr.on('data', (chunk) => {
         const stderr = chunk.toString();
         if (lodash_1.default.trim(stderr)) {
-            logger_js_1.default.warn(stderr);
+            logger_1.log.warn(stderr);
         }
     });
     zipStream.on('data', (chunk) => {
@@ -300,9 +244,9 @@ async function unzipStream(zipStream) {
             zipStream.once('error', reject);
             bsdtarProcess.once('exit', (code, signal) => {
                 zipStream.unpipe(bsdtarProcess.stdin);
-                logger_js_1.default.debug(`bsdtar process exited with code ${code}, signal ${signal}`);
+                logger_1.log.debug(`bsdtar process exited with code ${code}, signal ${signal}`);
                 if (code === 0) {
-                    resolve();
+                    resolve(undefined);
                 }
                 else {
                     reject(new Error('Is it a valid ZIP archive?'));
@@ -329,18 +273,128 @@ async function unzipStream(zipStream) {
     };
 }
 /**
- * Used to parse the file name value from response headers
+ * Builds Safari preferences object based on the given session capabilities
+ *
+ * @param opts
+ * @return
+ */
+function buildSafariPreferences(opts) {
+    const safariSettings = lodash_1.default.cloneDeep(opts?.safariGlobalPreferences ?? {});
+    for (const [name, [aliases, valueConverter]] of lodash_1.default.toPairs(SAFARI_OPTS_ALIASES_MAP)) {
+        if (!lodash_1.default.has(opts, name)) {
+            continue;
+        }
+        for (const alias of aliases) {
+            safariSettings[alias] = valueConverter(opts[name]);
+        }
+    }
+    return safariSettings;
+}
+/**
+ * The callback invoked by configureApp helper
+ * when it is necessary to download the remote application.
+ * We assume the remote file could be anythingm, but only
+ * .zip and .ipa formats are supported.
+ * A .zip archive can contain one or more
+ */
+async function onDownloadApp(opts) {
+    return this.isRealDevice()
+        ? await downloadIpa.bind(this)(opts.stream, opts.headers)
+        : await unzipApp.bind(this)(opts.stream);
+}
+async function onPostConfigureApp(opts) {
+    // Pick the previously cached entry if its integrity has been preserved
+    const appInfo = lodash_1.default.isPlainObject(opts.cachedAppInfo) ? opts.cachedAppInfo : undefined;
+    const cachedPath = appInfo ? appInfo.fullPath : undefined;
+    const shouldUseCachedApp = async () => {
+        if (!appInfo || !cachedPath || !await support_1.fs.exists(cachedPath)) {
+            return false;
+        }
+        const isCachedPathAFile = (await support_1.fs.stat(cachedPath)).isFile();
+        if (isCachedPathAFile) {
+            return await support_1.fs.hash(cachedPath) === appInfo.integrity?.file;
+        }
+        // If the cached path is a folder then it is expected to be previously extracted from
+        // an archive located under appPath whose hash is stored as `cachedAppInfo.packageHash`
+        if (!isCachedPathAFile
+            && opts.cachedAppInfo?.packageHash
+            && opts.appPath
+            && await support_1.fs.exists(opts.appPath)
+            && (await support_1.fs.stat(opts.appPath)).isFile()
+            && opts.cachedAppInfo.packageHash === await support_1.fs.hash(opts.appPath)) {
+            const nestedItemsCountInCache = appInfo.integrity?.folder;
+            if (nestedItemsCountInCache !== undefined) {
+                return (await support_1.fs.glob('**/*', { cwd: cachedPath })).length >= nestedItemsCountInCache;
+            }
+        }
+        return false;
+    };
+    if (await shouldUseCachedApp()) {
+        if (!cachedPath) {
+            return false;
+        }
+        this.log.info(`Using '${cachedPath}' which was cached from '${opts.appPath || 'unknown'}'`);
+        return { appPath: cachedPath };
+    }
+    if (!opts.appPath) {
+        return false;
+    }
+    const isLocalIpa = await isIpaBundle(opts.appPath);
+    const isLocalApp = !isLocalIpa && await isAppBundle(opts.appPath);
+    const isPackageReadyForInstall = isLocalApp || (this.isRealDevice() && isLocalIpa);
+    if (isPackageReadyForInstall) {
+        await this.appInfosCache.put(opts.appPath);
+    }
+    // Only local .app bundles (real device/Simulator)
+    // and .ipa packages for real devices should not be cached
+    if (!opts.isUrl && isPackageReadyForInstall) {
+        return false;
+    }
+    // Cache the app while unpacking the bundle if necessary
+    return {
+        appPath: isPackageReadyForInstall
+            ? opts.appPath
+            : await unzipApp.bind(this)(opts.appPath)
+    };
+}
+// Private functions
+async function readResource(resourcePath) {
+    const data = await support_1.plist.parsePlistFile(resourcePath);
+    return lodash_1.default.toPairs(data).reduce((result, [key, value]) => {
+        result[key] = lodash_1.default.isString(value) ? value : JSON.stringify(value);
+        return result;
+    }, {});
+}
+/**
+ * Check whether the given path on the file system points to the .app bundle root
  *
- * @param {import('@appium/types').HTTPHeaders} headers
- * @returns {string?}
+ * @param appPath Possible .app bundle root
+ * @returns Whether the given path points to an .app bundle
+ */
+async function isAppBundle(appPath) {
+    return (lodash_1.default.endsWith(lodash_1.default.toLower(appPath), exports.APP_EXT) &&
+        (await support_1.fs.stat(appPath)).isDirectory() &&
+        (await support_1.fs.exists(node_path_1.default.join(appPath, 'Info.plist'))));
+}
+/**
+ * Check whether the given path on the file system points to the .ipa file
+ *
+ * @param appPath Possible .ipa file
+ * @returns Whether the given path points to an .ipa bundle
+ */
+async function isIpaBundle(appPath) {
+    return lodash_1.default.endsWith(lodash_1.default.toLower(appPath), exports.IPA_EXT) && (await support_1.fs.stat(appPath)).isFile();
+}
+/**
+ * Used to parse the file name value from response headers
  */
 function parseFileName(headers) {
     const contentDisposition = headers['content-disposition'];
     if (!lodash_1.default.isString(contentDisposition)) {
         return null;
     }
-    if (/^attachment/i.test(/** @type {string} */ (contentDisposition))) {
-        const match = /filename="([^"]+)/i.exec(/** @type {string} */ (contentDisposition));
+    if (/^attachment/i.test(contentDisposition)) {
+        const match = /filename="([^"]+)/i.exec(contentDisposition);
         if (match) {
             return support_1.fs.sanitizeName(match[1], { replacement: SANITIZE_REPLACEMENT });
         }
@@ -349,15 +403,10 @@ function parseFileName(headers) {
 }
 /**
  * Downloads and verifies remote applications for real devices
- *
- * @this {XCUITestDriver}
- * @param {import('node:stream').Readable} stream
- * @param {import('@appium/types').HTTPHeaders} headers
- * @returns {Promise<string>}
  */
 async function downloadIpa(stream, headers) {
     const timer = new support_1.timing.Timer().start();
-    const logPerformance = (/** @type {string} */ dstPath, /** @type {number} */ fileSize, /** @type {string} */ action) => {
+    const logPerformance = (dstPath, fileSize, action) => {
         const secondsElapsed = timer.getDuration().asSeconds;
         this.log.info(`The remote file (${support_1.util.toReadableSizeString(fileSize)}) ` +
             `has been ${action} to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);
@@ -375,7 +424,7 @@ async function downloadIpa(stream, headers) {
             const matchedPaths = await findApps(rootDir, [exports.IPA_EXT]);
             if (!lodash_1.default.isEmpty(matchedPaths)) {
                 this.log.debug(`Found ${support_1.util.pluralize(`${exports.IPA_EXT} application`, matchedPaths.length, true)} in ` +
-                    `'${path_1.default.basename(rootDir)}': ${matchedPaths}`);
+                    `'${node_path_1.default.basename(rootDir)}': ${matchedPaths}`);
             }
             for (const matchedPath of matchedPaths) {
                 try {
@@ -386,7 +435,7 @@ async function downloadIpa(stream, headers) {
                     continue;
                 }
                 this.log.debug(`Selecting the application at '${matchedPath}'`);
-                const isolatedPath = path_1.default.join(await support_1.tempDir.openDir(), path_1.default.basename(matchedPath));
+                const isolatedPath = node_path_1.default.join(await support_1.tempDir.openDir(), node_path_1.default.basename(matchedPath));
                 await support_1.fs.mv(matchedPath, isolatedPath);
                 return isolatedPath;
             }
@@ -429,26 +478,26 @@ async function downloadIpa(stream, headers) {
 /**
  * Looks for items with given extensions in the given folder
  *
- * @param {string} appPath Full path to an app bundle
- * @param {Array<string>} appExtensions List of matching item extensions
- * @returns {Promise<string[]>} List of relative paths to matched items
+ * @param appPath Full path to an app bundle
+ * @param appExtensions List of matching item extensions
+ * @returns List of relative paths to matched items
  */
 async function findApps(appPath, appExtensions) {
     const globPattern = `**/*.+(${appExtensions.map((ext) => ext.replace(/^\./, '')).join('|')})`;
     const sortedBundleItems = (await support_1.fs.glob(globPattern, {
         cwd: appPath,
-    })).sort((a, b) => a.split(path_1.default.sep).length - b.split(path_1.default.sep).length);
+    })).sort((a, b) => a.split(node_path_1.default.sep).length - b.split(node_path_1.default.sep).length);
     return sortedBundleItems;
 }
 /**
  * Moves the application bundle to a newly created temporary folder
  *
- * @param {string} appPath Full path to the .app or .ipa bundle
- * @returns {Promise<string>} The new path to the app bundle.
+ * @param appPath Full path to the .app or .ipa bundle
+ * @returns The new path to the app bundle.
  * The name of the app bundle remains the same
  */
 async function isolateApp(appPath) {
-    const appFileName = path_1.default.basename(appPath);
+    const appFileName = node_path_1.default.basename(appPath);
     if ((await support_1.fs.stat(appPath)).isFile()) {
         const isolatedPath = await support_1.tempDir.path({
             prefix: appFileName,
@@ -458,36 +507,17 @@ async function isolateApp(appPath) {
         return isolatedPath;
     }
     const tmpRoot = await support_1.tempDir.openDir();
-    const isolatedRoot = path_1.default.join(tmpRoot, appFileName);
+    const isolatedRoot = node_path_1.default.join(tmpRoot, appFileName);
     await support_1.fs.mv(appPath, isolatedRoot, { mkdirp: true });
     return isolatedRoot;
 }
-/**
- * Builds Safari preferences object based on the given session capabilities
- *
- * @param {import('./driver').XCUITestDriverOpts} opts
- * @return {import('@appium/types').StringRecord}
- */
-function buildSafariPreferences(opts) {
-    const safariSettings = lodash_1.default.cloneDeep(opts?.safariGlobalPreferences ?? {});
-    for (const [name, [aliases, valueConverter]] of lodash_1.default.toPairs(SAFARI_OPTS_ALIASES_MAP)) {
-        if (!lodash_1.default.has(opts, name)) {
-            continue;
-        }
-        for (const alias of aliases) {
-            safariSettings[alias] = valueConverter(opts[name]);
-        }
-    }
-    return safariSettings;
-}
 /**
  * Unzip the given archive and find a matching .app bundle in it
  *
- * @this {XCUITestDriver}
- * @param {string|import('node:stream').Readable} appPathOrZipStream The path to the archive.
- * @param {number} depth [0] the current nesting depth. App bundles whose nesting level
+ * @param appPathOrZipStream The path to the archive.
+ * @param depth [0] the current nesting depth. App bundles whose nesting level
  * is greater than 1 are not supported.
- * @returns {Promise<string>} Full path to the first matching .app bundle..
+ * @returns Full path to the first matching .app bundle..
  * @throws If no matching .app bundles were found in the provided archive.
  */
 async function unzipApp(appPathOrZipStream, depth = 0) {
@@ -498,20 +528,17 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
         throw new Error(errMsg);
     }
     const timer = new support_1.timing.Timer().start();
-    /** @type {string} */
     let rootDir;
-    /** @type {number} */
     let archiveSize;
     try {
         if (lodash_1.default.isString(appPathOrZipStream)) {
-            ({ rootDir, archiveSize } = await unzipFile(/** @type {string} */ (appPathOrZipStream)));
+            ({ rootDir, archiveSize } = await unzipFile(appPathOrZipStream));
         }
         else {
             if (depth > 0) {
                 node_assert_1.default.fail('Streaming unzip cannot be invoked for nested archive items');
             }
-            ({ rootDir, archiveSize } = await unzipStream(
-            /** @type {import('node:stream').Readable} */ (appPathOrZipStream)));
+            ({ rootDir, archiveSize } = await unzipStream(appPathOrZipStream));
         }
     }
     catch (e) {
@@ -527,7 +554,7 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
         const bytesPerSec = Math.floor(archiveSize / secondsElapsed);
         this.log.debug(`Approximate decompression speed: ${support_1.util.toReadableSizeString(bytesPerSec)}/s`);
     }
-    const isCompatibleWithCurrentPlatform = async (/** @type {string} */ appPath) => {
+    const isCompatibleWithCurrentPlatform = async (appPath) => {
         let platforms;
         try {
             platforms = await this.appInfosCache.extractAppPlatforms(appPath);
@@ -550,15 +577,15 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
     };
     const matchedPaths = await findApps(rootDir, exports.SUPPORTED_EXTENSIONS);
     if (lodash_1.default.isEmpty(matchedPaths)) {
-        this.log.debug(`'${path_1.default.basename(rootDir)}' has no bundles`);
+        this.log.debug(`'${node_path_1.default.basename(rootDir)}' has no bundles`);
     }
     else {
         this.log.debug(`Found ${support_1.util.pluralize('bundle', matchedPaths.length, true)} in ` +
-            `'${path_1.default.basename(rootDir)}': ${matchedPaths}`);
+            `'${node_path_1.default.basename(rootDir)}': ${matchedPaths}`);
     }
     try {
         for (const matchedPath of matchedPaths) {
-            const fullPath = path_1.default.join(rootDir, matchedPath);
+            const fullPath = node_path_1.default.join(rootDir, matchedPath);
             if ((await isAppBundle(fullPath) || (this.isRealDevice() && await isIpaBundle(fullPath)))
                 && await isCompatibleWithCurrentPlatform(fullPath)) {
                 this.log.debug(`Selecting the application at '${matchedPath}'`);
@@ -571,90 +598,10 @@ async function unzipApp(appPathOrZipStream, depth = 0) {
     }
     throw new Error(errMsg);
 }
-/**
- * The callback invoked by configureApp helper
- * when it is necessary to download the remote application.
- * We assume the remote file could be anythingm, but only
- * .zip and .ipa formats are supported.
- * A .zip archive can contain one or more
- *
- * @this {XCUITestDriver}
- * @param {import('@appium/types').DownloadAppOptions} opts
- * @returns {Promise<string>}
- */
-async function onDownloadApp({ stream, headers }) {
-    return this.isRealDevice()
-        ? await downloadIpa.bind(this)(stream, headers)
-        : await unzipApp.bind(this)(stream);
-}
-/**
- * @this {XCUITestDriver}
- * @param {import('@appium/types').PostProcessOptions} opts
- * @returns {Promise<import('@appium/types').PostProcessResult|false>}
- */
-async function onPostConfigureApp({ cachedAppInfo, isUrl, appPath }) {
-    // Pick the previously cached entry if its integrity has been preserved
-    /** @type {import('@appium/types').CachedAppInfo|undefined} */
-    const appInfo = lodash_1.default.isPlainObject(cachedAppInfo) ? cachedAppInfo : undefined;
-    const cachedPath = appInfo ? /** @type {string} */ (appInfo.fullPath) : undefined;
-    const shouldUseCachedApp = async () => {
-        if (!appInfo || !cachedPath || !await support_1.fs.exists(cachedPath)) {
-            return false;
-        }
-        const isCachedPathAFile = (await support_1.fs.stat(cachedPath)).isFile();
-        if (isCachedPathAFile) {
-            return await support_1.fs.hash(cachedPath) === /** @type {any} */ (appInfo.integrity)?.file;
-        }
-        // If the cached path is a folder then it is expected to be previously extracted from
-        // an archive located under appPath whose hash is stored as `cachedAppInfo.packageHash`
-        if (!isCachedPathAFile
-            && cachedAppInfo?.packageHash
-            && await support_1.fs.exists(/** @type {string} */ (appPath))
-            && (await support_1.fs.stat(/** @type {string} */ (appPath))).isFile()
-            && cachedAppInfo.packageHash === await support_1.fs.hash(/** @type {string} */ (appPath))) {
-            /** @type {number|undefined} */
-            const nestedItemsCountInCache = /** @type {any} */ (appInfo.integrity)?.folder;
-            if (nestedItemsCountInCache !== undefined) {
-                return (await support_1.fs.glob('**/*', { cwd: cachedPath })).length >= nestedItemsCountInCache;
-            }
-        }
-        return false;
-    };
-    if (await shouldUseCachedApp()) {
-        this.log.info(`Using '${cachedPath}' which was cached from '${appPath}'`);
-        return { appPath: /** @type {string} */ (cachedPath) };
-    }
-    const isLocalIpa = await isIpaBundle(/** @type {string} */ (appPath));
-    const isLocalApp = !isLocalIpa && await isAppBundle(/** @type {string} */ (appPath));
-    const isPackageReadyForInstall = isLocalApp || (this.isRealDevice() && isLocalIpa);
-    if (isPackageReadyForInstall) {
-        await this.appInfosCache.put(/** @type {string} */ (appPath));
-    }
-    // Only local .app bundles (real device/Simulator)
-    // and .ipa packages for real devices should not be cached
-    if (!isUrl && isPackageReadyForInstall) {
-        return false;
-    }
-    // Cache the app while unpacking the bundle if necessary
-    return {
-        appPath: isPackageReadyForInstall
-            ? appPath
-            : await unzipApp.bind(this)(/** @type {string} */ (appPath))
-    };
-}
-/**
- * @returns {Promise<boolean>}
- */
 async function isRosettaInstalled() {
     return await support_1.fs.exists('/Library/Apple/usr/share/rosetta/rosetta');
 }
-/**
- * @returns {boolean}
- */
 function isAppleSilicon() {
     return node_os_1.default.cpus()[0].model.includes('Apple');
 }
-/**
- * @typedef {import('./driver').XCUITestDriver} XCUITestDriver
- */
 //# sourceMappingURL=app-utils.js.map