@devicecloud.dev/dcd 4.1.5 → 4.1.7

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,505 @@ 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, 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}`);
         }
     }
-    const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
     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);
-    await api_gateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha);
-    if (log) {
-        core_1.ux.action.stop(`\nBinary uploaded with id: ${id}`);
+    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] 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;
+        if (debug) {
+            const uploadDuration = Date.now() - uploadStartTime;
+            const uploadSpeed = (file.size / 1024 / 1024) / (uploadDuration / 1000);
+            console.log(`[DEBUG] Supabase upload completed in ${uploadDuration}ms`);
+            console.log(`[DEBUG] Average upload speed: ${uploadSpeed.toFixed(2)} MB/s`);
+        }
+    }
+    catch (error) {
+        lastError = 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] Upload path: ${path}`);
+            console.error(`[DEBUG] File size: ${file.size} bytes`);
+            console.log('[DEBUG] Will attempt Backblaze fallback if available...');
+        }
+    }
+    // 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...');
+            }
+        }
+        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`);
+                }
+            }
+        }
+        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;
+            }
+        }
+    }
+    else if (debug && !supabaseSuccess) {
+        console.log('[DEBUG] Backblaze not configured, cannot fallback');
+    }
+    // Check if at least one upload succeeded
+    if (!supabaseSuccess && !backblazeSuccess) {
+        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.'}`);
+    }
+    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)');
+        }
+    }
+    if (debug) {
+        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'}`);
+    }
+    const finalizeStartTime = Date.now();
+    await api_gateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha, supabaseSuccess, backblazeSuccess);
+    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;
+}
+/**
+ * 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 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)
+ * @returns Promise that resolves when upload completes or fails gracefully
+ */
+async function uploadLargeFileToBackblaze(apiUrl, apiKey, fileId, uploadPartUrls, _fileName, filePath, fileSize, debug, fileObject) {
+    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');
@@ -168,21 +608,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/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 {};