@devicecloud.dev/dcd 4.1.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',
@@ -308,7 +309,7 @@ class Cloud extends core_1.Command {
                 if (debug) {
                     this.log('DEBUG: Generating execution plan...');
                 }
-                executionPlan = await (0, plan_1.plan)(flowFile, includeTags.flat(), excludeTags.flat(), excludeFlows.flat(), configFile);
+                executionPlan = await (0, plan_1.plan)(flowFile, includeTags.flat(), excludeTags.flat(), excludeFlows.flat(), configFile, debug);
                 if (debug) {
                     this.log(`DEBUG: Execution plan generated`);
                     this.log(`DEBUG: Total flow files: ${executionPlan.totalFlowFiles}`);
@@ -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/plan.d.ts

@@ -35,5 +35,5 @@ interface IFlowSequence {
     continueOnFailure?: boolean;
     flows: string[];
 }
-export declare function plan(input: string, includeTags: string[], excludeTags: string[], excludeFlows?: string[], configFile?: string): Promise<IExecutionPlan>;
+export declare function plan(input: string, includeTags: string[], excludeTags: string[], excludeFlows?: string[], configFile?: string, debug?: boolean): Promise<IExecutionPlan>;
 export {};

package/dist/plan.js

@@ -64,7 +64,7 @@ function extractDeviceCloudOverrides(config) {
     }
     return overrides;
 }
-async function plan(input, includeTags, excludeTags, excludeFlows, configFile) {
+async function plan(input, includeTags, excludeTags, excludeFlows, configFile, debug = false) {
     const normalizedInput = path.normalize(input);
     const flowMetadata = {};
     if (!fs.existsSync(normalizedInput)) {
@@ -189,12 +189,30 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile) {
         const config = configPerFlowFile[filePath];
         const name = config?.name || path.parse(filePath).name;
         acc[name] = filePath;
+        if (debug) {
+            console.log(`[DEBUG] Flow name mapping: "${name}" -> ${filePath}`);
+        }
         return acc;
     }, {});
+    if (debug && workspaceConfig.executionOrder?.flowsOrder) {
+        console.log('[DEBUG] executionOrder.flowsOrder:', workspaceConfig.executionOrder.flowsOrder);
+        console.log('[DEBUG] Available flow names:', Object.keys(pathsByName));
+    }
     const flowsToRunInSequence = workspaceConfig.executionOrder?.flowsOrder
-        ?.map((flowOrder) => flowOrder.replace('.yaml', '').replace('.yml', '')) // support case where ext is left on
-        ?.map((flowOrder) => (0, planMethods_1.getFlowsToRunInSequence)(pathsByName, [flowOrder]))
+        ?.map((flowOrder) => {
+        // Strip .yaml/.yml extension only from the END of the string
+        // This supports flowsOrder entries like "my_test.yml" matching "my_test"
+        // while preserving extensions in the middle like "(file.yml) Name"
+        const normalizedFlowOrder = flowOrder.replace(/\.ya?ml$/i, '');
+        if (debug && flowOrder !== normalizedFlowOrder) {
+            console.log(`[DEBUG] Stripping trailing extension: "${flowOrder}" -> "${normalizedFlowOrder}"`);
+        }
+        return (0, planMethods_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
+    })
         .flat() || [];
+    if (debug) {
+        console.log(`[DEBUG] Sequential flows resolved: ${flowsToRunInSequence.length} flow(s)`);
+    }
     const normalFlows = allFlows
         .filter((flow) => !flowsToRunInSequence.includes(flow))
         .sort((a, b) => a.localeCompare(b));

package/dist/planMethods.d.ts

@@ -1,6 +1,6 @@
 export declare function getFlowsToRunInSequence(paths: {
     [key: string]: string;
-}, flowOrder: string[]): string[];
+}, flowOrder: string[], debug?: boolean): string[];
 export declare function isFlowFile(filePath: string): boolean;
 export declare const readYamlFileAsJson: (filePath: string) => unknown;
 export declare const readTestYamlFileAsJson: (filePath: string) => {

package/dist/planMethods.js

@@ -9,25 +9,50 @@ const yaml = require("js-yaml");
 const fs = require("node:fs");
 const path = require("node:path");
 const commandsThatRequireFiles = new Set(['addMedia', 'runFlow', 'runScript']);
-function getFlowsToRunInSequence(paths, flowOrder) {
-    if (flowOrder.length === 0)
+function getFlowsToRunInSequence(paths, flowOrder, debug = false) {
+    if (flowOrder.length === 0) {
+        if (debug) {
+            console.log('[DEBUG] getFlowsToRunInSequence: flowOrder is empty, returning []');
+        }
         return [];
+    }
     const orderSet = new Set(flowOrder);
-    const namesInOrder = Object.keys(paths).filter((key) => orderSet.has(key));
-    if (namesInOrder.length === 0)
+    const availableNames = Object.keys(paths);
+    if (debug) {
+        console.log(`[DEBUG] getFlowsToRunInSequence: Looking for flows in order: [${[...orderSet].join(', ')}]`);
+        console.log(`[DEBUG] getFlowsToRunInSequence: Available flow names: [${availableNames.join(', ')}]`);
+    }
+    const namesInOrder = availableNames.filter((key) => orderSet.has(key));
+    if (debug) {
+        console.log(`[DEBUG] getFlowsToRunInSequence: Matched ${namesInOrder.length} flow(s): [${namesInOrder.join(', ')}]`);
+    }
+    if (namesInOrder.length === 0) {
+        const notFound = [...orderSet].filter((item) => !availableNames.includes(item));
+        if (debug) {
+            console.log(`[DEBUG] getFlowsToRunInSequence: No flows matched, not found: [${notFound.join(', ')}]`);
+        }
         return [];
+    }
     const result = [...orderSet].filter((item) => namesInOrder.includes(item));
     if (result.length === 0) {
-        throw new Error(`Could not find flows needed for execution in order: ${[...orderSet]
-            .filter((item) => !namesInOrder.includes(item))
-            .join(', ')}`);
+        const notFound = [...orderSet].filter((item) => !namesInOrder.includes(item));
+        throw new Error(`Could not find flows needed for execution in order: ${notFound.join(', ')}\n\nAvailable flow names:\n${availableNames.join('\n')}`);
     }
     else if (flowOrder
         .slice(0, result.length)
         .every((value, index) => value === result[index])) {
-        return result.map((item) => paths[item]);
+        const resolvedPaths = result.map((item) => paths[item]);
+        if (debug) {
+            console.log(`[DEBUG] getFlowsToRunInSequence: Order matches, returning ${resolvedPaths.length} path(s)`);
+        }
+        return resolvedPaths;
     }
     else {
+        if (debug) {
+            console.log('[DEBUG] getFlowsToRunInSequence: Order does not match, returning []');
+            console.log(`[DEBUG] Expected order: [${flowOrder.slice(0, result.length).join(', ')}]`);
+            console.log(`[DEBUG] Actual result: [${result.join(', ')}]`);
+        }
         return [];
     }
 }

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.1"
+  "version": "4.1.2"
 }

package/package.json

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