@devicecloud.dev/dcd 4.1.2-beta.1 → 4.1.2

package/dist/commands/cloud.js

@@ -14,6 +14,7 @@ const api_gateway_1 = require("../gateways/api-gateway");
 const methods_1 = require("../methods");
 const plan_1 = require("../plan");
 const compatibility_1 = require("../utils/compatibility");
+const connectivity_1 = require("../utils/connectivity");
 const StreamZip = require("node-stream-zip");
 exports.mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
@@ -580,6 +581,7 @@ class Cloud extends core_1.Command {
                 this.log('\nYou can safely close this terminal and the tests will continue\n');
             }
             let sequentialPollFaillures = 0;
+            let previousSummary = '';
             if (debug) {
                 this.log(`DEBUG: Starting polling loop for results`);
             }
@@ -599,11 +601,34 @@ class Cloud extends core_1.Command {
                                 this.log(`DEBUG: Result status: ${result.test_file_name} - ${result.status}`);
                             }
                         }
-                        if (!quiet && !json) {
-                            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)' : ''}`;
+                        // 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))) {
@@ -728,6 +753,29 @@ class Cloud extends core_1.Command {
                         if (sequentialPollFaillures > 10) {
                             // dropped poll requests shouldn't err user CI
                             clearInterval(intervalId);
+                            // Check if the failure is due to internet connectivity issues
+                            if (debug) {
+                                this.log('DEBUG: Checking internet connectivity...');
+                            }
+                            const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
+                            if (debug) {
+                                this.log(`DEBUG: ${connectivityCheck.message}`);
+                                for (const result of connectivityCheck.endpointResults) {
+                                    if (result.success) {
+                                        this.log(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
+                                    }
+                                    else {
+                                        this.log(`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');
+                                throw new Error(`Unable to fetch results after 10 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 10 attempts');
                         }
                         this.log('unable to fetch results, trying again...');

package/dist/commands/status.d.ts

@@ -1,7 +1,13 @@
 import { Command } from '@oclif/core';
+import { ConnectivityCheckResult } from '../utils/connectivity';
 type StatusResponse = {
     appBinaryId?: string;
     attempts?: number;
+    connectivityCheck?: {
+        connected: boolean;
+        endpointResults: ConnectivityCheckResult['endpointResults'];
+        message: string;
+    };
     consoleUrl?: string;
     error?: string;
     status: 'CANCELLED' | 'FAILED' | 'PASSED' | 'PENDING' | 'RUNNING';

package/dist/commands/status.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const constants_1 = require("../constants");
 const api_gateway_1 = require("../gateways/api-gateway");
 const methods_1 = require("../methods");
+const connectivity_1 = require("../utils/connectivity");
 class Status extends core_1.Command {
     static description = 'Get the status of an upload by name or upload ID';
     static enableJsonFlag = true;
@@ -64,10 +65,27 @@ class Status extends core_1.Command {
             }
         }
         if (!status) {
-            const errorMessage = `Failed to get status after 5 attempts. Check your network. Last error: ${lastError?.message || 'Unknown error'}`;
+            // Check if the failure is due to internet connectivity issues
+            const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
+            let errorMessage;
+            if (connectivityCheck.connected) {
+                errorMessage = `Failed to get status after 5 attempts. Internet appears functional but unable to reach API. Last error: ${lastError?.message || 'Unknown error'}`;
+            }
+            else {
+                // Build detailed error message with endpoint diagnostics
+                const endpointDetails = connectivityCheck.endpointResults
+                    .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                    .join('\n');
+                errorMessage = `Failed to get status after 5 attempts.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.\nLast API error: ${lastError?.message || 'Unknown error'}`;
+            }
             if (json) {
                 return {
                     attempts: 5,
+                    connectivityCheck: {
+                        connected: connectivityCheck.connected,
+                        endpointResults: connectivityCheck.endpointResults,
+                        message: connectivityCheck.message,
+                    },
                     error: errorMessage,
                     status: 'FAILED',
                     tests: [],

package/dist/utils/connectivity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility for checking internet connectivity using third-party endpoints
+ */
+export type ConnectivityCheckResult = {
+    /** Whether internet connectivity was detected */
+    connected: boolean;
+    /** Detailed results for each endpoint tested */
+    endpointResults: Array<{
+        /** The endpoint URL that was tested */
+        endpoint: string;
+        /** Error message if request failed */
+        error?: string;
+        /** Time taken for the request in milliseconds */
+        latencyMs?: number;
+        /** HTTP status code if request succeeded */
+        statusCode?: number;
+        /** Whether this endpoint was reachable */
+        success: boolean;
+    }>;
+    /** Summary message for developers */
+    message: string;
+};
+/**
+ * Check if the system has internet connectivity by testing against
+ * multiple reliable third-party endpoints with detailed diagnostics.
+ *
+ * @returns Promise<ConnectivityCheckResult> - Detailed connectivity check results
+ */
+export declare function checkInternetConnectivity(): Promise<ConnectivityCheckResult>;

package/dist/utils/connectivity.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Utility for checking internet connectivity using third-party endpoints
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkInternetConnectivity = checkInternetConnectivity;
+/**
+ * Check if the system has internet connectivity by testing against
+ * multiple reliable third-party endpoints with detailed diagnostics.
+ *
+ * @returns Promise<ConnectivityCheckResult> - Detailed connectivity check results
+ */
+async function checkInternetConnectivity() {
+    // Use multiple reliable endpoints to test connectivity
+    const testEndpoints = [
+        { url: 'https://www.google.com/generate_204', description: 'Google' },
+        { url: 'https://www.cloudflare.com/cdn-cgi/trace', description: 'Cloudflare' },
+        { url: 'https://1.1.1.1/', description: 'Cloudflare DNS' },
+    ];
+    const endpointResults = [];
+    let anySuccess = false;
+    // Try each endpoint with a short timeout
+    for (const { url, description } of testEndpoints) {
+        const startTime = Date.now();
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 second timeout
+            const response = await fetch(url, {
+                method: 'HEAD', // Use HEAD to minimize data transfer
+                signal: controller.signal,
+                // Disable redirects to get faster response
+                redirect: 'manual',
+            });
+            clearTimeout(timeoutId);
+            const latencyMs = Date.now() - startTime;
+            // Any response (including 3xx redirects) indicates connectivity
+            if (response) {
+                anySuccess = true;
+                endpointResults.push({
+                    endpoint: `${description} (${url})`,
+                    success: true,
+                    statusCode: response.status,
+                    latencyMs,
+                });
+                // Found working connection, no need to test more
+                break;
+            }
+        }
+        catch (error) {
+            const latencyMs = Date.now() - startTime;
+            let errorMessage = 'Unknown error';
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    errorMessage = 'Request timeout (>3s)';
+                }
+                else if (error.message.includes('fetch failed')) {
+                    errorMessage = 'Network request failed (DNS/connection error)';
+                }
+                else if (error.message.includes('ENOTFOUND')) {
+                    errorMessage = 'DNS resolution failed';
+                }
+                else if (error.message.includes('ECONNREFUSED')) {
+                    errorMessage = 'Connection refused';
+                }
+                else if (error.message.includes('ETIMEDOUT')) {
+                    errorMessage = 'Connection timeout';
+                }
+                else if (error.message.includes('ENETUNREACH')) {
+                    errorMessage = 'Network unreachable';
+                }
+                else {
+                    errorMessage = error.message;
+                }
+            }
+            endpointResults.push({
+                endpoint: `${description} (${url})`,
+                success: false,
+                error: errorMessage,
+                latencyMs,
+            });
+            // Continue to next endpoint if this one fails
+            continue;
+        }
+    }
+    // Generate developer-friendly message
+    let message;
+    if (anySuccess) {
+        const successfulEndpoint = endpointResults.find((r) => r.success);
+        message = `Internet connectivity verified via ${successfulEndpoint?.endpoint} (${successfulEndpoint?.latencyMs}ms)`;
+    }
+    else {
+        const testedEndpoints = endpointResults.map((r) => r.endpoint).join(', ');
+        message = `No internet connectivity detected. Tested endpoints: ${testedEndpoints}`;
+    }
+    return {
+        connected: anySuccess,
+        endpointResults,
+        message,
+    };
+}

package/oclif.manifest.json

@@ -579,5 +579,5 @@
       ]
     }
   },
-  "version": "4.1.2-beta.1"
+  "version": "4.1.2"
 }

package/package.json

@@ -72,7 +72,7 @@
     "type": "git",
     "url": "https://devicecloud.dev"
   },
-  "version": "4.1.2-beta.1",
+  "version": "4.1.2",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },