@devicecloud.dev/dcd 4.1.6 → 4.1.7

package/dist/gateways/api-gateway.d.ts

@@ -12,13 +12,29 @@ export declare const ApiGateway: {
         exists: boolean;
     }>;
     downloadArtifactsZip(baseUrl: string, apiKey: string, uploadId: string, results: "ALL" | "FAILED", artifactsPath?: string): Promise<void>;
-    finaliseUpload(baseUrl: string, apiKey: string, id: string, metadata: TAppMetadata, path: string, sha: string): Promise<Record<string, never>>;
-    getBinaryUploadUrl(baseUrl: string, apiKey: string, platform: "android" | "ios"): Promise<{
+    finaliseUpload(baseUrl: string, apiKey: string, id: string, metadata: TAppMetadata, path: string, sha: string, supabaseSuccess: boolean, backblazeSuccess: boolean): Promise<Record<string, never>>;
+    getBinaryUploadUrl(baseUrl: string, apiKey: string, platform: "android" | "ios", fileSize: number): Promise<{
         message: string;
         path: string;
         token: string;
         id: string;
+        b2?: {
+            strategy: "simple" | "large";
+            simple?: {
+                uploadUrl: string;
+                authorizationToken: string;
+            };
+            large?: {
+                fileId: string;
+                fileName: string;
+                uploadPartUrls: Array<{
+                    uploadUrl: string;
+                    authorizationToken: string;
+                }>;
+            };
+        };
     }>;
+    finishLargeFile(baseUrl: string, apiKey: string, fileId: string, partSha1Array: string[]): Promise<any>;
     getResultsForUpload(baseUrl: string, apiKey: string, uploadId: string): Promise<{
         statusCode?: number;
         results?: import("../types/generated/schema.types").components["schemas"]["TResultResponse"][];

package/dist/gateways/api-gateway.js

@@ -99,9 +99,9 @@ exports.ApiGateway = {
         await finished(Readable.fromWeb(res.body).pipe(fileStream));
     },
     // eslint-disable-next-line max-params
-    async finaliseUpload(baseUrl, apiKey, id, metadata, path, sha) {
+    async finaliseUpload(baseUrl, apiKey, id, metadata, path, sha, supabaseSuccess, backblazeSuccess) {
         const res = await fetch(`${baseUrl}/uploads/finaliseUpload`, {
-            body: JSON.stringify({ id, metadata, path, sha }),
+            body: JSON.stringify({ id, metadata, path, sha, supabaseSuccess, backblazeSuccess }),
             headers: {
                 'content-type': 'application/json',
                 'x-app-api-key': apiKey,
@@ -113,9 +113,9 @@ exports.ApiGateway = {
         }
         return res.json();
     },
-    async getBinaryUploadUrl(baseUrl, apiKey, platform) {
+    async getBinaryUploadUrl(baseUrl, apiKey, platform, fileSize) {
         const res = await fetch(`${baseUrl}/uploads/getBinaryUploadUrl`, {
-            body: JSON.stringify({ platform }),
+            body: JSON.stringify({ platform, fileSize }),
             headers: {
                 'content-type': 'application/json',
                 'x-app-api-key': apiKey,
@@ -127,6 +127,20 @@ exports.ApiGateway = {
         }
         return res.json();
     },
+    async finishLargeFile(baseUrl, apiKey, fileId, partSha1Array) {
+        const res = await fetch(`${baseUrl}/uploads/finishLargeFile`, {
+            body: JSON.stringify({ fileId, partSha1Array }),
+            headers: {
+                'content-type': 'application/json',
+                'x-app-api-key': apiKey,
+            },
+            method: 'POST',
+        });
+        if (!res.ok) {
+            await this.handleApiError(res, 'Failed to finish large file');
+        }
+        return res.json();
+    },
     async getResultsForUpload(baseUrl, apiKey, uploadId) {
         // TODO: merge with getUploadStatus
         const res = await fetch(`${baseUrl}/results/${uploadId}`, {

package/dist/gateways/supabase-gateway.js

@@ -48,26 +48,43 @@ class SupabaseGateway {
         }
         catch (error) {
             if (debug) {
-                console.error(`[DEBUG] Supabase upload exception:`, error);
+                console.error(`[DEBUG] === SUPABASE UPLOAD EXCEPTION ===`);
+                console.error(`[DEBUG] Exception caught:`, 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] Error stack:\n${error.stack}`);
+                }
+                // Log additional context
+                console.error(`[DEBUG] Upload context:`);
+                console.error(`[DEBUG] - Environment: ${env}`);
+                console.error(`[DEBUG] - Supabase URL: ${SUPABASE_URL}`);
+                console.error(`[DEBUG] - Upload path: ${path}`);
+                console.error(`[DEBUG] - File name: ${file.name}`);
+                console.error(`[DEBUG] - File size: ${file.size} bytes`);
                 // Check for common network errors
                 if (error instanceof Error) {
-                    if (error.message.includes('ECONNREFUSED')) {
+                    const errorMsg = error.message.toLowerCase();
+                    if (errorMsg.includes('econnrefused') || errorMsg.includes('connection refused')) {
                         console.error(`[DEBUG] Network error: Connection refused - check internet connectivity`);
                     }
-                    else if (error.message.includes('ETIMEDOUT')) {
+                    else if (errorMsg.includes('etimedout') || errorMsg.includes('timeout')) {
                         console.error(`[DEBUG] Network error: Connection timeout - check internet connectivity or try again`);
                     }
-                    else if (error.message.includes('ENOTFOUND')) {
+                    else if (errorMsg.includes('enotfound') || errorMsg.includes('not found')) {
                         console.error(`[DEBUG] Network error: DNS lookup failed - check internet connectivity`);
                     }
-                    else if (error.message.includes('ECONNRESET')) {
-                        console.error(`[DEBUG] Network error: Connection reset - network unstable or interrupted`);
+                    else if (errorMsg.includes('econnreset') || errorMsg.includes('connection reset') || errorMsg.includes('connection lost')) {
+                        console.error(`[DEBUG] Network error: Connection reset/lost - network unstable or interrupted`);
+                    }
+                    else if (errorMsg.includes('network')) {
+                        console.error(`[DEBUG] Network-related error detected - check internet connectivity`);
                     }
                 }
             }
-            throw error;
+            // Re-throw with additional context
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Supabase upload error: ${errorMsg}`);
         }
     }
 }

package/dist/methods.js

@@ -249,11 +249,15 @@ async function performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTi
         console.log(`[DEBUG] Platform: ${filePath?.endsWith('.apk') ? 'android' : 'ios'}`);
     }
     const urlRequestStartTime = Date.now();
-    const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
+    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);
@@ -270,30 +274,308 @@ async function performUpload(filePath, apiUrl, apiKey, file, sha, debug, startTi
         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] File size: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
     }
-    const uploadStartTime = Date.now();
-    await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file, debug);
+    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) {
-        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`);
+        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);
+    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;
 }
+/**
+ * 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');

package/dist/types/generated/schema.types.d.ts

@@ -443,6 +443,21 @@ export interface components {
             path: string;
             token: string;
             id: string;
+            b2?: {
+                strategy: 'simple' | 'large';
+                simple?: {
+                    uploadUrl: string;
+                    authorizationToken: string;
+                };
+                large?: {
+                    fileId: string;
+                    fileName: string;
+                    uploadPartUrls: Array<{
+                        uploadUrl: string;
+                        authorizationToken: string;
+                    }>;
+                };
+            };
         };
         ICheckForExistingUploadArgs: {
             sha: string;

package/oclif.manifest.json

@@ -572,5 +572,5 @@
       ]
     }
   },
-  "version": "4.1.6"
+  "version": "4.1.7"
 }

package/package.json

@@ -66,7 +66,7 @@
     "type": "git",
     "url": "https://devicecloud.dev"
   },
-  "version": "4.1.6",
+  "version": "4.1.7",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },