Create server.js

server.js

@@ -0,0 +1,196 @@
+import express from 'express';
+import cors from 'cors';
+import rateLimit from 'express-rate-limit';
+import { Readable } from 'stream';
+
+const app = express();
+const PORT = 7860;
+
+// Configuración para que funcione el límite de IPs en Hugging Face Spaces
+app.set('trust proxy', 1);
+
+app.use(cors());
+app.use(express.json());
+
+// --- CONFIGURACIÓN DE PROVEEDORES ---
+const PROVIDERS = [
+    { 
+        id: "llm7", 
+        url: "https://api.llm7.io/v1/chat/completions" 
+    },
+    { 
+        id: "aquadevs", 
+        url: "https://api.aquadevs.com/v1/chat/completions", 
+        imageUrl: "https://api.aquadevs.com/v1/images/generations",
+        apiKey: "aqua_sk_4f51287cffce411e8c19afacc833481d" 
+    },
+    { 
+        id: "ventarys-mirror", 
+        url: "https://ventarys-mirror-1.hf.space/v1/chat/completions", 
+        proxySecret: "sk-52650650a50f0v10vg150vs0v" 
+    }
+];
+
+const MAX_PER_PROVIDER = 3; 
+const QUEUE_TIMEOUT = 25000; 
+
+const BLOCKED_TIERS = ["pro", "premium", "ultra", "vip", "plus", "enterprise", "max"];
+
+function isModelAllowed(modelId, modelObj = null) {
+    if (!modelId) return true; 
+    const lowerId = modelId.toLowerCase();
+    if (modelObj && modelObj.tier) {
+        const tier = modelObj.tier.toLowerCase();
+        if (tier === "pro" || tier === "premium" || tier === "vip") return false;
+        if (tier === "free" || tier === "standard") return true;
+    }
+    return !BLOCKED_TIERS.some(keyword => lowerId.includes(keyword));
+}
+
+let currentLoad = { "llm7": 0, "aquadevs": 0, "ventarys-mirror": 0 };
+
+// --- LÍMITE DE TASA (1 por minuto) ---
+const limiter = rateLimit({
+    windowMs: 60 * 1000, 
+    max: 1, 
+    message: { error: { message: "Límite alcanzado. Espera 1 minuto entre mensajes.", code: 429 } },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+
+// --- RUTAS INFORMATIVAS ---
+app.get('/health', (req, res) => {
+    res.json({ 
+        status: "online", 
+        type: "hf-node-proxy",
+        providers: PROVIDERS.map(p => p.id),
+        current_load: currentLoad 
+    });
+});
+
+app.get('/v1/models', async (req, res) => {
+    try {
+        const fetchPromises = PROVIDERS.map(async (provider) => {
+            const modelsUrl = provider.url.replace("/chat/completions", "/models");
+            const fetchHeaders = { "Content-Type": "application/json" };
+            
+            if (provider.apiKey) fetchHeaders["Authorization"] = `Bearer ${provider.apiKey}`;
+            if (provider.proxySecret) fetchHeaders["X-Proxy-Secret"] = provider.proxySecret;
+
+            const resp = await fetch(modelsUrl, { method: "GET", headers: fetchHeaders });
+            if (!resp.ok) throw new Error(`HTTP Error ${resp.status}`);
+            
+            const json = await resp.json();
+            if (json && Array.isArray(json.data)) {
+                return json.data
+                    .filter(model => isModelAllowed(model.id, model))
+                    .map(model => ({ ...model, owned_by: provider.id }));
+            }
+            return [];
+        });
+
+        const results = await Promise.allSettled(fetchPromises);
+        let allModels = [];
+        results.forEach(result => {
+            if (result.status === "fulfilled") allModels = allModels.concat(result.value);
+        });
+
+        res.json({ object: "list", data: allModels });
+    } catch (error) {
+        res.status(500).json({ error: "No se pudieron recuperar los modelos." });
+    }
+});
+
+// --- RUTA PRINCIPAL DE GENERACIÓN (Con Límite de Tasa) ---
+app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req, res) => {
+    const isImage = req.path === '/v1/images/generations';
+    const requestedModel = req.body.model;
+
+    // Filtro de Seguridad
+    if (requestedModel && !isModelAllowed(requestedModel)) {
+        return res.status(403).json({
+            error: { 
+                message: `Acceso denegado: El modelo '${requestedModel}' es de pago (Premium/Pro).`, 
+                type: "model_not_allowed", code: 403 
+            }
+        });
+    }
+
+    const availableProviders = isImage ? PROVIDERS.filter(p => p.imageUrl) : PROVIDERS;
+    const startTime = Date.now();
+    let selectedProvider = null;
+
+    // Sala de Espera
+    while (Date.now() - startTime < QUEUE_TIMEOUT) {
+        let shuffled = [...availableProviders].sort(() => Math.random() - 0.5);
+        for (let provider of shuffled) {
+            if (currentLoad[provider.id] < MAX_PER_PROVIDER) {
+                selectedProvider = provider;
+                currentLoad[provider.id]++;
+                break;
+            }
+        }
+        if (selectedProvider) break;
+        await new Promise(r => setTimeout(r, 1500));
+    }
+
+    if (!selectedProvider) {
+        return res.status(503).json({ error: { message: "Todas las APIs están ocupadas. Por favor, reintenta.", code: 503 } });
+    }
+
+    // Función segura para liberar el Slot
+    let isReleased = false;
+    const releaseSlot = () => {
+        if (!isReleased) {
+            currentLoad[selectedProvider.id] = Math.max(0, currentLoad[selectedProvider.id] - 1);
+            isReleased = true;
+        }
+    };
+
+    try {
+        const targetUrl = isImage ? selectedProvider.imageUrl : selectedProvider.url;
+        const fetchHeaders = { "Content-Type": "application/json" };
+        
+        if (selectedProvider.apiKey) fetchHeaders["Authorization"] = `Bearer ${selectedProvider.apiKey}`;
+        if (selectedProvider.proxySecret) fetchHeaders["X-Proxy-Secret"] = selectedProvider.proxySecret;
+
+        const response = await fetch(targetUrl, {
+            method: "POST",
+            headers: fetchHeaders,
+            body: JSON.stringify(req.body)
+        });
+
+        if (isImage) {
+            const responseData = await response.text();
+            releaseSlot();
+            return res.status(response.status).type('application/json').send(responseData);
+        } 
+        
+        // Manejo de Streaming para Chat
+        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', releaseSlot);
+            req.on('close', releaseSlot); // Libera si el usuario cierra la pestaña antes de terminar
+        } else {
+            releaseSlot();
+            res.end();
+        }
+
+    } catch (err) {
+        releaseSlot();
+        res.status(500).json({ error: `Error de conexión con la API de ${selectedProvider.id}.` });
+    }
+});
+
+app.listen(PORT, '0.0.0.0', () => {
+    console.log(`🚀 API Main Proxy (Node.js) corriendo en el puerto ${PORT}`);
+});