@testingbot/cli 1.0.2 → 1.0.4

package/dist/providers/maestro.js

@@ -48,7 +48,7 @@ const socket_io_client_1 = require("socket.io-client");
 const testingbot_error_1 = __importDefault(require("../models/testingbot_error"));
 const utils_1 = __importDefault(require("../utils"));
 const file_type_detector_1 = require("../utils/file-type-detector");
-const colors_1 = __importDefault(require("colors"));
+const picocolors_1 = __importDefault(require("picocolors"));
 const base_provider_1 = __importDefault(require("./base_provider"));
 class Maestro extends base_provider_1.default {
     URL = 'https://api.testingbot.com/v1/app-automate/maestro';
@@ -59,42 +59,53 @@ class Maestro extends base_provider_1.default {
     constructor(credentials, options) {
         super(credentials, options);
     }
+    static SUPPORTED_APP_EXTENSIONS = [
+        '.apk',
+        '.apks',
+        '.ipa',
+        '.app',
+        '.zip',
+    ];
     async validate() {
         if (this.options.app === undefined) {
             throw new testingbot_error_1.default(`app option is required`);
         }
-        try {
-            await node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK);
-        }
-        catch {
-            throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+        // Validate app file extension
+        const appExt = node_path_1.default.extname(this.options.app).toLowerCase();
+        if (!Maestro.SUPPORTED_APP_EXTENSIONS.includes(appExt)) {
+            throw new testingbot_error_1.default(`Unsupported app file format: ${appExt || '(no extension)'}. ` +
+                `Supported formats: ${Maestro.SUPPORTED_APP_EXTENSIONS.join(', ')}`);
         }
         if (this.options.flows === undefined || this.options.flows.length === 0) {
             throw new testingbot_error_1.default(`flows option is required`);
         }
+        if (this.options.report && !this.options.reportOutputDir) {
+            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
+        }
+        // Build list of all file checks to run in parallel
+        const fileChecks = [
+            node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK).catch(() => {
+                throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+            }),
+        ];
         // Check if all flows paths exist (can be files, directories or glob patterns)
         for (const flowsPath of this.options.flows) {
             const isGlobPattern = flowsPath.includes('*') ||
                 flowsPath.includes('?') ||
                 flowsPath.includes('{');
             if (!isGlobPattern) {
-                try {
-                    await node_fs_1.default.promises.access(flowsPath, node_fs_1.default.constants.R_OK);
-                }
-                catch {
+                fileChecks.push(node_fs_1.default.promises.access(flowsPath, node_fs_1.default.constants.R_OK).catch(() => {
                     throw new testingbot_error_1.default(`flows path does not exist ${flowsPath}`);
-                }
+                }));
             }
         }
-        if (this.options.report && !this.options.reportOutputDir) {
-            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
-        }
         if (this.options.reportOutputDir) {
-            await this.ensureOutputDirectory(this.options.reportOutputDir);
+            fileChecks.push(this.ensureOutputDirectory(this.options.reportOutputDir));
         }
         if (this.options.downloadArtifacts && this.options.artifactsOutputDir) {
-            await this.ensureOutputDirectory(this.options.artifactsOutputDir);
+            fileChecks.push(this.ensureOutputDirectory(this.options.artifactsOutputDir));
         }
+        await Promise.all(fileChecks);
         return true;
     }
     /**
@@ -161,44 +172,84 @@ class Maestro extends base_provider_1.default {
         }
     }
     async uploadApp() {
-        const appPath = this.options.app;
+        let appPath = this.options.app;
         const ext = node_path_1.default.extname(appPath).toLowerCase();
-        let contentType;
-        if (ext === '.apk') {
-            contentType = 'application/vnd.android.package-archive';
-        }
-        else if (ext === '.ipa' || ext === '.app') {
-            contentType = 'application/octet-stream';
-        }
-        else if (ext === '.zip') {
-            contentType = 'application/zip';
-        }
-        else {
-            contentType = 'application/octet-stream';
-        }
-        if (!this.options.ignoreChecksumCheck) {
-            const checksum = await this.upload.calculateChecksum(appPath);
-            const existingApp = await this.checkAppChecksum(checksum);
-            if (existingApp) {
-                this.appId = existingApp.id;
+        let tempZipPath = null;
+        // If .app bundle (directory), zip it first
+        if (ext === '.app') {
+            const stat = await node_fs_1.default.promises.stat(appPath);
+            if (stat.isDirectory()) {
                 if (!this.options.quiet) {
-                    logger_1.default.info('  App already uploaded, skipping upload');
+                    logger_1.default.info('Zipping .app bundle for upload');
                 }
-                return true;
+                tempZipPath = await this.zipAppBundle(appPath);
+                appPath = tempZipPath;
             }
         }
-        if (!this.options.quiet) {
-            logger_1.default.info('Uploading Maestro App');
-        }
-        const result = await this.upload.upload({
-            filePath: appPath,
-            url: `${this.URL}/app`,
-            credentials: this.credentials,
-            contentType,
-            showProgress: !this.options.quiet,
+        try {
+            let contentType;
+            if (ext === '.apk') {
+                contentType = 'application/vnd.android.package-archive';
+            }
+            else if (ext === '.ipa') {
+                contentType = 'application/octet-stream';
+            }
+            else if (ext === '.zip' || ext === '.app') {
+                // .app bundles are zipped, so use application/zip
+                contentType = 'application/zip';
+            }
+            else {
+                contentType = 'application/octet-stream';
+            }
+            if (!this.options.ignoreChecksumCheck) {
+                const checksum = await this.upload.calculateChecksum(appPath);
+                const existingApp = await this.checkAppChecksum(checksum);
+                if (existingApp) {
+                    this.appId = existingApp.id;
+                    if (!this.options.quiet) {
+                        logger_1.default.info('  App already uploaded, skipping upload');
+                    }
+                    return true;
+                }
+            }
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading Maestro App');
+            }
+            const result = await this.upload.upload({
+                filePath: appPath,
+                url: `${this.URL}/app`,
+                credentials: this.credentials,
+                contentType,
+                showProgress: !this.options.quiet,
+                validateZipFormat: true,
+            });
+            this.appId = result.id;
+            return true;
+        }
+        finally {
+            // Clean up temporary zip file
+            if (tempZipPath) {
+                await node_fs_1.default.promises.unlink(tempZipPath).catch(() => { });
+            }
+        }
+    }
+    /**
+     * Zip a .app bundle directory into a temporary zip file
+     */
+    async zipAppBundle(appPath) {
+        const appName = node_path_1.default.basename(appPath);
+        const tmpDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'testingbot-app-'));
+        const zipPath = node_path_1.default.join(tmpDir, `${appName}.zip`);
+        return new Promise((resolve, reject) => {
+            const output = node_fs_1.default.createWriteStream(zipPath);
+            const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve(zipPath));
+            archive.on('error', (err) => reject(err));
+            archive.pipe(output);
+            // Add the .app directory with its name preserved
+            archive.directory(appPath, appName);
+            archive.finalize();
         });
-        this.appId = result.id;
-        return true;
     }
     async checkAppChecksum(checksum) {
         try {
@@ -241,6 +292,7 @@ class Maestro extends base_provider_1.default {
                     credentials: this.credentials,
                     contentType: 'application/zip',
                     showProgress: !this.options.quiet,
+                    validateZipFormat: true,
                 });
                 return true;
             }
@@ -292,6 +344,19 @@ class Maestro extends base_provider_1.default {
         const baseDir = baseDirs.length === 1 ? baseDirs[0] : undefined;
         if (!this.options.quiet) {
             this.logIncludedFiles(allFlowFiles, baseDir);
+            // Show info about potential slow execution on specific real devices
+            utils_1.default.showRealDeviceFlowsInfo({
+                realDevice: this.options.realDevice,
+                device: this.options.device,
+                version: this.options.version,
+                flowCount: allFlowFiles.filter((f) => f.endsWith('.yaml') || f.endsWith('.yml')).filter((f) => !this.isConfigFile(f)).length,
+                shardSplit: this.options.shardSplit,
+            });
+        }
+        // Check for missing file references and warn the user
+        const missingReferences = await this.findMissingReferences(allFlowFiles, allFlowFiles, baseDir);
+        if (!this.options.quiet && missingReferences.length > 0) {
+            this.logMissingReferences(missingReferences, baseDir);
         }
         zipPath = await this.createFlowsZip(allFlowFiles, baseDir);
         shouldCleanup = true;
@@ -316,15 +381,20 @@ class Maestro extends base_provider_1.default {
             withFileTypes: true,
         });
         const flowFiles = [];
-        const configPath = node_path_1.default.join(directory, 'config.yaml');
+        let configPath = null;
         let config = null;
-        // Check for config.yaml
-        try {
-            const configContent = await node_fs_1.default.promises.readFile(configPath, 'utf-8');
-            config = yaml.load(configContent);
-        }
-        catch {
-            // No config.yaml, that's fine
+        // Check for config.yaml or config.yml
+        for (const configName of ['config.yaml', 'config.yml']) {
+            const candidatePath = node_path_1.default.join(directory, configName);
+            try {
+                const configContent = await node_fs_1.default.promises.readFile(candidatePath, 'utf-8');
+                config = yaml.load(configContent);
+                configPath = candidatePath;
+                break; // Use the first config file found
+            }
+            catch {
+                // Config file doesn't exist, try next
+            }
         }
         // If config specifies flows, use those
         if (config?.flows && config.flows.length > 0) {
@@ -339,7 +409,7 @@ class Maestro extends base_provider_1.default {
                 if (entry.isFile()) {
                     const ext = node_path_1.default.extname(entry.name).toLowerCase();
                     if ((ext === '.yaml' || ext === '.yml') &&
-                        entry.name !== 'config.yaml') {
+                        !this.isConfigFile(entry.name)) {
                         flowFiles.push(node_path_1.default.join(directory, entry.name));
                     }
                 }
@@ -351,8 +421,8 @@ class Maestro extends base_provider_1.default {
             const dependencies = await this.discoverDependencies(flowFile, directory);
             dependencies.forEach((dep) => allFiles.add(dep));
         }
-        // Include config.yaml if it exists
-        if (config) {
+        // Include config file if it exists
+        if (configPath) {
             allFiles.add(configPath);
         }
         return Array.from(allFiles);
@@ -384,6 +454,13 @@ class Maestro extends base_provider_1.default {
         }
         return dependencies;
     }
+    /**
+     * Check if a file path is a Maestro config file (config.yaml or config.yml)
+     */
+    isConfigFile(filePath) {
+        const basename = node_path_1.default.basename(filePath);
+        return basename === 'config.yaml' || basename === 'config.yml';
+    }
     /**
      * Check if a string looks like a file path (relative path with extension)
      */
@@ -539,6 +616,205 @@ class Maestro extends base_provider_1.default {
         }
         return dependencies;
     }
+    /**
+     * Find all file references in flow files that don't exist on disk.
+     * This validates that all referenced files (runScript, runFlow, addMedia, etc.)
+     * will be included in the zip.
+     */
+    async findMissingReferences(flowFiles, allIncludedFiles, baseDir) {
+        const missingReferences = [];
+        const includedFilesSet = new Set(allIncludedFiles.map((f) => node_path_1.default.resolve(f)));
+        for (const flowFile of flowFiles) {
+            const ext = node_path_1.default.extname(flowFile).toLowerCase();
+            if (ext !== '.yaml' && ext !== '.yml') {
+                continue;
+            }
+            try {
+                const content = await node_fs_1.default.promises.readFile(flowFile, 'utf-8');
+                const documents = [];
+                yaml.loadAll(content, (doc) => documents.push(doc));
+                for (const flowData of documents) {
+                    if (flowData !== null && typeof flowData === 'object') {
+                        const missing = await this.findMissingInValue(flowData, flowFile, includedFilesSet);
+                        missingReferences.push(...missing);
+                    }
+                }
+            }
+            catch {
+                // Ignore parsing errors
+            }
+        }
+        return missingReferences;
+    }
+    /**
+     * Recursively find missing file references in a YAML value
+     */
+    async findMissingInValue(value, flowFile, includedFiles) {
+        const missingReferences = [];
+        if (typeof value === 'string') {
+            if (this.looksLikePath(value)) {
+                const resolvedPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), value);
+                // Check if the file is in included files OR exists on disk
+                if (!includedFiles.has(resolvedPath)) {
+                    try {
+                        await node_fs_1.default.promises.access(resolvedPath);
+                        // File exists on disk but won't be included - also warn
+                    }
+                    catch {
+                        // File doesn't exist
+                        missingReferences.push({
+                            flowFile,
+                            referencedFile: value,
+                            resolvedPath,
+                        });
+                    }
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                const missing = await this.findMissingInValue(item, flowFile, includedFiles);
+                missingReferences.push(...missing);
+            }
+        }
+        else if (value !== null && typeof value === 'object') {
+            const obj = value;
+            const handledKeys = new Set();
+            // Handle runScript - extract file reference but don't recurse
+            // (runScript objects only contain file, env, when - no nested file refs)
+            if ('runScript' in obj) {
+                handledKeys.add('runScript');
+                const runScript = obj.runScript;
+                const scriptFile = typeof runScript === 'string'
+                    ? runScript
+                    : runScript?.file;
+                if (typeof scriptFile === 'string') {
+                    const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), scriptFile);
+                    if (!includedFiles.has(resolved)) {
+                        try {
+                            await node_fs_1.default.promises.access(resolved);
+                        }
+                        catch {
+                            missingReferences.push({
+                                flowFile,
+                                referencedFile: scriptFile,
+                                resolvedPath: resolved,
+                            });
+                        }
+                    }
+                }
+                // Don't recurse into runScript - it only has file, env, when (no nested file refs)
+            }
+            // Handle runFlow - extract file reference and recurse only into commands
+            if ('runFlow' in obj) {
+                handledKeys.add('runFlow');
+                const runFlow = obj.runFlow;
+                const flowRef = typeof runFlow === 'string'
+                    ? runFlow
+                    : runFlow?.file;
+                if (typeof flowRef === 'string') {
+                    const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), flowRef);
+                    if (!includedFiles.has(resolved)) {
+                        try {
+                            await node_fs_1.default.promises.access(resolved);
+                        }
+                        catch {
+                            missingReferences.push({
+                                flowFile,
+                                referencedFile: flowRef,
+                                resolvedPath: resolved,
+                            });
+                        }
+                    }
+                }
+                // Only recurse into 'commands' if present (for inline commands)
+                if (typeof runFlow === 'object' &&
+                    runFlow !== null &&
+                    'commands' in runFlow) {
+                    const commands = runFlow.commands;
+                    if (Array.isArray(commands)) {
+                        const nestedMissing = await this.findMissingInValue(commands, flowFile, includedFiles);
+                        missingReferences.push(...nestedMissing);
+                    }
+                }
+            }
+            // Handle addMedia
+            if ('addMedia' in obj) {
+                handledKeys.add('addMedia');
+                const addMedia = obj.addMedia;
+                const mediaFiles = Array.isArray(addMedia) ? addMedia : [addMedia];
+                for (const mediaFile of mediaFiles) {
+                    if (typeof mediaFile === 'string') {
+                        const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), mediaFile);
+                        if (!includedFiles.has(resolved)) {
+                            try {
+                                await node_fs_1.default.promises.access(resolved);
+                            }
+                            catch {
+                                missingReferences.push({
+                                    flowFile,
+                                    referencedFile: mediaFile,
+                                    resolvedPath: resolved,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // Handle file property
+            if ('file' in obj && typeof obj.file === 'string') {
+                handledKeys.add('file');
+                const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), obj.file);
+                if (!includedFiles.has(resolved)) {
+                    try {
+                        await node_fs_1.default.promises.access(resolved);
+                    }
+                    catch {
+                        missingReferences.push({
+                            flowFile,
+                            referencedFile: obj.file,
+                            resolvedPath: resolved,
+                        });
+                    }
+                }
+            }
+            // Handle onFlowStart, onFlowComplete, commands
+            for (const key of ['onFlowStart', 'onFlowComplete', 'commands']) {
+                if (key in obj) {
+                    handledKeys.add(key);
+                    const nested = obj[key];
+                    if (Array.isArray(nested)) {
+                        const nestedMissing = await this.findMissingInValue(nested, flowFile, includedFiles);
+                        missingReferences.push(...nestedMissing);
+                    }
+                }
+            }
+            // Recursively check remaining properties
+            for (const [key, propValue] of Object.entries(obj)) {
+                if (!handledKeys.has(key)) {
+                    const nestedMissing = await this.findMissingInValue(propValue, flowFile, includedFiles);
+                    missingReferences.push(...nestedMissing);
+                }
+            }
+        }
+        return missingReferences;
+    }
+    /**
+     * Log warnings for missing file references
+     */
+    logMissingReferences(missingReferences, baseDir) {
+        if (missingReferences.length === 0) {
+            return;
+        }
+        logger_1.default.warn(`Warning: ${missingReferences.length} referenced file(s) not found:`);
+        for (const ref of missingReferences) {
+            const flowRelative = baseDir
+                ? node_path_1.default.relative(baseDir, ref.flowFile)
+                : node_path_1.default.basename(ref.flowFile);
+            logger_1.default.warn(`  In ${flowRelative}: ${ref.referencedFile}`);
+        }
+        logger_1.default.warn('These files will not be included in the upload and may cause test failures.');
+    }
     logIncludedFiles(files, baseDir) {
         // Get relative paths for display
         const relativePaths = files
@@ -555,7 +831,7 @@ class Maestro extends base_provider_1.default {
         for (const filePath of relativePaths) {
             const ext = node_path_1.default.extname(filePath).toLowerCase();
             if (ext === '.yaml' || ext === '.yml') {
-                if (filePath === 'config.yaml' || filePath.endsWith('/config.yaml')) {
+                if (this.isConfigFile(filePath)) {
                     groups['Config files'].push(filePath);
                 }
                 else {
@@ -753,9 +1029,9 @@ class Maestro extends base_provider_1.default {
                         process.stdout.write(`\x1b[${linesToMove}A`);
                         // Clear header line, write new header, then clear separator line
                         process.stdout.write('\x1b[2K');
-                        console.log(colors_1.default.dim(` ${'Duration'.padEnd(10)} ${'Status'.padEnd(8)} Flow                              Fail reason`));
+                        console.log(picocolors_1.default.dim(` ${'Duration'.padEnd(10)} ${'Status'.padEnd(8)} Flow                              Fail reason`));
                         process.stdout.write('\x1b[2K');
-                        console.log(colors_1.default.dim(` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)} ${'─'.repeat(80)}`));
+                        console.log(picocolors_1.default.dim(` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)} ${'─'.repeat(80)}`));
                         // Redraw all flows with error messages
                         for (const flow of allFlows) {
                             // Clear the line before writing
@@ -848,18 +1124,18 @@ class Maestro extends base_provider_1.default {
     getFlowStatusDisplay(flow) {
         switch (flow.status) {
             case 'WAITING':
-                return { text: 'WAITING', colored: colors_1.default.white('WAITING') };
+                return { text: 'WAITING', colored: picocolors_1.default.white('WAITING') };
             case 'READY':
-                return { text: 'RUNNING', colored: colors_1.default.blue('RUNNING') };
+                return { text: 'RUNNING', colored: picocolors_1.default.blue('RUNNING') };
             case 'DONE':
                 if (flow.success === 1) {
-                    return { text: 'PASSED', colored: colors_1.default.green('PASSED') };
+                    return { text: 'PASSED', colored: picocolors_1.default.green('PASSED') };
                 }
                 else {
-                    return { text: 'FAILED', colored: colors_1.default.red('FAILED') };
+                    return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
                 }
             case 'FAILED':
-                return { text: 'FAILED', colored: colors_1.default.red('FAILED') };
+                return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
             default:
                 return { text: flow.status, colored: flow.status };
         }
@@ -927,13 +1203,13 @@ class Maestro extends base_provider_1.default {
         }
         const parts = [];
         if (waiting > 0)
-            parts.push(colors_1.default.white(`${waiting} waiting`));
+            parts.push(picocolors_1.default.white(`${waiting} waiting`));
         if (running > 0)
-            parts.push(colors_1.default.blue(`${running} running`));
+            parts.push(picocolors_1.default.blue(`${running} running`));
         if (passed > 0)
-            parts.push(colors_1.default.green(`${passed} passed`));
+            parts.push(picocolors_1.default.green(`${passed} passed`));
         if (failed > 0)
-            parts.push(colors_1.default.red(`${failed} failed`));
+            parts.push(picocolors_1.default.red(`${failed} failed`));
         return ` ... and ${remaining.length} more: ${parts.join(', ')}`;
     }
     displayFlowsWithLimit(flows, previousFlowStatus, hasFailures = false) {
@@ -947,7 +1223,7 @@ class Maestro extends base_provider_1.default {
         // Show summary for remaining flows
         if (flows.length > maxFlows) {
             const summary = this.getRemainingSummary(flows, maxFlows);
-            console.log(colors_1.default.dim(summary));
+            console.log(picocolors_1.default.dim(summary));
             linesWritten++;
         }
         return linesWritten;
@@ -959,8 +1235,8 @@ class Maestro extends base_provider_1.default {
             header += '                              Fail reason';
             separator += ` ${'─'.repeat(80)}`;
         }
-        console.log(colors_1.default.dim(header));
-        console.log(colors_1.default.dim(separator));
+        console.log(picocolors_1.default.dim(header));
+        console.log(picocolors_1.default.dim(separator));
     }
     displayFlowRow(flow, isUpdate = false, hasFailures = false) {
         const duration = this.calculateFlowDuration(flow).padEnd(10);
@@ -976,7 +1252,7 @@ class Maestro extends base_provider_1.default {
         let row = ` ${duration} ${statusPadded} ${name}`;
         // Add first error message on the same line if failed and has errors
         if (hasFailures && isFailed && errorMessages.length > 0) {
-            row += ` ${colors_1.default.red(errorMessages[0])}`;
+            row += ` ${picocolors_1.default.red(errorMessages[0])}`;
         }
         if (isUpdate) {
             process.stdout.write(`\r${row}`);
@@ -990,7 +1266,7 @@ class Maestro extends base_provider_1.default {
             // Indent to align with the Fail reason column: Duration(11) + Status(9) + Test(31) = 51 chars
             const indent = ' '.repeat(51);
             for (let i = 1; i < errorMessages.length; i++) {
-                console.log(`${indent} ${colors_1.default.red(errorMessages[i])}`);
+                console.log(`${indent} ${picocolors_1.default.red(errorMessages[i])}`);
                 linesWritten++;
             }
         }
@@ -1035,7 +1311,7 @@ class Maestro extends base_provider_1.default {
         // Update or add summary line for remaining flows
         if (hasRemaining) {
             const summary = this.getRemainingSummary(flows, maxFlows);
-            process.stdout.write(`\r\x1b[K${colors_1.default.dim(summary)}\n`);
+            process.stdout.write(`\r\x1b[K${picocolors_1.default.dim(summary)}\n`);
             linesWritten++;
         }
         // Return the number of lines we wrote

package/dist/providers/xcuitest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xcuitest.d.ts","sourceRoot":"","sources":["../../src/providers/xcuitest.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,4BAA4B,CAAC;AAEzD,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAOhD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAE3C,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAChD,YAAY,EAAE;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,eAAe,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,YAAY,CAAC,eAAe,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,GAAG,yDACkC;IAExD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,SAAS,CAAuB;gBAErB,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe;YAIvD,QAAQ;IAuCT,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC;YA+D7B,SAAS;YAaT,aAAa;YAYb,QAAQ;YA0DR,SAAS;YA4BT,iBAAiB;IAwE/B,OAAO,CAAC,gBAAgB;IAmCxB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,aAAa;YAkBP,YAAY;IA2D1B,OAAO,CAAC,qBAAqB;IAqC7B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,mBAAmB;CAa5B"}
+{"version":3,"file":"xcuitest.d.ts","sourceRoot":"","sources":["../../src/providers/xcuitest.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,4BAA4B,CAAC;AAEzD,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAOhD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAE3C,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAChD,YAAY,EAAE;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,eAAe,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,YAAY,CAAC,eAAe,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,GAAG,yDACkC;IAExD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,SAAS,CAAuB;gBAErB,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe;YAIvD,QAAQ;IAuCT,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC;YA+D7B,SAAS;YAcT,aAAa;YAab,QAAQ;YA0DR,SAAS;YA4BT,iBAAiB;IAwE/B,OAAO,CAAC,gBAAgB;IAmCxB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,aAAa;YAkBP,YAAY;IA2D1B,OAAO,CAAC,qBAAqB;IAqC7B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,mBAAmB;CAa5B"}

package/dist/providers/xcuitest.js

@@ -23,28 +23,26 @@ class XCUITest extends base_provider_1.default {
         if (this.options.app === undefined) {
             throw new testingbot_error_1.default(`app option is required`);
         }
-        try {
-            await node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK);
-        }
-        catch {
-            throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
-        }
         if (this.options.testApp === undefined) {
             throw new testingbot_error_1.default(`testApp option is required`);
         }
-        try {
-            await node_fs_1.default.promises.access(this.options.testApp, node_fs_1.default.constants.R_OK);
-        }
-        catch {
-            throw new testingbot_error_1.default(`testApp path does not exist ${this.options.testApp}`);
-        }
         // Validate report options
         if (this.options.report && !this.options.reportOutputDir) {
             throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
         }
+        // Validate file access in parallel for better performance
+        const fileChecks = [
+            node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK).catch(() => {
+                throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+            }),
+            node_fs_1.default.promises.access(this.options.testApp, node_fs_1.default.constants.R_OK).catch(() => {
+                throw new testingbot_error_1.default(`testApp path does not exist ${this.options.testApp}`);
+            }),
+        ];
         if (this.options.reportOutputDir) {
-            await this.ensureOutputDirectory(this.options.reportOutputDir);
+            fileChecks.push(this.ensureOutputDirectory(this.options.reportOutputDir));
         }
+        await Promise.all(fileChecks);
         return true;
     }
     async run() {
@@ -106,6 +104,7 @@ class XCUITest extends base_provider_1.default {
             credentials: this.credentials,
             contentType: 'application/octet-stream',
             showProgress: !this.options.quiet,
+            validateZipFormat: true,
         });
         this.appId = result.id;
         return true;
@@ -117,6 +116,7 @@ class XCUITest extends base_provider_1.default {
             credentials: this.credentials,
             contentType: 'application/zip',
             showProgress: !this.options.quiet,
+            validateZipFormat: true,
         });
         return true;
     }