"feat: Added debug server and related components for improved development experience"

frontend/debug-server/src/app.js

@@ -0,0 +1,235 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const app = express();
+const PORT = process.env.PORT || 8081;
+
+// Konfigurationsdatei
+const CONFIG_FILE = path.join(__dirname, '../../../.env.local');
+const DEFAULT_BACKEND_URL = 'http://192.168.0.105:5000';
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(express.static(path.join(__dirname, '../public')));
+app.set('view engine', 'ejs');
+app.set('views', path.join(__dirname, '../public/views'));
+
+// Hilfsfunktionen
+function getBackendUrl() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+            const match = content.match(/NEXT_PUBLIC_API_URL=(.+)/);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+    } catch (error) {
+        console.error('Fehler beim Lesen der Backend-URL:', error);
+    }
+    return DEFAULT_BACKEND_URL;
+}
+
+function setBackendUrl(url) {
+    try {
+        let content = '';
+        
+        if (fs.existsSync(CONFIG_FILE)) {
+            content = fs.readFileSync(CONFIG_FILE, 'utf8');
+            // Ersetze die URL, wenn sie bereits existiert
+            if (content.match(/NEXT_PUBLIC_API_URL=.+/)) {
+                content = content.replace(/NEXT_PUBLIC_API_URL=.+/, `NEXT_PUBLIC_API_URL=${url}`);
+            } else {
+                // Füge die URL hinzu, wenn sie nicht existiert
+                content += `\nNEXT_PUBLIC_API_URL=${url}`;
+            }
+        } else {
+            // Erstelle eine neue Datei mit der URL
+            content = `NEXT_PUBLIC_API_URL=${url}`;
+        }
+        
+        fs.writeFileSync(CONFIG_FILE, content, 'utf8');
+        return true;
+    } catch (error) {
+        console.error('Fehler beim Speichern der Backend-URL:', error);
+        return false;
+    }
+}
+
+function getNetworkInterfaces() {
+    const interfaces = [];
+    const networkInterfaces = os.networkInterfaces();
+    
+    for (const [name, netInterface] of Object.entries(networkInterfaces)) {
+        if (name.startsWith('lo') || name.startsWith('docker') || name.startsWith('br-')) {
+            continue;
+        }
+        
+        for (const iface of netInterface) {
+            if (iface.family === 'IPv4' || iface.family === 4) {
+                interfaces.push({
+                    name: name,
+                    address: iface.address
+                });
+                break;
+            }
+        }
+    }
+    
+    return interfaces;
+}
+
+function pingHost(host) {
+    try {
+        const platform = process.platform;
+        const cmd = platform === 'win32' ? 
+            `ping -n 1 -w 1000 ${host}` :
+            `ping -c 1 -W 1 ${host}`;
+            
+        execSync(cmd, { stdio: 'ignore' });
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+async function testBackendConnection(url) {
+    try {
+        const response = await axios.get(`${url}/api/test`, { timeout: 3000 });
+        return response.status === 200;
+    } catch (error) {
+        return false;
+    }
+}
+
+// Routen
+app.get('/', async (req, res) => {
+    const backendUrl = getBackendUrl();
+    const interfaces = getNetworkInterfaces();
+    
+    // Analysiere die URL, um Host und Port zu extrahieren
+    let backendHost = '';
+    let backendPort = '';
+    
+    try {
+        const url = new URL(backendUrl);
+        backendHost = url.hostname;
+        backendPort = url.port || (url.protocol === 'https:' ? '443' : '80');
+    } catch (error) {
+        console.error('Ungültige Backend-URL:', error);
+    }
+    
+    // Prüfe Backend-Verbindung
+    let backendStatus = 'Unbekannt';
+    let pingStatus = false;
+    
+    if (backendHost) {
+        pingStatus = pingHost(backendHost);
+        
+        if (pingStatus) {
+            try {
+                const connectionStatus = await testBackendConnection(backendUrl);
+                backendStatus = connectionStatus ? 'Verbunden' : 'Keine API-Verbindung';
+            } catch (error) {
+                backendStatus = 'Verbindungsfehler';
+            }
+        } else {
+            backendStatus = 'Nicht erreichbar';
+        }
+    }
+    
+    res.render('index', {
+        title: 'MYP Frontend Debug',
+        backendUrl,
+        backendHost,
+        backendPort,
+        backendStatus,
+        pingStatus,
+        interfaces,
+        lastCheck: new Date().toLocaleString('de-DE')
+    });
+});
+
+app.post('/update-backend', async (req, res) => {
+    const { backendUrl } = req.body;
+    
+    if (!backendUrl) {
+        return res.json({ success: false, message: 'Keine Backend-URL angegeben' });
+    }
+    
+    // Validiere URL
+    try {
+        new URL(backendUrl);
+    } catch (error) {
+        return res.json({ success: false, message: 'Ungültige URL' });
+    }
+    
+    // Speichere die URL
+    const saved = setBackendUrl(backendUrl);
+    
+    if (!saved) {
+        return res.json({ success: false, message: 'Fehler beim Speichern der URL' });
+    }
+    
+    // Teste die Verbindung zum Backend
+    let connectionStatus = false;
+    
+    try {
+        connectionStatus = await testBackendConnection(backendUrl);
+    } catch (error) {
+        // Ignoriere Fehler
+    }
+    
+    return res.json({ 
+        success: true, 
+        message: 'Backend-URL erfolgreich aktualisiert',
+        connection: connectionStatus
+    });
+});
+
+app.post('/test-backend', async (req, res) => {
+    const { backendUrl } = req.body;
+    
+    if (!backendUrl) {
+        return res.json({ success: false, message: 'Keine Backend-URL angegeben' });
+    }
+    
+    // Validiere URL
+    let hostname = '';
+    try {
+        const url = new URL(backendUrl);
+        hostname = url.hostname;
+    } catch (error) {
+        return res.json({ success: false, message: 'Ungültige URL' });
+    }
+    
+    // Teste Ping
+    const pingStatus = pingHost(hostname);
+    
+    // Teste API-Verbindung
+    let connectionStatus = false;
+    
+    if (pingStatus) {
+        try {
+            connectionStatus = await testBackendConnection(backendUrl);
+        } catch (error) {
+            // Ignoriere Fehler
+        }
+    }
+    
+    return res.json({
+        success: true,
+        ping: pingStatus,
+        connection: connectionStatus
+    });
+});
+
+// Server starten
+app.listen(PORT, () => {
+    console.log(`MYP Frontend Debug Server läuft auf Port ${PORT}`);
+});