Upload 7 files

app.py

@@ -1,23 +1,28 @@
 """
-HuggingFace Spaces Entry Point for Jade Bot
+HuggingFace Spaces Entry Point for Jade Bot - Using Webhooks
 """
 import os
 import socket
 import logging
 import asyncio
-import gradio as gr
 from datetime import datetime
+from fastapi import FastAPI, Request
+from telegram import Update
+from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
+import uvicorn
+import gradio as gr
 
-# FORCE IPv4 - Fix for HuggingFace Spaces DNS issues
+# FORCE IPv4
 original_getaddrinfo = socket.getaddrinfo
-def force_ipv4_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
+def force_ipv4(host, port, family=0, type=0, proto=0, flags=0):
     return original_getaddrinfo(host, port, socket.AF_INET, type, proto, flags)
-socket.getaddrinfo = force_ipv4_getaddrinfo
+socket.getaddrinfo = force_ipv4
 
 logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 bot_status = {"started_at": None, "is_running": False, "error": None}
+application = None
 
 
 def get_status():
@@ -28,29 +33,49 @@ def get_status():
     return f"## 🟢 Jade Running!\n- Started: {bot_status.get('started_at')}"
 
 
-def create_gradio_interface():
-    with gr.Blocks(title="Jade Bot", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🌿 Jade - 24h Personal Assistant")
-        status_display = gr.Markdown(get_status)
-        gr.Button("🔄 Refresh").click(fn=get_status, outputs=status_display)
-        gr.Markdown("**Usage:** Find your bot on Telegram → `/start`")
-    return demo
+# FastAPI for webhook
+app = FastAPI()
+
+
+@app.post("/webhook")
+async def webhook(request: Request):
+    """Handle incoming Telegram updates via webhook."""
+    global application
+    if application:
+        data = await request.json()
+        update = Update.de_json(data, application.bot)
+        await application.process_update(update)
+    return {"ok": True}
 
 
-async def run_bot():
-    global bot_status
+@app.get("/health")
+async def health():
+    return {"status": "ok", "bot_running": bot_status["is_running"]}
+
+
+async def setup_bot():
+    """Setup the Telegram bot with webhook."""
+    global application, bot_status
     
     token = os.getenv("TELEGRAM_BOT_TOKEN")
+    space_url = os.getenv("SPACE_URL", "")  # e.g., https://madras1-jade-assistant.hf.space
+    
     if not token:
         bot_status["error"] = "TELEGRAM_BOT_TOKEN not set!"
         return
     
-    logger.info("Waiting for network to stabilize...")
-    await asyncio.sleep(5)
+    if not space_url:
+        # Try to construct from SPACE_ID
+        space_id = os.getenv("SPACE_ID", "")
+        if space_id:
+            space_url = f"https://{space_id.replace('/', '-')}.hf.space"
+        else:
+            bot_status["error"] = "SPACE_URL not set! Add it to secrets."
+            return
+    
+    logger.info(f"Space URL: {space_url}")
     
     try:
-        from telegram import Update
-        from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
         from core import TelegramJadeAgent
         from tools import ReminderManager
         
@@ -67,57 +92,55 @@ async def run_bot():
             response = await loop.run_in_executor(None, agent.chat, chat_id, user_text)
             await context.bot.send_message(chat_id=chat_id, text=response)
         
-        # Retry loop - create NEW application each attempt
+        # Build application
+        application = ApplicationBuilder().token(token).build()
+        application.add_handler(CommandHandler('start', start))
+        application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
+        
+        await application.initialize()
+        
+        # Set webhook with retries
+        webhook_url = f"{space_url}/webhook"
         for attempt in range(5):
             try:
-                logger.info(f"Connecting to Telegram ({attempt + 1}/5)...")
-                
-                # Create fresh application each time
-                application = ApplicationBuilder().token(token).build()
-                application.add_handler(CommandHandler('start', start))
-                application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
-                
-                await application.initialize()
-                await application.start()
-                await application.updater.start_polling(drop_pending_updates=True)
-                
+                logger.info(f"Setting webhook to {webhook_url} (attempt {attempt + 1}/5)...")
+                await application.bot.set_webhook(url=webhook_url)
+                logger.info("✅ Webhook set successfully!")
                 bot_status["started_at"] = datetime.now().strftime("%H:%M:%S")
                 bot_status["is_running"] = True
-                logger.info("✅ Bot running!")
-                
-                # Keep running
-                while True:
-                    await asyncio.sleep(60)
-                    
+                break
             except Exception as e:
-                logger.warning(f"Attempt {attempt + 1} failed: {e}")
+                logger.warning(f"Webhook attempt {attempt + 1} failed: {e}")
                 if attempt < 4:
-                    await asyncio.sleep(5 * (attempt + 1))
+                    await asyncio.sleep(10)
                 else:
                     raise
-            
+                    
     except Exception as e:
-        logger.error(f"Bot failed: {e}")
+        logger.error(f"Bot setup failed: {e}")
         bot_status["error"] = str(e)
 
 
-def main():
-    required = ["TELEGRAM_BOT_TOKEN", "CHUTES_API_KEY"]
-    missing = [v for v in required if not os.getenv(v)]
-    if missing:
-        bot_status["error"] = f"Missing: {', '.join(missing)}"
-    
-    import threading
-    def run_async():
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        loop.run_until_complete(run_bot())
-    
-    threading.Thread(target=run_async, daemon=True).start()
-    logger.info("Bot thread started")
-    
-    create_gradio_interface().launch(server_name="0.0.0.0", server_port=7860)
+# Gradio interface
+def create_gradio():
+    with gr.Blocks(title="Jade Bot") as demo:
+        gr.Markdown("# 🌿 Jade - 24h Personal Assistant")
+        status = gr.Markdown(get_status)
+        gr.Button("🔄 Refresh").click(fn=get_status, outputs=status)
+        gr.Markdown("**Usage:** Message your bot on Telegram → `/start`")
+    return demo
+
+
+# Mount Gradio on FastAPI
+gradio_app = create_gradio()
+app = gr.mount_gradio_app(app, gradio_app, path="/")
+
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Starting bot setup...")
+    asyncio.create_task(setup_bot())
 
 
 if __name__ == "__main__":
-    main()
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -3,3 +3,5 @@ openai
 duckduckgo-search
 huggingface_hub>=0.20.0,<0.30.0
 gradio>=4.0.0,<5.0.0
+uvicorn
+fastapi