Update server.js

server.js

@@ -6,18 +6,30 @@ import { Readable } from 'stream';
 const app = express();
 const PORT = 7860;
 
-// Configuración CRÍTICA para que express-rate-limit lea la IP real del usuario
-// cuando la app está detrás de proxies inversos (ej. Vercel, Render, HF Spaces, Nginx)
+// --- CONFIGURACIÓN DE SEGURIDAD Y PRIVACIDAD ---
 app.set('trust proxy', 1);
+app.disable('x-powered-by'); // Oculta que estamos usando Express
+
 app.use(cors());
 
+// Inyección de cabeceras de seguridad estándar
+app.use((req, res, next) => {
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('X-Frame-Options', 'DENY');
+    res.setHeader('X-XSS-Protection', '1; mode=block');
+    res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+    res.setHeader('Referrer-Policy', 'no-referrer'); // Protege la privacidad del origen
+    next();
+});
+
 // Aumentar límite a 50mb para soportar imágenes en Base64 (Visión / Multimodal)
 app.use(express.json({ limit: '50mb' }));
 app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
-// --- FUNCIÓN DE LOGS ---
+// --- FUNCIÓN DE LOGS (Sanitizada) ---
 function logError(providerId, reason) {
     const timestamp = new Date().toISOString();
+    // No guardamos IPs ni prompts de usuarios, solo el estado de nuestros proveedores
     console.error(`[${timestamp}] [ERROR] Proveedor: ${providerId} | Motivo: ${reason}`);
 }
 
@@ -27,12 +39,6 @@ const PROVIDERS = [
         id: "llm7", 
         url: "https://api.llm7.io/v1/chat/completions" 
     },
-    { 
-        id: "pollinations", 
-        url: "https://text.pollinations.ai/openai", 
-        modelsUrl: "https://text.pollinations.ai/models",
-        imageUrl: "https://image.pollinations.ai/prompt"
-    },
     { 
         id: "airforce", 
         url: "https://api.airforce/v1/chat/completions",
@@ -48,14 +54,14 @@ const PROVIDERS = [
 const MAX_PER_PROVIDER = 3; 
 const QUEUE_TIMEOUT = 25000; 
 
-let currentLoad = { "llm7": 0, "pollinations": 0, "airforce": 0, "ventarys-mirror": 0 };
+let currentLoad = { "llm7": 0, "airforce": 0, "ventarys-mirror": 0 };
 
 // --- RATE LIMITING (Basado en la IP real del usuario) ---
 const limiter = rateLimit({
     windowMs: 60 * 1000, 
     max: 25, 
-    keyGenerator: (req) => req.ip, // Extrae la IP real verificada por 'trust proxy'
-    message: { error: { message: "Límite alcanzado. Espera 1 minuto entre mensajes.", code: 429 } },
+    keyGenerator: (req) => req.ip, 
+    message: { error: { message: "Límite de solicitudes alcanzado. Por favor, espera un momento.", code: 429 } },
     standardHeaders: true,
     legacyHeaders: false,
 });
@@ -66,7 +72,6 @@ const AUDIO_KEYWORDS = ["suno", "udio", "music", "audio", "song", "voice", "tts"
 
 function isImageModel(model) {
     if (!model) return false;
-    // Soporte directo para el flag de api.airforce
     if (model.type === 'image' || model.supports_images === true) return true;
     
     const id = (model.id || model.name || "").toLowerCase();
@@ -99,9 +104,17 @@ async function fetchAllModels() {
 
             if (modelsArray.length > 0) {
                 return modelsArray
-                    // Filtrar modelos de audio/música
+                    // 1. Filtrar modelos de audio/música
                     .filter(model => !isAudioModel(model))
-                    // Procesar y formatear campos
+                    // 2. CRÍTICO: Permitir estrictamente modelos con precio 0 (si la API reporta el precio)
+                    .filter(model => {
+                        if (model.pricepermilliontokens !== undefined && model.pricepermilliontokens !== null) {
+                            return model.pricepermilliontokens === 0;
+                        }
+                        // Si el proveedor (ej. llm7) no envía el campo de precio, lo asumimos como válido
+                        return true;
+                    })
+                    // 3. Procesar y formatear campos
                     .map(model => ({
                         ...model,
                         id: model.id || model.name,
@@ -138,10 +151,9 @@ app.get('/v1/models', async (req, res) => {
         const allModels = await fetchAllModels();
         
         const textModels = allModels
-            // Excluir imágenes y asegurar que soporte chat (filtro estricto para api.airforce)
             .filter(m => !isImageModel(m) && m.supports_chat !== false)
             .map(m => {
-                m.type = 'text'; // Forzar etiqueta
+                m.type = 'text';
                 return m;
             });
 
@@ -158,14 +170,12 @@ app.get('/v1/images/models', async (req, res) => {
         const allModels = await fetchAllModels();
         
         let imageModels = allModels
-            // Incluir explícitamente modelos de imagen (o que supports_images sea true en airforce)
             .filter(m => isImageModel(m))
             .map(m => {
-                m.type = 'image'; // Forzar etiqueta
+                m.type = 'image';
                 return m;
             });
 
-        // Garantizar que la App siempre reconozca los modelos base
         const baseImages = [
             { id: "flux", object: "model", type: "image", owned_by: "system", tier: "standard" },
             { id: "dall-e-3", object: "model", type: "image", owned_by: "system", tier: "standard" }
@@ -187,14 +197,16 @@ app.get('/v1/images/models', async (req, res) => {
 // --- RUTA PRINCIPAL DE GENERACIÓN ---
 app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req, res) => {
     const isImage = req.path === '/v1/images/generations';
-    const availableProviders = isImage ? PROVIDERS.filter(p => p.imageUrl) : PROVIDERS;
     
+    let availableProviders = isImage ? PROVIDERS.filter(p => p.imageUrl) : [...PROVIDERS];
     const startTime = Date.now();
-    let selectedProvider = null;
+    let responseSent = false;
 
-    // Sistema de cola inteligente
-    while (Date.now() - startTime < QUEUE_TIMEOUT) {
+    while (availableProviders.length > 0 && Date.now() - startTime < QUEUE_TIMEOUT) {
+        let selectedProvider = null;
+        
         let shuffled = [...availableProviders].sort(() => Math.random() - 0.5);
+        
         for (let provider of shuffled) {
             if (currentLoad[provider.id] < MAX_PER_PROVIDER) {
                 selectedProvider = provider;
@@ -202,144 +214,139 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
                 break;
             }
         }
-        if (selectedProvider) break;
-        await new Promise(r => setTimeout(r, 1500));
-    }
 
-    if (!selectedProvider) {
-        logError("ProxyMain", "Saturación - Todas las APIs están ocupadas");
-        return res.status(503).json({ error: { message: "Todas las APIs están ocupadas. Por favor, reintenta.", code: 503 } });
-    }
-
-    let isReleased = false;
-    const releaseSlot = () => {
-        if (!isReleased) {
-            currentLoad[selectedProvider.id] = Math.max(0, currentLoad[selectedProvider.id] - 1);
-            isReleased = true;
+        if (!selectedProvider) {
+            await new Promise(r => setTimeout(r, 1500));
+            continue;
         }
-    };
-
-    try {
-        let targetUrl = isImage ? selectedProvider.imageUrl : selectedProvider.url;
-        let reqMethod = "POST";
-        let reqBody = JSON.stringify(req.body);
-        const fetchHeaders = { "Content-Type": "application/json" };
-        
-        if (selectedProvider.apiKey) fetchHeaders["Authorization"] = `Bearer ${selectedProvider.apiKey}`;
-        if (selectedProvider.proxySecret) fetchHeaders["X-Proxy-Secret"] = selectedProvider.proxySecret;
 
-        // Adaptador especializado para Pollinations Imágenes (Formato nativo GET)
-        if (isImage && selectedProvider.id === "pollinations") {
-            const prompt = req.body.prompt || "A random image";
-            const seed = Math.floor(Math.random() * 10000000);
-            
-            let width = 1024, height = 1024;
-            if (req.body.size) {
-                const parts = req.body.size.split('x');
-                if (parts.length === 2) { width = parseInt(parts[0]); height = parseInt(parts[1]); }
+        let isReleased = false;
+        const releaseSlot = () => {
+            if (!isReleased) {
+                currentLoad[selectedProvider.id] = Math.max(0, currentLoad[selectedProvider.id] - 1);
+                isReleased = true;
             }
-            
-            const pollModel = req.body.model && req.body.model.includes('flux') ? 'flux' : 'dall-e-3';
-
-            targetUrl = `${targetUrl}/${encodeURIComponent(prompt)}?seed=${seed}&width=${width}&height=${height}&model=${pollModel}&nologo=true`;
-            reqMethod = "GET";
-            reqBody = undefined;
-            delete fetchHeaders["Content-Type"];
-        }
+        };
 
-        const response = await fetch(targetUrl, {
-            method: reqMethod,
-            headers: fetchHeaders,
-            body: reqBody
-        });
+        try {
+            let targetUrl = isImage ? selectedProvider.imageUrl : selectedProvider.url;
+            let reqMethod = "POST";
+            let reqBody = JSON.stringify(req.body);
+            const fetchHeaders = { "Content-Type": "application/json" };
+            
+            if (selectedProvider.apiKey) fetchHeaders["Authorization"] = `Bearer ${selectedProvider.apiKey}`;
+            if (selectedProvider.proxySecret) fetchHeaders["X-Proxy-Secret"] = selectedProvider.proxySecret;
 
-        if (!response.ok) {
-            logError(selectedProvider.id, `Respuesta HTTP ${response.status} - ${response.statusText}`);
-        }
+            const response = await fetch(targetUrl, {
+                method: reqMethod,
+                headers: fetchHeaders,
+                body: reqBody
+            });
 
-        // --- MANEJO EXCLUSIVO DE IMÁGENES (Estandarización a Base64 - Estilo Aqua AI) ---
-        if (isImage) {
-            const contentType = response.headers.get("content-type") || "";
+            if (!response.ok) {
+                logError(selectedProvider.id, `Fallo con código HTTP ${response.status}`);
+                releaseSlot();
+                availableProviders = availableProviders.filter(p => p.id !== selectedProvider.id);
+                continue; 
+            }
 
-            if (contentType.includes("application/json")) {
-                const jsonResp = await response.json();
-                
-                // Extraer el array de datos o crearlo si la API (ej. airforce) responde con { url: "..." } directo
-                let dataArray = jsonResp.data;
-                if (!dataArray && jsonResp.url) {
-                    dataArray = [{ url: jsonResp.url }];
-                }
-                
-                // Convertir URLs de imágenes a base64_json (Formato esperado idéntico a Aqua AI)
-                if (dataArray && Array.isArray(dataArray)) {
-                    for (let item of dataArray) {
-                        if (item.url && !item.b64_json) {
-                            try {
-                                const imgRes = await fetch(item.url);
-                                const arrayBuffer = await imgRes.arrayBuffer();
-                                item.b64_json = Buffer.from(arrayBuffer).toString('base64');
-                                delete item.url;
-                            } catch (e) {
-                                logError(selectedProvider.id, `Fallo convirtiendo URL a Base64: ${e.message}`);
+            // Sanitización: Evitar devolver cookies o cabeceras de servidor del proveedor original
+            const responseHeaders = new Headers(response.headers);
+            responseHeaders.delete('set-cookie');
+            responseHeaders.delete('server');
+            responseHeaders.delete('x-powered-by');
+            responseHeaders.delete('cf-ray');
+
+            if (isImage) {
+                const contentType = responseHeaders.get("content-type") || "";
+
+                if (contentType.includes("application/json")) {
+                    const jsonResp = await response.json();
+                    
+                    let dataArray = jsonResp.data;
+                    if (!dataArray && jsonResp.url) {
+                        dataArray = [{ url: jsonResp.url }];
+                    }
+                    
+                    if (dataArray && Array.isArray(dataArray)) {
+                        for (let item of dataArray) {
+                            if (item.url && !item.b64_json) {
+                                try {
+                                    const imgRes = await fetch(item.url);
+                                    const arrayBuffer = await imgRes.arrayBuffer();
+                                    item.b64_json = Buffer.from(arrayBuffer).toString('base64');
+                                    delete item.url;
+                                } catch (e) {
+                                    logError(selectedProvider.id, `Fallo convitiendo URL a Base64.`);
+                                }
                             }
                         }
+                        releaseSlot();
+                        responseSent = true;
+                        return res.status(response.status).json({
+                            created: Math.floor(Date.now() / 1000),
+                            data: dataArray
+                        });
                     }
+                    
                     releaseSlot();
-                    return res.status(response.status).json({
+                    responseSent = true;
+                    return res.status(response.status).json(jsonResp);
+                } 
+                else if (contentType.includes("image/")) {
+                    const arrayBuffer = await response.arrayBuffer();
+                    const b64 = Buffer.from(arrayBuffer).toString('base64');
+                    releaseSlot();
+                    
+                    responseSent = true;
+                    return res.status(200).json({
                         created: Math.floor(Date.now() / 1000),
-                        data: dataArray
+                        data: [{ b64_json: b64 }]
                     });
+                } 
+                else {
+                    const textResp = await response.text();
+                    releaseSlot();
+                    responseSent = true;
+                    return res.status(response.status).type(contentType).send(textResp);
                 }
-                
-                // Respaldo de seguridad si no encontró formato extraíble
-                releaseSlot();
-                return res.status(response.status).json(jsonResp);
             } 
-            else if (contentType.includes("image/")) {
-                // Si la API nos devuelve el binario directo (Ej. Pollinations)
-                const arrayBuffer = await response.arrayBuffer();
-                const b64 = Buffer.from(arrayBuffer).toString('base64');
-                releaseSlot();
+            
+            // Streaming (Texto)
+            res.writeHead(response.status, {
+                'Content-Type': responseHeaders.get('content-type') || 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            });
+
+            if (response.body) {
+                const stream = Readable.fromWeb(response.body);
+                stream.pipe(res);
                 
-                // Formato Aqua AI Strict:
-                return res.status(200).json({
-                    created: Math.floor(Date.now() / 1000),
-                    data: [{ b64_json: b64 }]
+                stream.on('end', releaseSlot);
+                stream.on('error', (err) => {
+                    logError(selectedProvider.id, `Stream interrumpido.`);
+                    releaseSlot();
                 });
-            } 
-            else {
-                const textResp = await response.text();
+                req.on('close', releaseSlot); 
+            } else {
                 releaseSlot();
-                return res.status(response.status).type(contentType).send(textResp);
+                res.end();
             }
-        } 
-        
-        // --- MANEJO EXCLUSIVO DE TEXTO (Streaming) ---
-        res.writeHead(response.status, {
-            'Content-Type': response.headers.get('content-type') || 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive'
-        });
-
-        if (response.body) {
-            const stream = Readable.fromWeb(response.body);
-            stream.pipe(res);
             
-            stream.on('end', releaseSlot);
-            stream.on('error', (err) => {
-                logError(selectedProvider.id, `Stream roto a mitad de respuesta: ${err.message}`);
-                releaseSlot();
-            });
-            req.on('close', releaseSlot); 
-        } else {
+            responseSent = true;
+            return; 
+
+        } catch (err) {
+            logError(selectedProvider.id, `Excepción de red conectando al upstream.`);
             releaseSlot();
-            res.end();
+            availableProviders = availableProviders.filter(p => p.id !== selectedProvider.id);
         }
+    }
 
-    } catch (err) {
-        releaseSlot();
-        logError(selectedProvider ? selectedProvider.id : "Proxy", `Fallo o Timeout conectando al proveedor: ${err.message}`);
-        res.status(500).json({ error: { message: "Error de conexión interna."} });
+    if (!responseSent) {
+        logError("ProxyMain", "Todos los proveedores fallaron o se agotó el tiempo de espera.");
+        return res.status(503).json({ error: { message: "El servicio no está disponible temporalmente. Inténtalo de nuevo.", code: 503 } });
     }
 });