Update app/app.py

app/app.py

@@ -4,6 +4,9 @@ import logging
 from waitress import serve
 from nacl.signing import VerifyKey
 from nacl.exceptions import BadSignatureError
+import threading
+import requests
+import time
 
 # Logging konfigurieren
 logging.basicConfig(
@@ -12,85 +15,97 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Konfiguration aus Umgebungsvariablen
-PUBLIC_KEY = os.getenv('Public_Key', '').strip()  # Strip entfernt Leerzeichen
+# Konfiguration
+PUBLIC_KEY = os.getenv('Public_Key', '').strip()
 APPLICATION_ID = os.getenv('Application_ID', '').strip()
+PORT = int(os.getenv('PORT', 7860))  # Hugging Face nutzt standardmäßig Port 7860
 
 app = Flask(__name__)
 
 try:
-    # Versuche den Public Key zu verifizieren
     verify_key = VerifyKey(bytes.fromhex(PUBLIC_KEY)) if PUBLIC_KEY else None
     logger.info("Successfully initialized verify_key")
 except Exception as e:
     logger.error(f"Error initializing verify_key: {str(e)}")
     verify_key = None
 
+def verify_discord_request():
+    try:
+        signature = request.headers.get('X-Signature-Ed25519')
+        timestamp = request.headers.get('X-Signature-Timestamp')
+        
+        if not signature or not timestamp:
+            return False
+        
+        body = request.data.decode('utf-8')
+        verify_key.verify(f"{timestamp}{body}".encode(), bytes.fromhex(signature))
+        return True
+    except Exception as e:
+        logger.error(f"Verification error: {str(e)}")
+        return False
+
 @app.route("/", methods=["GET"])
 def health_check():
+    """Hugging Face nutzt diesen Endpoint um zu prüfen ob der Space läuft"""
     return jsonify({
-        "status": "healthy",
+        "status": "running",
         "message": "Discord bot is running!",
         "public_key_present": bool(PUBLIC_KEY),
-        "verify_key_initialized": verify_key is not None,
-        "application_id_present": bool(APPLICATION_ID)
-    })
-
-@app.route("/debug", methods=["GET"])
-def debug():
-    # Zeige wichtige Informationen (aber keine sensiblen Daten!)
-    return jsonify({
-        "public_key_length": len(PUBLIC_KEY) if PUBLIC_KEY else 0,
-        "application_id_length": len(APPLICATION_ID) if APPLICATION_ID else 0,
-        "verify_key_status": "initialized" if verify_key else "failed",
-        "environment_variables": list(os.environ.keys())
+        "verify_key_initialized": verify_key is not None
     })
 
 @app.route("/interactions", methods=["POST"])
 def interactions():
-    logger.info("Received interaction request")
-    logger.info(f"Headers: {dict(request.headers)}")
-    
     if not verify_key:
         logger.error("verify_key not initialized")
         return "Configuration error", 500
 
-    # Verify the request
-    signature = request.headers.get('X-Signature-Ed25519')
-    timestamp = request.headers.get('X-Signature-Timestamp')
-    
-    logger.info(f"Signature present: {bool(signature)}")
-    logger.info(f"Timestamp present: {bool(timestamp)}")
-
-    if not signature or not timestamp:
-        logger.warning("Missing headers")
+    if not verify_discord_request():
         return "Invalid request signature", 401
 
     try:
-        body = request.data.decode('utf-8')
-        verify_key.verify(f"{timestamp}{body}".encode(), bytes.fromhex(signature))
-        
-        # Process the verified request
         data = request.json
         
+        # Discord Ping Verification
         if data.get("type") == 1:
-            logger.info("Responding to ping")
+            logger.info("Responding to ping verification")
             return jsonify({"type": 1})
-            
+        
+        # Slash Commands
         if data.get("type") == 2:
-            return jsonify({
-                "type": 4,
-                "data": {
-                    "content": "Command received!"
-                }
-            })
+            command = data.get("data", {}).get("name")
+            logger.info(f"Received command: {command}")
             
-        return jsonify({"error": "Unknown type"}), 400
+            if command == "settings":
+                return jsonify({
+                    "type": 4,
+                    "data": {
+                        "content": "✅ Bot ist aktiv und verifiziert!"
+                    }
+                })
+        
+        return jsonify({"type": 1})
         
     except Exception as e:
-        logger.error(f"Error: {str(e)}")
-        return "Invalid request signature", 401
+        logger.error(f"Error processing request: {str(e)}")
+        return "Internal server error", 500
+
+def health_check_worker():
+    """Background worker der regelmäßig den Health-Check Endpoint aufruft"""
+    while True:
+        try:
+            response = requests.get(f"http://localhost:{PORT}/")
+            logger.info(f"Health check status: {response.status_code}")
+        except Exception as e:
+            logger.error(f"Health check failed: {str(e)}")
+        time.sleep(30)
 
 if __name__ == "__main__":
-    logger.info("Starting Discord bot...")
-    serve(app, host="0.0.0.0", port=8080)
+    logger.info(f"Starting Discord bot on port {PORT}...")
+    
+    # Starte Health-Check Worker in separatem Thread
+    health_thread = threading.Thread(target=health_check_worker, daemon=True)
+    health_thread.start()
+    
+    # Starte Server
+    serve(app, host="0.0.0.0", port=PORT)