@devicecloud.dev/dcd 4.1.6 → 4.1.9-beta.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,68 +233,421 @@ 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 uploadToSupabase(env, tempPath, file, debug) {
+    if (debug) {
+        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.uploadResumable(env, tempPath, file, debug);
+        if (debug) {
+            const uploadDuration = Date.now() - uploadStartTime;
+            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) {
+        const uploadError = error instanceof Error ? error : new Error(String(error));
+        if (debug) {
+            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] 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 };
+    }
+}
+/**
+ * Handles Backblaze upload with appropriate strategy
+ * @param config - Configuration object for Backblaze upload
+ * @returns Upload result with success status and any error
  */
-async function performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTime) {
+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');
+        }
+        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,
+            });
+        }
+        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 };
+    }
+    catch (error) {
+        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}`);
+        }
+        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] Requesting upload URL...');
         console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/getBinaryUploadUrl`);
-        console.log(`[DEBUG] Platform: ${filePath?.endsWith('.apk') ? 'android' : 'ios'}`);
+        console.log(`[DEBUG] Platform: ${platform}`);
     }
     const urlRequestStartTime = Date.now();
-    const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
+    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] Upload path: ${path}`);
+        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 (!path)
-        throw new Error(message);
-    // Extract app metadata using the service
-    if (debug) {
+    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) {
+    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;
     }
-    const env = apiUrl === 'https://api.devicecloud.dev' ? 'prod' : 'dev';
     if (debug) {
-        console.log(`[DEBUG] Uploading to Supabase storage (${env})...`);
-        console.log(`[DEBUG] File size: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
+        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}`);
+        }
     }
-    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`);
+    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] Moving from temp: ${tempPath}`);
+        console.log(`[DEBUG] Moving to final: ${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);
+    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`);
     }
     return id;
 }
+/**
+ * Upload file to Backblaze using signed URL (simple upload for files < 100MB)
+ * @param uploadUrl - Backblaze upload URL
+ * @param authorizationToken - Authorization token for the upload
+ * @param fileName - Name/path of the file
+ * @param file - File to upload
+ * @param debug - Whether debug logging is enabled
+ * @returns Promise that resolves when upload completes or fails gracefully
+ */
+async function uploadToBackblaze(uploadUrl, authorizationToken, fileName, file, debug) {
+    try {
+        const arrayBuffer = await file.arrayBuffer();
+        // Calculate SHA1 hash for Backblaze (B2 requires SHA1, not SHA256)
+        const sha1 = (0, node_crypto_1.createHash)('sha1');
+        sha1.update(Buffer.from(arrayBuffer));
+        const sha1Hex = sha1.digest('hex');
+        // Detect if this is an S3 pre-signed URL (authorization token is empty)
+        const isS3PreSignedUrl = !authorizationToken || authorizationToken === '';
+        if (debug) {
+            console.log(`[DEBUG] Uploading to Backblaze URL: ${uploadUrl}`);
+            console.log(`[DEBUG] Upload method: ${isS3PreSignedUrl ? 'S3 pre-signed URL (PUT)' : 'B2 native API (POST)'}`);
+            console.log(`[DEBUG] File name: ${fileName}`);
+            console.log(`[DEBUG] File SHA1: ${sha1Hex}`);
+        }
+        // Build headers based on upload method
+        const headers = {
+            'Content-Length': file.size.toString(),
+            'Content-Type': file.type || 'application/octet-stream',
+            'X-Bz-Content-Sha1': sha1Hex,
+        };
+        // S3 pre-signed URLs have auth embedded in URL, native B2 uses Authorization header
+        if (!isS3PreSignedUrl) {
+            headers.Authorization = authorizationToken;
+            headers['X-Bz-File-Name'] = encodeURIComponent(fileName);
+        }
+        const response = await fetch(uploadUrl, {
+            body: arrayBuffer,
+            headers,
+            method: isS3PreSignedUrl ? 'PUT' : 'POST',
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (debug) {
+                console.error(`[DEBUG] Backblaze upload failed with status ${response.status}: ${errorText}`);
+            }
+            // Don't throw - we don't want Backblaze failures to block the primary upload
+            console.warn(`Warning: Backblaze upload failed with status ${response.status}`);
+            return false;
+        }
+        if (debug) {
+            console.log('[DEBUG] Backblaze upload successful');
+        }
+        return true;
+    }
+    catch (error) {
+        if (debug) {
+            console.error('[DEBUG] Backblaze upload exception:', error);
+        }
+        // Don't throw - we don't want Backblaze failures to block the primary upload
+        console.warn(`Warning: Backblaze upload failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Helper function to read a chunk from a file stream
+ * @param filePath - Path to the file
+ * @param start - Start byte position
+ * @param end - End byte position (exclusive)
+ * @returns Promise resolving to Buffer containing the chunk
+ */
+async function readFileChunk(filePath, start, end) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const stream = (0, node_fs_1.createReadStream)(filePath, { start, end: end - 1 }); // end is inclusive in createReadStream
+        stream.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        stream.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Helper function to read a chunk from a File/Blob object
+ * @param file - File or Blob object
+ * @param start - Start byte position
+ * @param end - End byte position (exclusive)
+ * @returns Promise resolving to Buffer containing the chunk
+ */
+async function readFileObjectChunk(file, start, end) {
+    const slice = file.slice(start, end);
+    const arrayBuffer = await slice.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}
+/**
+ * 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 config - Configuration object for the large file upload
+ * @returns Promise that resolves when upload completes or fails gracefully
+ */
+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)
+        const partSize = Math.ceil(fileSize / uploadPartUrls.length);
+        if (debug) {
+            console.log(`[DEBUG] Uploading large file in ${uploadPartUrls.length} parts (streaming mode)`);
+            console.log(`[DEBUG] Part size: ${(partSize / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`[DEBUG] Reading from: ${fileObject ? 'in-memory File object' : filePath}`);
+        }
+        // Upload each part using streaming to avoid loading entire file into memory
+        for (let i = 0; i < uploadPartUrls.length; i++) {
+            const partNumber = i + 1;
+            const start = i * partSize;
+            const end = Math.min(start + partSize, fileSize);
+            const partLength = end - start;
+            if (debug) {
+                console.log(`[DEBUG] Reading part ${partNumber}/${uploadPartUrls.length} bytes ${start}-${end}`);
+            }
+            // Read part from File object (for .app bundles) or from disk
+            const partBuffer = fileObject
+                ? await readFileObjectChunk(fileObject, start, end)
+                : await readFileChunk(filePath, start, end);
+            // Calculate SHA1 for this part
+            const sha1 = (0, node_crypto_1.createHash)('sha1');
+            sha1.update(partBuffer);
+            const sha1Hex = sha1.digest('hex');
+            partSha1Array.push(sha1Hex);
+            if (debug) {
+                console.log(`[DEBUG] Uploading part ${partNumber}/${uploadPartUrls.length} (${(partLength / 1024 / 1024).toFixed(2)} MB, SHA1: ${sha1Hex})`);
+            }
+            const response = await fetch(uploadPartUrls[i].uploadUrl, {
+                body: new Uint8Array(partBuffer),
+                headers: {
+                    Authorization: uploadPartUrls[i].authorizationToken,
+                    'Content-Length': partLength.toString(),
+                    'X-Bz-Content-Sha1': sha1Hex,
+                    'X-Bz-Part-Number': partNumber.toString(),
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                if (debug) {
+                    console.error(`[DEBUG] Part ${partNumber} upload failed with status ${response.status}: ${errorText}`);
+                }
+                throw new Error(`Part ${partNumber} upload failed with status ${response.status}`);
+            }
+            if (debug) {
+                console.log(`[DEBUG] Part ${partNumber}/${uploadPartUrls.length} uploaded successfully`);
+            }
+        }
+        // Finish the large file upload
+        if (debug) {
+            console.log('[DEBUG] Finishing large file upload...');
+        }
+        await api_gateway_1.ApiGateway.finishLargeFile(apiUrl, apiKey, fileId, partSha1Array);
+        if (debug) {
+            console.log('[DEBUG] Large file upload completed successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        if (debug) {
+            console.error('[DEBUG] Large file upload exception:', error);
+        }
+        // Don't throw - we don't want Backblaze failures to block the primary upload
+        console.warn(`Warning: Backblaze large file upload failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
 async function getFileHashFromFile(file) {
     return new Promise((resolve, reject) => {
         const hash = (0, node_crypto_1.createHash)('sha256');

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