fix: template engine, youtube cookies, ffmpeg

Aptfile

@@ -0,0 +1 @@
+ffmpeg

bot/youtube.py

@@ -5,18 +5,29 @@ from config import DOWNLOAD_DIR
 
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 
+COOKIES_FILE = os.path.join(DOWNLOAD_DIR, "..", "cookies.txt")
+
+
+def _cookies_opts():
+    if os.path.exists(COOKIES_FILE):
+        return {"cookiefile": COOKIES_FILE}
+    return {}
+
 
 def _get_ydl_opts(format_spec: str, ext: str):
-    return {
+    opts = {
         "format": format_spec,
         "outtmpl": os.path.join(DOWNLOAD_DIR, f"{uuid.uuid4()}.%(ext)s"),
         "quiet": True,
         "no_warnings": True,
     }
+    opts.update(_cookies_opts())
+    return opts
 
 
 async def get_video_info(url: str):
     ydl_opts = {"quiet": True, "no_warnings": True}
+    ydl_opts.update(_cookies_opts())
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         info = ydl.extract_info(url, download=False)
         return {
@@ -42,6 +53,8 @@ async def download_yt(url: str, quality: str = "audio"):
     else:
         opts = _get_ydl_opts("best", "mp4")
 
+    opts["paths"] = {"home": DOWNLOAD_DIR}
+
     with yt_dlp.YoutubeDL(opts) as ydl:
         info = ydl.extract_info(url, download=True)
         file_path = ydl.prepare_filename(info)
@@ -54,6 +67,6 @@ async def download_yt(url: str, quality: str = "audio"):
             return file_path, info.get("title", "video")
         for f in os.listdir(DOWNLOAD_DIR):
             p = os.path.join(DOWNLOAD_DIR, f)
-            if os.path.isfile(p):
+            if os.path.isfile(p) and f != "cookies.txt":
                 return p, info.get("title", "video")
         return None, None

web/routes.py

@@ -1,77 +1,59 @@
-from fastapi import APIRouter, Request, Form
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.templating import Jinja2Templates
-import os
-
-from fastapi.responses import FileResponse
+from fastapi import APIRouter, Form, UploadFile, File
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 import os
 
 from bot.youtube import get_video_info, download_yt
 from bot.filedl import download_file, cleanup_file
 from bot.chatgpt import ask_gpt
-from db import get_all_users, get_stats_summary, set_admin, is_admin, get_setting, set_setting, log_stat
+from db import get_all_users, get_stats_summary, set_admin, is_admin, get_setting, set_setting
 from config import DOWNLOAD_DIR
-
-templates = Jinja2Templates(directory="web/templates")
+from web.template_engine import render
 
 router = APIRouter()
 
 
 @router.get("/", response_class=HTMLResponse)
-async def index(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
+async def index():
+    return render("index.html")
 
 
 @router.get("/youtube", response_class=HTMLResponse)
-async def youtube_page(request: Request):
-    return templates.TemplateResponse("youtube.html", {"request": request})
+async def youtube_page():
+    return render("youtube.html")
 
 
 @router.post("/youtube", response_class=HTMLResponse)
-async def youtube_download(request: Request, url: str = Form(...), format: str = Form("audio")):
+async def youtube_download(url: str = Form(...), format: str = Form("audio")):
     try:
         info = await get_video_info(url)
         quality = "audio" if format == "audio" else "720p"
         filepath, title = await download_yt(url, quality)
         if filepath and os.path.exists(filepath):
-            # Re-host the file for download
             download_url = f"/download/{os.path.basename(filepath)}"
-            return templates.TemplateResponse("youtube.html", {
-                "request": request,
-                "result": {"title": title, "download_url": download_url},
-            })
-        return templates.TemplateResponse("youtube.html", {
-            "request": request,
-            "error": "Processing failed.",
-        })
+            return render("youtube.html", result={"title": title, "download_url": download_url})
+        return render("youtube.html", error="Processing failed.")
     except Exception as e:
-        return templates.TemplateResponse("youtube.html", {
-            "request": request,
-            "error": str(e),
-        })
+        return render("youtube.html", error=str(e))
 
 
 @router.get("/filedl", response_class=HTMLResponse)
-async def filedl_page(request: Request):
-    return templates.TemplateResponse("filedl.html", {"request": request})
+async def filedl_page():
+    return render("filedl.html")
 
 
 @router.post("/filedl", response_class=HTMLResponse)
-async def filedl_download(request: Request, url: str = Form(...)):
+async def filedl_download(url: str = Form(...)):
     try:
         filepath, error, content_type, size = await download_file(url)
         if error:
-            return templates.TemplateResponse("filedl.html", {"request": request, "error": error})
+            return render("filedl.html", error=error)
         if filepath and os.path.exists(filepath):
             sz = f"{size / 1024 / 1024:.1f} MB" if size > 1024 * 1024 else f"{size / 1024:.1f} KB"
             download_url = f"/download/{os.path.basename(filepath)}"
-            return templates.TemplateResponse("filedl.html", {
-                "request": request,
-                "result": {"size": sz, "download_url": download_url},
-            })
-        return templates.TemplateResponse("filedl.html", {"request": request, "error": "Download failed."})
+            return render("filedl.html", result={"size": sz, "download_url": download_url})
+        return render("filedl.html", error="Download failed.")
     except Exception as e:
-        return templates.TemplateResponse("filedl.html", {"request": request, "error": str(e)})
+        return render("filedl.html", error=str(e))
 
 
 @router.get("/download/{filename}")
@@ -83,8 +65,8 @@ async def serve_file(filename: str):
 
 
 @router.get("/chat", response_class=HTMLResponse)
-async def chat_page(request: Request):
-    return templates.TemplateResponse("chat.html", {"request": request, "messages": []})
+async def chat_page():
+    return render("chat.html", messages=[])
 
 
 @router.post("/chat")
@@ -102,18 +84,17 @@ async def chat_send(data: dict):
 # --- Admin routes ---
 
 @router.get("/admin", response_class=HTMLResponse)
-async def admin_dashboard(request: Request):
+async def admin_dashboard():
     users = await get_all_users()
     summary, stat_rows = await get_stats_summary()
     total_downloads = sum(r["count"] for r in stat_rows if r["action"] in ("youtube", "filedl"))
     chatgpt_count = sum(r["count"] for r in stat_rows if r["action"] == "chatgpt")
-    return templates.TemplateResponse("admin/dashboard.html", {
-        "request": request,
-        "total_users": summary[0] if summary else 0,
-        "total_downloads": total_downloads,
-        "chatgpt_count": chatgpt_count,
-        "users": users,
-    })
+    return render("admin/dashboard.html",
+        total_users=summary[0] if summary else 0,
+        total_downloads=total_downloads,
+        chatgpt_count=chatgpt_count,
+        users=users,
+    )
 
 
 @router.post("/admin/toggle-admin")
@@ -124,17 +105,16 @@ async def toggle_admin(bale_id: str = Form(...)):
 
 
 @router.get("/admin/settings", response_class=HTMLResponse)
-async def admin_settings_page(request: Request):
+async def admin_settings_page():
     settings = {
         "openai_key": await get_setting("openai_key", ""),
         "webhook_url": await get_setting("webhook_url", ""),
     }
-    return templates.TemplateResponse("admin/settings.html", {"request": request, "settings": settings})
+    return render("admin/settings.html", settings=settings)
 
 
 @router.post("/admin/settings")
 async def admin_settings_save(
-    request: Request,
     openai_key: str = Form(""),
     webhook_url: str = Form(""),
 ):
@@ -142,8 +122,22 @@ async def admin_settings_save(
     await set_setting("webhook_url", webhook_url)
     if openai_key:
         os.environ["OPENAI_API_KEY"] = openai_key
-    return templates.TemplateResponse("admin/settings.html", {
-        "request": request,
-        "settings": {"openai_key": openai_key, "webhook_url": webhook_url},
-        "saved": True,
-    })
+    return render("admin/settings.html", settings={"openai_key": openai_key, "webhook_url": webhook_url}, saved=True)
+
+
+@router.post("/admin/upload-cookies")
+async def upload_cookies(cookies: UploadFile = File(...)):
+    from bot.youtube import COOKIES_FILE
+    try:
+        content = await cookies.read()
+        with open(COOKIES_FILE, "wb") as f:
+            f.write(content)
+        return render("admin/settings.html",
+            settings={"openai_key": await get_setting("openai_key", ""), "webhook_url": await get_setting("webhook_url", "")},
+            cookies_status={"success": True, "message": f"Cookies uploaded ({len(content)} bytes)"},
+        )
+    except Exception as e:
+        return render("admin/settings.html",
+            settings={"openai_key": await get_setting("openai_key", ""), "webhook_url": await get_setting("webhook_url", "")},
+            cookies_status={"success": False, "message": str(e)},
+        )

web/template_engine.py

@@ -0,0 +1,9 @@
+from jinja2 import Environment, FileSystemLoader
+from pathlib import Path
+
+_env = Environment(loader=FileSystemLoader(Path(__file__).parent / "templates"), autoescape=True)
+
+
+def render(name: str, **context):
+    t = _env.get_template(name)
+    return t.render(**context)

web/templates/admin/settings.html

@@ -3,19 +3,29 @@
 {% block content %}
 <div class="max-w-2xl mx-auto py-8">
     <h1 class="text-3xl font-bold mb-6">⚙️ Bot Settings</h1>
-    <form method="POST" action="/admin/settings" class="space-y-4">
+
+    <form method="POST" action="/admin/settings" class="space-y-4 mb-8">
         <div>
             <label class="block text-gray-400 mb-1">OpenAI API Key</label>
             <input type="password" name="openai_key" value="{{ settings.openai_key or '' }}"
                    class="w-full p-3 rounded bg-gray-800 border border-gray-700 focus:border-purple-500 outline-none">
         </div>
-        <div>
-            <label class="block text-gray-400 mb-1">Webhook URL</label>
-            <input type="url" name="webhook_url" value="{{ settings.webhook_url or '' }}"
-                   class="w-full p-3 rounded bg-gray-800 border border-gray-700 focus:border-purple-500 outline-none">
-        </div>
         <button type="submit" class="p-3 bg-purple-600 rounded hover:bg-purple-500 font-semibold">Save Settings</button>
     </form>
+
+    <h2 class="text-xl font-bold mb-4">🍪 YouTube Cookies</h2>
+    <p class="text-gray-400 text-sm mb-4">Upload a <code>cookies.txt</code> file to bypass YouTube's bot detection. <a href="https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp" class="text-purple-400" target="_blank">How to get cookies</a></p>
+    <form method="POST" action="/admin/upload-cookies" enctype="multipart/form-data" class="space-y-4">
+        <input type="file" name="cookies" accept=".txt"
+               class="w-full p-3 rounded bg-gray-800 border border-gray-700 file:mr-4 file:py-2 file:px-4 file:rounded file:border-0 file:bg-purple-600 file:text-white hover:file:bg-purple-500">
+        <button type="submit" class="p-3 bg-purple-600 rounded hover:bg-purple-500 font-semibold">Upload Cookies</button>
+    </form>
+    {% if cookies_status %}
+    <div class="mt-4 p-3 rounded {{ 'bg-green-900/50 border border-green-700 text-green-300' if cookies_status.success else 'bg-red-900/50 border border-red-700 text-red-300' }}">
+        {{ cookies_status.message }}
+    </div>
+    {% endif %}
+
     {% if saved %}
     <div class="mt-4 p-3 bg-green-900/50 border border-green-700 rounded text-green-300">Settings saved!</div>
     {% endif %}