Fix: Prefer Hugging Face storage in HF Spaces, handle Telegram failures gracefully

src/app/api/v1/upload/route.ts

@@ -47,17 +47,21 @@ export async function POST(req: NextRequest) {
         // 2. Generate ID first
         const id = customId ? customId.toLowerCase().replace(/[^a-z0-9-]/g, '-') : generateId();
 
-        // Determine storage based on file size
+        // Determine storage based on configuration
+        // Prefer Hugging Face if configured (especially in HF Spaces environment)
         const LARGE_FILE_THRESHOLD = 50 * 1024 * 1024; // 50MB
         const isLargeFile = file.size > LARGE_FILE_THRESHOLD;
         const useHFForLargeFiles = isHuggingFaceConfigured() && process.env.USE_HF_FOR_LARGE_FILES === 'true';
+        const useHFStorage = isHuggingFaceConfigured() && (process.env.USE_HF_STORAGE === 'true' || process.env.SPACE_ID); // Auto-enable in HF Spaces
+        const isHFEnvironment = !!process.env.SPACE_ID; // Detect Hugging Face Spaces environment
 
-        // 1. Upload to storage (HF Hub for large files if configured, else Telegram)
+        // 1. Upload to storage (prefer Hugging Face if configured, especially in HF Spaces)
         let storageResult: { file_id: string; file_url?: string };
         let storageType: 'telegram' | 'huggingface' = 'telegram';
 
-        if (useHFForLargeFiles && isLargeFile) {
-            // Use HF Hub for large files (>50MB)
+        // Priority: HF Storage > HF for large files > Telegram (with graceful fallback)
+        if (useHFStorage) {
+            // Use HF Hub for all files if configured
             try {
                 const fileName = customId || `upload-${id}`;
                 const hfResult = await uploadToHuggingFace(file, fileName, id);
@@ -67,32 +71,98 @@ export async function POST(req: NextRequest) {
                 };
                 storageType = 'huggingface';
                 
-                // Also forward to Telegram chat (for backup/notification)
+                // Also forward to Telegram chat (for backup/notification) - optional
                 try {
                     let mediaType: 'photo' | 'animation' | 'video' = 'photo';
                     if (file.type.startsWith('video/')) mediaType = 'video';
                     if (file.type === 'image/gif') mediaType = 'animation';
                     await uploadToTelegram(file, fileName, `📦 <b>Uploaded in web (HF Hub)</b>\n🔗 <b>HF URL:</b> ${hfResult.file_url}`, mediaType);
                 } catch (tgError) {
-                    console.error('Failed to forward HF upload to Telegram chat:', tgError);
+                    console.error('Failed to forward HF upload to Telegram chat (optional):', tgError);
+                    // Don't fail the upload if Telegram forwarding fails
+                }
+            } catch (hfError: any) {
+                console.error('HF upload failed:', hfError);
+                // In HF Spaces, don't fallback to Telegram (it won't work)
+                if (isHFEnvironment) {
+                    throw new Error(`Hugging Face upload failed: ${hfError.message}. Please check HF_TOKEN and HF_REPO_ID configuration.`);
+                }
+                // Fallback to Telegram only if not in HF Spaces
+                try {
+                    let mediaType: 'photo' | 'animation' | 'video' = 'photo';
+                    if (file.type.startsWith('video/')) mediaType = 'video';
+                    if (file.type === 'image/gif') mediaType = 'animation';
+                    const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded in web</b>', mediaType);
+                    storageResult = { file_id: telegramResult.file_id };
+                } catch (tgError: any) {
+                    throw new Error(`Both HF and Telegram uploads failed. HF: ${hfError.message}, Telegram: ${tgError.message}`);
+                }
+            }
+        } else if (useHFForLargeFiles && isLargeFile) {
+            // Use HF Hub for large files only
+            try {
+                const fileName = customId || `upload-${id}`;
+                const hfResult = await uploadToHuggingFace(file, fileName, id);
+                storageResult = {
+                    file_id: hfResult.file_id,
+                    file_url: hfResult.file_url
+                };
+                storageType = 'huggingface';
+                
+                // Also forward to Telegram chat (for backup/notification) - optional
+                try {
+                    let mediaType: 'photo' | 'animation' | 'video' = 'photo';
+                    if (file.type.startsWith('video/')) mediaType = 'video';
+                    if (file.type === 'image/gif') mediaType = 'animation';
+                    await uploadToTelegram(file, fileName, `📦 <b>Uploaded in web (HF Hub)</b>\n🔗 <b>HF URL:</b> ${hfResult.file_url}`, mediaType);
+                } catch (tgError) {
+                    console.error('Failed to forward HF upload to Telegram chat (optional):', tgError);
                     // Don't fail the upload if Telegram forwarding fails
                 }
             } catch (hfError: any) {
                 console.error('HF upload failed, falling back to Telegram:', hfError);
-                // Fallback to Telegram
+                // Fallback to Telegram if HF fails
+                try {
+                    let mediaType: 'photo' | 'animation' | 'video' = 'photo';
+                    if (file.type.startsWith('video/')) mediaType = 'video';
+                    if (file.type === 'image/gif') mediaType = 'animation';
+                    const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded in web</b>', mediaType);
+                    storageResult = { file_id: telegramResult.file_id };
+                } catch (tgError: any) {
+                    throw new Error(`Upload failed. HF: ${hfError.message}, Telegram: ${tgError.message}`);
+                }
+            }
+        } else {
+            // Use Telegram (default) - but check if we're in HF Spaces
+            if (isHFEnvironment && !isHuggingFaceConfigured()) {
+                throw new Error('Telegram API is not accessible in Hugging Face Spaces. Please configure HF_TOKEN and HF_REPO_ID to use Hugging Face storage.');
+            }
+            
+            try {
                 let mediaType: 'photo' | 'animation' | 'video' = 'photo';
                 if (file.type.startsWith('video/')) mediaType = 'video';
                 if (file.type === 'image/gif') mediaType = 'animation';
                 const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded in web</b>', mediaType);
                 storageResult = { file_id: telegramResult.file_id };
+            } catch (tgError: any) {
+                // If Telegram fails and HF is configured, try HF as fallback
+                if (isHuggingFaceConfigured()) {
+                    console.error('Telegram upload failed, trying HF as fallback:', tgError);
+                    try {
+                        const fileName = customId || `upload-${id}`;
+                        const hfResult = await uploadToHuggingFace(file, fileName, id);
+                        storageResult = {
+                            file_id: hfResult.file_id,
+                            file_url: hfResult.file_url
+                        };
+                        storageType = 'huggingface';
+                    } catch (hfError: any) {
+                        throw new Error(`Both Telegram and HF uploads failed. Telegram: ${tgError.message}, HF: ${hfError.message}`);
+                    }
+                } else {
+                    throw new Error(`Telegram upload failed: ${tgError.message}. Consider configuring Hugging Face storage.`);
+                }
             }
-        } else {
-            // Use Telegram for small files (<50MB) or if HF not configured
-            let mediaType: 'photo' | 'animation' | 'video' = 'photo';
-            if (file.type.startsWith('video/')) mediaType = 'video';
-            if (file.type === 'image/gif') mediaType = 'animation';
-            const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded in web</b>', mediaType);
-            storageResult = { file_id: telegramResult.file_id };
         }
 
         const record: any = {
@@ -116,8 +186,12 @@ export async function POST(req: NextRequest) {
 
         const publicUrl = `${baseUrl}/i/${id}`;
 
-        // Log to Telegram
-        await sendLog(`🌐 <b>New Web Upload</b>\n\nType: ${file.type}\nSize: ${(file.size / 1024 / 1024).toFixed(2)} MB\nLink: ${publicUrl}`);
+        // Log to Telegram (optional - don't fail if it doesn't work)
+        try {
+            await sendLog(`🌐 <b>New Web Upload</b>\n\nType: ${file.type}\nSize: ${(file.size / 1024 / 1024).toFixed(2)} MB\nLink: ${publicUrl}`);
+        } catch (logError) {
+            console.error('Failed to send log to Telegram (optional):', logError);
+        }
 
         return NextResponse.json({
             success: true,
@@ -131,7 +205,12 @@ export async function POST(req: NextRequest) {
 
     } catch (error: any) {
         console.error('Upload API Error:', error);
-        await sendLog(`❌ <b>Web Upload Error</b>\n\nError: ${error.message || error}`);
+        // Try to log error to Telegram (optional)
+        try {
+            await sendLog(`❌ <b>Web Upload Error</b>\n\nError: ${error.message || error}`);
+        } catch (logError) {
+            console.error('Failed to send error log to Telegram (optional):', logError);
+        }
         return NextResponse.json({
             success: false,
             error: { code: 'INTERNAL_ERROR', message: error.message || 'Server processed request failed' }

src/app/api/v2/upload/route.ts

@@ -73,18 +73,21 @@ export async function POST(req: NextRequest) {
         // 2. Generate ID
         const id = customId ? customId.toLowerCase().replace(/[^a-z0-9-]/g, '-') : generateId();
 
-        // Determine storage based on file size
-        // Large files (>50MB) go to HF Hub, small files go to Telegram
+        // Determine storage based on configuration
+        // Prefer Hugging Face if configured (especially in HF Spaces environment)
         const LARGE_FILE_THRESHOLD = 50 * 1024 * 1024; // 50MB
         const isLargeFile = file.size > LARGE_FILE_THRESHOLD;
         const useHFForLargeFiles = isHuggingFaceConfigured() && process.env.USE_HF_FOR_LARGE_FILES === 'true';
+        const useHFStorage = isHuggingFaceConfigured() && (process.env.USE_HF_STORAGE === 'true' || process.env.SPACE_ID); // Auto-enable in HF Spaces
+        const isHFEnvironment = !!process.env.SPACE_ID; // Detect Hugging Face Spaces environment
 
-        // 1. Upload to storage (Hugging Face for large files if configured, else Telegram)
+        // 1. Upload to storage (prefer Hugging Face if configured, especially in HF Spaces)
         let storageResult: { file_id: string; file_url?: string };
         let storageType: 'telegram' | 'huggingface' = 'telegram';
 
-        if (useHFForLargeFiles && isLargeFile) {
-            // Use Hugging Face Hub for large files
+        // Priority: HF Storage > HF for large files > Telegram (with graceful fallback)
+        if (useHFStorage) {
+            // Use HF Hub for all files if configured
             try {
                 const fileName = customId || `upload-${id}`;
                 const hfResult = await uploadToHuggingFace(file, fileName, id);
@@ -94,27 +97,35 @@ export async function POST(req: NextRequest) {
                 };
                 storageType = 'huggingface';
                 
-                // Also forward to Telegram chat (for backup/notification)
+                // Also forward to Telegram chat (for backup/notification) - optional
                 try {
                     let mediaType: 'photo' | 'animation' | 'video' = 'photo';
                     if (file.type.startsWith('video/')) mediaType = 'video';
                     if (file.type === 'image/gif') mediaType = 'animation';
                     await uploadToTelegram(file, fileName, `📦 <b>Uploaded via API v2 (HF Hub)</b>\n🔗 <b>HF URL:</b> ${hfResult.file_url}`, mediaType);
                 } catch (tgError) {
-                    console.error('Failed to forward HF upload to Telegram chat:', tgError);
+                    console.error('Failed to forward HF upload to Telegram chat (optional):', tgError);
                     // Don't fail the upload if Telegram forwarding fails
                 }
             } catch (hfError: any) {
-                console.error('HF upload failed, falling back to Telegram:', hfError);
-                // Fallback to Telegram if HF fails
-                let mediaType: 'photo' | 'animation' | 'video' = 'photo';
-                if (file.type.startsWith('video/')) mediaType = 'video';
-                if (file.type === 'image/gif') mediaType = 'animation';
-                const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded via API v2</b>', mediaType);
-                storageResult = { file_id: telegramResult.file_id };
+                console.error('HF upload failed:', hfError);
+                // In HF Spaces, don't fallback to Telegram (it won't work)
+                if (isHFEnvironment) {
+                    throw new Error(`Hugging Face upload failed: ${hfError.message}. Please check HF_TOKEN and HF_REPO_ID configuration.`);
+                }
+                // Fallback to Telegram only if not in HF Spaces
+                try {
+                    let mediaType: 'photo' | 'animation' | 'video' = 'photo';
+                    if (file.type.startsWith('video/')) mediaType = 'video';
+                    if (file.type === 'image/gif') mediaType = 'animation';
+                    const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded via API v2</b>', mediaType);
+                    storageResult = { file_id: telegramResult.file_id };
+                } catch (tgError: any) {
+                    throw new Error(`Both HF and Telegram uploads failed. HF: ${hfError.message}, Telegram: ${tgError.message}`);
+                }
             }
-        } else if (isHuggingFaceConfigured() && process.env.USE_HF_STORAGE === 'true') {
-            // Use HF Hub for all files if configured
+        } else if (useHFForLargeFiles && isLargeFile) {
+            // Use Hugging Face Hub for large files only
             try {
                 const fileName = customId || `upload-${id}`;
                 const hfResult = await uploadToHuggingFace(file, fileName, id);
@@ -124,31 +135,60 @@ export async function POST(req: NextRequest) {
                 };
                 storageType = 'huggingface';
                 
-                // Also forward to Telegram chat (for backup/notification)
+                // Also forward to Telegram chat (for backup/notification) - optional
                 try {
                     let mediaType: 'photo' | 'animation' | 'video' = 'photo';
                     if (file.type.startsWith('video/')) mediaType = 'video';
                     if (file.type === 'image/gif') mediaType = 'animation';
                     await uploadToTelegram(file, fileName, `📦 <b>Uploaded via API v2 (HF Hub)</b>\n🔗 <b>HF URL:</b> ${hfResult.file_url}`, mediaType);
                 } catch (tgError) {
-                    console.error('Failed to forward HF upload to Telegram chat:', tgError);
+                    console.error('Failed to forward HF upload to Telegram chat (optional):', tgError);
                     // Don't fail the upload if Telegram forwarding fails
                 }
             } catch (hfError: any) {
                 console.error('HF upload failed, falling back to Telegram:', hfError);
+                // Fallback to Telegram if HF fails
+                try {
+                    let mediaType: 'photo' | 'animation' | 'video' = 'photo';
+                    if (file.type.startsWith('video/')) mediaType = 'video';
+                    if (file.type === 'image/gif') mediaType = 'animation';
+                    const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded via API v2</b>', mediaType);
+                    storageResult = { file_id: telegramResult.file_id };
+                } catch (tgError: any) {
+                    throw new Error(`Upload failed. HF: ${hfError.message}, Telegram: ${tgError.message}`);
+                }
+            }
+        } else {
+            // Use Telegram (default) - but check if we're in HF Spaces
+            if (isHFEnvironment && !isHuggingFaceConfigured()) {
+                throw new Error('Telegram API is not accessible in Hugging Face Spaces. Please configure HF_TOKEN and HF_REPO_ID to use Hugging Face storage.');
+            }
+            
+            try {
                 let mediaType: 'photo' | 'animation' | 'video' = 'photo';
                 if (file.type.startsWith('video/')) mediaType = 'video';
                 if (file.type === 'image/gif') mediaType = 'animation';
                 const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded via API v2</b>', mediaType);
                 storageResult = { file_id: telegramResult.file_id };
+            } catch (tgError: any) {
+                // If Telegram fails and HF is configured, try HF as fallback
+                if (isHuggingFaceConfigured()) {
+                    console.error('Telegram upload failed, trying HF as fallback:', tgError);
+                    try {
+                        const fileName = customId || `upload-${id}`;
+                        const hfResult = await uploadToHuggingFace(file, fileName, id);
+                        storageResult = {
+                            file_id: hfResult.file_id,
+                            file_url: hfResult.file_url
+                        };
+                        storageType = 'huggingface';
+                    } catch (hfError: any) {
+                        throw new Error(`Both Telegram and HF uploads failed. Telegram: ${tgError.message}, HF: ${hfError.message}`);
+                    }
+                } else {
+                    throw new Error(`Telegram upload failed: ${tgError.message}. Consider configuring Hugging Face storage.`);
+                }
             }
-        } else {
-            // Use Telegram (default)
-            let mediaType: 'photo' | 'animation' | 'video' = 'photo';
-            if (file.type.startsWith('video/')) mediaType = 'video';
-            if (file.type === 'image/gif') mediaType = 'animation';
-            const telegramResult = await uploadToTelegram(file, 'upload', '📦 <b>Uploaded via API v2</b>', mediaType);
-            storageResult = { file_id: telegramResult.file_id };
         }
 
         const record: any = {
@@ -177,9 +217,13 @@ export async function POST(req: NextRequest) {
 
         const publicUrl = `${baseUrl}/i/${id}`;
 
-        // Log to Telegram
-        const authInfo = auth?.apiKey ? `API Key: ${auth.apiKey.prefix}...` : auth?.userId ? `User: ${auth.userId}` : 'Anonymous';
-        await sendLog(`🌐 <b>New API v2 Upload</b>\n\n${authInfo}\nType: ${file.type}\nSize: ${(file.size / 1024 / 1024).toFixed(2)} MB\nLink: ${publicUrl}`);
+        // Log to Telegram (optional - don't fail if it doesn't work)
+        try {
+            const authInfo = auth?.apiKey ? `API Key: ${auth.apiKey.prefix}...` : auth?.userId ? `User: ${auth.userId}` : 'Anonymous';
+            await sendLog(`🌐 <b>New API v2 Upload</b>\n\n${authInfo}\nType: ${file.type}\nSize: ${(file.size / 1024 / 1024).toFixed(2)} MB\nLink: ${publicUrl}`);
+        } catch (logError) {
+            console.error('Failed to send log to Telegram (optional):', logError);
+        }
 
         // Trigger webhooks if user has any
         if (auth?.userId) {
@@ -213,7 +257,12 @@ export async function POST(req: NextRequest) {
 
     } catch (error: any) {
         console.error('Upload API Error:', error);
-        await sendLog(`❌ <b>API v2 Upload Error</b>\n\nError: ${error.message || error}`);
+        // Try to log error to Telegram (optional)
+        try {
+            await sendLog(`❌ <b>API v2 Upload Error</b>\n\nError: ${error.message || error}`);
+        } catch (logError) {
+            console.error('Failed to send error log to Telegram (optional):', logError);
+        }
         return NextResponse.json({
             success: false,
             error: { code: 'INTERNAL_ERROR', message: error.message || 'Server processed request failed' }