Update app/app.py

app/app.py

@@ -4,7 +4,6 @@ import logging
 from waitress import serve
 from nacl.signing import VerifyKey
 from nacl.exceptions import BadSignatureError
-import json
 
 # Logging konfigurieren
 logging.basicConfig(
@@ -14,82 +13,84 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 # Konfiguration aus Umgebungsvariablen
-PUBLIC_KEY = os.getenv('Public_Key')
-APPLICATION_ID = os.getenv('Application_ID')
-
-if not PUBLIC_KEY or not APPLICATION_ID:
-    logger.error("Missing required environment variables!")
-    logger.error("Please set Public_Key and Application_ID in Hugging Face Spaces variables")
-    raise ValueError("Missing required environment variables")
+PUBLIC_KEY = os.getenv('Public_Key', '').strip()  # Strip entfernt Leerzeichen
+APPLICATION_ID = os.getenv('Application_ID', '').strip()
 
 app = Flask(__name__)
-verify_key = VerifyKey(bytes.fromhex(PUBLIC_KEY))
 
-def verify_discord_request():
-    signature = request.headers.get('X-Signature-Ed25519')
-    timestamp = request.headers.get('X-Signature-Timestamp')
-    
-    if not signature or not timestamp:
-        logger.warning("Missing Discord signature headers")
-        return False
-    
-    try:
-        body = request.data.decode('utf-8')
-        verify_key.verify(f"{timestamp}{body}".encode(), bytes.fromhex(signature))
-        return True
-    except (BadSignatureError, Exception) as e:
-        logger.warning(f"Failed to verify request: {str(e)}")
-        return False
+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
 
 @app.route("/", methods=["GET"])
 def health_check():
-    logger.info("Health check endpoint called")
     return jsonify({
         "status": "healthy",
-        "message": "Discord bot is running on Hugging Face Spaces!",
-        "application_id": APPLICATION_ID[:6] + "..." if APPLICATION_ID else "Not set",
-        "public_key_set": bool(PUBLIC_KEY),
+        "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())
     })
 
 @app.route("/interactions", methods=["POST"])
 def interactions():
-    # Verify the request is from Discord
-    if not verify_discord_request():
-        logger.warning("Failed to verify Discord request")
-        return "Invalid request signature", 401
+    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
 
-    if not request.is_json:
-        logger.warning("Received non-JSON request")
-        return jsonify({"error": "Expected JSON data"}), 400
+    # 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")
+        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
-        logger.info(f"Received verified interaction type: {data.get('type')}")
         
-        # Discord Ping Verification
         if data.get("type") == 1:
-            logger.info("Responding to ping verification")
+            logger.info("Responding to ping")
             return jsonify({"type": 1})
-        
-        # Slash Command Handler
+            
         if data.get("type") == 2:
-            command = data.get("data", {}).get("name")
-            logger.info(f"Received command: {command}")
-            if command == "settings":
-                return jsonify({
-                    "type": 4,
-                    "data": {
-                        "content": f"🔧 Bot Einstellungen:\n• Application ID: {APPLICATION_ID[:6]}...\n• Verifizierung: ✅ Aktiv"
-                    }
-                })
-        
-        return jsonify({"error": "Unknown interaction type"}), 400
+            return jsonify({
+                "type": 4,
+                "data": {
+                    "content": "Command received!"
+                }
+            })
+            
+        return jsonify({"error": "Unknown type"}), 400
         
     except Exception as e:
-        logger.error(f"Error processing request: {str(e)}")
-        return jsonify({"error": "Internal server error"}), 500
+        logger.error(f"Error: {str(e)}")
+        return "Invalid request signature", 401
 
 if __name__ == "__main__":
-    logger.info(f"Starting Discord bot (Application ID: {APPLICATION_ID[:6]}...)")
-    logger.info("Public Key verification is enabled")
+    logger.info("Starting Discord bot...")
     serve(app, host="0.0.0.0", port=8080)