@devicecloud.dev/dcd 4.1.7 → 4.2.0

package/dist/methods.js

@@ -77,7 +77,8 @@ const verifyAppZip = async (zipPath) => {
     zip.close();
 };
 exports.verifyAppZip = verifyAppZip;
-const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, log = true, debug = false) => {
+const uploadBinary = async (config) => {
+    const { filePath, apiUrl, apiKey, ignoreShaCheck = false, log = true, debug = false } = config;
     if (log) {
         core_1.ux.action.start(styling_1.colors.bold('Checking and uploading binary'), styling_1.colors.dim('Initializing'), {
             stdout: true,
@@ -107,7 +108,7 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
             }
         }
         // Perform the upload
-        const uploadId = await performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTime);
+        const uploadId = await performUpload({ apiKey, apiUrl, debug, file, filePath, sha, startTime });
         if (log) {
             core_1.ux.action.stop(styling_1.colors.success('\n✓ Binary uploaded with ID: ') + (0, styling_1.formatId)(uploadId));
         }
@@ -232,162 +233,240 @@ async function checkExistingUpload(apiUrl, apiKey, sha, debug) {
     }
 }
 /**
- * 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
+ * Uploads file to Supabase using resumable uploads
+ * @param env - Environment (dev or prod)
+ * @param tempPath - Temporary staging path for upload
+ * @param file - File to upload
+ * @param debug - Enable debug logging
+ * @returns Upload result with success status and any error
  */
-async function performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTime) {
+async function uploadToSupabase(env, tempPath, file, debug) {
     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, b2 } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios', file.size);
-    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}`);
-        console.log(`[DEBUG] Backblaze upload URL provided: ${Boolean(b2)}`);
-        if (b2) {
-            console.log(`[DEBUG] Backblaze strategy: ${b2.strategy}`);
-        }
-    }
-    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';
-    let supabaseSuccess = false;
-    let backblazeSuccess = false;
-    let lastError = null;
-    // Try Supabase upload first
-    if (debug) {
-        console.log(`[DEBUG] Uploading to Supabase storage (${env})...`);
+        console.log(`[DEBUG] Uploading to Supabase storage (${env}) using resumable uploads...`);
+        console.log(`[DEBUG] Staging path: ${tempPath}`);
         console.log(`[DEBUG] File size: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
     }
     try {
         const uploadStartTime = Date.now();
-        await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file, debug);
-        supabaseSuccess = true;
+        await supabase_gateway_1.SupabaseGateway.uploadResumable(env, tempPath, file, debug);
         if (debug) {
             const uploadDuration = Date.now() - uploadStartTime;
-            const uploadSpeed = (file.size / 1024 / 1024) / (uploadDuration / 1000);
-            console.log(`[DEBUG] Supabase upload completed in ${uploadDuration}ms`);
+            const uploadDurationSeconds = uploadDuration / 1000;
+            const uploadSpeed = (file.size / 1024 / 1024) / uploadDurationSeconds;
+            console.log(`[DEBUG] Supabase resumable upload completed in ${uploadDurationSeconds.toFixed(2)}s (${uploadDuration}ms)`);
             console.log(`[DEBUG] Average upload speed: ${uploadSpeed.toFixed(2)} MB/s`);
         }
+        return { error: null, success: true };
     }
     catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
+        const uploadError = error instanceof Error ? error : new Error(String(error));
         if (debug) {
-            console.error(`[DEBUG] === SUPABASE UPLOAD FAILED ===`);
-            console.error(`[DEBUG] Error message: ${lastError.message}`);
-            console.error(`[DEBUG] Error name: ${lastError.name}`);
-            if (lastError.stack) {
-                console.error(`[DEBUG] Error stack:\n${lastError.stack}`);
+            console.error(`[DEBUG] === SUPABASE RESUMABLE UPLOAD FAILED ===`);
+            console.error(`[DEBUG] Error message: ${uploadError.message}`);
+            console.error(`[DEBUG] Error name: ${uploadError.name}`);
+            if (uploadError.stack) {
+                console.error(`[DEBUG] Error stack:\n${uploadError.stack}`);
             }
-            console.error(`[DEBUG] Upload path: ${path}`);
+            console.error(`[DEBUG] Staging path: ${tempPath}`);
             console.error(`[DEBUG] File size: ${file.size} bytes`);
             console.log('[DEBUG] Will attempt Backblaze fallback if available...');
         }
+        return { error: uploadError, success: false };
     }
-    // Try Backblaze upload (either as backup or fallback)
-    if (b2) {
-        if (debug) {
-            if (supabaseSuccess) {
-                console.log('[DEBUG] Starting Backblaze backup upload...');
-            }
-            else {
-                console.log('[DEBUG] Starting Backblaze fallback upload...');
-            }
+}
+/**
+ * Handles Backblaze upload with appropriate strategy
+ * @param config - Configuration object for Backblaze upload
+ * @returns Upload result with success status and any error
+ */
+async function handleBackblazeUpload(config) {
+    const { b2, apiUrl, apiKey, finalPath, file, filePath, debug, supabaseSuccess } = config;
+    if (!b2) {
+        if (debug && !supabaseSuccess) {
+            console.log('[DEBUG] Backblaze not configured, cannot fallback');
         }
-        try {
-            const b2UploadStartTime = Date.now();
-            if (b2.strategy === 'simple' && b2.simple) {
-                // Simple upload for files < 100MB
-                backblazeSuccess = await uploadToBackblaze(b2.simple.uploadUrl, b2.simple.authorizationToken, `organizations/${path}`, file, debug);
-            }
-            else if (b2.strategy === 'large' && b2.large) {
-                // Multi-part upload for files >= 100MB (uses streaming to avoid memory issues)
-                backblazeSuccess = await uploadLargeFileToBackblaze(apiUrl, apiKey, b2.large.fileId, b2.large.uploadPartUrls, `organizations/${path}`, filePath, file.size, debug, file);
-            }
-            if (debug) {
-                const b2UploadDuration = Date.now() - b2UploadStartTime;
-                if (backblazeSuccess) {
-                    console.log(`[DEBUG] Backblaze upload completed successfully in ${b2UploadDuration}ms`);
-                }
-                else {
-                    console.log(`[DEBUG] Backblaze upload failed after ${b2UploadDuration}ms`);
-                }
-            }
+        return { error: null, success: false };
+    }
+    if (debug) {
+        console.log(supabaseSuccess ? '[DEBUG] Starting Backblaze backup upload...' : '[DEBUG] Starting Backblaze fallback upload...');
+    }
+    try {
+        const b2UploadStartTime = Date.now();
+        let backblazeSuccess = false;
+        if (b2.strategy === 'simple' && b2.simple) {
+            const simple = b2.simple;
+            backblazeSuccess = await uploadToBackblaze(simple.uploadUrl, simple.authorizationToken, `organizations/${finalPath}`, file, debug);
+        }
+        else if (b2.strategy === 'large' && b2.large) {
+            const large = b2.large;
+            backblazeSuccess = await uploadLargeFileToBackblaze({
+                apiKey,
+                apiUrl,
+                debug,
+                fileId: large.fileId,
+                fileName: `organizations/${finalPath}`,
+                fileObject: file,
+                filePath,
+                fileSize: file.size,
+                uploadPartUrls: large.uploadPartUrls,
+            });
         }
-        catch (error) {
-            // This catch block should rarely be reached now since upload functions handle their own errors
-            const b2Error = error instanceof Error ? error : new Error(String(error));
-            if (debug) {
-                console.error(`[DEBUG] === UNEXPECTED BACKBLAZE UPLOAD ERROR ===`);
-                console.error(`[DEBUG] Error message: ${b2Error.message}`);
-                console.error(`[DEBUG] Error name: ${b2Error.name}`);
-                if (b2Error.stack) {
-                    console.error(`[DEBUG] Error stack:\n${b2Error.stack}`);
-                }
-                console.error(`[DEBUG] Upload strategy: ${b2.strategy}`);
-            }
-            backblazeSuccess = false;
-            // Only update lastError if Supabase also failed
-            if (!supabaseSuccess) {
-                lastError = b2Error;
-            }
+        if (debug) {
+            const duration = Date.now() - b2UploadStartTime;
+            const durationSeconds = duration / 1000;
+            console.log(backblazeSuccess
+                ? `[DEBUG] Backblaze upload completed successfully in ${durationSeconds.toFixed(2)}s (${duration}ms)`
+                : `[DEBUG] Backblaze upload failed after ${durationSeconds.toFixed(2)}s (${duration}ms)`);
         }
+        return { error: null, success: backblazeSuccess };
     }
-    else if (debug && !supabaseSuccess) {
-        console.log('[DEBUG] Backblaze not configured, cannot fallback');
-    }
-    // Check if at least one upload succeeded
-    if (!supabaseSuccess && !backblazeSuccess) {
+    catch (error) {
+        const b2Error = error instanceof Error ? error : new Error(String(error));
         if (debug) {
-            console.error(`[DEBUG] === ALL UPLOADS FAILED ===`);
-            console.error(`[DEBUG] Supabase upload: FAILED`);
-            console.error(`[DEBUG] Backblaze upload: ${b2 ? 'FAILED' : 'NOT CONFIGURED'}`);
-            if (lastError) {
-                console.error(`[DEBUG] Final error details:`);
-                console.error(`[DEBUG] - Message: ${lastError.message}`);
-                console.error(`[DEBUG] - Name: ${lastError.name}`);
-                console.error(`[DEBUG] - Stack: ${lastError.stack}`);
+            console.error(`[DEBUG] === UNEXPECTED BACKBLAZE UPLOAD ERROR ===`);
+            console.error(`[DEBUG] Error message: ${b2Error.message}`);
+            console.error(`[DEBUG] Error name: ${b2Error.name}`);
+            if (b2Error.stack) {
+                console.error(`[DEBUG] Error stack:\n${b2Error.stack}`);
             }
+            console.error(`[DEBUG] Upload strategy: ${b2.strategy}`);
         }
-        throw new Error(`All uploads failed. ${lastError ? `Last error: ${JSON.stringify({ message: lastError.message, name: lastError.name, stack: lastError.stack })}` : 'No upload targets available.'}`);
+        return { error: b2Error, success: false };
     }
+}
+/**
+ * Requests upload URL and paths from API
+ * @param apiUrl - API base URL
+ * @param apiKey - API authentication key
+ * @param filePath - Path to the file being uploaded
+ * @param fileSize - Size of the file in bytes
+ * @param debug - Enable debug logging
+ * @returns Promise resolving to upload paths and configuration
+ */
+async function requestUploadPaths(apiUrl, apiKey, filePath, fileSize, debug) {
+    const platform = filePath?.endsWith('.apk') ? 'android' : 'ios';
     if (debug) {
-        console.log(`[DEBUG] Upload summary - Supabase: ${supabaseSuccess ? '✓' : '✗'}, Backblaze: ${backblazeSuccess ? '✓' : '✗'}`);
-        if (!supabaseSuccess && backblazeSuccess) {
-            console.log('[DEBUG] ⚠ Warning: File only exists in Backblaze (Supabase failed)');
+        console.log('[DEBUG] Requesting upload URL...');
+        console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/getBinaryUploadUrl`);
+        console.log(`[DEBUG] Platform: ${platform}`);
+    }
+    const urlRequestStartTime = Date.now();
+    const { id, tempPath, finalPath, b2 } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, platform, fileSize);
+    if (debug) {
+        const hasStrategy = b2 && typeof b2 === 'object' && 'strategy' in b2;
+        console.log(`[DEBUG] Upload URL request completed in ${Date.now() - urlRequestStartTime}ms`);
+        console.log(`[DEBUG] Upload ID: ${id}`);
+        console.log(`[DEBUG] Temp path (TUS upload): ${tempPath}`);
+        console.log(`[DEBUG] Final path (after finalize): ${finalPath}`);
+        console.log(`[DEBUG] Backblaze upload URL provided: ${Boolean(b2)}`);
+        if (hasStrategy)
+            console.log(`[DEBUG] Backblaze strategy: ${b2.strategy}`);
+    }
+    if (!tempPath)
+        throw new Error('No upload path provided by API');
+    return { b2, finalPath, id, tempPath };
+}
+/**
+ * Extracts metadata from the binary file
+ * @param filePath - Path to the binary file
+ * @param debug - Enable debug logging
+ * @returns Promise resolving to extracted metadata containing appId and platform
+ */
+async function extractBinaryMetadata(filePath, debug) {
+    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)}`);
+    return metadata;
+}
+/**
+ * Validates upload results and throws if all uploads failed
+ * @param supabaseSuccess - Whether Supabase upload succeeded
+ * @param backblazeSuccess - Whether Backblaze upload succeeded
+ * @param lastError - Last error encountered during uploads
+ * @param b2 - Backblaze configuration
+ * @param debug - Enable debug logging
+ * @returns void - throws error if all uploads failed
+ */
+function validateUploadResults(supabaseSuccess, backblazeSuccess, lastError, b2, debug) {
+    if (supabaseSuccess || backblazeSuccess) {
+        return;
+    }
+    if (debug) {
+        console.error(`[DEBUG] === ALL UPLOADS FAILED ===`);
+        console.error(`[DEBUG] Supabase upload: FAILED`);
+        console.error(`[DEBUG] Backblaze upload: ${b2 ? 'FAILED' : 'NOT CONFIGURED'}`);
+        if (lastError) {
+            console.error(`[DEBUG] Final error details:`);
+            console.error(`[DEBUG] - Message: ${lastError.message}`);
+            console.error(`[DEBUG] - Name: ${lastError.name}`);
+            console.error(`[DEBUG] - Stack: ${lastError.stack}`);
         }
     }
+    throw new Error(`All uploads failed. ${lastError ? `Last error: ${JSON.stringify({ message: lastError.message, name: lastError.name, stack: lastError.stack })}` : 'No upload targets available.'}`);
+}
+/**
+ * Performs the actual file upload
+ * @param config Configuration object for the upload
+ * @returns Promise resolving to upload ID
+ */
+async function performUpload(config) {
+    const { filePath, apiUrl, apiKey, file, sha, debug, startTime } = config;
+    // Request upload URL and paths
+    const { id, tempPath, finalPath, b2 } = await requestUploadPaths(apiUrl, apiKey, filePath, file.size, debug);
+    // Extract app metadata
+    const metadata = await extractBinaryMetadata(filePath, debug);
+    const env = apiUrl === 'https://api.devicecloud.dev' ? 'prod' : 'dev';
+    // Upload to Supabase
+    const supabaseResult = await uploadToSupabase(env, tempPath, file, debug);
+    let lastError = supabaseResult.error;
+    // Upload to Backblaze
+    const backblazeResult = await handleBackblazeUpload({
+        apiKey,
+        apiUrl,
+        b2: b2,
+        debug,
+        file,
+        filePath,
+        finalPath,
+        supabaseSuccess: supabaseResult.success,
+    });
+    // Update lastError if Supabase also failed
+    if (!supabaseResult.success && backblazeResult.error) {
+        lastError = backblazeResult.error;
+    }
+    // Validate results
+    validateUploadResults(supabaseResult.success, backblazeResult.success, lastError, b2, debug);
+    // Log upload summary
     if (debug) {
+        const hasWarning = !supabaseResult.success && backblazeResult.success;
+        console.log(`[DEBUG] Upload summary - Supabase: ${supabaseResult.success ? '✓' : '✗'}, Backblaze: ${backblazeResult.success ? '✓' : '✗'}`);
         console.log('[DEBUG] Finalizing upload...');
         console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/finaliseUpload`);
-        console.log(`[DEBUG] Supabase upload status: ${supabaseSuccess ? 'SUCCESS' : 'FAILED'}`);
-        console.log(`[DEBUG] Backblaze upload status: ${backblazeSuccess ? 'SUCCESS' : 'FAILED'}`);
+        console.log(`[DEBUG] Uploaded to staging path: ${tempPath}`);
+        console.log(`[DEBUG] API will move to final path: ${finalPath}`);
+        console.log(`[DEBUG] Supabase upload status: ${supabaseResult.success ? 'SUCCESS' : 'FAILED'}`);
+        console.log(`[DEBUG] Backblaze upload status: ${backblazeResult.success ? 'SUCCESS' : 'FAILED'}`);
+        if (hasWarning)
+            console.log('[DEBUG] ⚠ Warning: File only exists in Backblaze (Supabase failed)');
     }
+    // Finalize upload
     const finalizeStartTime = Date.now();
-    await api_gateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha, supabaseSuccess, backblazeSuccess);
+    await api_gateway_1.ApiGateway.finaliseUpload({
+        apiKey,
+        backblazeSuccess: backblazeResult.success,
+        baseUrl: apiUrl,
+        id,
+        metadata,
+        path: tempPath,
+        sha: sha,
+        supabaseSuccess: supabaseResult.success,
+    });
     if (debug) {
         console.log(`[DEBUG] Upload finalization completed in ${Date.now() - finalizeStartTime}ms`);
         console.log(`[DEBUG] Total upload time: ${Date.now() - startTime}ms`);
@@ -494,18 +573,11 @@ async function readFileObjectChunk(file, start, end) {
 /**
  * Upload large file to Backblaze using multi-part upload with streaming (for files >= 5MB)
  * Uses file streaming to avoid loading entire file into memory, preventing OOM errors on large files
- * @param apiUrl - API base URL
- * @param apiKey - API key for authentication
- * @param fileId - Backblaze file ID
- * @param uploadPartUrls - Array of upload URLs for each part
- * @param fileName - Name/path of the file in Backblaze
- * @param filePath - Local file path to upload from (used when fileObject is not provided)
- * @param fileSize - Total size of the file in bytes
- * @param debug - Whether debug logging is enabled
- * @param fileObject - Optional File/Blob object to upload from (used for .app bundles that are compressed in memory)
+ * @param config - Configuration object for the large file upload
  * @returns Promise that resolves when upload completes or fails gracefully
  */
-async function uploadLargeFileToBackblaze(apiUrl, apiKey, fileId, uploadPartUrls, _fileName, filePath, fileSize, debug, fileObject) {
+async function uploadLargeFileToBackblaze(config) {
+    const { apiUrl, apiKey, fileId, uploadPartUrls, filePath, fileSize, debug, fileObject } = config;
     try {
         const partSha1Array = [];
         // Calculate part size (divide file evenly across all parts)

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

@@ -34,10 +34,10 @@ class DeviceValidationService {
             throw new Error(`${androidDeviceID} ${googlePlay ? '(Play Store) ' : ''}only supports these Android API levels: ${supportedAndroidVersions.join(', ')}`);
         }
         if (debug && logger) {
-            logger(`DEBUG: Android device: ${androidDeviceID}`);
-            logger(`DEBUG: Android API level: ${version}`);
-            logger(`DEBUG: Google Play enabled: ${googlePlay}`);
-            logger(`DEBUG: Supported Android versions: ${supportedAndroidVersions.join(', ')}`);
+            logger(`[DEBUG] Android device: ${androidDeviceID}`);
+            logger(`[DEBUG] Android API level: ${version}`);
+            logger(`[DEBUG] Google Play enabled: ${googlePlay}`);
+            logger(`[DEBUG] Supported Android versions: ${supportedAndroidVersions.join(', ')}`);
         }
     }
     /**
@@ -65,9 +65,9 @@ class DeviceValidationService {
             throw new Error(`${iOSDeviceID} only supports these iOS versions: ${supportediOSVersions.join(', ')}`);
         }
         if (debug && logger) {
-            logger(`DEBUG: iOS device: ${iOSDeviceID}`);
-            logger(`DEBUG: iOS version: ${version}`);
-            logger(`DEBUG: Supported iOS versions: ${supportediOSVersions.join(', ')}`);
+            logger(`[DEBUG] iOS device: ${iOSDeviceID}`);
+            logger(`[DEBUG] iOS version: ${version}`);
+            logger(`[DEBUG] Supported iOS versions: ${supportediOSVersions.join(', ')}`);
         }
     }
 }

package/dist/services/moropo.service.js

@@ -18,8 +18,8 @@ class MoropoService {
      */
     async downloadAndExtract(options) {
         const { apiKey, branchName = 'main', debug = false, quiet = false, json = false, logger } = options;
-        this.logDebug(debug, logger, 'DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
-        this.logDebug(debug, 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', {
@@ -37,7 +37,7 @@ class MoropoService {
                 throw new Error(`Failed to download Moropo tests: ${response.statusText}`);
             }
             const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
-            this.logDebug(debug, 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 });
@@ -51,17 +51,17 @@ class MoropoService {
             if (!quiet && !json) {
                 core_1.ux.action.stop('completed');
             }
-            this.logDebug(debug, logger, 'DEBUG: Successfully extracted Moropo tests');
+            this.logDebug(debug, logger, '[DEBUG] Successfully extracted Moropo tests');
             // Create config.yaml file
             this.createConfigFile(moropoDir);
-            this.logDebug(debug, logger, 'DEBUG: Created config.yaml file');
+            this.logDebug(debug, logger, '[DEBUG] Created config.yaml file');
             return moropoDir;
         }
         catch (error) {
             if (!quiet && !json) {
                 core_1.ux.action.stop('failed');
             }
-            this.logDebug(debug, 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}`);
         }
     }

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

@@ -16,7 +16,7 @@ class ReportDownloadService {
         const { apiUrl, apiKey, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
         try {
             if (debug && logger) {
-                logger(`DEBUG: Downloading artifacts: ${downloadType}`);
+                logger(`[DEBUG] Downloading artifacts: ${downloadType}`);
             }
             await api_gateway_1.ApiGateway.downloadArtifactsZip(apiUrl, apiKey, uploadId, downloadType, artifactsPath);
             if (logger) {
@@ -26,7 +26,7 @@ class ReportDownloadService {
         }
         catch (error) {
             if (debug && logger) {
-                logger(`DEBUG: Error downloading artifacts: ${error}`);
+                logger(`[DEBUG] Error downloading artifacts: ${error}`);
             }
             if (warnLogger) {
                 warnLogger('Failed to download artifacts');
@@ -83,7 +83,7 @@ class ReportDownloadService {
         const { apiUrl, apiKey, uploadId, debug = false, logger, warnLogger } = options;
         try {
             if (debug && logger) {
-                logger(`DEBUG: Downloading ${type.toUpperCase()} report`);
+                logger(`[DEBUG] Downloading ${type.toUpperCase()} report`);
             }
             await api_gateway_1.ApiGateway.downloadReportGeneric(apiUrl, apiKey, uploadId, type, filePath);
             if (logger) {
@@ -92,7 +92,7 @@ class ReportDownloadService {
         }
         catch (error) {
             if (debug && logger) {
-                logger(`DEBUG: Error downloading ${type.toUpperCase()} report: ${error}`);
+                logger(`[DEBUG] Error downloading ${type.toUpperCase()} report: ${error}`);
             }
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (warnLogger) {

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

@@ -37,7 +37,7 @@ class ResultsPollingService {
         let sequentialPollFailures = 0;
         let previousSummary = '';
         if (debug && logger) {
-            logger(`DEBUG: Starting polling loop for results`);
+            logger(`[DEBUG] Starting polling loop for results`);
         }
         // Poll in a loop until all tests complete
         // eslint-disable-next-line no-constant-condition
@@ -186,16 +186,16 @@ class ResultsPollingService {
      */
     async fetchAndLogResults(apiUrl, apiKey, uploadId, debug, logger) {
         if (debug && logger) {
-            logger(`DEBUG: Polling for results: ${uploadId}`);
+            logger(`[DEBUG] Polling for results: ${uploadId}`);
         }
         const { results: updatedResults } = await api_gateway_1.ApiGateway.getResultsForUpload(apiUrl, apiKey, uploadId);
         if (!updatedResults) {
             throw new Error('no results');
         }
         if (debug && logger) {
-            logger(`DEBUG: Poll received ${updatedResults.length} results`);
+            logger(`[DEBUG] Poll received ${updatedResults.length} results`);
             for (const result of updatedResults) {
-                logger(`DEBUG: Result status: ${result.test_file_name} - ${result.status}`);
+                logger(`[DEBUG] Result status: ${result.test_file_name} - ${result.status}`);
             }
         }
         return updatedResults;
@@ -216,39 +216,39 @@ class ResultsPollingService {
     async handleCompletedTests(updatedResults, options) {
         const { uploadId, consoleUrl, json, debug, logger } = options;
         if (debug && logger) {
-            logger(`DEBUG: All tests completed, stopping poll`);
+            logger(`[DEBUG] All tests completed, stopping poll`);
         }
         this.displayFinalResults(updatedResults, consoleUrl, json, logger);
         const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl);
         if (output.status === 'FAILED') {
             if (debug && logger) {
-                logger(`DEBUG: Some tests failed, returning failed status`);
+                logger(`[DEBUG] Some tests failed, returning failed status`);
             }
             throw new RunFailedError(output);
         }
         if (debug && logger) {
-            logger(`DEBUG: All tests passed, returning success status`);
+            logger(`[DEBUG] All tests passed, returning success status`);
         }
         return output;
     }
     async handlePollingError(error, sequentialPollFailures, debug, logger) {
         if (debug && logger) {
-            logger(`DEBUG: Error polling for results: ${error}`);
-            logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+            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...');
+                logger('[DEBUG] Checking internet connectivity...');
             }
             const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
             if (debug && logger) {
-                logger(`DEBUG: ${connectivityCheck.message}`);
+                logger(`[DEBUG] ${connectivityCheck.message}`);
                 for (const result of connectivityCheck.endpointResults) {
                     if (result.success) {
-                        logger(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
+                        logger(`[DEBUG] ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
                     }
                     else {
-                        logger(`DEBUG: ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
+                        logger(`[DEBUG] ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
                     }
                 }
             }

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

@@ -26,7 +26,6 @@ export interface TestSubmissionConfig {
     retry?: number;
     runnerType?: string;
     showCrosshairs?: boolean;
-    skipChromeOnboarding?: boolean;
 }
 /**
  * Service for building test submission form data