Update server.js

server.js

@@ -76,7 +76,7 @@ app.use((err, req, res, next) => {
 
 // --- API KEY AUTHENTICATION MIDDLEWARE ---
 app.use((req, res, next) => {
-    if (req.path === '/' || req.path === '/health') {
+    if (req.path === '/' || req.path === '/health' || req.path.startsWith('/test-')) {
         return next();
     }
     
@@ -265,37 +265,80 @@ async function resolveChatflowId(instanceNum, botName) {
     return { id: match.id, instance };
 }
 
-// --- STREAMING HANDLER ---
+// --- IMPROVED STREAMING HANDLER WITH TIMEOUT ---
 async function handleStreamingResponse(flowiseResponse, clientRes) {
     clientRes.setHeader('Content-Type', 'text/event-stream');
     clientRes.setHeader('Cache-Control', 'no-cache');
     clientRes.setHeader('Connection', 'keep-alive');
+    clientRes.setHeader('X-Accel-Buffering', 'no');
     
     console.log('[Streaming] Forwarding SSE stream...');
     
     let streamStarted = false;
+    let dataReceived = false;
+    let lastDataTime = Date.now();
+    let totalBytes = 0;
+    
+    // Check for stream timeout every 5 seconds
+    const timeoutCheck = setInterval(() => {
+        const timeSinceData = Date.now() - lastDataTime;
+        
+        if (timeSinceData > 45000) {  // 45 seconds without data
+            console.error(`[Streaming] Timeout - no data for ${(timeSinceData/1000).toFixed(1)}s`);
+            clearInterval(timeoutCheck);
+            
+            if (!dataReceived) {
+                console.error('[Streaming] Stream completed with NO data received!');
+                if (!streamStarted) {
+                    clientRes.status(504).json({ 
+                        error: 'Gateway timeout',
+                        message: 'No response from chatbot within 45 seconds' 
+                    });
+                } else {
+                    clientRes.write('\n\nevent: error\ndata: {"error": "Response timeout - no data received"}\n\n');
+                }
+            }
+            clientRes.end();
+        }
+    }, 5000);
     
     flowiseResponse.body.on('data', (chunk) => {
+        clearTimeout(timeoutCheck);
         streamStarted = true;
+        dataReceived = true;
+        lastDataTime = Date.now();
+        totalBytes += chunk.length;
+        
+        console.log(`[Streaming] Received chunk: ${chunk.length} bytes (total: ${totalBytes})`);
         clientRes.write(chunk);
     });
     
     flowiseResponse.body.on('end', () => {
-        console.log('[Streaming] Stream completed');
+        clearInterval(timeoutCheck);
+        
+        if (dataReceived) {
+            console.log(`[Streaming] Stream completed successfully - ${totalBytes} bytes total`);
+        } else {
+            console.warn('[Streaming] Stream completed but NO data was received!');
+        }
+        
         clientRes.end();
     });
     
     flowiseResponse.body.on('error', (err) => {
+        clearInterval(timeoutCheck);
         console.error('[Streaming Error]', err.message);
         
-        if (streamStarted) {
+        if (streamStarted && dataReceived) {
             clientRes.write(`\n\nevent: error\ndata: {"error": "Stream interrupted"}\n\n`);
+        } else if (!streamStarted) {
+            clientRes.status(500).json({ error: 'Stream failed to start' });
         }
         clientRes.end();
     });
 }
 
-// --- ROUTES ---
+// --- ROUTE 1: PREDICTION (WITH IMPROVED TIMEOUT) ---
 app.post('/api/v1/prediction/:instanceNum/:botName', async (req, res) => {
     try {
         const instanceNum = parseInt(req.params.instanceNum);
@@ -322,6 +365,10 @@ app.post('/api/v1/prediction/:instanceNum/:botName', async (req, res) => {
             headers['Authorization'] = `Bearer ${instance.key}`;
         }
         
+        // TIMING: Track how long Flowise takes
+        const startTime = Date.now();
+        console.log(`[Timing] Calling Flowise at ${new Date().toISOString()}`);
+        
         const response = await fetchWithTimeout(
             `${instance.url}/api/v1/prediction/${id}`,
             {
@@ -329,9 +376,12 @@ app.post('/api/v1/prediction/:instanceNum/:botName', async (req, res) => {
                 headers,
                 body: JSON.stringify(req.body)
             },
-            30000
+            60000  // ← INCREASED TO 60 SECONDS
         );
         
+        const duration = Date.now() - startTime;
+        console.log(`[Timing] Flowise responded in ${duration}ms (${(duration/1000).toFixed(1)}s)`);
+        
         if (!response.ok) {
             const errorText = await response.text();
             console.error(`[Error] Instance returned ${response.status}: ${errorText.substring(0, 200)}`);
@@ -368,6 +418,7 @@ app.post('/api/v1/prediction/:instanceNum/:botName', async (req, res) => {
     }
 });
 
+// --- ROUTE 2: CHATBOT CONFIG ---
 app.get('/api/v1/public-chatbotConfig/:instanceNum/:botName', async (req, res) => {
     try {
         const instanceNum = parseInt(req.params.instanceNum);
@@ -399,6 +450,7 @@ app.get('/api/v1/public-chatbotConfig/:instanceNum/:botName', async (req, res) =
     }
 });
 
+// --- ROUTE 3: STREAMING CHECK ---
 app.get('/api/v1/chatflows-streaming/:instanceNum/:botName', async (req, res) => {
     try {
         const instanceNum = parseInt(req.params.instanceNum);
@@ -430,6 +482,43 @@ app.get('/api/v1/chatflows-streaming/:instanceNum/:botName', async (req, res) =>
     }
 });
 
+// --- TEST ENDPOINT: Stream Test ---
+app.get('/test-stream', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    
+    let count = 0;
+    const interval = setInterval(() => {
+        count++;
+        res.write(`data: {"message": "Test chunk ${count}", "timestamp": "${new Date().toISOString()}"}\n\n`);
+        
+        if (count >= 5) {
+            clearInterval(interval);
+            res.write('data: {"message": "Test complete"}\n\n');
+            res.end();
+        }
+    }, 500);
+});
+
+// --- TEST ENDPOINT: Delay Test ---
+app.post('/test-delay', async (req, res) => {
+    const start = Date.now();
+    const delaySeconds = req.body.delay || 35;
+    
+    console.log(`[Test] Starting ${delaySeconds}s delay test...`);
+    await new Promise(resolve => setTimeout(resolve, delaySeconds * 1000));
+    
+    const duration = Date.now() - start;
+    res.json({
+        message: 'Test completed',
+        duration_ms: duration,
+        duration_sec: (duration/1000).toFixed(1),
+        requested_delay: delaySeconds
+    });
+});
+
+// --- HEALTH CHECK ---
 app.get('/', (req, res) => res.send('Federated Proxy Active'));
 
 app.get('/health', (req, res) => {
@@ -438,21 +527,30 @@ app.get('/health', (req, res) => {
         instances: INSTANCES.length,
         cached_bots: flowCache.size,
         daily_active_ips: dailyUsage.size,
-        uptime: process.uptime()
+        uptime: process.uptime(),
+        memory: process.memoryUsage()
     });
 });
 
+// --- 404 HANDLER ---
 app.use((req, res) => {
     res.status(404).json({ error: 'Route not found' });
 });
 
+// --- GLOBAL ERROR HANDLER ---
 app.use((err, req, res, next) => {
     console.error('[Error] Unhandled error:', err);
     res.status(500).json({ error: 'Internal server error' });
 });
 
+// --- GRACEFUL SHUTDOWN ---
 const server = app.listen(7860, '0.0.0.0', () => {
-    console.log('Federated Proxy running on port 7860');
+    console.log('===== Federated Proxy Started =====');
+    console.log('Port: 7860');
+    console.log(`Instances: ${INSTANCES.length}`);
+    console.log(`Allowed Origins: ${allowedOrigins.length || 'Open mode'}`);
+    console.log(`API Keys: ${API_KEYS.length || 'None'}`);
+    console.log('====================================');
 });
 
 process.on('SIGTERM', () => {