@devicecloud.dev/dcd 4.1.4 → 4.1.6

package/dist/methods.js

@@ -12,6 +12,7 @@ const StreamZip = require("node-stream-zip");
 const api_gateway_1 = require("./gateways/api-gateway");
 const supabase_gateway_1 = require("./gateways/supabase-gateway");
 const metadata_extractor_service_1 = require("./services/metadata-extractor.service");
+const styling_1 = require("./utils/styling");
 const mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
     yaml: 'application/x-yaml',
@@ -76,66 +77,223 @@ const verifyAppZip = async (zipPath) => {
     zip.close();
 };
 exports.verifyAppZip = verifyAppZip;
-const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, log = true) => {
+const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, log = true, debug = false) => {
     if (log) {
-        core_1.ux.action.start('Checking and uploading binary', 'Initializing', {
+        core_1.ux.action.start(styling_1.colors.bold('Checking and uploading binary'), styling_1.colors.dim('Initializing'), {
             stdout: true,
         });
     }
+    if (debug) {
+        console.log('[DEBUG] Binary upload started');
+        console.log(`[DEBUG] File path: ${filePath}`);
+        console.log(`[DEBUG] API URL: ${apiUrl}`);
+        console.log(`[DEBUG] Ignore SHA check: ${ignoreShaCheck}`);
+    }
+    const startTime = Date.now();
+    try {
+        // Prepare file for upload
+        const file = await prepareFileForUpload(filePath, debug, startTime);
+        // Calculate SHA hash
+        const sha = await calculateFileHash(file, debug, log);
+        // Check for existing upload with same SHA
+        if (!ignoreShaCheck && sha) {
+            const { exists, binaryId } = await checkExistingUpload(apiUrl, apiKey, sha, debug);
+            if (exists && binaryId) {
+                if (log) {
+                    core_1.ux.info(styling_1.colors.dim('SHA hash matches existing binary with ID: ') + (0, styling_1.formatId)(binaryId) + styling_1.colors.dim(', skipping upload. Force upload with --ignore-sha-check'));
+                    core_1.ux.action.stop(styling_1.colors.info('Skipping upload'));
+                }
+                return binaryId;
+            }
+        }
+        // Perform the upload
+        const uploadId = await performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTime);
+        if (log) {
+            core_1.ux.action.stop(styling_1.colors.success('\n✓ Binary uploaded with ID: ') + (0, styling_1.formatId)(uploadId));
+        }
+        return uploadId;
+    }
+    catch (error) {
+        if (debug) {
+            console.error('[DEBUG] Binary upload failed:', error);
+            console.error(`[DEBUG] Error type: ${error instanceof Error ? error.name : typeof error}`);
+            console.error(`[DEBUG] Error message: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                console.error(`[DEBUG] Stack trace: ${error.stack}`);
+            }
+            console.error(`[DEBUG] Failed after ${Date.now() - startTime}ms`);
+        }
+        throw error;
+    }
+};
+exports.uploadBinary = uploadBinary;
+/**
+ * Prepares a file for upload by reading or compressing it
+ * @param filePath Path to the file to upload
+ * @param debug Whether debug logging is enabled
+ * @param startTime Timestamp when upload started
+ * @returns Promise resolving to prepared File object
+ */
+async function prepareFileForUpload(filePath, debug, startTime) {
+    if (debug) {
+        console.log('[DEBUG] Preparing file for upload...');
+    }
     let file;
     if (filePath?.endsWith('.app')) {
+        if (debug) {
+            console.log('[DEBUG] Compressing .app folder to zip...');
+        }
         const zippedAppBlob = await (0, exports.compressFolderToBlob)(filePath);
         file = new File([zippedAppBlob], filePath + '.zip');
+        if (debug) {
+            console.log(`[DEBUG] Compressed file size: ${(zippedAppBlob.size / 1024 / 1024).toFixed(2)} MB`);
+        }
     }
     else {
+        if (debug) {
+            console.log('[DEBUG] Reading binary file...');
+        }
         const fileBuffer = await (0, promises_1.readFile)(filePath);
+        if (debug) {
+            console.log(`[DEBUG] File size: ${(fileBuffer.length / 1024 / 1024).toFixed(2)} MB`);
+        }
         const binaryBlob = new Blob([new Uint8Array(fileBuffer)], {
             type: mimeTypeLookupByExtension[filePath.split('.').pop()],
         });
         file = new File([binaryBlob], filePath);
     }
-    let sha;
+    if (debug) {
+        console.log(`[DEBUG] File preparation completed in ${Date.now() - startTime}ms`);
+    }
+    return file;
+}
+/**
+ * Calculates SHA-256 hash for a file
+ * @param file File to calculate hash for
+ * @param debug Whether debug logging is enabled
+ * @param log Whether to log warnings
+ * @returns Promise resolving to SHA-256 hash or undefined if failed
+ */
+async function calculateFileHash(file, debug, log) {
     try {
-        sha = await getFileHashFromFile(file);
+        if (debug) {
+            console.log('[DEBUG] Calculating SHA-256 hash...');
+        }
+        const hashStartTime = Date.now();
+        const sha = await getFileHashFromFile(file);
+        if (debug) {
+            console.log(`[DEBUG] SHA-256 hash: ${sha}`);
+            console.log(`[DEBUG] Hash calculation completed in ${Date.now() - hashStartTime}ms`);
+        }
+        return sha;
     }
     catch (error) {
         if (log) {
             console.warn('Warning: Failed to get file hash', error);
         }
+        if (debug) {
+            console.error('[DEBUG] Hash calculation failed:', error);
+        }
+        return undefined;
     }
-    if (!ignoreShaCheck && sha) {
-        try {
-            const { appBinaryId, exists } = await api_gateway_1.ApiGateway.checkForExistingUpload(apiUrl, apiKey, sha);
+}
+/**
+ * Checks if an upload with the same SHA already exists
+ * @param apiUrl API base URL
+ * @param apiKey API authentication key
+ * @param sha SHA-256 hash to check
+ * @param debug Whether debug logging is enabled
+ * @returns Promise resolving to object with exists flag and optional binaryId
+ */
+async function checkExistingUpload(apiUrl, apiKey, sha, debug) {
+    try {
+        if (debug) {
+            console.log('[DEBUG] Checking for existing upload with matching SHA...');
+            console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/checkForExistingUpload`);
+        }
+        const shaCheckStartTime = Date.now();
+        const { appBinaryId, exists } = await api_gateway_1.ApiGateway.checkForExistingUpload(apiUrl, apiKey, sha);
+        if (debug) {
+            console.log(`[DEBUG] SHA check completed in ${Date.now() - shaCheckStartTime}ms`);
+            console.log(`[DEBUG] Existing binary found: ${exists}`);
             if (exists) {
-                if (log) {
-                    core_1.ux.info(`sha hash matches existing binary with id: ${appBinaryId}, skipping upload. Force upload with --ignore-sha-check`);
-                    core_1.ux.action.stop(`Skipping upload.`);
-                }
-                return appBinaryId;
+                console.log(`[DEBUG] Existing binary ID: ${appBinaryId}`);
             }
         }
-        catch {
-            // ignore error
+        return { binaryId: appBinaryId, exists };
+    }
+    catch (error) {
+        if (debug) {
+            console.error('[DEBUG] SHA check failed (continuing with upload):', error);
+            console.error(`[DEBUG] Error type: ${error instanceof Error ? error.name : typeof error}`);
+            console.error(`[DEBUG] Error message: ${error instanceof Error ? error.message : String(error)}`);
         }
+        return { exists: false };
+    }
+}
+/**
+ * Performs the actual file upload
+ * @param filePath Path to the file being uploaded
+ * @param apiUrl API base URL
+ * @param apiKey API authentication key
+ * @param file Prepared file to upload
+ * @param sha SHA-256 hash of the file
+ * @param debug Whether debug logging is enabled
+ * @param startTime Timestamp when upload started
+ * @returns Promise resolving to upload ID
+ */
+async function performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTime) {
+    if (debug) {
+        console.log('[DEBUG] Requesting upload URL...');
+        console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/getBinaryUploadUrl`);
+        console.log(`[DEBUG] Platform: ${filePath?.endsWith('.apk') ? 'android' : 'ios'}`);
     }
+    const urlRequestStartTime = Date.now();
     const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
+    if (debug) {
+        console.log(`[DEBUG] Upload URL request completed in ${Date.now() - urlRequestStartTime}ms`);
+        console.log(`[DEBUG] Upload ID: ${id}`);
+        console.log(`[DEBUG] Upload path: ${path}`);
+    }
     if (!path)
         throw new Error(message);
     // Extract app metadata using the service
+    if (debug) {
+        console.log('[DEBUG] Extracting app metadata...');
+    }
     const metadataExtractor = new metadata_extractor_service_1.MetadataExtractorService();
     const metadata = await metadataExtractor.extract(filePath);
     if (!metadata) {
         throw new Error(`Failed to extract metadata from ${filePath}. Supported formats: .apk, .app, .zip`);
     }
+    if (debug) {
+        console.log(`[DEBUG] Metadata extracted: ${JSON.stringify(metadata)}`);
+    }
     const env = apiUrl === 'https://api.devicecloud.dev' ? 'prod' : 'dev';
-    await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file);
+    if (debug) {
+        console.log(`[DEBUG] Uploading to Supabase storage (${env})...`);
+        console.log(`[DEBUG] File size: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
+    }
+    const uploadStartTime = Date.now();
+    await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file, debug);
+    if (debug) {
+        const uploadDuration = Date.now() - uploadStartTime;
+        const uploadSpeed = (file.size / 1024 / 1024) / (uploadDuration / 1000);
+        console.log(`[DEBUG] File upload completed in ${uploadDuration}ms`);
+        console.log(`[DEBUG] Average upload speed: ${uploadSpeed.toFixed(2)} MB/s`);
+    }
+    if (debug) {
+        console.log('[DEBUG] Finalizing upload...');
+        console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/finaliseUpload`);
+    }
+    const finalizeStartTime = Date.now();
     await api_gateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha);
-    if (log) {
-        core_1.ux.action.stop(`\nBinary uploaded with id: ${id}`);
+    if (debug) {
+        console.log(`[DEBUG] Upload finalization completed in ${Date.now() - finalizeStartTime}ms`);
+        console.log(`[DEBUG] Total upload time: ${Date.now() - startTime}ms`);
     }
     return id;
-};
-exports.uploadBinary = uploadBinary;
+}
 async function getFileHashFromFile(file) {
     return new Promise((resolve, reject) => {
         const hash = (0, node_crypto_1.createHash)('sha256');
@@ -168,21 +326,21 @@ async function getFileHashFromFile(file) {
 const writeJSONFile = (filePath, data, logger) => {
     try {
         (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2));
-        logger.log(`JSON output written to: ${path.resolve(filePath)}`);
+        logger.log(styling_1.colors.dim('JSON output written to: ') + styling_1.colors.highlight(path.resolve(filePath)));
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const isPermissionError = errorMessage.includes('EACCES') || errorMessage.includes('EPERM');
         const isNoSuchFileError = errorMessage.includes('ENOENT');
-        logger.warn(`Failed to write JSON output to file: ${filePath}`);
+        logger.warn(styling_1.colors.warning('⚠') + '  ' + styling_1.colors.error(`Failed to write JSON output to file: ${filePath}`));
         if (isPermissionError) {
-            logger.warn('Permission denied - check file/directory write permissions');
-            logger.warn('Try running with appropriate permissions or choose a different output location');
+            logger.warn(styling_1.colors.dim('   Permission denied - check file/directory write permissions'));
+            logger.warn(styling_1.colors.dim('   Try running with appropriate permissions or choose a different output location'));
         }
         else if (isNoSuchFileError) {
-            logger.warn('Directory does not exist - create the directory first or choose an existing path');
+            logger.warn(styling_1.colors.dim('   Directory does not exist - create the directory first or choose an existing path'));
         }
-        logger.warn(`Error details: ${errorMessage}`);
+        logger.warn(styling_1.colors.dim('   Error details: ') + errorMessage);
     }
 };
 exports.writeJSONFile = writeJSONFile;

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

@@ -1,3 +1,4 @@
+/** Email notification configuration */
 interface INotificationsConfig {
     email?: {
         enabled?: boolean;
@@ -5,6 +6,7 @@ interface INotificationsConfig {
         recipients?: string[];
     };
 }
+/** Workspace configuration from config.yaml */
 interface IWorkspaceConfig {
     excludeTags?: null | string[];
     executionOrder?: IExecutionOrder | null;
@@ -13,13 +15,16 @@ interface IWorkspaceConfig {
     local?: ILocal | null;
     notifications?: INotificationsConfig;
 }
+/** Local execution configuration */
 interface ILocal {
     deterministicOrder: boolean | null;
 }
+/** Sequential execution configuration */
 interface IExecutionOrder {
     continueOnFailure: boolean;
     flowsOrder: string[];
 }
+/** Options for execution plan generation */
 export interface PlanOptions {
     configFile?: string;
     debug?: boolean;
@@ -28,6 +33,7 @@ export interface PlanOptions {
     includeTags?: string[];
     input: string;
 }
+/** Execution plan containing all flows to run with metadata and dependencies */
 export interface IExecutionPlan {
     allExcludeTags?: null | string[];
     allIncludeTags?: null | string[];
@@ -39,9 +45,26 @@ export interface IExecutionPlan {
     totalFlowFiles: number;
     workspaceConfig?: IWorkspaceConfig;
 }
+/** Flow sequence configuration for ordered execution */
 interface IFlowSequence {
     continueOnFailure?: boolean;
     flows: string[];
 }
+/**
+ * Generate execution plan for test flows
+ *
+ * Handles:
+ * - Single file or directory input
+ * - Workspace configuration (config.yaml)
+ * - Flow inclusion/exclusion patterns
+ * - Tag-based filtering (include/exclude)
+ * - Dependency resolution (runFlow, scripts, media)
+ * - Sequential execution ordering
+ * - DeviceCloud-specific overrides
+ *
+ * @param options - Plan generation options
+ * @returns Complete execution plan with flows, dependencies, and metadata
+ * @throws Error if input path doesn't exist, no flows found, or dependencies missing
+ */
 export declare function plan(options: PlanOptions): Promise<IExecutionPlan>;
 export {};

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

@@ -5,6 +5,13 @@ const glob_1 = require("glob");
 const fs = require("node:fs");
 const path = require("node:path");
 const execution_plan_utils_1 = require("./execution-plan.utils");
+/**
+ * Recursively check and resolve all dependencies for a flow file
+ * Includes runFlow references, JavaScript scripts, and media files
+ * @param input - Path to flow file to check
+ * @returns Array of all dependency file paths (deduplicated)
+ * @throws Error if any referenced files are missing
+ */
 async function checkDependencies(input) {
     const checkedDependencies = [];
     const uncheckedDependencies = [input];
@@ -35,12 +42,24 @@ async function checkDependencies(input) {
     }
     return checkedDependencies;
 }
+/**
+ * Filter flow files based on exclude patterns
+ * @param unfilteredFlowFiles - All discovered flow files
+ * @param excludeFlows - Patterns to exclude
+ * @returns Filtered array of flow file paths
+ */
 function filterFlowFiles(unfilteredFlowFiles, excludeFlows) {
     if (excludeFlows) {
         return unfilteredFlowFiles.filter((file) => !excludeFlows.some((flow) => path.normalize(file).startsWith(path.normalize(path.resolve(flow)))));
     }
     return unfilteredFlowFiles;
 }
+/**
+ * Load workspace configuration from config.yaml/yml if present
+ * @param input - Input directory path
+ * @param unfilteredFlowFiles - List of discovered flow files
+ * @returns Workspace configuration object (empty if no config file found)
+ */
 function getWorkspaceConfig(input, unfilteredFlowFiles) {
     const possibleConfigPaths = new Set([path.join(input, 'config.yaml'), path.join(input, 'config.yml')].map((p) => path.normalize(p)));
     const configFilePath = unfilteredFlowFiles.find((file) => possibleConfigPaths.has(path.normalize(file)));
@@ -49,6 +68,12 @@ function getWorkspaceConfig(input, unfilteredFlowFiles) {
         : {};
     return config;
 }
+/**
+ * Extract DeviceCloud-specific override environment variables
+ * Looks for env vars prefixed with DEVICECLOUD_OVERRIDE_
+ * @param config - Flow configuration object
+ * @returns Object containing override key-value pairs
+ */
 function extractDeviceCloudOverrides(config) {
     if (!config || !config.env || typeof config.env !== 'object') {
         return {};
@@ -64,6 +89,22 @@ function extractDeviceCloudOverrides(config) {
     }
     return overrides;
 }
+/**
+ * Generate execution plan for test flows
+ *
+ * Handles:
+ * - Single file or directory input
+ * - Workspace configuration (config.yaml)
+ * - Flow inclusion/exclusion patterns
+ * - Tag-based filtering (include/exclude)
+ * - Dependency resolution (runFlow, scripts, media)
+ * - Sequential execution ordering
+ * - DeviceCloud-specific overrides
+ *
+ * @param options - Plan generation options
+ * @returns Complete execution plan with flows, dependencies, and metadata
+ * @throws Error if input path doesn't exist, no flows found, or dependencies missing
+ */
 async function plan(options) {
     const { input, includeTags = [], excludeTags = [], excludeFlows, configFile, debug = false, } = options;
     const normalizedInput = path.normalize(input);

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

@@ -44,8 +44,38 @@ export declare class ResultsPollingService {
     private buildPollingResult;
     private calculateStatusSummary;
     private displayFinalResults;
+    /**
+     * Fetch results from API and log debug information
+     * @param apiUrl API base URL
+     * @param apiKey API authentication key
+     * @param uploadId Upload ID to fetch results for
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns Promise resolving to test results
+     */
+    private fetchAndLogResults;
     private filterLatestResults;
+    /**
+     * Handle completed tests and return final result
+     * @param updatedResults Test results from API
+     * @param options Completion handling options
+     * @returns Promise resolving to final polling result
+     */
+    private handleCompletedTests;
     private handlePollingError;
+    /**
+     * Initialize the polling display UI
+     * @param json Whether to output in JSON format
+     * @param logger Optional logger function for output
+     * @returns void
+     */
+    private initializePollingDisplay;
+    /**
+     * Sleep for the specified number of milliseconds
+     * @param ms Number of milliseconds to sleep
+     * @returns Promise that resolves after the delay
+     */
+    private sleep;
     private updateDisplayStatus;
 }
 export {};