@devicecloud.dev/dcd 4.1.3 → 4.1.4

package/dist/commands/cloud.js

@@ -186,7 +186,14 @@ class Cloud extends core_1.Command {
                 if (debug) {
                     this.log('DEBUG: Generating execution plan...');
                 }
-                executionPlan = await (0, execution_plan_service_1.plan)(flowFile, includeTags.flat(), excludeTags.flat(), excludeFlows.flat(), configFile, debug);
+                executionPlan = await (0, execution_plan_service_1.plan)({
+                    input: flowFile,
+                    includeTags: includeTags.flat(),
+                    excludeTags: excludeTags.flat(),
+                    excludeFlows: excludeFlows.flat(),
+                    configFile,
+                    debug,
+                });
                 if (debug) {
                     this.log(`DEBUG: Execution plan generated`);
                     this.log(`DEBUG: Total flow files: ${executionPlan.totalFlowFiles}`);
@@ -395,7 +402,7 @@ class Cloud extends core_1.Command {
                 quiet,
                 uploadId: results[0].test_upload_id,
             })
-                .catch((error) => {
+                .catch(async (error) => {
                 if (error instanceof results_polling_service_1.RunFailedError) {
                     // Handle failed test run
                     const jsonOutput = error.result;
@@ -406,11 +413,38 @@ class Cloud extends core_1.Command {
                     if (json) {
                         output = jsonOutput;
                     }
+                    // Download artifacts and reports even when tests fail
+                    if (downloadArtifacts) {
+                        await this.reportDownloadService.downloadArtifacts({
+                            apiKey,
+                            apiUrl,
+                            artifactsPath,
+                            debug,
+                            downloadType: downloadArtifacts,
+                            logger: this.log.bind(this),
+                            uploadId: results[0].test_upload_id,
+                            warnLogger: this.warn.bind(this),
+                        });
+                    }
+                    if (report && ['allure', 'html', 'junit'].includes(report)) {
+                        await this.reportDownloadService.downloadReports({
+                            allurePath,
+                            apiKey,
+                            apiUrl,
+                            debug,
+                            htmlPath,
+                            junitPath,
+                            logger: this.log.bind(this),
+                            reportType: report,
+                            uploadId: results[0].test_upload_id,
+                            warnLogger: this.warn.bind(this),
+                        });
+                    }
                     throw new Error('RUN_FAILED');
                 }
                 throw error;
             });
-            // Handle successful completion
+            // Handle successful completion - download artifacts and reports
             if (downloadArtifacts) {
                 await this.reportDownloadService.downloadArtifacts({
                     apiKey,

package/dist/gateways/api-gateway.js

@@ -95,7 +95,7 @@ exports.ApiGateway = {
                 }
             }
         }
-        const fileStream = createWriteStream(artifactsPath, { flags: 'wx' });
+        const fileStream = createWriteStream(artifactsPath, { flags: 'w' });
         await finished(Readable.fromWeb(res.body).pipe(fileStream));
     },
     // eslint-disable-next-line max-params

package/dist/services/device-validation.service.d.ts

@@ -14,6 +14,7 @@ export declare class DeviceValidationService {
      * @param googlePlay Whether Google Play services are enabled
      * @param compatibilityData Compatibility data from API
      * @param options Validation options
+     * @returns void
      * @throws Error if device/API level combination is not supported
      */
     validateAndroidDevice(androidApiLevel: string | undefined, androidDevice: string | undefined, googlePlay: boolean, compatibilityData: CompatibilityData, options?: DeviceValidationOptions): void;
@@ -23,6 +24,7 @@ export declare class DeviceValidationService {
      * @param iOSDevice iOS device model to validate
      * @param compatibilityData Compatibility data from API
      * @param options Validation options
+     * @returns void
      * @throws Error if device/version combination is not supported
      */
     validateiOSDevice(iOSVersion: string | undefined, iOSDevice: string | undefined, compatibilityData: CompatibilityData, options?: DeviceValidationOptions): void;

package/dist/services/device-validation.service.js

@@ -12,6 +12,7 @@ class DeviceValidationService {
      * @param googlePlay Whether Google Play services are enabled
      * @param compatibilityData Compatibility data from API
      * @param options Validation options
+     * @returns void
      * @throws Error if device/API level combination is not supported
      */
     validateAndroidDevice(androidApiLevel, androidDevice, googlePlay, compatibilityData, options = {}) {
@@ -45,6 +46,7 @@ class DeviceValidationService {
      * @param iOSDevice iOS device model to validate
      * @param compatibilityData Compatibility data from API
      * @param options Validation options
+     * @returns void
      * @throws Error if device/version combination is not supported
      */
     validateiOSDevice(iOSVersion, iOSDevice, compatibilityData, options = {}) {

package/dist/services/execution-plan.service.d.ts

@@ -20,6 +20,14 @@ interface IExecutionOrder {
     continueOnFailure: boolean;
     flowsOrder: string[];
 }
+export interface PlanOptions {
+    configFile?: string;
+    debug?: boolean;
+    excludeFlows?: string[];
+    excludeTags?: string[];
+    includeTags?: string[];
+    input: string;
+}
 export interface IExecutionPlan {
     allExcludeTags?: null | string[];
     allIncludeTags?: null | string[];
@@ -35,5 +43,5 @@ interface IFlowSequence {
     continueOnFailure?: boolean;
     flows: string[];
 }
-export declare function plan(input: string, includeTags: string[], excludeTags: string[], excludeFlows?: string[], configFile?: string, debug?: boolean): Promise<IExecutionPlan>;
+export declare function plan(options: PlanOptions): Promise<IExecutionPlan>;
 export {};

package/dist/services/execution-plan.service.js

@@ -64,7 +64,8 @@ function extractDeviceCloudOverrides(config) {
     }
     return overrides;
 }
-async function plan(input, includeTags, excludeTags, excludeFlows, configFile, debug = false) {
+async function plan(options) {
+    const { input, includeTags = [], excludeTags = [], excludeFlows, configFile, debug = false, } = options;
     const normalizedInput = path.normalize(input);
     const flowMetadata = {};
     if (!fs.existsSync(normalizedInput)) {

package/dist/services/moropo.service.d.ts

@@ -17,4 +17,9 @@ export declare class MoropoService {
      * @returns Path to the extracted Moropo tests directory
      */
     downloadAndExtract(options: MoropoDownloadOptions): Promise<string>;
+    private createConfigFile;
+    private downloadZipFile;
+    private extractZipFile;
+    private logDebug;
+    private showProgress;
 }

package/dist/services/moropo.service.js

@@ -18,10 +18,8 @@ class MoropoService {
      */
     async downloadAndExtract(options) {
         const { apiKey, branchName = 'main', debug = false, quiet = false, json = false, logger } = options;
-        if (debug && logger) {
-            logger('DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
-            logger(`DEBUG: Using branch name: ${branchName}`);
-        }
+        this.logDebug(debug, logger, 'DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
+        this.logDebug(debug, logger, `DEBUG: Using branch name: ${branchName}`);
         try {
             if (!quiet && !json) {
                 core_1.ux.action.start('Downloading Moropo tests', 'Initializing', {
@@ -38,76 +36,83 @@ class MoropoService {
             if (!response.ok) {
                 throw new Error(`Failed to download Moropo tests: ${response.statusText}`);
             }
-            const contentLength = response.headers.get('content-length');
-            const totalSize = contentLength
-                ? Number.parseInt(contentLength, 10)
-                : 0;
-            let downloadedSize = 0;
             const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
-            if (debug && logger) {
-                logger(`DEBUG: Extracting Moropo tests to: ${moropoDir}`);
-            }
+            this.logDebug(debug, logger, `DEBUG: Extracting Moropo tests to: ${moropoDir}`);
             // Create moropo directory if it doesn't exist
             if (!fs.existsSync(moropoDir)) {
                 fs.mkdirSync(moropoDir, { recursive: true });
             }
-            // Write zip file to moropo directory
+            // Download zip file
             const zipPath = path.join(moropoDir, 'moropo-tests.zip');
-            const fileStream = fs.createWriteStream(zipPath);
-            const reader = response.body?.getReader();
-            if (!reader) {
-                throw new Error('Failed to get response reader');
-            }
-            let readerResult = await reader.read();
-            while (!readerResult.done) {
-                const { value } = readerResult;
-                downloadedSize += value.length;
-                if (!quiet && !json && totalSize) {
-                    const progress = Math.round((downloadedSize / totalSize) * 100);
-                    core_1.ux.action.status = `Downloading: ${progress}%`;
-                }
-                fileStream.write(value);
-                readerResult = await reader.read();
-            }
-            fileStream.end();
-            await new Promise((resolve) => {
-                fileStream.on('finish', () => {
-                    resolve();
-                });
-            });
-            if (!quiet && !json) {
-                core_1.ux.action.status = 'Extracting tests...';
-            }
+            await this.downloadZipFile(response, zipPath, { quiet, json });
+            this.showProgress(quiet, json, 'Extracting tests...');
             // Extract zip file
-            // eslint-disable-next-line new-cap
-            const zip = new StreamZip.async({ file: zipPath });
-            await zip.extract(null, moropoDir);
-            await zip.close();
-            // Delete zip file after extraction
-            fs.unlinkSync(zipPath);
+            await this.extractZipFile(zipPath, moropoDir);
             if (!quiet && !json) {
                 core_1.ux.action.stop('completed');
             }
-            if (debug && logger) {
-                logger('DEBUG: Successfully extracted Moropo tests');
-            }
+            this.logDebug(debug, logger, 'DEBUG: Successfully extracted Moropo tests');
             // Create config.yaml file
-            const configPath = path.join(moropoDir, 'config.yaml');
-            fs.writeFileSync(configPath, 'flows:\n- ./**/*.yaml\n- ./*.yaml\n');
-            if (debug && logger) {
-                logger('DEBUG: Created config.yaml file');
-            }
+            this.createConfigFile(moropoDir);
+            this.logDebug(debug, logger, 'DEBUG: Created config.yaml file');
             return moropoDir;
         }
         catch (error) {
             if (!quiet && !json) {
                 core_1.ux.action.stop('failed');
             }
-            if (debug && logger) {
-                logger(`DEBUG: Error downloading/extracting Moropo tests: ${error}`);
-            }
+            this.logDebug(debug, logger, `DEBUG: Error downloading/extracting Moropo tests: ${error}`);
             throw new Error(`Failed to download/extract Moropo tests: ${error}`);
         }
     }
+    createConfigFile(moropoDir) {
+        const configPath = path.join(moropoDir, 'config.yaml');
+        fs.writeFileSync(configPath, 'flows:\n- ./**/*.yaml\n- ./*.yaml\n');
+    }
+    async downloadZipFile(response, zipPath, options) {
+        const { quiet, json } = options;
+        const contentLength = response.headers.get('content-length');
+        const totalSize = contentLength ? Number.parseInt(contentLength, 10) : 0;
+        let downloadedSize = 0;
+        const fileStream = fs.createWriteStream(zipPath);
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Failed to get response reader');
+        }
+        let readerResult = await reader.read();
+        while (!readerResult.done) {
+            const { value } = readerResult;
+            downloadedSize += value.length;
+            if (!quiet && !json && totalSize) {
+                const progress = Math.round((downloadedSize / totalSize) * 100);
+                core_1.ux.action.status = `Downloading: ${progress}%`;
+            }
+            fileStream.write(value);
+            readerResult = await reader.read();
+        }
+        fileStream.end();
+        await new Promise((resolve) => {
+            fileStream.on('finish', () => {
+                resolve();
+            });
+        });
+    }
+    async extractZipFile(zipPath, extractPath) {
+        // eslint-disable-next-line new-cap
+        const zip = new StreamZip.async({ file: zipPath });
+        await zip.extract(null, extractPath);
+        await zip.close();
+        fs.unlinkSync(zipPath);
+    }
+    logDebug(debug, logger, message) {
+        if (debug && logger) {
+            logger(message);
+        }
+    }
+    showProgress(quiet, json, message) {
+        if (!quiet && !json) {
+            core_1.ux.action.status = message;
+        }
+    }
 }
 exports.MoropoService = MoropoService;

package/dist/services/report-download.service.d.ts

@@ -23,11 +23,13 @@ export declare class ReportDownloadService {
     /**
      * Download test artifacts as a zip file
      * @param options Download configuration
+     * @returns Promise that resolves when download is complete
      */
     downloadArtifacts(options: ArtifactsDownloadOptions): Promise<void>;
     /**
      * Handle downloading reports based on the report type specified
      * @param options Report download configuration
+     * @returns Promise that resolves when download is complete
      */
     downloadReports(options: ReportDownloadOptions): Promise<void>;
     /**
@@ -35,6 +37,7 @@ export declare class ReportDownloadService {
      * @param type Report type to download
      * @param filePath Path where report should be saved
      * @param options Download configuration
+     * @returns Promise that resolves when download is complete
      */
     private downloadReport;
 }

package/dist/services/report-download.service.js

@@ -10,6 +10,7 @@ class ReportDownloadService {
     /**
      * Download test artifacts as a zip file
      * @param options Download configuration
+     * @returns Promise that resolves when download is complete
      */
     async downloadArtifacts(options) {
         const { apiUrl, apiKey, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
@@ -35,6 +36,7 @@ class ReportDownloadService {
     /**
      * Handle downloading reports based on the report type specified
      * @param options Report download configuration
+     * @returns Promise that resolves when download is complete
      */
     async downloadReports(options) {
         const { reportType, junitPath, allurePath, htmlPath, warnLogger, ...downloadOptions } = options;
@@ -75,6 +77,7 @@ class ReportDownloadService {
      * @param type Report type to download
      * @param filePath Path where report should be saved
      * @param options Download configuration
+     * @returns Promise that resolves when download is complete
      */
     async downloadReport(type, filePath, options) {
         const { apiUrl, apiKey, uploadId, debug = false, logger, warnLogger } = options;

package/dist/services/results-polling.service.d.ts

@@ -41,5 +41,11 @@ export declare class ResultsPollingService {
      * @returns Promise that resolves with final test results or rejects if tests fail
      */
     pollUntilComplete(results: TestResult[], options: PollingOptions): Promise<PollingResult>;
+    private buildPollingResult;
+    private calculateStatusSummary;
+    private displayFinalResults;
+    private filterLatestResults;
+    private handlePollingError;
+    private updateDisplayStatus;
 }
 export {};

package/dist/services/results-polling.service.js

@@ -61,93 +61,16 @@ class ResultsPollingService {
                             logger(`DEBUG: Result status: ${result.test_file_name} - ${result.status}`);
                         }
                     }
-                    // Calculate summary statistics
-                    const statusCounts = {};
-                    for (const result of updatedResults) {
-                        statusCounts[result.status] = (statusCounts[result.status] || 0) + 1;
-                    }
-                    const passed = statusCounts.PASSED || 0;
-                    const failed = statusCounts.FAILED || 0;
-                    const pending = statusCounts.PENDING || 0;
-                    const running = statusCounts.RUNNING || 0;
-                    const total = updatedResults.length;
-                    const completed = passed + failed;
-                    // Display quantitative summary in quiet mode only
-                    const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
-                    if (!json) {
-                        if (quiet) {
-                            // Only update status when the summary changes in quiet mode
-                            if (summary !== previousSummary) {
-                                core_1.ux.action.status = summary;
-                                previousSummary = summary;
-                            }
-                        }
-                        else {
-                            // Show detailed table in non-quiet mode (no summary)
-                            core_1.ux.action.status =
-                                '\nStatus      Test\n─────────── ───────────────';
-                            for (const { retry_of: isRetry, status, test_file_name: test, } of updatedResults) {
-                                core_1.ux.action.status += `\n${status.padEnd(10, ' ')}  ${test} ${isRetry ? '(retry)' : ''}`;
-                            }
-                        }
-                    }
-                    if (updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status))) {
+                    const { summary } = this.calculateStatusSummary(updatedResults);
+                    previousSummary = this.updateDisplayStatus(updatedResults, quiet, json, summary, previousSummary);
+                    const allComplete = updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status));
+                    if (allComplete) {
                         if (debug && logger) {
                             logger(`DEBUG: All tests completed, stopping poll`);
                         }
-                        if (!json) {
-                            core_1.ux.action.stop('completed');
-                            if (logger) {
-                                logger('\n');
-                            }
-                            const hasFailedTests = updatedResults.some((result) => result.status === 'FAILED');
-                            (0, cli_ux_1.table)(updatedResults, {
-                                status: { get: (row) => row.status },
-                                test: {
-                                    get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
-                                },
-                                duration: {
-                                    get: (row) => row.duration_seconds
-                                        ? (0, methods_1.formatDurationSeconds)(Number(row.duration_seconds))
-                                        : '-',
-                                },
-                                ...(hasFailedTests && {
-                                    // eslint-disable-next-line camelcase
-                                    fail_reason: {
-                                        get: (row) => row.status === 'FAILED' && row.fail_reason
-                                            ? row.fail_reason
-                                            : '',
-                                    },
-                                }),
-                            }, { printLine: logger });
-                            if (logger) {
-                                logger('\n');
-                                logger('Run completed, you can access the results at:');
-                                logger(consoleUrl);
-                                logger('\n');
-                            }
-                        }
+                        this.displayFinalResults(updatedResults, consoleUrl, json, logger);
                         clearInterval(intervalId);
-                        const resultsWithoutEarlierTries = updatedResults.filter((result) => {
-                            const originalTryId = result.retry_of || result.id;
-                            const tries = updatedResults.filter((r) => r.retry_of === originalTryId || r.id === originalTryId);
-                            return result.id === Math.max(...tries.map((t) => t.id));
-                        });
-                        const output = {
-                            consoleUrl,
-                            status: resultsWithoutEarlierTries.some((result) => result.status === 'FAILED')
-                                ? 'FAILED'
-                                : 'PASSED',
-                            tests: resultsWithoutEarlierTries.map((r) => ({
-                                durationSeconds: r.duration_seconds,
-                                failReason: r.status === 'FAILED'
-                                    ? r.fail_reason || 'No reason provided'
-                                    : undefined,
-                                name: r.test_file_name,
-                                status: r.status,
-                            })),
-                            uploadId,
-                        };
+                        const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl);
                         if (output.status === 'FAILED') {
                             if (debug && logger) {
                                 logger(`DEBUG: Some tests failed, returning failed status`);
@@ -165,46 +88,137 @@ class ResultsPollingService {
                 }
                 catch (error) {
                     sequentialPollFailures++;
-                    if (debug && logger) {
-                        logger(`DEBUG: Error polling for results: ${error}`);
-                        logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+                    try {
+                        await this.handlePollingError(error, sequentialPollFailures, debug, logger);
                     }
-                    if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
-                        // dropped poll requests shouldn't err user CI
+                    catch (error) {
                         clearInterval(intervalId);
-                        // Check if the failure is due to internet connectivity issues
-                        if (debug && logger) {
-                            logger('DEBUG: Checking internet connectivity...');
-                        }
-                        const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
-                        if (debug && logger) {
-                            logger(`DEBUG: ${connectivityCheck.message}`);
-                            for (const result of connectivityCheck.endpointResults) {
-                                if (result.success) {
-                                    logger(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
-                                }
-                                else {
-                                    logger(`DEBUG: ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
-                                }
-                            }
-                        }
-                        if (!connectivityCheck.connected) {
-                            // Build detailed error message with endpoint diagnostics
-                            const endpointDetails = connectivityCheck.endpointResults
-                                .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
-                                .join('\n');
-                            reject(new Error(`Unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.`));
-                            return;
-                        }
-                        reject(new Error(`unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts`));
-                        return;
-                    }
-                    if (logger) {
-                        logger('unable to fetch results, trying again...');
+                        reject(error);
                     }
                 }
             }, this.POLL_INTERVAL_MS);
         });
     }
+    buildPollingResult(results, uploadId, consoleUrl) {
+        const resultsWithoutEarlierTries = this.filterLatestResults(results);
+        return {
+            consoleUrl,
+            status: resultsWithoutEarlierTries.some((result) => result.status === 'FAILED')
+                ? 'FAILED'
+                : 'PASSED',
+            tests: resultsWithoutEarlierTries.map((r) => ({
+                durationSeconds: r.duration_seconds,
+                failReason: r.status === 'FAILED' ? r.fail_reason || 'No reason provided' : undefined,
+                name: r.test_file_name,
+                status: r.status,
+            })),
+            uploadId,
+        };
+    }
+    calculateStatusSummary(results) {
+        const statusCounts = {};
+        for (const result of results) {
+            statusCounts[result.status] = (statusCounts[result.status] || 0) + 1;
+        }
+        const passed = statusCounts.PASSED || 0;
+        const failed = statusCounts.FAILED || 0;
+        const pending = statusCounts.PENDING || 0;
+        const running = statusCounts.RUNNING || 0;
+        const total = results.length;
+        const completed = passed + failed;
+        const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
+        return { completed, failed, passed, pending, running, summary, total };
+    }
+    displayFinalResults(results, consoleUrl, json, logger) {
+        if (json) {
+            return;
+        }
+        core_1.ux.action.stop('completed');
+        if (logger) {
+            logger('\n');
+        }
+        const hasFailedTests = results.some((result) => result.status === 'FAILED');
+        (0, cli_ux_1.table)(results, {
+            duration: {
+                get: (row) => row.duration_seconds
+                    ? (0, methods_1.formatDurationSeconds)(Number(row.duration_seconds))
+                    : '-',
+            },
+            status: { get: (row) => row.status },
+            test: {
+                get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
+            },
+            ...(hasFailedTests && {
+                // eslint-disable-next-line camelcase
+                fail_reason: {
+                    get: (row) => row.status === 'FAILED' && row.fail_reason ? row.fail_reason : '',
+                },
+            }),
+        }, { printLine: logger });
+        if (logger) {
+            logger('\n');
+            logger('Run completed, you can access the results at:');
+            logger(consoleUrl);
+            logger('\n');
+        }
+    }
+    filterLatestResults(results) {
+        return results.filter((result) => {
+            const originalTryId = result.retry_of || result.id;
+            const tries = results.filter((r) => r.retry_of === originalTryId || r.id === originalTryId);
+            return result.id === Math.max(...tries.map((t) => t.id));
+        });
+    }
+    async handlePollingError(error, sequentialPollFailures, debug, logger) {
+        if (debug && logger) {
+            logger(`DEBUG: Error polling for results: ${error}`);
+            logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+        }
+        if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
+            if (debug && logger) {
+                logger('DEBUG: Checking internet connectivity...');
+            }
+            const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
+            if (debug && logger) {
+                logger(`DEBUG: ${connectivityCheck.message}`);
+                for (const result of connectivityCheck.endpointResults) {
+                    if (result.success) {
+                        logger(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
+                    }
+                    else {
+                        logger(`DEBUG: ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
+                    }
+                }
+            }
+            if (!connectivityCheck.connected) {
+                const endpointDetails = connectivityCheck.endpointResults
+                    .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                    .join('\n');
+                throw new Error(`Unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.`);
+            }
+            throw new Error(`unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts`);
+        }
+        if (logger) {
+            logger('unable to fetch results, trying again...');
+        }
+    }
+    updateDisplayStatus(results, quiet, json, summary, previousSummary) {
+        if (json) {
+            return previousSummary;
+        }
+        if (quiet) {
+            if (summary !== previousSummary) {
+                core_1.ux.action.status = summary;
+                return summary;
+            }
+        }
+        else {
+            core_1.ux.action.status = '\nStatus      Test\n─────────── ───────────────';
+            for (const { retry_of: isRetry, status, test_file_name: test, } of results) {
+                core_1.ux.action.status += `\n${status.padEnd(10, ' ')}  ${test} ${isRetry ? '(retry)' : ''}`;
+            }
+        }
+        return previousSummary;
+    }
 }
 exports.ResultsPollingService = ResultsPollingService;

package/dist/services/test-submission.service.d.ts

@@ -38,4 +38,10 @@ export declare class TestSubmissionService {
      * @returns FormData ready to be submitted to the API
      */
     buildTestFormData(config: TestSubmissionConfig): Promise<FormData>;
+    private logDebug;
+    private normalizeFilePath;
+    private normalizePathMap;
+    private normalizePaths;
+    private parseKeyValuePairs;
+    private setOptionalFields;
 }

package/dist/services/test-submission.service.js

@@ -20,29 +20,15 @@ class TestSubmissionService {
         const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, referencedFiles, sequence, workspaceConfig, } = executionPlan;
         const { flows: sequentialFlows = [] } = sequence ?? {};
         const testFormData = new FormData();
-        // eslint-disable-next-line unicorn/no-array-reduce
-        const envObject = env.reduce((acc, cur) => {
-            const [key, ...value] = cur.split('=');
-            // handle case where value includes an equals sign
-            acc[key] = value.join('=');
-            return acc;
-        }, {});
-        // eslint-disable-next-line unicorn/no-array-reduce
-        const metadataObject = metadata.reduce((acc, cur) => {
-            const [key, ...value] = cur.split('=');
-            // handle case where value includes an equals sign
-            acc[key] = value.join('=');
-            return acc;
-        }, {});
-        if (debug && logger && Object.keys(envObject).length > 0) {
-            logger(`DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
-        }
-        if (debug && logger && Object.keys(metadataObject).length > 0) {
-            logger(`DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
+        const envObject = this.parseKeyValuePairs(env);
+        const metadataObject = this.parseKeyValuePairs(metadata);
+        if (Object.keys(envObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
         }
-        if (debug && logger) {
-            logger(`DEBUG: Compressing files from path: ${flowFile}`);
+        if (Object.keys(metadataObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
         }
+        this.logDebug(debug, logger, `DEBUG: Compressing files from path: ${flowFile}`);
         const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
             ? path.dirname(flowFile)
             : flowFile, [
@@ -52,24 +38,16 @@ class TestSubmissionService {
                 ...sequentialFlows,
             ]),
         ], commonRoot);
-        if (debug && logger) {
-            logger(`DEBUG: Compressed file size: ${buffer.length} bytes`);
-        }
+        this.logDebug(debug, logger, `DEBUG: Compressed file size: ${buffer.length} bytes`);
         const blob = new Blob([buffer], {
             type: mimeTypeLookupByExtension.zip,
         });
         testFormData.set('file', blob, 'flowFile.zip');
         testFormData.set('appBinaryId', appBinaryId);
-        testFormData.set('testFileNames', JSON.stringify(testFileNames.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
-        testFormData.set('flowMetadata', JSON.stringify(Object.fromEntries(Object.entries(flowMetadata).map(([key, value]) => [
-            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
-            value,
-        ]))));
-        testFormData.set('testFileOverrides', JSON.stringify(Object.fromEntries(Object.entries(flowOverrides).map(([key, value]) => [
-            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
-            value,
-        ]))));
-        testFormData.set('sequentialFlows', JSON.stringify(sequentialFlows.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
+        testFormData.set('testFileNames', JSON.stringify(this.normalizePaths(testFileNames, commonRoot)));
+        testFormData.set('flowMetadata', JSON.stringify(this.normalizePathMap(flowMetadata, commonRoot)));
+        testFormData.set('testFileOverrides', JSON.stringify(this.normalizePathMap(flowOverrides, commonRoot)));
+        testFormData.set('sequentialFlows', JSON.stringify(this.normalizePaths(sequentialFlows, commonRoot)));
         testFormData.set('env', JSON.stringify(envObject));
         testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
         const configPayload = {
@@ -92,25 +70,53 @@ class TestSubmissionService {
         if (Object.keys(metadataObject).length > 0) {
             const metadataPayload = { userMetadata: metadataObject };
             testFormData.set('metadata', JSON.stringify(metadataPayload));
-            if (debug && logger) {
-                logger(`DEBUG: Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
-            }
+            this.logDebug(debug, logger, `DEBUG: Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
         }
-        if (androidApiLevel)
-            testFormData.set('androidApiLevel', androidApiLevel.toString());
-        if (androidDevice)
-            testFormData.set('androidDevice', androidDevice.toString());
-        if (iOSVersion)
-            testFormData.set('iOSVersion', iOSVersion.toString());
-        if (iOSDevice)
-            testFormData.set('iOSDevice', iOSDevice.toString());
-        if (name)
-            testFormData.set('name', name.toString());
-        if (runnerType)
-            testFormData.set('runnerType', runnerType.toString());
-        if (workspaceConfig)
+        this.setOptionalFields(testFormData, {
+            androidApiLevel,
+            androidDevice,
+            iOSDevice,
+            iOSVersion,
+            name,
+            runnerType,
+        });
+        if (workspaceConfig) {
             testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+        }
         return testFormData;
     }
+    logDebug(debug, logger, message) {
+        if (debug && logger) {
+            logger(message);
+        }
+    }
+    normalizeFilePath(filePath, commonRoot) {
+        return filePath.replaceAll(commonRoot, '.').split(path.sep).join('/');
+    }
+    normalizePathMap(map, commonRoot) {
+        return Object.fromEntries(Object.entries(map).map(([key, value]) => [
+            this.normalizeFilePath(key, commonRoot),
+            value,
+        ]));
+    }
+    normalizePaths(paths, commonRoot) {
+        return paths.map((p) => this.normalizeFilePath(p, commonRoot));
+    }
+    parseKeyValuePairs(pairs) {
+        // eslint-disable-next-line unicorn/no-array-reduce
+        return pairs.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+    }
+    setOptionalFields(formData, fields) {
+        for (const [key, value] of Object.entries(fields)) {
+            if (value) {
+                formData.set(key, value.toString());
+            }
+        }
+    }
 }
 exports.TestSubmissionService = TestSubmissionService;

package/dist/services/version.service.d.ts

@@ -19,8 +19,9 @@ export declare class VersionService {
      * Resolve and validate Maestro version against API compatibility data
      * @param requestedVersion - Version requested by user (or undefined for default)
      * @param compatibilityData - API compatibility data
-     * @param debug - Enable debug logging
-     * @param logger - Optional logger function
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
      * @returns Validated Maestro version string
      * @throws Error if version is not supported
      */

package/dist/services/version.service.js

@@ -44,8 +44,9 @@ class VersionService {
      * Resolve and validate Maestro version against API compatibility data
      * @param requestedVersion - Version requested by user (or undefined for default)
      * @param compatibilityData - API compatibility data
-     * @param debug - Enable debug logging
-     * @param logger - Optional logger function
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
      * @returns Validated Maestro version string
      * @throws Error if version is not supported
      */

package/oclif.manifest.json

@@ -565,5 +565,5 @@
       ]
     }
   },
-  "version": "4.1.3"
+  "version": "4.1.4"
 }

package/package.json

@@ -65,7 +65,7 @@
     "type": "git",
     "url": "https://devicecloud.dev"
   },
-  "version": "4.1.3",
+  "version": "4.1.4",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },